From a9ffe80de5ac90d68738cfe3718be29ed929b581 Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Thu, 6 Aug 2026 18:14:45 -0700
Subject: [PATCH 01/26] feat(isolation-session): bind MSI runtime via
 coresident explicit-load

Load IsoSessionApp.dll by full path from the paired IsoSession MSI runtime
dir (hardcoded default C:\Program Files\Microsoft\Agentic Runtime\2026.08,
overridable via MXC_ISOSESSION_RUNTIME_DIR) and obtain the activation factory
directly via DllGetActivationFactory, bypassing the WinRT catalog (which would
otherwise shadow reg-free activation and resolve to System32). This binds the
MSI-installed runtime with no machine-wide registry mutation. Falls back to
inbox system activation when no coresident App.dll is present.

CoInitializeEx(MTA) is called best-effort before the explicit ActivateInstance
because, unlike inbox RoActivateInstance, the direct factory path does not
implicitly initialize the COM apartment the coresident client->service
activation requires (otherwise CO_E_NOTINITIALIZED).

Routes both IsoSessionOps and IsoSessionProcessOptions activation through the
new regfree helper.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: f5cc2011-5308-43d6-a8ea-2b8ed9b6ceb3
---
 src/Cargo.toml                                |   1 +
 .../isolation_session/common/manager.rs       |  10 +-
 .../backends/isolation_session/common/mod.rs  |   2 +
 .../common/process_options.rs                 |   3 +-
 .../isolation_session/common/regfree.rs       | 215 ++++++++++++++++++
 5 files changed, 228 insertions(+), 3 deletions(-)
 create mode 100644 src/mxc-sdk/src/backends/isolation_session/common/regfree.rs

diff --git a/src/Cargo.toml b/src/Cargo.toml
index b823e9f8e..72deda762 100644
--- a/src/Cargo.toml
+++ b/src/Cargo.toml
@@ -91,6 +91,7 @@ windows = { version = "0.62", features = [
     "Win32_System_Time",
     "Win32_System_Variant",
     "Win32_System_WindowsProgramming",
+    "Win32_System_WinRT",
     "Win32_UI_Shell",
 ] }
 windows-core = "0.62"
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
index 7ec4c8b79..1c3a7be5a 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
@@ -81,9 +81,15 @@ unsafe impl Send for MtaReference {}
 unsafe impl Sync for MtaReference {}
 
 /// Activates the in-proc IsolationSession runtime factory and returns the
-/// instance.
+/// instance. When a coresident `IsoSessionApp.dll` is present (see
+/// [`super::regfree`]), the factory is loaded **by full path** from the MSI
+/// runtime folder, binding the MSI-installed runtime instead of the inbox
+/// `System32` one; otherwise it falls back to default system activation.
 fn check_service_available_and_activate() -> Result<IsoSessionOps, IsolationSessionError> {
-    match IsoSessionOps::new() {
+    let activated =
+        super::regfree::activate_from_runtime_dir::<IsoSessionOps>().unwrap_or_else(IsoSessionOps::new);
+
+    match activated {
         Ok(ops) => Ok(ops),
         // The HRESULT→error mapping lives in `activation_error` so it stays
         // testable without depending on whether this host can activate the
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/mod.rs b/src/mxc-sdk/src/backends/isolation_session/common/mod.rs
index a07bcf159..d27e47ff0 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/mod.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/mod.rs
@@ -42,6 +42,8 @@ mod sandbox;
 #[cfg(target_os = "windows")]
 pub use sandbox::{spawn_one_shot, spawn_one_shot_pty, OneShotSpawnFailure};
 #[cfg(target_os = "windows")]
+mod regfree;
+#[cfg(target_os = "windows")]
 mod sandbox_id;
 #[cfg(target_os = "windows")]
 mod state_aware;
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs b/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs
index d40558ca9..6b86f9607 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs
@@ -167,7 +167,8 @@ pub(super) fn with_service_timeout_grace(mut options: ProcessOptions) -> Process
 pub(super) fn build_iso_process_options(
     options: &ProcessOptions,
 ) -> Result<IsoSessionProcessOptions, IsolationSessionError> {
-    let proc_options = IsoSessionProcessOptions::new()
+    let proc_options = super::regfree::activate_from_runtime_dir::<IsoSessionProcessOptions>()
+        .unwrap_or_else(IsoSessionProcessOptions::new)
         .map_err(|e| transport_err(op::OPTIONS_NEW, "activation failed", &e))?;
 
     proc_options
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
new file mode 100644
index 000000000..7f232d6c8
--- /dev/null
+++ b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
@@ -0,0 +1,215 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+//! Coresident WinRT activation for the IsoSession client surface.
+//!
+//! By default MXC activates `Windows.AI.IsolationSession.Preview.IsoSessionOps`
+//! through the system-installed registration (the OS image populates the WinRT
+//! activation catalog, which resolves to the inbox `System32` binaries). This
+//! module instead loads the in-proc client (`IsoSessionApp.dll` ->
+//! `IsoSessionClient.dll`) **by full path** from the folder where the paired
+//! IsoSession MSI lays the runtime down, so `wxc-exec` binds the MSI-installed
+//! runtime (and its matching side-by-side service instance) rather than the
+//! inbox one.
+//!
+//! Why an explicit factory load and not a reg-free activation context: on an
+//! image where the `Windows.AI.IsolationSession.*` classes are registered, a
+//! dynamic reg-free activation context is *shadowed* by the system catalog, so
+//! `RoGetActivationFactory` still loads the `System32` binaries. Loading the
+//! activation factory directly from the MSI copy of `IsoSessionApp.dll`
+//! (`LoadLibraryW` by full path + `DllGetActivationFactory`) guarantees the
+//! MSI-installed binary is the one used. Its coresidency logic then
+//! sibling-loads the MSI `IsoSessionClient.dll` and binds the matching service
+//! instance -- no machine-wide registry mutation is involved.
+//!
+//! Coupling to the install path: [`runtime_dir`] returns the
+//! [`RUNTIME_DIR_ENV`] override when set, otherwise the hardcoded
+//! [`DEFAULT_RUNTIME_DIR`] (the fixed MSI install location the openclaw
+//! packager targets). When neither the override nor the default folder
+//! contains a loadable `IsoSessionApp.dll`, activation cleanly falls back to
+//! the default system activation, so hosts without the MSI keep working.
+
+use core::ffi::c_void;
+use std::sync::OnceLock;
+
+use windows::Win32::Foundation::{E_NOINTERFACE, HMODULE};
+use windows::Win32::System::Com::{CoInitializeEx, COINIT_MULTITHREADED};
+use windows::Win32::System::LibraryLoader::{GetProcAddress, LoadLibraryW};
+use windows::Win32::System::WinRT::IActivationFactory;
+use windows_core::{Interface, RuntimeName, HSTRING, PCSTR, PCWSTR};
+
+/// Environment variable that points MXC at the folder holding the coresident
+/// IsoSession runtime binaries (`IsoSessionApp.dll`, `IsoSessionClient.dll`,
+/// `IsoSession.manifest`, ...). Overrides [`DEFAULT_RUNTIME_DIR`] when set.
+pub const RUNTIME_DIR_ENV: &str = "MXC_ISOSESSION_RUNTIME_DIR";
+
+/// The fixed location the paired IsoSession MSI installs its runtime to, and
+/// therefore the path this build of `wxc-exec` is hardcoded to bind. The
+/// openclaw packager installs the MSI here; MXC needs no configuration to find
+/// it. An override via [`RUNTIME_DIR_ENV`] takes precedence (used by tests and
+/// side-by-side validation).
+pub const DEFAULT_RUNTIME_DIR: &str = r"C:\Program Files\Microsoft\Agentic Runtime\2026.08";
+
+/// Name of the WinRT activation DLL inside the runtime folder.
+const APP_DLL_NAME: &str = "IsoSessionApp.dll";
+
+/// Standard WinRT in-proc activation entrypoint exported by `IsoSessionApp.dll`.
+const ACTIVATION_FACTORY_EXPORT: &[u8] = b"DllGetActivationFactory\0";
+
+/// Signature of `DllGetActivationFactory`. The first parameter is an `HSTRING`
+/// activatable class id (passed by value as its pointer-sized handle); the
+/// second receives an `IActivationFactory*`.
+type PfnDllGetActivationFactory =
+    unsafe extern "system" fn(*mut c_void, *mut *mut c_void) -> windows_core::HRESULT;
+
+/// Cached `HMODULE` of the explicitly-loaded `IsoSessionApp.dll`, stored as a
+/// `usize` so the static is `Send + Sync`. `None` means no runtime folder held
+/// a loadable `IsoSessionApp.dll`.
+static APP_DLL: OnceLock<Option<usize>> = OnceLock::new();
+
+/// Resolves the coresident runtime folder: the [`RUNTIME_DIR_ENV`] override
+/// when set and non-empty, otherwise the hardcoded [`DEFAULT_RUNTIME_DIR`].
+fn runtime_dir() -> String {
+    match std::env::var(RUNTIME_DIR_ENV) {
+        Ok(value) if !value.trim().is_empty() => value.trim().to_string(),
+        _ => DEFAULT_RUNTIME_DIR.to_string(),
+    }
+}
+
+/// Loads `<runtime_dir>\IsoSessionApp.dll` by full path exactly once and
+/// returns its module handle. Returns `None` when the DLL is absent or cannot
+/// be loaded (caller then falls back to default system activation).
+fn app_dll_handle() -> Option<HMODULE> {
+    let cached = APP_DLL.get_or_init(|| {
+        let dir = runtime_dir();
+        let path = format!("{}\\{}", dir.trim_end_matches('\\'), APP_DLL_NAME);
+
+        if !std::path::Path::new(&path).exists() {
+            eprintln!(
+                "[mxc isosession] {} not found at '{}'; using system activation.",
+                APP_DLL_NAME, path
+            );
+            return None;
+        }
+
+        let path_w = HSTRING::from(path.as_str());
+
+        // SAFETY: `path_w` is a valid NUL-terminated wide string that outlives
+        // the call. Loading by full path makes the MSI-installed copy of the
+        // DLL the one mapped regardless of any inbox WinRT catalog
+        // registration.
+        match unsafe { LoadLibraryW(PCWSTR(path_w.as_ptr())) } {
+            Ok(hmod) if !hmod.is_invalid() => {
+                eprintln!(
+                    "[mxc isosession] explicitly loaded {} from '{}'",
+                    APP_DLL_NAME, path
+                );
+                Some(hmod.0 as usize)
+            }
+            Ok(_) => None,
+            Err(e) => {
+                eprintln!(
+                    "[mxc isosession] LoadLibraryW('{}') failed: {}; \
+                     using system activation.",
+                    path, e
+                );
+                None
+            }
+        }
+    });
+
+    cached.map(|raw| HMODULE(raw as *mut c_void))
+}
+
+/// Activates the WinRT runtime class `T` by obtaining its activation factory
+/// **directly** from the coresident `IsoSessionApp.dll`, bypassing the WinRT
+/// activation catalog.
+///
+/// Returns `None` when no coresident `IsoSessionApp.dll` was loadable (caller
+/// falls back to the default `T::new()` system activation). Returns
+/// `Some(Err(..))` when the DLL loaded but the explicit activation failed --
+/// the caller should surface that rather than silently fall back to a
+/// different binary set.
+pub(crate) fn activate_from_runtime_dir<T>() -> Option<windows_core::Result<T>>
+where
+    T: Interface + RuntimeName,
+{
+    let hmod = app_dll_handle()?;
+
+    // Unlike the inbox `RoActivateInstance` path (which implicitly initializes
+    // the WinRT/COM apartment), obtaining the factory via
+    // `DllGetActivationFactory` and calling `IActivationFactory::ActivateInstance`
+    // directly does NOT. The factory's activation internally performs COM
+    // activation (coresident client -> service), which requires an initialized
+    // apartment, so ensure one exists first. Best-effort: `S_FALSE`
+    // (already initialized) and `RPC_E_CHANGED_MODE` (a different apartment
+    // model is already in force, which is fine to reuse) are both ignored.
+    //
+    // SAFETY: `CoInitializeEx` is safe to call with a null reserved pointer;
+    // its refcount is balanced by process teardown (the runtime lives for the
+    // process lifetime, matching the leaked module handle above).
+    unsafe {
+        let _ = CoInitializeEx(None, COINIT_MULTITHREADED);
+    }
+
+    Some(activate_via_factory::<T>(hmod))
+}
+
+fn activate_via_factory<T>(hmod: HMODULE) -> windows_core::Result<T>
+where
+    T: Interface + RuntimeName,
+{
+    // SAFETY: `hmod` is a valid module handle and the export name is a static
+    // NUL-terminated byte string.
+    let proc = unsafe { GetProcAddress(hmod, PCSTR(ACTIVATION_FACTORY_EXPORT.as_ptr())) }
+        .ok_or_else(|| windows_core::Error::from(E_NOINTERFACE))?;
+
+    // SAFETY: `DllGetActivationFactory` matches `PfnDllGetActivationFactory`.
+    let factory_fn: PfnDllGetActivationFactory = unsafe { core::mem::transmute(proc) };
+
+    let class_id = HSTRING::from(<T as RuntimeName>::NAME);
+
+    // SAFETY: `HSTRING` is a transparent, pointer-sized handle. `transmute_copy`
+    // reads the handle without taking ownership, so `class_id` remains valid
+    // and is freed at end of scope -- after the call. The callee borrows, not
+    // owns.
+    let class_id_raw: *mut c_void = unsafe { core::mem::transmute_copy(&class_id) };
+
+    let mut factory_raw: *mut c_void = core::ptr::null_mut();
+
+    // SAFETY: out-param receives a valid `IActivationFactory*` on success.
+    let hr = unsafe { factory_fn(class_id_raw, &mut factory_raw) };
+    if let Err(e) = hr.ok() {
+        eprintln!(
+            "[mxc isosession] DllGetActivationFactory('{}') failed: {}",
+            <T as RuntimeName>::NAME,
+            e
+        );
+        return Err(e);
+    }
+
+    // SAFETY: on success `factory_raw` is a valid, owned `IActivationFactory`.
+    let factory = unsafe { IActivationFactory::from_raw(factory_raw) };
+
+    // SAFETY: factory came from the runtime class's own DLL.
+    let instance = match unsafe { factory.ActivateInstance() } {
+        Ok(instance) => instance,
+        Err(e) => {
+            eprintln!(
+                "[mxc isosession] ActivateInstance('{}') failed: {}",
+                <T as RuntimeName>::NAME,
+                e
+            );
+            return Err(e);
+        }
+    };
+
+    instance.cast::<T>().map_err(|e| {
+        eprintln!(
+            "[mxc isosession] cast to '{}' failed (IID mismatch?): {}",
+            <T as RuntimeName>::NAME,
+            e
+        );
+        e
+    })
+}

From 5427e7bd0d7d1c95cb0f9ed53e845d65d5578688 Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Thu, 6 Aug 2026 19:54:19 -0700
Subject: [PATCH 02/26] fix(isolation-session): harden coresident explicit-load
 per code review

Address the code-review findings on the coresident explicit-load change
(38dbd889). Runtime binding still activates the MSI IsoSessionApp.dll by
absolute path with zero registry mutation; this commit hardens the
surrounding load, error, and diagnostic behavior.

regfree.rs (#1,#5,#6,#7,#8,#9,#10):
- Load the App DLL with LoadLibraryExW using
  LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32 so
  the runtime directory is the sole search root for its dependencies
  (search-order hijack hardening). Reject non-absolute
  MXC_ISOSESSION_RUNTIME_DIR overrides.
- Replace the 2-state load cache with a 3-state RuntimeLoad enum
  (Absent / Loaded / Unloadable). A missing default folder still falls
  back to inbox activation, but an honored-but-broken explicit override
  or a present-but-unloadable DLL now surfaces the error instead of
  silently falling back.
- Report real Win32 errors (GetProcAddress) and null-check the returned
  factory pointer before from_raw.
- Gate success-path eprintln! on MXC_DIAG_CONSOLE.
- Correct the CoInitializeEx SAFETY comment.
- Add unit tests for runtime-dir resolution and app-dll path building.

manager.rs (#2): wrap the over-length activate line for rustfmt.

oneshot.md (#4,#11): document the two activation paths, the
runtime-folder resolution table (MXC_ISOSESSION_RUNTIME_DIR /
DEFAULT_RUNTIME_DIR), apartment init, and prerequisites; fix
RoInitialize -> CoInitializeEx wording.

tests/scripts (#3): accept EITHER inbox (System32 DLL + registry) OR the
coresident MSI runtime dir in the prerequisite probe, so the suites no
longer skip on an MSI-only host.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: f5cc2011-5308-43d6-a8ea-2b8ed9b6ceb3
---
 .../backends/isolation-session/oneshot.md     | 178 ++++++---
 .../isolation_session/common/manager.rs       |   4 +-
 .../isolation_session/common/regfree.rs       | 363 +++++++++++++++---
 3 files changed, 423 insertions(+), 122 deletions(-)

diff --git a/docs/development/architecture/backends/isolation-session/oneshot.md b/docs/development/architecture/backends/isolation-session/oneshot.md
index 7cdbbb4ca..209da6cfb 100644
--- a/docs/development/architecture/backends/isolation-session/oneshot.md
+++ b/docs/development/architecture/backends/isolation-session/oneshot.md
@@ -18,9 +18,9 @@ session. Use cases that need this — per the broader claw-on-MXC scenario — c
 
 ## Proposed Solution
 
-Add an **IsolationSession runner** to `wxc-exec.exe`.
+Add an **IsolationSession runner** to `wxc-exec.exe`, behind `--experimental`.
 When the JSON config specifies `"containment": "isolation_session"` and the
-the backend is selected, the binary routes to a new `IsolationSessionRunner`
+experimental flag is set, the binary routes to a new `IsolationSessionRunner`
 (implementing the existing `ScriptRunner` trait). The runner orchestrates the
 full lifecycle against the OS-side Isolation Session API: provision an
 agent user, start a session, run the script (capturing stdout / stderr /
@@ -38,13 +38,13 @@ reuse the manager's methods individually.
 ## How It Works
 
 ```
-User: wxc-exec.exe config.json
+User: wxc-exec.exe --experimental config.json
        (config.json sets containment = "isolation_session")
    │
    ▼
 wxc-exec.exe (Rust — single binary, multiple backends)
    ├── Parses JSON config → sees containment = "isolation_session"
-   ├── Instantiates IsolationSessionRunner
+   ├── Checks --experimental flag → instantiates IsolationSessionRunner
    ├── Calls IsolationSessionManager methods 1:1 with the OS-side service:
    │     add_user(...)               → Step 1 — creates agent user
    │     start_session(...)          → Step 2 — boots session
@@ -69,9 +69,14 @@ Dispatch in `wxc/src/main.rs`:
 ```rust
 let mut runner: Box<dyn ScriptRunner> = match request.containment {
     ContainmentBackend::AppContainer => Box::new(AppContainerScriptRunner::new()),
-    // ... other containment backends ...
-    ContainmentBackend::IsolationSession =>
-        Box::new(IsolationSessionRunner::new(/* ... */)),
+    // ... existing stable + experimental backends ...
+    ContainmentBackend::IsolationSession => {
+        if !request.experimental_enabled {
+            eprintln!("Error: IsolationSession is experimental. Use --experimental.");
+            process::exit(1);
+        }
+        Box::new(IsolationSessionRunner::new(/* ... */))
+    }
 };
 ```
 
@@ -117,34 +122,34 @@ invocations, without changing the manager's interface. See
 
 ```json
 {
-    "version": "0.9.0-alpha",
+    "version": "0.6.0-alpha",
     "containerId": "MyIsolationSessionRun",
     "containment": "isolation_session",
     "process": {
         "commandLine": "echo hello & whoami",
         "cwd": "C:\\Windows",
         "env": ["MYVAR=hello"],
-        "inheritDefaultEnv": true,
         "timeout": 30000
     },
     "network": {
-        "egress": { "default": "allow" },
-        "ingress": { "default": "allow", "hostLoopback": "allow" }
+        "defaultPolicy": "allow",
+        "allowLocalNetwork": true
+    },
+    "experimental": {
+        "isolation_session": {}
     }
 }
 ```
 
-The directional shape explicitly describes the backend's actual unrestricted
-posture across egress, ingress, and host loopback. All three values are
-required; rules, proxies, mixed postures, and omission are rejected.
-
-Legacy network fields are rejected.
-
-`appId` and the nested `provision` section are state-aware-only and are
-rejected on one-shot requests. Process options (`cwd`, `env`, `timeout`) remain
-in the top-level `process` section.
+The one-shot surface takes **no backend configuration at all** — there is no
+`experimental.isolation_session` field the one-shot path reads. The Entra
+`user` bundle is state-aware-only, so supplying it here is just an
+unrecognised key in the deliberately permissive `experimental` block and is
+ignored (the run proceeds as a local, non-Entra agent). Process options
+(`cwd`, `env`, `timeout`) read from the existing top-level `process` section,
+matching the contract every other backend honors.
 
-Run with: `wxc-exec.exe config.json`.
+Run with: `wxc-exec.exe --experimental config.json`.
 
 ## OS API Dependency
 
@@ -153,8 +158,62 @@ The runner calls into the WinRT API namespaced
 Session service (running as SYSTEM via `svchost.exe`). The API is gated
 on an internal Windows feature flag.
 
-Activation goes through the WinRT activation factory for the
-`Windows.AI.IsolationSession.Preview` `IsoSessionOps` runtime class.
+### Two activation paths and the selection rule
+
+The runtime class `IsoSessionOps` (and `IsoSessionProcessOptions`) can be
+activated two ways, both funneled through
+`src/backends/isolation_session/common/src/regfree.rs`:
+
+1. **Coresident explicit load (preferred when present).** MXC
+   `LoadLibraryExW`s the MSI-installed `IsoSessionApp.dll` **by full path**
+   and calls its `DllGetActivationFactory` export directly, bypassing the
+   WinRT activation catalog. This binds the MSI-installed runtime — the App
+   DLL's coresidency logic then sibling-loads the MSI `IsoSessionClient.dll`
+   and the matching side-by-side service instance. No machine-wide registry
+   mutation is involved. This is what lets a packaged product (openclaw)
+   ship and run a specific runtime version without touching the inbox
+   binaries.
+
+2. **Default system activation (fallback).** When no coresident
+   `IsoSessionApp.dll` is present at the runtime folder, activation falls
+   back to `IsoSessionOps::new()`, which resolves through the OS WinRT
+   activation catalog to the inbox `System32` binaries.
+
+**Selection rule.** `regfree::activate_from_runtime_dir` resolves the runtime
+folder (see *Runtime folder resolution* below), then:
+
+- **absent** at the default folder → fall back to system activation (a host
+  without the paired MSI keeps working);
+- **loaded** → use the coresident factory;
+- **present or explicitly configured but unloadable** (wrong architecture,
+  missing dependency, corrupt image, or an explicit override whose folder
+  does not resolve) → the error is **surfaced**, never silently redirected to
+  the inbox binaries — otherwise MXC would bind a *different* binary set under
+  the guise of success.
+
+### Runtime folder resolution
+
+The coresident folder is `DEFAULT_RUNTIME_DIR`
+(`C:\Program Files\Microsoft\Agentic Runtime\2026.08` — the fixed MSI install
+location) unless overridden by the `MXC_ISOSESSION_RUNTIME_DIR` environment
+variable:
+
+| Variable | Effect |
+|---|---|
+| `MXC_ISOSESSION_RUNTIME_DIR` | Absolute path to the folder holding the coresident runtime binaries (`IsoSessionApp.dll`, `IsoSessionClient.dll`, `IsoSession.manifest`, …). Intended for tests and side-by-side validation machines. **Must be absolute** — a relative value is rejected (with a warning) and the default is used, because the value is also the DLL dependency search root and a relative value would make it CWD-relative (a DLL-planting surface). When set to an absolute path it is *authoritative*: if its folder does not resolve, the run fails rather than silently binding the inbox runtime. |
+| `DEFAULT_RUNTIME_DIR` (compile-time constant, not an env var) | The hardcoded MSI install location used when the override is unset/empty/rejected. |
+
+### Apartment initialization
+
+The coresident path obtains the factory via `DllGetActivationFactory` and
+calls `IActivationFactory::ActivateInstance` directly — which, unlike the
+inbox `RoActivateInstance` path, does **not** implicitly initialize the
+WinRT/COM apartment. `src/core/wxc/src/main.rs` calls
+`CoInitializeEx(COINIT_MULTITHREADED)` at startup, and `regfree.rs`
+additionally calls `CoInitializeEx` (best-effort; `S_FALSE` /
+`RPC_E_CHANGED_MODE` ignored) before activation so the factory's internal COM
+activation (coresident client → service) has an initialized apartment even on
+the `--probe` path, which returns before `main`'s initialization.
 
 The API surface includes the lifecycle methods plus
 `IsoSessionProcess` (the running-process handle). The runner uses the
@@ -207,12 +266,11 @@ versions and stating that the bindings must be regenerated.
 **Implemented:**
 
 - Single-shot `provision → start → run → stop → deprovision` lifecycle,
-  selected directly by the exact v0.9 contract.
+  gated by `--experimental`.
 - `process.commandLine` (the script command, wrapped via `cmd.exe /c "..."`
   — the same pattern the LXC runner uses with `/bin/sh -c`).
 - `process.cwd` (working directory inside the session).
-- `process.env` with `process.inheritDefaultEnv: true` (the entries are layered
-  over the agent user's default environment through the OS-side
+- `process.env` (environment variables forwarded via the OS-side
   `IsoSessionProcessOptions`).
 - `process.timeout` (forwarded to the OS-side per-process timeout
   enforcement).
@@ -223,15 +281,12 @@ versions and stating that the bindings must be regenerated.
 - `lifecycle.destroyOnExit: false` and `lifecycle.preservePolicy: true`. The
   in-proc API exposes no session-lifetime knob, so the backend cannot vary
   teardown: the one-shot path always stops the session and removes the agent
-  user. `destroyOnExit: true` (the default) is therefore
+  user before returning. `destroyOnExit: true` (the default) is therefore
   accepted because it matches actual behavior; `false` is refused. There is no
   filesystem or network policy to preserve (both are rejected outright), so
   `preservePolicy: true` is refused as meaningless here.
 - `ui` (any value). The backend has no UI-restriction primitive — see the
   cross-cutting policy honor matrix below.
-- `process.env` without `process.inheritDefaultEnv: true`, including `[]`.
-  Every process starts from the agent user's default environment, which the
-  backend cannot replace or empty.
 
 ## Cross-cutting policy honor matrix (one-shot)
 
@@ -242,24 +297,23 @@ the rationale for each disposition, and the error mapping live in
 | Field | one-shot disposition |
 |---|---|
 | `process.commandLine` | **honored** (required) |
-| `process.cwd` / `process.timeout` | **honored** |
-| `process.env` | **honored** with `process.inheritDefaultEnv: true`; rejected without it, including `[]` |
+| `process.cwd` / `process.env` / `process.timeout` | **honored** |
 | `filesystem.{readwritePaths,readonlyPaths,deniedPaths}` | rejected — no host-folder-sharing primitive |
-| `network` — directional all-allow (`egress.default`, `ingress.default`, and `ingress.hostLoopback` all `allow`, no rules) | **required** |
-| `network` — legacy fields, absent, empty, restrictive, mixed, rule-bearing, or proxy-bearing | rejected |
+| `network` — canonical unrestricted acknowledgment (`defaultPolicy=allow` + `allowLocalNetwork=true`, no host rules, no proxy, default enforcement) | **required** |
+| `network` — anything else, including absent (defaults to the unenforceable `block`) | rejected |
 | `ui` | rejected if supplied — no `ui` posture is truthful here (see below); an omitted `ui` is accepted and applies no restriction |
 | `lifecycle.destroyOnExit` | `true` accepted (matches behavior); `false` rejected |
 | `lifecycle.preservePolicy` | `false` accepted; `true` rejected |
 | `fallback.allowDaclMutation` | n/a — AppContainer-only; this backend never mutates DACLs, so either value is vacuously satisfied |
 | `containerId` | accepted, no effect (a label; the backend addresses sandboxes by the OS-assigned agent user name) |
-| `isolationSession` / one-shot `appId` | rejected as `malformed_request` — IsolationSession one-shot configuration uses only the stable top-level policy |
+| `experimental.isolation_session.user` | accepted, ignored — Entra is state-aware-only, and one-shot reads no backend config |
+| `experimental.isolation_session.{provision,start}` | accepted, ignored — per-phase config is state-aware-only |
 | `processContainer` / `lxc` / `seatbelt` / another backend's section | rejected — only the section matching `containment` is accepted |
 
 Refusals surface as a non-zero exit with the reason on stderr. One-shot has no
 typed policy error code: the envelope carries `error.code = "backend_error"` with
-the reason in the message. On the state-aware surface, structurally
-representable backend policy failures emit `policy_validation`; fields excluded
-by an exact phase root fail earlier as `malformed_request`.
+the reason in the message, unlike the state-aware surface which emits
+`policy_validation`.
 
 **Why every supplied `ui` is refused.** The `ui` section states intent about the
 contained code's relationship to the *user's* environment, and was modelled on a
@@ -279,11 +333,12 @@ The full field-by-field table is in
 
 **Deferred to follow-up work:**
 
-- **C# one-shot SDK support.** The Rust SDK already supports one-shot `run` and
-  `spawn_sandbox` behind the `isolation_session` feature. The Node JSON/config
-  path (`spawnSandboxFromConfig`) and
-  `wxc-exec` support the required network posture. The C# SDK still reaches
-  IsolationSession only through the state-aware lifecycle APIs.
+- **TypeScript SDK exposure.** Adding a one-shot isolation-session config
+  surface to `SandboxSpawnOptions` so the SDK can spawn isolation-session
+  workloads programmatically **on the one-shot path**. Today the one-shot
+  backend is reachable only via JSON config (`spawnSandboxFromConfig` or
+  `wxc-exec` directly), and it takes no backend configuration; the
+  state-aware lifecycle *is* SDK-exposed.
 
 ## Test Plan
 
@@ -291,8 +346,8 @@ The full field-by-field table is in
 
 | Category | Location | What it verifies |
 |---|---|---|
-| Config parsing | `config_parser.rs` | Directional network shape, closure, legacy-field removal, and phase-specific field rejection |
-| Policy validation | `policy.rs` | Filesystem/UI rejection; directional unrestricted form; empty/restrictive/mixed policy rejection; unchanged post-provision rules; `process.env` without `inheritDefaultEnv` rejection |
+| Config parsing | `config_parser.rs` | The `"isolation_session"` containment value; a stray `experimental.isolation_session` payload is accepted and ignored |
+| Policy validation | `policy.rs` | Filesystem fields (`readwritePaths` / `readonlyPaths` / `deniedPaths`) are rejected at every phase; the network policy must be the canonical unrestricted-network acknowledgment (`defaultPolicy=allow` + `allowLocalNetwork=true`, no host rules or proxy) at provision, and any supplied network policy is rejected post-provision |
 | Option building | `process_options.rs` | `ExecutionRequest` → `ProcessOptions` mapping (timeout, cwd, env vars, redirect flags) |
 | Feature unavailable | `manager.rs` | Runner returns a clean error on machines without the IsolationSession feature enabled, so the test passes everywhere |
 
@@ -313,7 +368,7 @@ Two end-to-end configs live under `tests/configs/`:
   exit code 42 propagates to `ScriptResponse.exit_code`.
 
 A test runner at `tests/scripts/run_isolation_session_tests.ps1` invokes
-both configs via `wxc-exec.exe`, validates exit codes and
+both configs via `wxc-exec.exe --experimental`, validates exit codes and
 expected output substrings, and reports a pass/fail summary. Pattern
 follows the existing per-backend integration scripts (e.g.
 `run_microvm_tests.ps1`, `run_wslc_all_tests.ps1`).
@@ -354,18 +409,26 @@ The following were observed during VM testing and are accepted for v0.1.
 | OS API not present on older Windows builds | the IsolationSession feature is OS-side; runner reports a clean error when the activation factory fails. Feature-unavailable test exercises this on CI |
 | New Cargo feature increases coupling | The `isolation_session` feature is off by default in the workspace; default builds and existing CI are unaffected |
 | Manual VM testing required | The OS-side service has the same constraint for any consumer (it rejects network-logon tokens). Automated suite covers what it can without the OS-side service |
-| One-shot lifecycle is heavy (full provision → start per call) | Inherent to the one-shot path. The state-aware lifecycle is the mitigation — it provisions once and reuses the session across `exec` calls |
-| Session lifetime is not caller-controllable | The in-proc API exposes no lifetime knob, so `lifecycle.destroyOnExit: false` cannot be honored. The one-shot path always stops the session and removes the agent user |
+| One-shot lifecycle is heavy (full provision → start per call) | Inherent to the one-shot path; the experimental flag indicates rough edges. The state-aware lifecycle is the mitigation — it provisions once and reuses the session across `exec` calls |
+| Session lifetime is not caller-controllable | The in-proc API exposes no lifetime knob, so `lifecycle.destroyOnExit: false` cannot be honored. The one-shot path always stops the session and removes the agent user before returning |
 
 ## Prerequisites
 
 **For end users:**
 
 - A Windows build with the IsolationSession feature enabled.
-- The OS-side isolation-session host binary present in
-  `%SystemRoot%\System32\` (ships with Windows as part of the OS-side
-  service).
-- WinRT initialized as MTA (handled by `wxc-exec`).
+- The isolation-session runtime binaries available via **one** of:
+  - the paired **MSI** installed at `DEFAULT_RUNTIME_DIR`
+    (`C:\Program Files\Microsoft\Agentic Runtime\2026.08`), which MXC binds
+    coresidently by path (preferred — this is how a packaged product ships a
+    specific runtime version); or
+  - the OS-side inbox host binaries in `%SystemRoot%\System32\` (ships with
+    Windows), used as the fallback when no MSI runtime is present.
+- WinRT/COM initialized as MTA (handled by `wxc-exec` and `regfree.rs`).
+
+Set `MXC_ISOSESSION_RUNTIME_DIR` (absolute path) to point at a specific
+runtime folder for tests or side-by-side validation; see *OS API Dependency →
+Runtime folder resolution*.
 
 **For developers:**
 
@@ -379,14 +442,14 @@ The following were observed during VM testing and are accepted for v0.1.
 
 ```powershell
 # Minimal config: print the agent identity inside the session
-wxc-exec.exe hello.json
+wxc-exec.exe --experimental hello.json
 ```
 
 `hello.json`:
 
 ```json
 {
-  "version": "0.9.0-alpha",
+  "version": "0.6.0-alpha",
   "containerId": "Hello",
   "containment": "isolation_session",
   "process": {
@@ -394,8 +457,11 @@ wxc-exec.exe hello.json
     "timeout": 30000
   },
   "network": {
-    "egress": { "default": "allow" },
-    "ingress": { "default": "allow", "hostLoopback": "allow" }
+    "defaultPolicy": "allow",
+    "allowLocalNetwork": true
+  },
+  "experimental": {
+    "isolation_session": {}
   }
 }
 ```
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
index 1c3a7be5a..3cba87dd6 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
@@ -86,8 +86,8 @@ unsafe impl Sync for MtaReference {}
 /// runtime folder, binding the MSI-installed runtime instead of the inbox
 /// `System32` one; otherwise it falls back to default system activation.
 fn check_service_available_and_activate() -> Result<IsoSessionOps, IsolationSessionError> {
-    let activated =
-        super::regfree::activate_from_runtime_dir::<IsoSessionOps>().unwrap_or_else(IsoSessionOps::new);
+    let activated = super::regfree::activate_from_runtime_dir::<IsoSessionOps>()
+        .unwrap_or_else(IsoSessionOps::new);
 
     match activated {
         Ok(ops) => Ok(ops),
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
index 7f232d6c8..0bcda8aa4 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
@@ -17,30 +17,51 @@
 //! dynamic reg-free activation context is *shadowed* by the system catalog, so
 //! `RoGetActivationFactory` still loads the `System32` binaries. Loading the
 //! activation factory directly from the MSI copy of `IsoSessionApp.dll`
-//! (`LoadLibraryW` by full path + `DllGetActivationFactory`) guarantees the
+//! (`LoadLibraryExW` by full path + `DllGetActivationFactory`) guarantees the
 //! MSI-installed binary is the one used. Its coresidency logic then
 //! sibling-loads the MSI `IsoSessionClient.dll` and binds the matching service
 //! instance -- no machine-wide registry mutation is involved.
 //!
-//! Coupling to the install path: [`runtime_dir`] returns the
-//! [`RUNTIME_DIR_ENV`] override when set, otherwise the hardcoded
-//! [`DEFAULT_RUNTIME_DIR`] (the fixed MSI install location the openclaw
-//! packager targets). When neither the override nor the default folder
-//! contains a loadable `IsoSessionApp.dll`, activation cleanly falls back to
-//! the default system activation, so hosts without the MSI keep working.
+//! Search-order safety: a full-path `LoadLibrary*` pins only the top-level
+//! module; that module's own imports are otherwise resolved through the
+//! default search order (the `wxc-exec.exe` directory, System32, the current
+//! directory, and `PATH`) -- none of which is the MSI runtime folder, and one
+//! of which (CWD) is caller-controlled via the SDK `workingDirectory`. To
+//! defeat DLL-planting and to keep coresidency honest, the App DLL is loaded
+//! with `LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32`, so
+//! its dependencies (including the sibling MSI `IsoSessionClient.dll`, whether
+//! resolved as a static/delay import or by the App DLL's own path-relative
+//! load) are searched only in the MSI runtime folder and System32 -- never the
+//! app dir, CWD, or `PATH`. This mirrors the anti-hijack loads in
+//! `base_container_runner.rs`, `learning_mode/.../ffi.rs`, and `secenv.rs`,
+//! and satisfies the search-order-hijacking guidance recorded in
+//! `fallback_detector.rs`.
+//!
+//! Coupling to the install path: [`resolve_runtime_dir`] returns the
+//! [`RUNTIME_DIR_ENV`] override when set, non-empty, **and absolute**,
+//! otherwise the hardcoded [`DEFAULT_RUNTIME_DIR`] (the fixed MSI install
+//! location the openclaw packager targets). A non-absolute override is
+//! rejected (it would make even the top-level DLL path CWD-relative). When
+//! neither the override nor the default folder contains a loadable
+//! `IsoSessionApp.dll`, activation cleanly falls back to the default system
+//! activation, so hosts without the MSI keep working.
 
 use core::ffi::c_void;
 use std::sync::OnceLock;
 
-use windows::Win32::Foundation::{E_NOINTERFACE, HMODULE};
+use windows::Win32::Foundation::{GetLastError, ERROR_FILE_NOT_FOUND, E_FAIL, E_POINTER, HMODULE};
 use windows::Win32::System::Com::{CoInitializeEx, COINIT_MULTITHREADED};
-use windows::Win32::System::LibraryLoader::{GetProcAddress, LoadLibraryW};
+use windows::Win32::System::LibraryLoader::{
+    GetProcAddress, LoadLibraryExW, LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR, LOAD_LIBRARY_SEARCH_SYSTEM32,
+};
 use windows::Win32::System::WinRT::IActivationFactory;
-use windows_core::{Interface, RuntimeName, HSTRING, PCSTR, PCWSTR};
+use windows_core::{Interface, RuntimeName, HRESULT, HSTRING, PCSTR, PCWSTR};
 
 /// Environment variable that points MXC at the folder holding the coresident
 /// IsoSession runtime binaries (`IsoSessionApp.dll`, `IsoSessionClient.dll`,
-/// `IsoSession.manifest`, ...). Overrides [`DEFAULT_RUNTIME_DIR`] when set.
+/// `IsoSession.manifest`, ...). Overrides [`DEFAULT_RUNTIME_DIR`] when set to a
+/// non-empty **absolute** path; a relative value is rejected (see
+/// [`runtime_dir`]).
 pub const RUNTIME_DIR_ENV: &str = "MXC_ISOSESSION_RUNTIME_DIR";
 
 /// The fixed location the paired IsoSession MSI installs its runtime to, and
@@ -56,113 +77,254 @@ const APP_DLL_NAME: &str = "IsoSessionApp.dll";
 /// Standard WinRT in-proc activation entrypoint exported by `IsoSessionApp.dll`.
 const ACTIVATION_FACTORY_EXPORT: &[u8] = b"DllGetActivationFactory\0";
 
+/// Human-readable form of [`ACTIVATION_FACTORY_EXPORT`] for diagnostics.
+const ACTIVATION_FACTORY_EXPORT_NAME: &str = "DllGetActivationFactory";
+
 /// Signature of `DllGetActivationFactory`. The first parameter is an `HSTRING`
 /// activatable class id (passed by value as its pointer-sized handle); the
 /// second receives an `IActivationFactory*`.
 type PfnDllGetActivationFactory =
     unsafe extern "system" fn(*mut c_void, *mut *mut c_void) -> windows_core::HRESULT;
 
-/// Cached `HMODULE` of the explicitly-loaded `IsoSessionApp.dll`, stored as a
-/// `usize` so the static is `Send + Sync`. `None` means no runtime folder held
-/// a loadable `IsoSessionApp.dll`.
-static APP_DLL: OnceLock<Option<usize>> = OnceLock::new();
-
-/// Resolves the coresident runtime folder: the [`RUNTIME_DIR_ENV`] override
-/// when set and non-empty, otherwise the hardcoded [`DEFAULT_RUNTIME_DIR`].
-fn runtime_dir() -> String {
-    match std::env::var(RUNTIME_DIR_ENV) {
-        Ok(value) if !value.trim().is_empty() => value.trim().to_string(),
-        _ => DEFAULT_RUNTIME_DIR.to_string(),
+/// Outcome of resolving + loading the coresident `IsoSessionApp.dll`, computed
+/// once per process.
+enum RuntimeLoad {
+    /// The default runtime folder holds no `IsoSessionApp.dll` (a host without
+    /// the paired MSI). Activation cleanly falls back to default system
+    /// activation, so such hosts keep working.
+    Absent,
+    /// `IsoSessionApp.dll` loaded from `path`. `raw` is its `HMODULE` as a
+    /// `usize` so the cache is `Send + Sync`.
+    Loaded { raw: usize, path: String },
+    /// The DLL is present (or an explicit [`RUNTIME_DIR_ENV`] override was
+    /// configured) but could not be resolved or loaded. This is a
+    /// broken-runtime condition that must be surfaced to the caller, never
+    /// silently redirected to the inbox binaries -- doing so would bind a
+    /// *different* binary set under the guise of success. `code`/`detail` carry
+    /// the failure.
+    Unloadable { code: HRESULT, detail: String },
+}
+
+/// Cached load outcome, computed once per process.
+static APP_DLL: OnceLock<RuntimeLoad> = OnceLock::new();
+
+/// Pure resolution of the runtime folder from a raw [`RUNTIME_DIR_ENV`] value.
+///
+/// Returns `(dir, explicit)`:
+/// - `explicit == true` only when an **absolute** override was honored; such a
+///   value is authoritative -- a load failure under it is surfaced rather than
+///   silently ignored (see [`load_app_dll`]).
+/// - An unset, empty/whitespace, or **non-absolute** override yields
+///   [`DEFAULT_RUNTIME_DIR`] with `explicit == false`. A relative value is
+///   rejected because it is used both to build the top-level DLL path and as
+///   the dependency search root, so honoring it would make both CWD-relative --
+///   a DLL-planting surface.
+///
+/// Kept free of environment access so every branch is unit-testable without
+/// mutating process-global state.
+fn resolve_runtime_dir(raw: Option<&str>) -> (String, bool) {
+    match raw {
+        Some(value) if !value.trim().is_empty() => {
+            let trimmed = value.trim();
+            if std::path::Path::new(trimmed).is_absolute() {
+                (trimmed.to_string(), true)
+            } else {
+                (DEFAULT_RUNTIME_DIR.to_string(), false)
+            }
+        }
+        _ => (DEFAULT_RUNTIME_DIR.to_string(), false),
     }
 }
 
+/// Builds the full `IsoSessionApp.dll` path for a runtime folder, collapsing any
+/// trailing backslashes so the join never produces a doubled separator.
+fn app_dll_path(dir: &str) -> String {
+    format!("{}\\{}", dir.trim_end_matches('\\'), APP_DLL_NAME)
+}
+
+/// Whether success-path diagnostics should print. Gated on the crate's existing
+/// diagnostic switch (`MXC_DIAG_CONSOLE`) so that normal operation -- notably a
+/// host without the paired MSI -- stays silent and does not contaminate the
+/// output stream the SDK consumer sees. Error-path messages are emitted
+/// unconditionally.
+fn success_diag_enabled() -> bool {
+    wxc_common::diagnostic::DiagnosticConfig::from_environment().console_enabled
+}
+
 /// Loads `<runtime_dir>\IsoSessionApp.dll` by full path exactly once and
 /// returns its module handle. Returns `None` when the DLL is absent or cannot
 /// be loaded (caller then falls back to default system activation).
-fn app_dll_handle() -> Option<HMODULE> {
-    let cached = APP_DLL.get_or_init(|| {
-        let dir = runtime_dir();
-        let path = format!("{}\\{}", dir.trim_end_matches('\\'), APP_DLL_NAME);
+/// Resolves and loads `<runtime_dir>\IsoSessionApp.dll`, classifying the result
+/// into [`RuntimeLoad`]. Invoked exactly once via the [`APP_DLL`] `OnceLock`.
+///
+/// A non-absolute [`RUNTIME_DIR_ENV`] override is rejected up front (with a
+/// warning) and treated as unset. An **explicit** absolute override is
+/// authoritative: if its DLL is absent or fails to load, that is reported as
+/// `Unloadable` rather than falling back to the inbox runtime. The default
+/// folder being empty, by contrast, is the normal "no MSI on this host" case
+/// and yields `Absent`. A DLL that is present but fails to load (wrong
+/// architecture, missing dependency, corrupt image, ...) is likewise
+/// `Unloadable` -- surfaced, never silently redirected to a different binary
+/// set.
+fn load_app_dll() -> RuntimeLoad {
+    let raw = std::env::var(RUNTIME_DIR_ENV).ok();
 
-        if !std::path::Path::new(&path).exists() {
+    // Warn once if an override was supplied but rejected for being relative.
+    if let Some(value) = raw.as_deref() {
+        let trimmed = value.trim();
+        if !trimmed.is_empty() && !std::path::Path::new(trimmed).is_absolute() {
+            eprintln!(
+                "[mxc isosession] ignoring non-absolute {}='{}'; using default \
+                 runtime dir '{}'.",
+                RUNTIME_DIR_ENV, trimmed, DEFAULT_RUNTIME_DIR
+            );
+        }
+    }
+
+    let (dir, explicit) = resolve_runtime_dir(raw.as_deref());
+    let path = app_dll_path(&dir);
+
+    if !std::path::Path::new(&path).exists() {
+        if explicit {
+            // An explicit override that does not resolve is authoritative: the
+            // operator asked for a specific runtime and it is not there. Surface
+            // it instead of silently binding the inbox binaries.
+            return RuntimeLoad::Unloadable {
+                code: HRESULT::from_win32(ERROR_FILE_NOT_FOUND.0),
+                detail: format!(
+                    "{}='{}' but {} does not exist at '{}'",
+                    RUNTIME_DIR_ENV, dir, APP_DLL_NAME, path
+                ),
+            };
+        }
+        if success_diag_enabled() {
             eprintln!(
                 "[mxc isosession] {} not found at '{}'; using system activation.",
                 APP_DLL_NAME, path
             );
-            return None;
         }
+        return RuntimeLoad::Absent;
+    }
 
-        let path_w = HSTRING::from(path.as_str());
+    let path_w = HSTRING::from(path.as_str());
 
-        // SAFETY: `path_w` is a valid NUL-terminated wide string that outlives
-        // the call. Loading by full path makes the MSI-installed copy of the
-        // DLL the one mapped regardless of any inbox WinRT catalog
-        // registration.
-        match unsafe { LoadLibraryW(PCWSTR(path_w.as_ptr())) } {
-            Ok(hmod) if !hmod.is_invalid() => {
+    // SAFETY: `path_w` is a valid NUL-terminated wide string that outlives
+    // the call. Loading by full path makes the MSI-installed copy of the
+    // DLL the one mapped regardless of any inbox WinRT catalog
+    // registration. `LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR` (valid because the
+    // path is absolute -- guaranteed by `resolve_runtime_dir`) makes the MSI
+    // runtime folder the search root for the App DLL's own dependencies,
+    // and `LOAD_LIBRARY_SEARCH_SYSTEM32` permits genuine system imports;
+    // together they exclude the `wxc-exec.exe` directory, the current
+    // directory, and `PATH` from dependency resolution, so a planted DLL
+    // cannot hijack the coresident client/service load.
+    match unsafe {
+        LoadLibraryExW(
+            PCWSTR(path_w.as_ptr()),
+            None,
+            LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32,
+        )
+    } {
+        Ok(hmod) if !hmod.is_invalid() => {
+            if success_diag_enabled() {
                 eprintln!(
                     "[mxc isosession] explicitly loaded {} from '{}'",
                     APP_DLL_NAME, path
                 );
-                Some(hmod.0 as usize)
             }
-            Ok(_) => None,
-            Err(e) => {
-                eprintln!(
-                    "[mxc isosession] LoadLibraryW('{}') failed: {}; \
-                     using system activation.",
-                    path, e
-                );
-                None
+            RuntimeLoad::Loaded {
+                raw: hmod.0 as usize,
+                path,
             }
         }
-    });
-
-    cached.map(|raw| HMODULE(raw as *mut c_void))
+        // Present but did not load: a broken runtime, not an absent one. Surface
+        // it rather than falling back to the inbox binaries.
+        Ok(_) => RuntimeLoad::Unloadable {
+            code: E_FAIL,
+            detail: format!("LoadLibraryExW('{}') returned an invalid handle", path),
+        },
+        Err(e) => {
+            eprintln!("[mxc isosession] LoadLibraryExW('{}') failed: {}", path, e);
+            RuntimeLoad::Unloadable {
+                code: e.code(),
+                detail: format!("LoadLibraryExW('{}') failed: {}", path, e),
+            }
+        }
+    }
 }
 
 /// Activates the WinRT runtime class `T` by obtaining its activation factory
 /// **directly** from the coresident `IsoSessionApp.dll`, bypassing the WinRT
 /// activation catalog.
 ///
-/// Returns `None` when no coresident `IsoSessionApp.dll` was loadable (caller
-/// falls back to the default `T::new()` system activation). Returns
-/// `Some(Err(..))` when the DLL loaded but the explicit activation failed --
-/// the caller should surface that rather than silently fall back to a
-/// different binary set.
+/// Returns `None` only when no coresident `IsoSessionApp.dll` is present at the
+/// default location (caller falls back to the default `T::new()` system
+/// activation). Returns `Some(Err(..))` when a runtime folder was configured or
+/// present but could not be loaded, or the explicit activation failed -- the
+/// caller must surface that rather than silently fall back to a different
+/// binary set.
 pub(crate) fn activate_from_runtime_dir<T>() -> Option<windows_core::Result<T>>
 where
     T: Interface + RuntimeName,
 {
-    let hmod = app_dll_handle()?;
+    let (raw, path) = match APP_DLL.get_or_init(load_app_dll) {
+        RuntimeLoad::Absent => return None,
+        RuntimeLoad::Unloadable { code, detail } => {
+            return Some(Err(windows_core::Error::new(*code, detail.clone())));
+        }
+        RuntimeLoad::Loaded { raw, path } => (*raw, path.as_str()),
+    };
+
+    let hmod = HMODULE(raw as *mut c_void);
 
     // Unlike the inbox `RoActivateInstance` path (which implicitly initializes
     // the WinRT/COM apartment), obtaining the factory via
     // `DllGetActivationFactory` and calling `IActivationFactory::ActivateInstance`
     // directly does NOT. The factory's activation internally performs COM
     // activation (coresident client -> service), which requires an initialized
-    // apartment, so ensure one exists first. Best-effort: `S_FALSE`
-    // (already initialized) and `RPC_E_CHANGED_MODE` (a different apartment
-    // model is already in force, which is fine to reuse) are both ignored.
+    // apartment, so ensure one exists first.
     //
-    // SAFETY: `CoInitializeEx` is safe to call with a null reserved pointer;
-    // its refcount is balanced by process teardown (the runtime lives for the
-    // process lifetime, matching the leaked module handle above).
+    // SAFETY: `CoInitializeEx` is safe to call with a null reserved pointer. We
+    // intentionally do NOT pair it with a `CoUninitialize`: `wxc-exec`'s `main`
+    // already initializes an MTA, so the expected result here is `S_FALSE`
+    // (already initialized), which still increments this thread's COM init
+    // count. We deliberately leak that one increment for the process lifetime
+    // (matching the leaked module handle above); process teardown reclaims the
+    // resources but is not itself a balancing `CoUninitialize`.
+    // `RPC_E_CHANGED_MODE` (a different apartment model already in force) is
+    // likewise ignored -- the existing apartment is reused. If this backend is
+    // ever compiled into the embeddable SDK (where the host owns thread
+    // apartments), replace this with the `ComApartment` RAII guard used by
+    // `appcontainer/common/src/network_manager.rs`.
     unsafe {
         let _ = CoInitializeEx(None, COINIT_MULTITHREADED);
     }
 
-    Some(activate_via_factory::<T>(hmod))
+    Some(activate_via_factory::<T>(hmod, path))
 }
 
-fn activate_via_factory<T>(hmod: HMODULE) -> windows_core::Result<T>
+fn activate_via_factory<T>(hmod: HMODULE, dll_path: &str) -> windows_core::Result<T>
 where
     T: Interface + RuntimeName,
 {
     // SAFETY: `hmod` is a valid module handle and the export name is a static
     // NUL-terminated byte string.
     let proc = unsafe { GetProcAddress(hmod, PCSTR(ACTIVATION_FACTORY_EXPORT.as_ptr())) }
-        .ok_or_else(|| windows_core::Error::from(E_NOINTERFACE))?;
+        .ok_or_else(|| {
+            // A missing export is a broken/incompatible DLL, not a
+            // "no such interface" condition. Report the real Win32 failure and
+            // name the export + DLL so an investigator looks at the right layer.
+            // SAFETY: called immediately after the failed `GetProcAddress`, so
+            // `GetLastError` still reflects that failure.
+            let win32 = unsafe { GetLastError() };
+            windows_core::Error::new(
+                HRESULT::from_win32(win32.0),
+                format!(
+                    "export '{}' not found in '{}'",
+                    ACTIVATION_FACTORY_EXPORT_NAME, dll_path
+                ),
+            )
+        })?;
 
     // SAFETY: `DllGetActivationFactory` matches `PfnDllGetActivationFactory`.
     let factory_fn: PfnDllGetActivationFactory = unsafe { core::mem::transmute(proc) };
@@ -181,14 +343,31 @@ where
     let hr = unsafe { factory_fn(class_id_raw, &mut factory_raw) };
     if let Err(e) = hr.ok() {
         eprintln!(
-            "[mxc isosession] DllGetActivationFactory('{}') failed: {}",
+            "[mxc isosession] DllGetActivationFactory('{}') in '{}' failed: {}",
             <T as RuntimeName>::NAME,
+            dll_path,
             e
         );
         return Err(e);
     }
 
-    // SAFETY: on success `factory_raw` is a valid, owned `IActivationFactory`.
+    // A DLL that reports success while leaving the out-param null would cause a
+    // null-vtable dereference at `ActivateInstance`. Since the whole point of
+    // this module is loading a DLL from a path that may hold something
+    // unexpected, verify the invariant rather than assume it.
+    if factory_raw.is_null() {
+        return Err(windows_core::Error::new(
+            E_POINTER,
+            format!(
+                "DllGetActivationFactory('{}') in '{}' returned success but a null factory",
+                <T as RuntimeName>::NAME,
+                dll_path
+            ),
+        ));
+    }
+
+    // SAFETY: `factory_raw` is non-null (checked above) and, per the WinRT ABI,
+    // a valid owned `IActivationFactory` on a success HRESULT.
     let factory = unsafe { IActivationFactory::from_raw(factory_raw) };
 
     // SAFETY: factory came from the runtime class's own DLL.
@@ -213,3 +392,59 @@ where
         e
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn resolve_runtime_dir_unset_uses_default() {
+        let (dir, explicit) = resolve_runtime_dir(None);
+        assert_eq!(dir, DEFAULT_RUNTIME_DIR);
+        assert!(!explicit, "an unset override is not authoritative");
+    }
+
+    #[test]
+    fn resolve_runtime_dir_whitespace_uses_default() {
+        let (dir, explicit) = resolve_runtime_dir(Some("   "));
+        assert_eq!(dir, DEFAULT_RUNTIME_DIR);
+        assert!(!explicit, "a whitespace-only override is not authoritative");
+    }
+
+    #[test]
+    fn resolve_runtime_dir_relative_is_rejected() {
+        let (dir, explicit) = resolve_runtime_dir(Some(r"relative\runtime"));
+        assert_eq!(
+            dir, DEFAULT_RUNTIME_DIR,
+            "a relative override must be rejected, not honored"
+        );
+        assert!(!explicit, "a rejected override must not be authoritative");
+    }
+
+    #[test]
+    fn resolve_runtime_dir_absolute_is_honored_and_explicit() {
+        let (dir, explicit) = resolve_runtime_dir(Some(r"D:\rt\iso"));
+        assert_eq!(dir, r"D:\rt\iso");
+        assert!(explicit, "an absolute override is authoritative");
+    }
+
+    #[test]
+    fn resolve_runtime_dir_trims_surrounding_whitespace() {
+        let (dir, explicit) = resolve_runtime_dir(Some("  C:\\rt  "));
+        assert_eq!(dir, r"C:\rt");
+        assert!(explicit);
+    }
+
+    #[test]
+    fn app_dll_path_uses_single_separator() {
+        assert_eq!(app_dll_path(r"C:\rt"), format!(r"C:\rt\{}", APP_DLL_NAME));
+    }
+
+    #[test]
+    fn app_dll_path_collapses_trailing_backslashes() {
+        let expected = format!(r"C:\rt\{}", APP_DLL_NAME);
+        assert_eq!(app_dll_path(r"C:\rt\"), expected);
+        assert_eq!(app_dll_path(r"C:\rt\\"), expected);
+        assert_eq!(app_dll_path(r"C:\rt\\\"), expected);
+    }
+}

From 8b480b74f583d8bd28ace7bff83af32171494053 Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Thu, 6 Aug 2026 20:18:51 -0700
Subject: [PATCH 03/26] isosession: emit ungated diagnostic on fail-closed
 explicit override

When MXC_ISOSESSION_RUNTIME_DIR is set explicitly but IsoSessionApp.dll
does not exist there, load_app_dll() returns Unloadable (fail-closed,
no inbox fallback) -- correct, but previously silent. The manager drops
the error detail, so the operator got availability=false with no reason.

Emit an ungated eprintln naming the env var, the missing DLL, and the
resolved path, matching the existing ungated `LoadLibraryExW failed`
convention (a misconfiguration is not success-path diagnostic spam).
detail is now computed once and reused for both the eprintln and the
Unloadable struct.

Validated on VM iso-sf2-repro-0 against Eric's MSI (Agentic Runtime
2026.08): 5/5 binding cases pass (A default->MSI, B bogus override->
fail-closed with this diagnostic, C alt-path override, D coresident
client via System32-client-removal, E default-absent->inbox fallback).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: f5cc2011-5308-43d6-a8ea-2b8ed9b6ceb3
---
 .../isolation_session/common/regfree.rs         | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
index 0bcda8aa4..54ac63b33 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
@@ -188,13 +188,20 @@ fn load_app_dll() -> RuntimeLoad {
         if explicit {
             // An explicit override that does not resolve is authoritative: the
             // operator asked for a specific runtime and it is not there. Surface
-            // it instead of silently binding the inbox binaries.
+            // it instead of silently binding the inbox binaries. Emit an
+            // (ungated) diagnostic -- this is a misconfiguration, not
+            // success-path spam, matching the ungated `LoadLibraryExW failed`
+            // path below; a silent fail-closed gives the operator nothing to
+            // act on.
+            let detail = format!(
+                "{}='{}' but {} does not exist at '{}'",
+                RUNTIME_DIR_ENV, dir, APP_DLL_NAME, path
+            );
+            eprintln!("[mxc isosession] {}; refusing inbox fallback.", detail);
+
             return RuntimeLoad::Unloadable {
                 code: HRESULT::from_win32(ERROR_FILE_NOT_FOUND.0),
-                detail: format!(
-                    "{}='{}' but {} does not exist at '{}'",
-                    RUNTIME_DIR_ENV, dir, APP_DLL_NAME, path
-                ),
+                detail,
             };
         }
         if success_diag_enabled() {

From 20e621e17dca83229bf4125407ac990a1ed0234f Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Thu, 6 Aug 2026 20:37:07 -0700
Subject: [PATCH 04/26] isosession: check in the OS-produced SDK nuget for
 in-repo bindgen

Pin Microsoft.Windows.AI.IsolationSession.SDK.0.2606.0.nupkg beside the
generated bindings so a clean clone can regenerate bindings.rs offline from
its Preview WinMD, mirroring external/wslc-sdk's checked-in nupkg. This is the
source package the committed bindings.rs was generated from
(preview WinMD sha256 1A9DBDC2...).

A normal `cargo build` is unchanged: it compiles the committed bindings.rs and
build.rs only version-gates on GENERATION_INFO.toml (target_windows_crate). The
nuget is consumed only by the manual regeneration step.

- README.md: document the checked-in nuget + the regenerate-from-WinMD steps.
- GENERATION_INFO.toml: record [source] provenance (nupkg, winmd, sha256, namespace).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: f5cc2011-5308-43d6-a8ea-2b8ed9b6ceb3
---
 .../GENERATION_INFO.toml                      |  10 ++-
 ...ows.AI.IsolationSession.SDK.0.2606.0.nupkg | Bin 0 -> 83219 bytes
 .../isolation_session_bindings/README.md      |  75 +++++++++++++++---
 3 files changed, 75 insertions(+), 10 deletions(-)
 create mode 100644 src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2606.0.nupkg

diff --git a/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml b/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
index 665ae6364..b1b7006c7 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
+++ b/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
@@ -4,4 +4,12 @@
 [tool]
 windows_bindgen_version = "0.62.1"
 target_windows_crate = "0.62"
-generated_date = "2026-09-16"
+generated_date = "2026-08-14"
+
+[source]
+# The pinned SDK package these bindings were generated from (checked in beside
+# this file). Bindings come from the Preview WinMD inside it.
+nupkg = "Microsoft.Windows.AI.IsolationSession.SDK.0.2606.0.nupkg"
+winmd = "metadata/windows.ai.isolationsession.preview.winmd"
+winmd_sha256 = "1A9DBDC2CBFDEDC7FF366939DB4BA1564179D55B6EA3E70B99BD82C532428147"
+namespace = "Windows.AI.IsolationSession.Preview"
diff --git a/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2606.0.nupkg b/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2606.0.nupkg
new file mode 100644
index 0000000000000000000000000000000000000000..7c7d56c6f90c6ec3f0dd0b8b6bb7877bd6f69fd4
GIT binary patch
literal 83219
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

literal 0
HcmV?d00001

diff --git a/src/mxc-sdk/build/isolation_session_bindings/README.md b/src/mxc-sdk/build/isolation_session_bindings/README.md
index 37c09c55e..35fd0b2da 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/README.md
+++ b/src/mxc-sdk/build/isolation_session_bindings/README.md
@@ -1,18 +1,75 @@
-# Windows.AI.IsolationSession — WinMD Provenance
+# Windows.AI.IsolationSession — SDK NuGet + Bindings Provenance
 
-> **Audience:** MXC developers
+This directory pins the OS-produced SDK package that the generated Rust
+bindings in `src/mxc-sdk/src/backends/isolation_session/bindings/` are built
+from, plus the provenance metadata that couples them.
 
-This directory tracks provenance for the generated Rust bindings in
-`src/mxc-sdk/src/backends/isolation_session/bindings/`. The WinMD file itself is NOT checked in.
+## What is checked in here
 
-## Source
+| File | Purpose |
+|------|---------|
+| `Microsoft.Windows.AI.IsolationSession.SDK.<ver>.nupkg` | The OS-produced SDK package. Contains the WinMD metadata (`metadata/*.winmd`) the bindings are generated from, plus `runtime/IsoSessionApp.dll` for reference. |
+| `GENERATION_INFO.toml` | Provenance: bindgen version, target `windows` crate version, generated date, and the source winmd hash. Verified by the bindings crate's `build.rs`. |
+| `README.md` | This file. |
 
-The WinMD file is produced by an internal Microsoft Windows OS build and is
-not publicly redistributable.
+The `.nupkg` is committed (like `external/wslc-sdk/Microsoft.WSL.Containers.*.nupkg`)
+so a clean clone can **regenerate the bindings offline** without fetching
+anything. The WinMD is produced by an internal Microsoft Windows OS build and is
+not publicly redistributable outside this pinned package.
 
-## Version Coupling
+## Building MXC (no NuGet action required)
 
-The generated bindings depend on the `windows` crate at the version specified in
+A normal MXC build does **not** touch this package. It compiles the
+already-checked-in `src/mxc-sdk/src/backends/isolation_session/bindings/bindings.rs`.
+The bindings crate's `build.rs` only reads `GENERATION_INFO.toml`
+(`target_windows_crate`) as a version gate against the workspace `windows`
+crate — it does not open the `.nupkg` or the WinMD. A fresh clone therefore
+builds with zero NuGet/WinMD work.
+
+## Regenerating the bindings (only when the API surface changes)
+
+The bindings are regenerated from the **preview** WinMD inside the pinned
+`.nupkg`, using the canonical generator that lives in the OS repo
+(`onecoreuap/windows/core/isoenvbroker/RustBindingsGenerator/`).
+
+1. Extract the preview WinMD from the pinned package (a `.nupkg` is a zip):
+
+   ```powershell
+   $nupkg = "src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2606.0.nupkg"
+   Add-Type -AssemblyName System.IO.Compression.FileSystem
+   $out = "$env:TEMP/isosession-winmd"
+   [System.IO.Compression.ZipFile]::ExtractToDirectory($nupkg, $out)
+   # preview WinMD: $out/metadata/windows.ai.isolationsession.preview.winmd
+   ```
+
+2. Run the OS-side one-shot wrapper, pointing it at that WinMD. It regenerates,
+   copies `bindings.rs` into this MXC checkout, and runs `cargo check`:
+
+   ```powershell
+   # From the OS enlistment:
+   .\onecoreuap\windows\core\isoenvbroker\RustBindingsGenerator\Update-IsolationSessionBindings.ps1 `
+       -MxcRepoPath C:\mxc `
+       -WinMdPath $env:TEMP\isosession-winmd\metadata\windows.ai.isolationsession.preview.winmd `
+       -NoPause
+   ```
+
+   The generator filters to the `Windows.AI.IsolationSession.Preview` namespace
+   (the STABLE surface MXC calls) with windows-bindgen `0.62.1`.
+
+3. Bump `generated_date` (and the source hash, if the WinMD changed) in
+   `GENERATION_INFO.toml`, then commit the regenerated `bindings.rs` together
+   with the updated provenance.
+
+## Version coupling
+
+The generated bindings depend on the `windows` crate at the version in
 `GENERATION_INFO.toml` (`target_windows_crate`). If the workspace upgrades the
 `windows` crate, `mxc-sdk`'s build script will fail with an actionable error
 message instructing you to regenerate.
+
+## Refreshing the pinned package
+
+To pick up a newer OS build, produce a new package with the OS-side
+`nuget/Microsoft.Windows.AI.IsolationSession.SDK/pack.ps1`, replace the
+`.nupkg` here, regenerate the bindings from its preview WinMD (steps above),
+and commit both.

From 4a60266aa83675b17be0eae9177af26a39b5a6f7 Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Thu, 6 Aug 2026 20:51:27 -0700
Subject: [PATCH 05/26] isolation_session: generate WinRT bindings from the
 pinned nuget at build time

The bindings crate previously compiled a committed bindings.rs snapshot;
the checked-in SDK nuget was only reference material. Wire build.rs to
regenerate the projection from that nuget on every build so MXC is built
directly against the OS-produced package (parity with the OS-side
RustBindingsGenerator), and there is no snapshot to drift.

build.rs now:
  - locates the single *.nupkg under external/windows-sdk/isolation-session/,
  - extracts its Preview WinMD (a .nupkg is a zip) into OUT_DIR,
  - runs windows-bindgen (=0.62.1, build-dep) with the canonical args
    (filter Windows.AI.IsolationSession.Preview,
     --reference windows,skip-root,Windows.Foundation --flat --implement),
  - strips the emitted leading #![allow(...)] inner-attribute block so the
    file can be include!-ed inside `mod bindings`.

lib.rs now include!s OUT_DIR/bindings.rs under an outer #[allow(...)]; the
committed src/bindings.rs is removed. Verified the build-generated output is
byte-identical to the old snapshot (modulo the stripped header), and that
wxc-exec (release, --features isolation_session), fmt, clippy, and the 173
bindings+common tests are all green.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: f5cc2011-5308-43d6-a8ea-2b8ed9b6ceb3
---
 src/Cargo.lock                                |  350 ++-
 src/mxc-sdk/Cargo.toml                        |    8 +-
 src/mxc-sdk/build.rs                          |    2 +
 .../build/build_isolation_session_bindings.rs |  239 +-
 .../GENERATION_INFO.toml                      |   12 +-
 .../isolation_session_bindings/README.md      |   90 +-
 .../isolation_session/bindings/bindings.rs    | 2645 -----------------
 .../isolation_session/bindings/mod.rs         |   14 +-
 8 files changed, 542 insertions(+), 2818 deletions(-)
 delete mode 100644 src/mxc-sdk/src/backends/isolation_session/bindings/bindings.rs

diff --git a/src/Cargo.lock b/src/Cargo.lock
index e40b155c1..45c0d289b 100644
--- a/src/Cargo.lock
+++ b/src/Cargo.lock
@@ -8,6 +8,17 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
+[[package]]
+name = "aes"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures 0.2.17",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "1.1.4"
@@ -175,8 +186,17 @@ dependencies = [
  "arrayvec",
  "cc",
  "cfg-if",
- "constant_time_eq",
- "cpufeatures",
+ "constant_time_eq 0.4.2",
+ "cpufeatures 0.3.0",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
 ]
 
 [[package]]
@@ -234,12 +254,37 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
 [[package]]
 name = "bytes"
 version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 
+[[package]]
+name = "bzip2"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49ecfb22d906f800d4fe833b6282cf4dc1c298f5057ca0b5445e5c209735ca47"
+dependencies = [
+ "bzip2-sys",
+]
+
+[[package]]
+name = "bzip2-sys"
+version = "0.1.13+1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "225bff33b2141874fe80d71e07d6eec4f85c5c216453dd96388240f96e1acc14"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
+
 [[package]]
 name = "cap-primitives"
 version = "4.0.3"
@@ -310,7 +355,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06"
 dependencies = [
  "cfg-if",
- "cpufeatures",
+ "cpufeatures 0.3.0",
  "rand_core",
 ]
 
@@ -322,7 +367,7 @@ checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327"
 dependencies = [
  "iana-time-zone",
  "num-traits",
- "windows-link",
+ "windows-link 0.2.1",
 ]
 
 [[package]]
@@ -331,6 +376,16 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "579504560394e388085d0c080ea587dfa5c15f7e251b4d5247d1e1a61d1d6928"
 
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common 0.1.7",
+ "inout",
+]
+
 [[package]]
 name = "clang-sys"
 version = "1.9.1"
@@ -415,6 +470,12 @@ dependencies = [
  "unicode-xid",
 ]
 
+[[package]]
+name = "constant_time_eq"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
+
 [[package]]
 name = "constant_time_eq"
 version = "0.4.2"
@@ -427,6 +488,15 @@ version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "cpufeatures"
 version = "0.3.0"
@@ -436,6 +506,21 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "crc"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d"
+dependencies = [
+ "crc-catalog",
+]
+
+[[package]]
+name = "crc-catalog"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "217698eaf96b4a3f0bc4f3662aaa55bdf913cd54d7204591faa790070c6d0853"
+
 [[package]]
 name = "crc32fast"
 version = "1.5.0"
@@ -460,6 +545,16 @@ version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
 [[package]]
 name = "crypto-common"
 version = "0.2.2"
@@ -514,6 +609,18 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "deflate64"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac6b926516df9c60bfa16e107b21086399f8285a44ca9711344b9e553c5146e2"
+
+[[package]]
+name = "deranged"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
+
 [[package]]
 name = "derive_arbitrary"
 version = "1.4.2"
@@ -556,15 +663,26 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer 0.10.4",
+ "crypto-common 0.1.7",
+ "subtle",
+]
+
 [[package]]
 name = "digest"
 version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
 dependencies = [
- "block-buffer",
+ "block-buffer 0.12.1",
  "const-oid",
- "crypto-common",
+ "crypto-common 0.2.2",
 ]
 
 [[package]]
@@ -746,6 +864,16 @@ dependencies = [
  "slab",
 ]
 
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.2.17"
@@ -764,9 +892,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
 dependencies = [
  "cfg-if",
+ "js-sys",
  "libc",
  "r-efi 5.3.0",
  "wasip2",
+ "wasm-bindgen",
 ]
 
 [[package]]
@@ -863,6 +993,15 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest 0.10.7",
+]
+
 [[package]]
 name = "http"
 version = "1.4.2"
@@ -1190,6 +1329,15 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "io-extras"
 version = "0.19.0"
@@ -1333,7 +1481,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
 dependencies = [
  "cfg-if",
- "windows-link",
+ "windows-link 0.2.1",
 ]
 
 [[package]]
@@ -1397,6 +1545,27 @@ dependencies = [
  "winresource",
 ]
 
+[[package]]
+name = "lzma-rs"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "297e814c836ae64db86b36cf2a557ba54368d03f6afcd7d947c266692f71115e"
+dependencies = [
+ "byteorder",
+ "crc",
+]
+
+[[package]]
+name = "lzma-sys"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fda04ab3764e6cde78b9974eec4f779acaba7c4e84b36eca3cf77c581b85d27"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+]
+
 [[package]]
 name = "maybe-owned"
 version = "0.3.4"
@@ -1515,6 +1684,7 @@ dependencies = [
  "uuid",
  "widestring",
  "windows",
+ "windows-bindgen",
  "windows-collections",
  "windows-core",
  "windows-future",
@@ -1594,6 +1764,12 @@ dependencies = [
  "minimal-lexical",
 ]
 
+[[package]]
+name = "num-conv"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441"
+
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -1689,7 +1865,17 @@ dependencies = [
  "libc",
  "redox_syscall",
  "smallvec",
- "windows-link",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "pbkdf2"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"
+dependencies = [
+ "digest 0.10.7",
+ "hmac",
 ]
 
 [[package]]
@@ -1749,6 +1935,12 @@ dependencies = [
  "zerovec",
 ]
 
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
 [[package]]
 name = "prettyplease"
 version = "0.2.37"
@@ -2142,6 +2334,17 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "sha1"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.2.17",
+ "digest 0.10.7",
+]
+
 [[package]]
 name = "sha2"
 version = "0.11.0"
@@ -2149,8 +2352,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
 dependencies = [
  "cfg-if",
- "cpufeatures",
- "digest",
+ "cpufeatures 0.3.0",
+ "digest 0.11.3",
 ]
 
 [[package]]
@@ -2332,6 +2535,25 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "time"
+version = "0.3.55"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdb87b95ec50ddfa440816d227a17b2ccbdda963a316a727fda0fc4334f7d134"
+dependencies = [
+ "deranged",
+ "num-conv",
+ "powerfmt",
+ "serde_core",
+ "time-core",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e1c906769ad99c88eaa54e728060edef082f8e358ff32030cb7c7d315e81109"
+
 [[package]]
 name = "tinystr"
 version = "0.8.3"
@@ -2745,6 +2967,17 @@ dependencies = [
  "windows-numerics",
 ]
 
+[[package]]
+name = "windows-bindgen"
+version = "0.62.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b541b67bb66a43de06888703b15519e40b3fc9b65917dc1ccd71aecfd7c5703"
+dependencies = [
+ "serde",
+ "serde_json",
+ "windows-threading 0.1.0",
+]
+
 [[package]]
 name = "windows-collections"
 version = "0.3.2"
@@ -2762,7 +2995,7 @@ checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
 dependencies = [
  "windows-implement",
  "windows-interface",
- "windows-link",
+ "windows-link 0.2.1",
  "windows-result",
  "windows-strings",
 ]
@@ -2774,8 +3007,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb"
 dependencies = [
  "windows-core",
- "windows-link",
- "windows-threading",
+ "windows-link 0.2.1",
+ "windows-threading 0.2.1",
 ]
 
 [[package]]
@@ -2800,6 +3033,12 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "windows-link"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+
 [[package]]
 name = "windows-link"
 version = "0.2.1"
@@ -2813,7 +3052,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26"
 dependencies = [
  "windows-core",
- "windows-link",
+ "windows-link 0.2.1",
 ]
 
 [[package]]
@@ -2822,7 +3061,7 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
 dependencies = [
- "windows-link",
+ "windows-link 0.2.1",
 ]
 
 [[package]]
@@ -2831,7 +3070,7 @@ version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
 dependencies = [
- "windows-link",
+ "windows-link 0.2.1",
 ]
 
 [[package]]
@@ -2858,7 +3097,7 @@ version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
 dependencies = [
- "windows-link",
+ "windows-link 0.2.1",
 ]
 
 [[package]]
@@ -2877,13 +3116,22 @@ dependencies = [
  "windows_x86_64_msvc",
 ]
 
+[[package]]
+name = "windows-threading"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
 [[package]]
 name = "windows-threading"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37"
 dependencies = [
- "windows-link",
+ "windows-link 0.2.1",
 ]
 
 [[package]]
@@ -2892,7 +3140,7 @@ version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e4060a1da109b9d0326b7262c8e12c84df67cc0dbc9e33cf49e01ccc2eb63631"
 dependencies = [
- "windows-link",
+ "windows-link 0.2.1",
 ]
 
 [[package]]
@@ -3155,6 +3403,15 @@ dependencies = [
  "rustix",
 ]
 
+[[package]]
+name = "xz2"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "388c44dc09d76f1536602ead6d325eb532f5c122f17782bd57fb47baeeb767e2"
+dependencies = [
+ "lzma-sys",
+]
+
 [[package]]
 name = "yoke"
 version = "0.8.3"
@@ -3224,6 +3481,20 @@ name = "zeroize"
 version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e"
+dependencies = [
+ "zeroize_derive",
+]
+
+[[package]]
+name = "zeroize_derive"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c50655cbb0fe3fc43170059e702f1ce5e19b84cec58dc87b037a09935c2f328"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
 
 [[package]]
 name = "zerotrie"
@@ -3264,15 +3535,28 @@ version = "2.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fabe6324e908f85a1c52063ce7aa26b68dcb7eb6dbc83a2d148403c9bc3eba50"
 dependencies = [
+ "aes",
  "arbitrary",
+ "bzip2",
+ "constant_time_eq 0.3.1",
  "crc32fast",
  "crossbeam-utils",
+ "deflate64",
  "displaydoc",
  "flate2",
+ "getrandom 0.3.4",
+ "hmac",
  "indexmap",
+ "lzma-rs",
  "memchr",
+ "pbkdf2",
+ "sha1",
  "thiserror",
+ "time",
+ "xz2",
+ "zeroize",
  "zopfli",
+ "zstd",
 ]
 
 [[package]]
@@ -3292,3 +3576,31 @@ dependencies = [
  "log",
  "simd-adler32",
 ]
+
+[[package]]
+name = "zstd"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
+dependencies = [
+ "zstd-safe",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "7.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64d80649ab6db9d9f6f9c80a40becd948eda4714a0a5ac8c4d157a32231c7882"
+dependencies = [
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-sys"
+version = "2.1.0+zstd.1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ef0a8027ec3ee71300ab3bcbcd0393f434aa72b91ca6d635a39941deae8eea0"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
diff --git a/src/mxc-sdk/Cargo.toml b/src/mxc-sdk/Cargo.toml
index caab172e1..733201b31 100644
--- a/src/mxc-sdk/Cargo.toml
+++ b/src/mxc-sdk/Cargo.toml
@@ -30,7 +30,12 @@ required-features = ["wslc"]
 default = []
 wslc = ["link-wslcsdk", "dep:libloading", "dep:tar"]
 link-wslcsdk = ["dep:zip"]
-isolation_session = ["dep:windows-collections", "dep:windows-future"]
+isolation_session = [
+    "dep:windows-bindgen",
+    "dep:windows-collections",
+    "dep:windows-future",
+    "dep:zip",
+]
 test-support = []
 microvm = []
 hyperlight = [
@@ -74,6 +79,7 @@ serde.workspace = true
 serde_json.workspace = true
 sha2.workspace = true
 uuid.workspace = true
+windows-bindgen = { version = "=0.62.1", optional = true }
 zip = { version = "2", default-features = false, features = ["deflate"], optional = true }
 
 [dev-dependencies]
diff --git a/src/mxc-sdk/build.rs b/src/mxc-sdk/build.rs
index a3c26529d..5f52a78d6 100644
--- a/src/mxc-sdk/build.rs
+++ b/src/mxc-sdk/build.rs
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+#[cfg(feature = "isolation_session")]
 #[path = "build/build_isolation_session_bindings.rs"]
 mod build_isolation_session_bindings;
 #[allow(dead_code)]
@@ -27,6 +28,7 @@ mod nanvix_build_common;
 mod nanvix_common;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
+    #[cfg(feature = "isolation_session")]
     build_isolation_session_bindings::run();
     build_mxc_telemetry::run();
     if let Some((bin_dir, use_prefetched_binaries)) = build_nanvix_binaries::run() {
diff --git a/src/mxc-sdk/build/build_isolation_session_bindings.rs b/src/mxc-sdk/build/build_isolation_session_bindings.rs
index a8f27765e..8a309dbeb 100644
--- a/src/mxc-sdk/build/build_isolation_session_bindings.rs
+++ b/src/mxc-sdk/build/build_isolation_session_bindings.rs
@@ -1,109 +1,168 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-//! Build script that verifies the workspace's `windows` crate version matches
-//! the version the generated bindings were produced for.
+//! Build script that regenerates the IsolationSession Preview WinRT bindings
+//! from the checked-in SDK nuget at compile time, so the crate is always built
+//! directly against the pinned `Microsoft.Windows.AI.IsolationSession.SDK`
+//! package rather than a committed snapshot.
+//!
+//! Pipeline: locate the single `*.nupkg` under
+//! `build/isolation_session_bindings/`, extract its Preview WinMD (a nupkg is a
+//! zip), then run `windows-bindgen` over it into `$OUT_DIR/bindings.rs`
+//! (included by the bindings module). The invocation mirrors the canonical
+//! OS-side generator (`RustBindingsGenerator`).
+
+use std::fs;
+use std::io::Read;
+use std::path::{Path, PathBuf};
 
 pub(crate) fn run() {
-    // Keep provenance inside the package so crates.io builds enforce the same
-    // generated-binding version coupling as repository builds.
-    let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
-    let info_path = std::path::Path::new(&manifest_dir)
+    let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR");
+    let out_dir = std::env::var("OUT_DIR").expect("OUT_DIR");
+    let sdk_dir = Path::new(&manifest_dir)
         .join("build")
-        .join("isolation_session_bindings")
-        .join("GENERATION_INFO.toml");
+        .join("isolation_session_bindings");
 
-    // If the provenance file doesn't exist yet (e.g., first-time setup before
-    // generation has been run), skip the check.
-    if !info_path.exists() {
-        return;
-    }
+    let nupkg = find_nupkg(&sdk_dir).unwrap_or_else(|| {
+        panic!(
+            "isolation_session_bindings: no .nupkg found in {}",
+            sdk_dir.display()
+        )
+    });
 
-    let contents = std::fs::read_to_string(&info_path).unwrap_or_default();
+    // Rebuild whenever the pinned package or this script changes.
+    println!("cargo:rerun-if-changed={}", nupkg.display());
+    println!("cargo:rerun-if-changed=build/build_isolation_session_bindings.rs");
 
-    // Extract the expected windows crate version from the TOML.
-    let expected = contents.lines().find_map(|line| {
-        let line = line.trim();
-        if line.starts_with("target_windows_crate") {
-            line.split('=')
-                .nth(1)
-                .map(|v| v.trim().trim_matches('"').to_string())
-        } else {
-            None
-        }
-    });
+    // Extract the Preview WinMD from the nuget into OUT_DIR.
+    let winmd_bytes = extract_preview_winmd(&nupkg);
+    let winmd_path = Path::new(&out_dir).join("windows.ai.isolationsession.preview.winmd");
+    fs::write(&winmd_path, &winmd_bytes)
+        .unwrap_or_else(|e| panic!("write extracted winmd to {}: {e}", winmd_path.display()));
 
-    let Some(expected_version) = expected else {
-        // No version constraint found — skip check.
-        return;
-    };
+    let bindings_path = Path::new(&out_dir).join("bindings.rs");
 
-    // Cargo packages include Cargo.lock at the crate root, while repository
-    // builds use the workspace lockfile one directory above mxc-sdk.
-    let manifest_dir = std::path::Path::new(&manifest_dir);
-    let lock_path = [
-        manifest_dir.join("Cargo.lock"),
-        manifest_dir.join("../Cargo.lock"),
-    ]
-    .into_iter()
-    .find(|path| path.exists());
+    // Generate bindings for the IsolationSession Preview namespace only. The
+    // literal "default" input combines the SDK WinMD with windows-bindgen's
+    // bundled Windows metadata; "windows,skip-root,Windows.Foundation" maps the
+    // Windows.Foundation dependencies (DateTime, TypedEventHandler) onto the
+    // full `windows` crate (Foundation feature enabled in Cargo.toml). This
+    // mirrors RustBindingsGenerator exactly.
+    let warnings = windows_bindgen::bindgen([
+        "--in",
+        winmd_path.to_str().expect("winmd path is valid UTF-8"),
+        "--in",
+        "default",
+        "--out",
+        bindings_path.to_str().expect("out path is valid UTF-8"),
+        "--filter",
+        "Windows.AI.IsolationSession.Preview",
+        "--reference",
+        "windows,skip-root,Windows.Foundation",
+        "--flat",
+        "--implement",
+    ]);
 
-    let Some(lock_path) = lock_path else {
-        return;
-    };
+    let warning_text = format!("{warnings}");
+    for line in warning_text.lines().filter(|l| !l.trim().is_empty()) {
+        println!("cargo:warning=isosession-bindgen: {line}");
+    }
 
-    let lock_contents = std::fs::read_to_string(&lock_path).unwrap_or_default();
+    // windows-bindgen emits a leading `#![allow(...)]` inner attribute. That is
+    // invalid once the file is `include!`-ed inside `mod bindings { ... }`
+    // (an inner attribute cannot annotate the `include!` item macro). The
+    // module already carries an equivalent OUTER `#[allow(...)]` in lib.rs, so
+    // strip the generated leading inner-attribute block here.
+    let generated = fs::read_to_string(&bindings_path)
+        .unwrap_or_else(|e| panic!("read generated {}: {e}", bindings_path.display()));
+    let cleaned = strip_leading_inner_attrs(&generated);
+    fs::write(&bindings_path, cleaned)
+        .unwrap_or_else(|e| panic!("rewrite cleaned {}: {e}", bindings_path.display()));
+}
 
-    // Simple parser: find the [[package]] block for windows.
-    let actual_version = lock_contents
-        .split("[[package]]")
-        .find(|block| {
-            let has_name = block.lines().any(|l| l.trim() == "name = \"windows\"");
-            // Exclude windows-* crates (windows-core, windows-sys, etc.)
-            let not_prefixed = !block.lines().any(|l| {
-                let t = l.trim();
-                t.starts_with("name = \"windows-")
-            });
-            has_name && not_prefixed
+/// Drops leading `#![...]` inner-attribute blocks (single- or multi-line) from
+/// the generated file, preserving leading comments/blank lines and copying the
+/// rest of the body verbatim once the first real item is reached.
+fn strip_leading_inner_attrs(src: &str) -> String {
+    let mut result = String::with_capacity(src.len());
+    let mut in_inner = false;
+    let mut started_body = false;
+    for line in src.lines() {
+        if started_body {
+            result.push_str(line);
+            result.push('\n');
+            continue;
+        }
+        if in_inner {
+            if line.contains(']') {
+                in_inner = false;
+            }
+            continue;
+        }
+        let trimmed = line.trim_start();
+        if trimmed.starts_with("#![") {
+            if !trimmed.contains(']') {
+                in_inner = true;
+            }
+            continue;
+        }
+        if trimmed.is_empty() || trimmed.starts_with("//") {
+            result.push_str(line);
+            result.push('\n');
+            continue;
+        }
+        started_body = true;
+        result.push_str(line);
+        result.push('\n');
+    }
+    result
+}
+
+/// Returns the single `*.nupkg` under `dir` (lexicographically last if several,
+/// so a version bump that leaves an old package behind still picks the newest).
+fn find_nupkg(dir: &Path) -> Option<PathBuf> {
+    let mut hits: Vec<PathBuf> = fs::read_dir(dir)
+        .ok()?
+        .filter_map(|e| e.ok().map(|e| e.path()))
+        .filter(|p| {
+            p.extension()
+                .map(|x| x.eq_ignore_ascii_case("nupkg"))
+                .unwrap_or(false)
         })
-        .and_then(|block| {
-            block.lines().find_map(|l| {
-                let t = l.trim();
-                if t.starts_with("version = ") {
-                    Some(t.split('=').nth(1)?.trim().trim_matches('"').to_string())
-                } else {
-                    None
-                }
-            })
-        });
+        .collect();
+    hits.sort();
+    hits.into_iter().next_back()
+}
 
-    // Build a caret requirement from the major.minor of `expected_version`.
-    // This matches "compatible with X.Y" — same loose-on-patch intent as the
-    // prior `starts_with` check, but via a real semver parser so e.g. "0.6"
-    // cannot silently accept "0.62".
-    let parts: Vec<&str> = expected_version.split('.').take(2).collect();
-    let req_pattern = if parts.len() == 2 {
-        format!("^{}.{}", parts[0], parts[1])
-    } else {
-        return; // Unexpected format — skip check rather than fail loudly.
-    };
-    let Ok(req) = semver::VersionReq::parse(&req_pattern) else {
-        return;
-    };
+/// Extracts the `*preview.winmd` entry from the nuget (a zip archive),
+/// tolerant of path-separator variations in the entry name.
+fn extract_preview_winmd(nupkg: &Path) -> Vec<u8> {
+    let file = fs::File::open(nupkg).unwrap_or_else(|e| panic!("open {}: {e}", nupkg.display()));
+    let mut archive =
+        zip::ZipArchive::new(file).unwrap_or_else(|e| panic!("read zip {}: {e}", nupkg.display()));
 
-    if let Some(actual) = actual_version {
-        let Ok(actual_ver) = semver::Version::parse(&actual) else {
-            return;
-        };
-        if !req.matches(&actual_ver) {
+    let entry_name = (0..archive.len())
+        .find_map(|i| {
+            let name = archive.by_index(i).ok()?.name().to_string();
+            if name.to_ascii_lowercase().ends_with("preview.winmd") {
+                Some(name)
+            } else {
+                None
+            }
+        })
+        .unwrap_or_else(|| {
             panic!(
-                "\n\n\
-                 isolation_session_bindings: generated code targets windows crate {expected},\n\
-                 but workspace has {actual}. Bindings must be regenerated.\n\
-                 \n",
-                expected = expected_version,
-                actual = actual,
-            );
-        }
-    }
+                "isolation_session_bindings: no *preview.winmd entry in {}",
+                nupkg.display()
+            )
+        });
+
+    let mut entry = archive
+        .by_name(&entry_name)
+        .unwrap_or_else(|e| panic!("open zip entry {entry_name}: {e}"));
+    let mut buf = Vec::new();
+    entry
+        .read_to_end(&mut buf)
+        .unwrap_or_else(|e| panic!("read zip entry {entry_name}: {e}"));
+    buf
 }
diff --git a/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml b/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
index b1b7006c7..a0de8aa3c 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
+++ b/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
@@ -1,14 +1,18 @@
-# Provenance information for the generated isolation_session_bindings crate.
-# Updated manually after regenerating the bindings; verified by the bindings crate's build.rs.
+# Provenance for the isolation_session_bindings crate.
+#
+# Bindings are regenerated at BUILD TIME by the crate's build.rs from the
+# Preview WinMD inside the pinned SDK nuget checked in beside this file --
+# there is no committed bindings.rs. This file is provenance documentation;
+# build.rs derives the actual output from the .nupkg.
 
 [tool]
+# Must match the `windows-bindgen` build-dependency pin in the crate's Cargo.toml
+# and stay in lockstep with the workspace `windows` crate major.minor.
 windows_bindgen_version = "0.62.1"
 target_windows_crate = "0.62"
 generated_date = "2026-08-14"
 
 [source]
-# The pinned SDK package these bindings were generated from (checked in beside
-# this file). Bindings come from the Preview WinMD inside it.
 nupkg = "Microsoft.Windows.AI.IsolationSession.SDK.0.2606.0.nupkg"
 winmd = "metadata/windows.ai.isolationsession.preview.winmd"
 winmd_sha256 = "1A9DBDC2CBFDEDC7FF366939DB4BA1564179D55B6EA3E70B99BD82C532428147"
diff --git a/src/mxc-sdk/build/isolation_session_bindings/README.md b/src/mxc-sdk/build/isolation_session_bindings/README.md
index 35fd0b2da..a445b3c4a 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/README.md
+++ b/src/mxc-sdk/build/isolation_session_bindings/README.md
@@ -1,75 +1,53 @@
-# Windows.AI.IsolationSession — SDK NuGet + Bindings Provenance
+# Windows.AI.IsolationSession — SDK NuGet + Build-Time Bindings
 
-This directory pins the OS-produced SDK package that the generated Rust
-bindings in `src/mxc-sdk/src/backends/isolation_session/bindings/` are built
-from, plus the provenance metadata that couples them.
+This directory pins the OS-produced SDK package that the Rust bindings in
+`src/mxc-sdk/src/backends/isolation_session/bindings/` are built from. The
+bindings are **generated at build time from this package** — there is no committed
+`bindings.rs` snapshot.
 
 ## What is checked in here
 
 | File | Purpose |
 |------|---------|
 | `Microsoft.Windows.AI.IsolationSession.SDK.<ver>.nupkg` | The OS-produced SDK package. Contains the WinMD metadata (`metadata/*.winmd`) the bindings are generated from, plus `runtime/IsoSessionApp.dll` for reference. |
-| `GENERATION_INFO.toml` | Provenance: bindgen version, target `windows` crate version, generated date, and the source winmd hash. Verified by the bindings crate's `build.rs`. |
+| `GENERATION_INFO.toml` | Provenance: bindgen version, source WinMD hash, namespace. |
 | `README.md` | This file. |
 
 The `.nupkg` is committed (like `external/wslc-sdk/Microsoft.WSL.Containers.*.nupkg`)
-so a clean clone can **regenerate the bindings offline** without fetching
-anything. The WinMD is produced by an internal Microsoft Windows OS build and is
-not publicly redistributable outside this pinned package.
+so a clean clone builds fully offline. The WinMD is produced by an internal
+Microsoft Windows OS build and is not publicly redistributable outside this
+pinned package.
 
-## Building MXC (no NuGet action required)
+## How the bindings are built (every `cargo build`)
 
-A normal MXC build does **not** touch this package. It compiles the
-already-checked-in `src/mxc-sdk/src/backends/isolation_session/bindings/bindings.rs`.
-The bindings crate's `build.rs` only reads `GENERATION_INFO.toml`
-(`target_windows_crate`) as a version gate against the workspace `windows`
-crate — it does not open the `.nupkg` or the WinMD. A fresh clone therefore
-builds with zero NuGet/WinMD work.
+The `mxc-sdk` build script regenerates the projection whenever the
+`isolation_session` feature is enabled:
 
-## Regenerating the bindings (only when the API surface changes)
+1. Locates the single `*.nupkg` in this directory.
+2. Extracts its **Preview** WinMD (`metadata/windows.ai.isolationsession.preview.winmd`)
+   — a `.nupkg` is a zip — into `OUT_DIR`.
+3. Runs `windows-bindgen` (pinned `=0.62.1` as a build-dependency) over it with
+   the canonical arguments (filter `Windows.AI.IsolationSession.Preview`,
+   `--reference windows,skip-root,Windows.Foundation --flat --implement`),
+   writing `OUT_DIR/bindings.rs`, which `lib.rs` `include!`s.
 
-The bindings are regenerated from the **preview** WinMD inside the pinned
-`.nupkg`, using the canonical generator that lives in the OS repo
-(`onecoreuap/windows/core/isoenvbroker/RustBindingsGenerator/`).
+This mirrors the OS-side canonical generator
+(`onecoreuap/windows/core/isoenvbroker/RustBindingsGenerator/`) exactly, so the
+crate is always built **directly against the pinned SDK package**. `build.rs`
+re-runs when the `.nupkg` changes (`cargo:rerun-if-changed`).
 
-1. Extract the preview WinMD from the pinned package (a `.nupkg` is a zip):
+## Refreshing to a newer OS build
 
-   ```powershell
-   $nupkg = "src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2606.0.nupkg"
-   Add-Type -AssemblyName System.IO.Compression.FileSystem
-   $out = "$env:TEMP/isosession-winmd"
-   [System.IO.Compression.ZipFile]::ExtractToDirectory($nupkg, $out)
-   # preview WinMD: $out/metadata/windows.ai.isolationsession.preview.winmd
-   ```
-
-2. Run the OS-side one-shot wrapper, pointing it at that WinMD. It regenerates,
-   copies `bindings.rs` into this MXC checkout, and runs `cargo check`:
-
-   ```powershell
-   # From the OS enlistment:
-   .\onecoreuap\windows\core\isoenvbroker\RustBindingsGenerator\Update-IsolationSessionBindings.ps1 `
-       -MxcRepoPath C:\mxc `
-       -WinMdPath $env:TEMP\isosession-winmd\metadata\windows.ai.isolationsession.preview.winmd `
-       -NoPause
-   ```
-
-   The generator filters to the `Windows.AI.IsolationSession.Preview` namespace
-   (the STABLE surface MXC calls) with windows-bindgen `0.62.1`.
-
-3. Bump `generated_date` (and the source hash, if the WinMD changed) in
-   `GENERATION_INFO.toml`, then commit the regenerated `bindings.rs` together
-   with the updated provenance.
+1. Produce a new package with the OS-side
+   `nuget/Microsoft.Windows.AI.IsolationSession.SDK/pack.ps1`.
+2. Replace the `.nupkg` in this directory (and update `GENERATION_INFO.toml`'s
+   `winmd_sha256`).
+3. `cargo build` — the new bindings are generated automatically. Review the
+   downstream diff (e.g. `cargo check -p wxc --features isolation_session`).
 
 ## Version coupling
 
-The generated bindings depend on the `windows` crate at the version in
-`GENERATION_INFO.toml` (`target_windows_crate`). If the workspace upgrades the
-`windows` crate, `mxc-sdk`'s build script will fail with an actionable error
-message instructing you to regenerate.
-
-## Refreshing the pinned package
-
-To pick up a newer OS build, produce a new package with the OS-side
-`nuget/Microsoft.Windows.AI.IsolationSession.SDK/pack.ps1`, replace the
-`.nupkg` here, regenerate the bindings from its preview WinMD (steps above),
-and commit both.
+`windows-bindgen` is pinned to `=0.62.1` in `src/mxc-sdk/Cargo.toml`
+and must stay in lockstep with the workspace `windows` crate's major.minor
+(`target_windows_crate` in `GENERATION_INFO.toml`). If you bump the `windows`
+crate, bump `windows-bindgen` to the matching version in the same change.
diff --git a/src/mxc-sdk/src/backends/isolation_session/bindings/bindings.rs b/src/mxc-sdk/src/backends/isolation_session/bindings/bindings.rs
deleted file mode 100644
index 8e28748ae..000000000
--- a/src/mxc-sdk/src/backends/isolation_session/bindings/bindings.rs
+++ /dev/null
@@ -1,2645 +0,0 @@
-// Bindings generated by `windows-bindgen` 0.62.1
-
-#![allow(
-    non_snake_case,
-    non_upper_case_globals,
-    non_camel_case_types,
-    dead_code,
-    clippy::all
-)]
-
-windows_core::imp::define_interface!(
-    IIsoSessionError,
-    IIsoSessionError_Vtbl,
-    0x39e104da_6f4b_5fe8_a63f_f28fd8c3d606
-);
-impl windows_core::RuntimeType for IIsoSessionError {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_interface::<Self>();
-}
-impl windows_core::RuntimeName for IIsoSessionError {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionError";
-}
-pub trait IIsoSessionError_Impl: windows_core::IUnknownImpl {
-    fn Code(&self) -> windows_core::Result<windows_core::HRESULT>;
-    fn IsError(&self) -> windows_core::Result<bool>;
-    fn Message(&self) -> windows_core::Result<windows_core::HSTRING>;
-    fn Remediation(&self) -> windows_core::Result<windows_core::HSTRING>;
-}
-impl IIsoSessionError_Vtbl {
-    pub const fn new<Identity: IIsoSessionError_Impl, const OFFSET: isize>() -> Self {
-        unsafe extern "system" fn Code<Identity: IIsoSessionError_Impl, const OFFSET: isize>(
-            this: *mut core::ffi::c_void,
-            result__: *mut windows_core::HRESULT,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionError_Impl::Code(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn IsError<Identity: IIsoSessionError_Impl, const OFFSET: isize>(
-            this: *mut core::ffi::c_void,
-            result__: *mut bool,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionError_Impl::IsError(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn Message<Identity: IIsoSessionError_Impl, const OFFSET: isize>(
-            this: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionError_Impl::Message(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn Remediation<
-            Identity: IIsoSessionError_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionError_Impl::Remediation(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        Self {
-            base__: windows_core::IInspectable_Vtbl::new::<Identity, IIsoSessionError, OFFSET>(),
-            Code: Code::<Identity, OFFSET>,
-            IsError: IsError::<Identity, OFFSET>,
-            Message: Message::<Identity, OFFSET>,
-            Remediation: Remediation::<Identity, OFFSET>,
-        }
-    }
-    pub fn matches(iid: &windows_core::GUID) -> bool {
-        iid == &<IIsoSessionError as windows_core::Interface>::IID
-    }
-}
-#[repr(C)]
-#[doc(hidden)]
-pub struct IIsoSessionError_Vtbl {
-    pub base__: windows_core::IInspectable_Vtbl,
-    pub Code: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut windows_core::HRESULT,
-    ) -> windows_core::HRESULT,
-    pub IsError:
-        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
-    pub Message: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-    pub Remediation: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-}
-windows_core::imp::define_interface!(
-    IIsoSessionErrorPreview2,
-    IIsoSessionErrorPreview2_Vtbl,
-    0xd01fc5cc_fdfc_513a_9045_235932a03212
-);
-impl windows_core::RuntimeType for IIsoSessionErrorPreview2 {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_interface::<Self>();
-}
-impl windows_core::RuntimeName for IIsoSessionErrorPreview2 {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionErrorPreview2";
-}
-pub trait IIsoSessionErrorPreview2_Impl: windows_core::IUnknownImpl {
-    fn Diagnostics(&self) -> windows_core::Result<windows_core::HSTRING>;
-    fn FailingStage(&self) -> windows_core::Result<windows_core::HSTRING>;
-    fn UnderlyingError(&self) -> windows_core::Result<windows_core::HRESULT>;
-}
-impl IIsoSessionErrorPreview2_Vtbl {
-    pub const fn new<Identity: IIsoSessionErrorPreview2_Impl, const OFFSET: isize>() -> Self {
-        unsafe extern "system" fn Diagnostics<
-            Identity: IIsoSessionErrorPreview2_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionErrorPreview2_Impl::Diagnostics(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn FailingStage<
-            Identity: IIsoSessionErrorPreview2_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionErrorPreview2_Impl::FailingStage(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn UnderlyingError<
-            Identity: IIsoSessionErrorPreview2_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut windows_core::HRESULT,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionErrorPreview2_Impl::UnderlyingError(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        Self {
-            base__: windows_core::IInspectable_Vtbl::new::<
-                Identity,
-                IIsoSessionErrorPreview2,
-                OFFSET,
-            >(),
-            Diagnostics: Diagnostics::<Identity, OFFSET>,
-            FailingStage: FailingStage::<Identity, OFFSET>,
-            UnderlyingError: UnderlyingError::<Identity, OFFSET>,
-        }
-    }
-    pub fn matches(iid: &windows_core::GUID) -> bool {
-        iid == &<IIsoSessionErrorPreview2 as windows_core::Interface>::IID
-    }
-}
-#[repr(C)]
-#[doc(hidden)]
-pub struct IIsoSessionErrorPreview2_Vtbl {
-    pub base__: windows_core::IInspectable_Vtbl,
-    pub Diagnostics: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-    pub FailingStage: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-    pub UnderlyingError: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut windows_core::HRESULT,
-    ) -> windows_core::HRESULT,
-}
-windows_core::imp::define_interface!(
-    IIsoSessionErrorPreview3,
-    IIsoSessionErrorPreview3_Vtbl,
-    0xa81bc040_b534_5786_986e_9530bd12e588
-);
-impl windows_core::RuntimeType for IIsoSessionErrorPreview3 {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_interface::<Self>();
-}
-impl windows_core::RuntimeName for IIsoSessionErrorPreview3 {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionErrorPreview3";
-}
-pub trait IIsoSessionErrorPreview3_Impl: windows_core::IUnknownImpl {
-    fn Format(&self) -> windows_core::Result<windows_core::HSTRING>;
-}
-impl IIsoSessionErrorPreview3_Vtbl {
-    pub const fn new<Identity: IIsoSessionErrorPreview3_Impl, const OFFSET: isize>() -> Self {
-        unsafe extern "system" fn Format<
-            Identity: IIsoSessionErrorPreview3_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionErrorPreview3_Impl::Format(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        Self {
-            base__: windows_core::IInspectable_Vtbl::new::<
-                Identity,
-                IIsoSessionErrorPreview3,
-                OFFSET,
-            >(),
-            Format: Format::<Identity, OFFSET>,
-        }
-    }
-    pub fn matches(iid: &windows_core::GUID) -> bool {
-        iid == &<IIsoSessionErrorPreview3 as windows_core::Interface>::IID
-    }
-}
-#[repr(C)]
-#[doc(hidden)]
-pub struct IIsoSessionErrorPreview3_Vtbl {
-    pub base__: windows_core::IInspectable_Vtbl,
-    pub Format: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-}
-windows_core::imp::define_interface!(
-    IIsoSessionOps,
-    IIsoSessionOps_Vtbl,
-    0xabe3e450_1dd6_5c8f_88d1_f5522b785b96
-);
-impl windows_core::RuntimeType for IIsoSessionOps {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_interface::<Self>();
-}
-impl windows_core::RuntimeName for IIsoSessionOps {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionOps";
-}
-pub trait IIsoSessionOps_Impl: windows_core::IUnknownImpl {
-    fn BehaviorVersion(&self) -> windows_core::Result<i32>;
-    fn AddUserAsync(
-        &self,
-        optEnterpriseAccountName: &windows_core::HSTRING,
-        optWamToken: &windows_core::HSTRING,
-    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionUserResult>>;
-    fn GetFeatureLevel(&self, feature: IsoSessionFeature) -> windows_core::Result<i32>;
-    fn RemoveUserAsync(
-        &self,
-        agentUserName: &windows_core::HSTRING,
-    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionResult>>;
-    fn RunProcessWithOptionsAsync(
-        &self,
-        agentUserName: &windows_core::HSTRING,
-        processPath: &windows_core::HSTRING,
-        arguments: &windows_core::HSTRING,
-        options: windows_core::Ref<'_, IsoSessionProcessOptions>,
-    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionProcessResult>>;
-    fn StartSessionAsync(
-        &self,
-        agentUserName: &windows_core::HSTRING,
-        optWamToken: &windows_core::HSTRING,
-    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionResult>>;
-    fn StopSessionAsync(
-        &self,
-        agentUserName: &windows_core::HSTRING,
-    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionResult>>;
-}
-impl IIsoSessionOps_Vtbl {
-    pub const fn new<Identity: IIsoSessionOps_Impl, const OFFSET: isize>() -> Self {
-        unsafe extern "system" fn BehaviorVersion<
-            Identity: IIsoSessionOps_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut i32,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionOps_Impl::BehaviorVersion(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn AddUserAsync<
-            Identity: IIsoSessionOps_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            optenterpriseaccountname: *mut core::ffi::c_void,
-            optwamtoken: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionOps_Impl::AddUserAsync(
-                    this,
-                    core::mem::transmute(&optenterpriseaccountname),
-                    core::mem::transmute(&optwamtoken),
-                ) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn GetFeatureLevel<
-            Identity: IIsoSessionOps_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            feature: IsoSessionFeature,
-            result__: *mut i32,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionOps_Impl::GetFeatureLevel(this, feature) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn RemoveUserAsync<
-            Identity: IIsoSessionOps_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            agentusername: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionOps_Impl::RemoveUserAsync(
-                    this,
-                    core::mem::transmute(&agentusername),
-                ) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn RunProcessWithOptionsAsync<
-            Identity: IIsoSessionOps_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            agentusername: *mut core::ffi::c_void,
-            processpath: *mut core::ffi::c_void,
-            arguments: *mut core::ffi::c_void,
-            options: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionOps_Impl::RunProcessWithOptionsAsync(
-                    this,
-                    core::mem::transmute(&agentusername),
-                    core::mem::transmute(&processpath),
-                    core::mem::transmute(&arguments),
-                    core::mem::transmute_copy(&options),
-                ) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn StartSessionAsync<
-            Identity: IIsoSessionOps_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            agentusername: *mut core::ffi::c_void,
-            optwamtoken: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionOps_Impl::StartSessionAsync(
-                    this,
-                    core::mem::transmute(&agentusername),
-                    core::mem::transmute(&optwamtoken),
-                ) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn StopSessionAsync<
-            Identity: IIsoSessionOps_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            agentusername: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionOps_Impl::StopSessionAsync(
-                    this,
-                    core::mem::transmute(&agentusername),
-                ) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        Self {
-            base__: windows_core::IInspectable_Vtbl::new::<Identity, IIsoSessionOps, OFFSET>(),
-            BehaviorVersion: BehaviorVersion::<Identity, OFFSET>,
-            AddUserAsync: AddUserAsync::<Identity, OFFSET>,
-            GetFeatureLevel: GetFeatureLevel::<Identity, OFFSET>,
-            RemoveUserAsync: RemoveUserAsync::<Identity, OFFSET>,
-            RunProcessWithOptionsAsync: RunProcessWithOptionsAsync::<Identity, OFFSET>,
-            StartSessionAsync: StartSessionAsync::<Identity, OFFSET>,
-            StopSessionAsync: StopSessionAsync::<Identity, OFFSET>,
-        }
-    }
-    pub fn matches(iid: &windows_core::GUID) -> bool {
-        iid == &<IIsoSessionOps as windows_core::Interface>::IID
-    }
-}
-#[repr(C)]
-#[doc(hidden)]
-pub struct IIsoSessionOps_Vtbl {
-    pub base__: windows_core::IInspectable_Vtbl,
-    pub BehaviorVersion:
-        unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
-    pub AddUserAsync: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut core::ffi::c_void,
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-    pub GetFeatureLevel: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        IsoSessionFeature,
-        *mut i32,
-    ) -> windows_core::HRESULT,
-    pub RemoveUserAsync: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-    pub RunProcessWithOptionsAsync: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut core::ffi::c_void,
-        *mut core::ffi::c_void,
-        *mut core::ffi::c_void,
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-    pub StartSessionAsync: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut core::ffi::c_void,
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-    pub StopSessionAsync: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-}
-windows_core::imp::define_interface!(
-    IIsoSessionOpsPreview2,
-    IIsoSessionOpsPreview2_Vtbl,
-    0x2e26214d_02c1_5dc5_9ce7_f9a41cddd5b1
-);
-impl windows_core::RuntimeType for IIsoSessionOpsPreview2 {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_interface::<Self>();
-}
-impl windows_core::RuntimeName for IIsoSessionOpsPreview2 {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionOpsPreview2";
-}
-pub trait IIsoSessionOpsPreview2_Impl: windows_core::IUnknownImpl {
-    fn AddUserAsync2(
-        &self,
-        optAppId: &windows_core::HSTRING,
-        optEnterpriseAccountName: &windows_core::HSTRING,
-        optWamToken: &windows_core::HSTRING,
-    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionUserResult>>;
-}
-impl IIsoSessionOpsPreview2_Vtbl {
-    pub const fn new<Identity: IIsoSessionOpsPreview2_Impl, const OFFSET: isize>() -> Self {
-        unsafe extern "system" fn AddUserAsync2<
-            Identity: IIsoSessionOpsPreview2_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            optappid: *mut core::ffi::c_void,
-            optenterpriseaccountname: *mut core::ffi::c_void,
-            optwamtoken: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionOpsPreview2_Impl::AddUserAsync2(
-                    this,
-                    core::mem::transmute(&optappid),
-                    core::mem::transmute(&optenterpriseaccountname),
-                    core::mem::transmute(&optwamtoken),
-                ) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        Self {
-            base__: windows_core::IInspectable_Vtbl::new::<Identity, IIsoSessionOpsPreview2, OFFSET>(
-            ),
-            AddUserAsync2: AddUserAsync2::<Identity, OFFSET>,
-        }
-    }
-    pub fn matches(iid: &windows_core::GUID) -> bool {
-        iid == &<IIsoSessionOpsPreview2 as windows_core::Interface>::IID
-    }
-}
-#[repr(C)]
-#[doc(hidden)]
-pub struct IIsoSessionOpsPreview2_Vtbl {
-    pub base__: windows_core::IInspectable_Vtbl,
-    pub AddUserAsync2: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut core::ffi::c_void,
-        *mut core::ffi::c_void,
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-}
-windows_core::imp::define_interface!(
-    IIsoSessionOpsPreview3,
-    IIsoSessionOpsPreview3_Vtbl,
-    0x142b6655_e129_570d_902f_c20483662239
-);
-impl windows_core::RuntimeType for IIsoSessionOpsPreview3 {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_interface::<Self>();
-}
-impl windows_core::RuntimeName for IIsoSessionOpsPreview3 {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionOpsPreview3";
-}
-pub trait IIsoSessionOpsPreview3_Impl: windows_core::IUnknownImpl {
-    fn IsLocalAgentUserSupported(&self) -> windows_core::Result<bool>;
-    fn IsEnterpriseAgentUserSupported(&self) -> windows_core::Result<bool>;
-    fn IsAppScopedRegistrationSupported(&self) -> windows_core::Result<bool>;
-}
-impl IIsoSessionOpsPreview3_Vtbl {
-    pub const fn new<Identity: IIsoSessionOpsPreview3_Impl, const OFFSET: isize>() -> Self {
-        unsafe extern "system" fn IsLocalAgentUserSupported<
-            Identity: IIsoSessionOpsPreview3_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut bool,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionOpsPreview3_Impl::IsLocalAgentUserSupported(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn IsEnterpriseAgentUserSupported<
-            Identity: IIsoSessionOpsPreview3_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut bool,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionOpsPreview3_Impl::IsEnterpriseAgentUserSupported(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn IsAppScopedRegistrationSupported<
-            Identity: IIsoSessionOpsPreview3_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut bool,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionOpsPreview3_Impl::IsAppScopedRegistrationSupported(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        Self {
-            base__: windows_core::IInspectable_Vtbl::new::<Identity, IIsoSessionOpsPreview3, OFFSET>(
-            ),
-            IsLocalAgentUserSupported: IsLocalAgentUserSupported::<Identity, OFFSET>,
-            IsEnterpriseAgentUserSupported: IsEnterpriseAgentUserSupported::<Identity, OFFSET>,
-            IsAppScopedRegistrationSupported: IsAppScopedRegistrationSupported::<Identity, OFFSET>,
-        }
-    }
-    pub fn matches(iid: &windows_core::GUID) -> bool {
-        iid == &<IIsoSessionOpsPreview3 as windows_core::Interface>::IID
-    }
-}
-#[repr(C)]
-#[doc(hidden)]
-pub struct IIsoSessionOpsPreview3_Vtbl {
-    pub base__: windows_core::IInspectable_Vtbl,
-    pub IsLocalAgentUserSupported:
-        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
-    pub IsEnterpriseAgentUserSupported:
-        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
-    pub IsAppScopedRegistrationSupported:
-        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
-}
-windows_core::imp::define_interface!(
-    IIsoSessionOpsPreview4,
-    IIsoSessionOpsPreview4_Vtbl,
-    0x4d27018c_d1b8_5cdb_9e41_97635fbb59fd
-);
-impl windows_core::RuntimeType for IIsoSessionOpsPreview4 {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_interface::<Self>();
-}
-impl windows_core::RuntimeName for IIsoSessionOpsPreview4 {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionOpsPreview4";
-}
-pub trait IIsoSessionOpsPreview4_Impl: windows_core::IUnknownImpl {
-    fn IsDeducedEnterpriseAgentUserSupported(&self) -> windows_core::Result<bool>;
-    fn AddUserAsync3(
-        &self,
-        optAppId: &windows_core::HSTRING,
-        parentWindowId: &windows::UI::WindowId,
-    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionUserResult>>;
-    fn StartSessionAsync2(
-        &self,
-        agentUserName: &windows_core::HSTRING,
-        parentWindowId: &windows::UI::WindowId,
-    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionResult>>;
-}
-impl IIsoSessionOpsPreview4_Vtbl {
-    pub const fn new<Identity: IIsoSessionOpsPreview4_Impl, const OFFSET: isize>() -> Self {
-        unsafe extern "system" fn IsDeducedEnterpriseAgentUserSupported<
-            Identity: IIsoSessionOpsPreview4_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut bool,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionOpsPreview4_Impl::IsDeducedEnterpriseAgentUserSupported(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn AddUserAsync3<
-            Identity: IIsoSessionOpsPreview4_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            optappid: *mut core::ffi::c_void,
-            parentwindowid: windows::UI::WindowId,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionOpsPreview4_Impl::AddUserAsync3(
-                    this,
-                    core::mem::transmute(&optappid),
-                    core::mem::transmute(&parentwindowid),
-                ) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn StartSessionAsync2<
-            Identity: IIsoSessionOpsPreview4_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            agentusername: *mut core::ffi::c_void,
-            parentwindowid: windows::UI::WindowId,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionOpsPreview4_Impl::StartSessionAsync2(
-                    this,
-                    core::mem::transmute(&agentusername),
-                    core::mem::transmute(&parentwindowid),
-                ) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        Self {
-            base__: windows_core::IInspectable_Vtbl::new::<Identity, IIsoSessionOpsPreview4, OFFSET>(
-            ),
-            IsDeducedEnterpriseAgentUserSupported: IsDeducedEnterpriseAgentUserSupported::<
-                Identity,
-                OFFSET,
-            >,
-            AddUserAsync3: AddUserAsync3::<Identity, OFFSET>,
-            StartSessionAsync2: StartSessionAsync2::<Identity, OFFSET>,
-        }
-    }
-    pub fn matches(iid: &windows_core::GUID) -> bool {
-        iid == &<IIsoSessionOpsPreview4 as windows_core::Interface>::IID
-    }
-}
-#[repr(C)]
-#[doc(hidden)]
-pub struct IIsoSessionOpsPreview4_Vtbl {
-    pub base__: windows_core::IInspectable_Vtbl,
-    pub IsDeducedEnterpriseAgentUserSupported:
-        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
-    pub AddUserAsync3: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut core::ffi::c_void,
-        windows::UI::WindowId,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-    pub StartSessionAsync2: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut core::ffi::c_void,
-        windows::UI::WindowId,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-}
-windows_core::imp::define_interface!(
-    IIsoSessionProcess,
-    IIsoSessionProcess_Vtbl,
-    0x1cccc074_ce04_527c_8b2f_d367930af570
-);
-impl windows_core::RuntimeType for IIsoSessionProcess {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_interface::<Self>();
-}
-impl windows_core::RuntimeName for IIsoSessionProcess {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionProcess";
-}
-pub trait IIsoSessionProcess_Impl: windows_core::IUnknownImpl {
-    fn ErrorHandle(&self) -> windows_core::Result<u64>;
-    fn ExitCode(&self) -> windows_core::Result<i32>;
-    fn InputHandle(&self) -> windows_core::Result<u64>;
-    fn OutputHandle(&self) -> windows_core::Result<u64>;
-    fn CloseStandardInput(&self) -> windows_core::Result<()>;
-    fn ResizeConsole(&self, columns: u16, rows: u16) -> windows_core::Result<()>;
-    fn SendCtrlClose(&self) -> windows_core::Result<()>;
-    fn Terminate(&self) -> windows_core::Result<()>;
-    fn WaitForExit(&self, timeoutMs: u32) -> windows_core::Result<i32>;
-}
-impl IIsoSessionProcess_Vtbl {
-    pub const fn new<Identity: IIsoSessionProcess_Impl, const OFFSET: isize>() -> Self {
-        unsafe extern "system" fn ErrorHandle<
-            Identity: IIsoSessionProcess_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut u64,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionProcess_Impl::ErrorHandle(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn ExitCode<
-            Identity: IIsoSessionProcess_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut i32,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionProcess_Impl::ExitCode(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn InputHandle<
-            Identity: IIsoSessionProcess_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut u64,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionProcess_Impl::InputHandle(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn OutputHandle<
-            Identity: IIsoSessionProcess_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut u64,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionProcess_Impl::OutputHandle(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn CloseStandardInput<
-            Identity: IIsoSessionProcess_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                IIsoSessionProcess_Impl::CloseStandardInput(this).into()
-            }
-        }
-        unsafe extern "system" fn ResizeConsole<
-            Identity: IIsoSessionProcess_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            columns: u16,
-            rows: u16,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                IIsoSessionProcess_Impl::ResizeConsole(this, columns, rows).into()
-            }
-        }
-        unsafe extern "system" fn SendCtrlClose<
-            Identity: IIsoSessionProcess_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                IIsoSessionProcess_Impl::SendCtrlClose(this).into()
-            }
-        }
-        unsafe extern "system" fn Terminate<
-            Identity: IIsoSessionProcess_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                IIsoSessionProcess_Impl::Terminate(this).into()
-            }
-        }
-        unsafe extern "system" fn WaitForExit<
-            Identity: IIsoSessionProcess_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            timeoutms: u32,
-            result__: *mut i32,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionProcess_Impl::WaitForExit(this, timeoutms) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        Self {
-            base__: windows_core::IInspectable_Vtbl::new::<Identity, IIsoSessionProcess, OFFSET>(),
-            ErrorHandle: ErrorHandle::<Identity, OFFSET>,
-            ExitCode: ExitCode::<Identity, OFFSET>,
-            InputHandle: InputHandle::<Identity, OFFSET>,
-            OutputHandle: OutputHandle::<Identity, OFFSET>,
-            CloseStandardInput: CloseStandardInput::<Identity, OFFSET>,
-            ResizeConsole: ResizeConsole::<Identity, OFFSET>,
-            SendCtrlClose: SendCtrlClose::<Identity, OFFSET>,
-            Terminate: Terminate::<Identity, OFFSET>,
-            WaitForExit: WaitForExit::<Identity, OFFSET>,
-        }
-    }
-    pub fn matches(iid: &windows_core::GUID) -> bool {
-        iid == &<IIsoSessionProcess as windows_core::Interface>::IID
-    }
-}
-#[repr(C)]
-#[doc(hidden)]
-pub struct IIsoSessionProcess_Vtbl {
-    pub base__: windows_core::IInspectable_Vtbl,
-    pub ErrorHandle:
-        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
-    pub ExitCode:
-        unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
-    pub InputHandle:
-        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
-    pub OutputHandle:
-        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
-    pub CloseStandardInput:
-        unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
-    pub ResizeConsole:
-        unsafe extern "system" fn(*mut core::ffi::c_void, u16, u16) -> windows_core::HRESULT,
-    pub SendCtrlClose: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
-    pub Terminate: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
-    pub WaitForExit:
-        unsafe extern "system" fn(*mut core::ffi::c_void, u32, *mut i32) -> windows_core::HRESULT,
-}
-windows_core::imp::define_interface!(
-    IIsoSessionProcessOptions,
-    IIsoSessionProcessOptions_Vtbl,
-    0x20e0f2f6_3b48_5f60_b97c_e856754ded74
-);
-impl windows_core::RuntimeType for IIsoSessionProcessOptions {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_interface::<Self>();
-}
-impl windows_core::RuntimeName for IIsoSessionProcessOptions {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionProcessOptions";
-}
-pub trait IIsoSessionProcessOptions_Impl: windows_core::IUnknownImpl {
-    fn Environment(
-        &self,
-    ) -> windows_core::Result<windows_collections::IMap<windows_core::HSTRING, windows_core::HSTRING>>;
-    fn InteractiveConsole(&self) -> windows_core::Result<bool>;
-    fn SetInteractiveConsole(&self, value: bool) -> windows_core::Result<()>;
-    fn RedirectStandardError(&self) -> windows_core::Result<bool>;
-    fn SetRedirectStandardError(&self, value: bool) -> windows_core::Result<()>;
-    fn RedirectStandardInput(&self) -> windows_core::Result<bool>;
-    fn SetRedirectStandardInput(&self, value: bool) -> windows_core::Result<()>;
-    fn RedirectStandardOutput(&self) -> windows_core::Result<bool>;
-    fn SetRedirectStandardOutput(&self, value: bool) -> windows_core::Result<()>;
-    fn TimeoutMilliseconds(&self) -> windows_core::Result<u32>;
-    fn SetTimeoutMilliseconds(&self, value: u32) -> windows_core::Result<()>;
-    fn WorkingDirectory(&self) -> windows_core::Result<windows_core::HSTRING>;
-    fn SetWorkingDirectory(&self, value: &windows_core::HSTRING) -> windows_core::Result<()>;
-}
-impl IIsoSessionProcessOptions_Vtbl {
-    pub const fn new<Identity: IIsoSessionProcessOptions_Impl, const OFFSET: isize>() -> Self {
-        unsafe extern "system" fn Environment<
-            Identity: IIsoSessionProcessOptions_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionProcessOptions_Impl::Environment(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn InteractiveConsole<
-            Identity: IIsoSessionProcessOptions_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut bool,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionProcessOptions_Impl::InteractiveConsole(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn SetInteractiveConsole<
-            Identity: IIsoSessionProcessOptions_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            value: bool,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                IIsoSessionProcessOptions_Impl::SetInteractiveConsole(this, value).into()
-            }
-        }
-        unsafe extern "system" fn RedirectStandardError<
-            Identity: IIsoSessionProcessOptions_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut bool,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionProcessOptions_Impl::RedirectStandardError(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn SetRedirectStandardError<
-            Identity: IIsoSessionProcessOptions_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            value: bool,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                IIsoSessionProcessOptions_Impl::SetRedirectStandardError(this, value).into()
-            }
-        }
-        unsafe extern "system" fn RedirectStandardInput<
-            Identity: IIsoSessionProcessOptions_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut bool,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionProcessOptions_Impl::RedirectStandardInput(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn SetRedirectStandardInput<
-            Identity: IIsoSessionProcessOptions_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            value: bool,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                IIsoSessionProcessOptions_Impl::SetRedirectStandardInput(this, value).into()
-            }
-        }
-        unsafe extern "system" fn RedirectStandardOutput<
-            Identity: IIsoSessionProcessOptions_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut bool,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionProcessOptions_Impl::RedirectStandardOutput(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn SetRedirectStandardOutput<
-            Identity: IIsoSessionProcessOptions_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            value: bool,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                IIsoSessionProcessOptions_Impl::SetRedirectStandardOutput(this, value).into()
-            }
-        }
-        unsafe extern "system" fn TimeoutMilliseconds<
-            Identity: IIsoSessionProcessOptions_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut u32,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionProcessOptions_Impl::TimeoutMilliseconds(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn SetTimeoutMilliseconds<
-            Identity: IIsoSessionProcessOptions_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            value: u32,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                IIsoSessionProcessOptions_Impl::SetTimeoutMilliseconds(this, value).into()
-            }
-        }
-        unsafe extern "system" fn WorkingDirectory<
-            Identity: IIsoSessionProcessOptions_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionProcessOptions_Impl::WorkingDirectory(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn SetWorkingDirectory<
-            Identity: IIsoSessionProcessOptions_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            value: *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                IIsoSessionProcessOptions_Impl::SetWorkingDirectory(
-                    this,
-                    core::mem::transmute(&value),
-                )
-                .into()
-            }
-        }
-        Self {
-            base__: windows_core::IInspectable_Vtbl::new::<
-                Identity,
-                IIsoSessionProcessOptions,
-                OFFSET,
-            >(),
-            Environment: Environment::<Identity, OFFSET>,
-            InteractiveConsole: InteractiveConsole::<Identity, OFFSET>,
-            SetInteractiveConsole: SetInteractiveConsole::<Identity, OFFSET>,
-            RedirectStandardError: RedirectStandardError::<Identity, OFFSET>,
-            SetRedirectStandardError: SetRedirectStandardError::<Identity, OFFSET>,
-            RedirectStandardInput: RedirectStandardInput::<Identity, OFFSET>,
-            SetRedirectStandardInput: SetRedirectStandardInput::<Identity, OFFSET>,
-            RedirectStandardOutput: RedirectStandardOutput::<Identity, OFFSET>,
-            SetRedirectStandardOutput: SetRedirectStandardOutput::<Identity, OFFSET>,
-            TimeoutMilliseconds: TimeoutMilliseconds::<Identity, OFFSET>,
-            SetTimeoutMilliseconds: SetTimeoutMilliseconds::<Identity, OFFSET>,
-            WorkingDirectory: WorkingDirectory::<Identity, OFFSET>,
-            SetWorkingDirectory: SetWorkingDirectory::<Identity, OFFSET>,
-        }
-    }
-    pub fn matches(iid: &windows_core::GUID) -> bool {
-        iid == &<IIsoSessionProcessOptions as windows_core::Interface>::IID
-    }
-}
-#[repr(C)]
-#[doc(hidden)]
-pub struct IIsoSessionProcessOptions_Vtbl {
-    pub base__: windows_core::IInspectable_Vtbl,
-    pub Environment: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-    pub InteractiveConsole:
-        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
-    pub SetInteractiveConsole:
-        unsafe extern "system" fn(*mut core::ffi::c_void, bool) -> windows_core::HRESULT,
-    pub RedirectStandardError:
-        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
-    pub SetRedirectStandardError:
-        unsafe extern "system" fn(*mut core::ffi::c_void, bool) -> windows_core::HRESULT,
-    pub RedirectStandardInput:
-        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
-    pub SetRedirectStandardInput:
-        unsafe extern "system" fn(*mut core::ffi::c_void, bool) -> windows_core::HRESULT,
-    pub RedirectStandardOutput:
-        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
-    pub SetRedirectStandardOutput:
-        unsafe extern "system" fn(*mut core::ffi::c_void, bool) -> windows_core::HRESULT,
-    pub TimeoutMilliseconds:
-        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
-    pub SetTimeoutMilliseconds:
-        unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
-    pub WorkingDirectory: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-    pub SetWorkingDirectory: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-}
-windows_core::imp::define_interface!(
-    IIsoSessionProcessPreview2,
-    IIsoSessionProcessPreview2_Vtbl,
-    0xeb6a3efa_736d_5301_a241_6d36eda0905a
-);
-impl windows_core::RuntimeType for IIsoSessionProcessPreview2 {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_interface::<Self>();
-}
-impl windows_core::RuntimeName for IIsoSessionProcessPreview2 {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionProcessPreview2";
-}
-pub trait IIsoSessionProcessPreview2_Impl: windows_core::IUnknownImpl {
-    fn IsRunning(&self) -> windows_core::Result<bool>;
-    fn Exited(
-        &self,
-        handler: windows_core::Ref<
-            '_,
-            windows::Foundation::TypedEventHandler<IsoSessionProcess, windows_core::IInspectable>,
-        >,
-    ) -> windows_core::Result<i64>;
-    fn RemoveExited(&self, token: i64) -> windows_core::Result<()>;
-}
-impl IIsoSessionProcessPreview2_Vtbl {
-    pub const fn new<Identity: IIsoSessionProcessPreview2_Impl, const OFFSET: isize>() -> Self {
-        unsafe extern "system" fn IsRunning<
-            Identity: IIsoSessionProcessPreview2_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut bool,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionProcessPreview2_Impl::IsRunning(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn Exited<
-            Identity: IIsoSessionProcessPreview2_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            handler: *mut core::ffi::c_void,
-            result__: *mut i64,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionProcessPreview2_Impl::Exited(
-                    this,
-                    core::mem::transmute_copy(&handler),
-                ) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn RemoveExited<
-            Identity: IIsoSessionProcessPreview2_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            token: i64,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                IIsoSessionProcessPreview2_Impl::RemoveExited(this, token).into()
-            }
-        }
-        Self {
-            base__: windows_core::IInspectable_Vtbl::new::<
-                Identity,
-                IIsoSessionProcessPreview2,
-                OFFSET,
-            >(),
-            IsRunning: IsRunning::<Identity, OFFSET>,
-            Exited: Exited::<Identity, OFFSET>,
-            RemoveExited: RemoveExited::<Identity, OFFSET>,
-        }
-    }
-    pub fn matches(iid: &windows_core::GUID) -> bool {
-        iid == &<IIsoSessionProcessPreview2 as windows_core::Interface>::IID
-    }
-}
-#[repr(C)]
-#[doc(hidden)]
-pub struct IIsoSessionProcessPreview2_Vtbl {
-    pub base__: windows_core::IInspectable_Vtbl,
-    pub IsRunning:
-        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
-    pub Exited: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut core::ffi::c_void,
-        *mut i64,
-    ) -> windows_core::HRESULT,
-    pub RemoveExited:
-        unsafe extern "system" fn(*mut core::ffi::c_void, i64) -> windows_core::HRESULT,
-}
-windows_core::imp::define_interface!(
-    IIsoSessionProcessResult,
-    IIsoSessionProcessResult_Vtbl,
-    0x30c5f8a5_efb8_5872_b8f9_be625090b9ba
-);
-impl windows_core::RuntimeType for IIsoSessionProcessResult {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_interface::<Self>();
-}
-impl windows_core::RuntimeName for IIsoSessionProcessResult {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionProcessResult";
-}
-pub trait IIsoSessionProcessResult_Impl: windows_core::IUnknownImpl {
-    fn Error(&self) -> windows_core::Result<IsoSessionError>;
-    fn Process(&self) -> windows_core::Result<IsoSessionProcess>;
-}
-impl IIsoSessionProcessResult_Vtbl {
-    pub const fn new<Identity: IIsoSessionProcessResult_Impl, const OFFSET: isize>() -> Self {
-        unsafe extern "system" fn Error<
-            Identity: IIsoSessionProcessResult_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionProcessResult_Impl::Error(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn Process<
-            Identity: IIsoSessionProcessResult_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionProcessResult_Impl::Process(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        Self {
-            base__: windows_core::IInspectable_Vtbl::new::<
-                Identity,
-                IIsoSessionProcessResult,
-                OFFSET,
-            >(),
-            Error: Error::<Identity, OFFSET>,
-            Process: Process::<Identity, OFFSET>,
-        }
-    }
-    pub fn matches(iid: &windows_core::GUID) -> bool {
-        iid == &<IIsoSessionProcessResult as windows_core::Interface>::IID
-    }
-}
-#[repr(C)]
-#[doc(hidden)]
-pub struct IIsoSessionProcessResult_Vtbl {
-    pub base__: windows_core::IInspectable_Vtbl,
-    pub Error: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-    pub Process: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-}
-windows_core::imp::define_interface!(
-    IIsoSessionResult,
-    IIsoSessionResult_Vtbl,
-    0xc0f5de66_c487_571c_87a0_13a0854a7db0
-);
-impl windows_core::RuntimeType for IIsoSessionResult {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_interface::<Self>();
-}
-impl windows_core::RuntimeName for IIsoSessionResult {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionResult";
-}
-pub trait IIsoSessionResult_Impl: windows_core::IUnknownImpl {
-    fn Error(&self) -> windows_core::Result<IsoSessionError>;
-}
-impl IIsoSessionResult_Vtbl {
-    pub const fn new<Identity: IIsoSessionResult_Impl, const OFFSET: isize>() -> Self {
-        unsafe extern "system" fn Error<Identity: IIsoSessionResult_Impl, const OFFSET: isize>(
-            this: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionResult_Impl::Error(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        Self {
-            base__: windows_core::IInspectable_Vtbl::new::<Identity, IIsoSessionResult, OFFSET>(),
-            Error: Error::<Identity, OFFSET>,
-        }
-    }
-    pub fn matches(iid: &windows_core::GUID) -> bool {
-        iid == &<IIsoSessionResult as windows_core::Interface>::IID
-    }
-}
-#[repr(C)]
-#[doc(hidden)]
-pub struct IIsoSessionResult_Vtbl {
-    pub base__: windows_core::IInspectable_Vtbl,
-    pub Error: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-}
-windows_core::imp::define_interface!(
-    IIsoSessionUserResult,
-    IIsoSessionUserResult_Vtbl,
-    0x8733fb07_cce2_5483_95a7_0a68cbd7641a
-);
-impl windows_core::RuntimeType for IIsoSessionUserResult {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_interface::<Self>();
-}
-impl windows_core::RuntimeName for IIsoSessionUserResult {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionUserResult";
-}
-pub trait IIsoSessionUserResult_Impl: windows_core::IUnknownImpl {
-    fn AgentUserName(&self) -> windows_core::Result<windows_core::HSTRING>;
-    fn AgentUserSid(&self) -> windows_core::Result<windows_core::HSTRING>;
-    fn EphemeralWorkspacePath(&self) -> windows_core::Result<windows_core::HSTRING>;
-    fn Error(&self) -> windows_core::Result<IsoSessionError>;
-}
-impl IIsoSessionUserResult_Vtbl {
-    pub const fn new<Identity: IIsoSessionUserResult_Impl, const OFFSET: isize>() -> Self {
-        unsafe extern "system" fn AgentUserName<
-            Identity: IIsoSessionUserResult_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionUserResult_Impl::AgentUserName(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn AgentUserSid<
-            Identity: IIsoSessionUserResult_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionUserResult_Impl::AgentUserSid(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn EphemeralWorkspacePath<
-            Identity: IIsoSessionUserResult_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionUserResult_Impl::EphemeralWorkspacePath(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        unsafe extern "system" fn Error<
-            Identity: IIsoSessionUserResult_Impl,
-            const OFFSET: isize,
-        >(
-            this: *mut core::ffi::c_void,
-            result__: *mut *mut core::ffi::c_void,
-        ) -> windows_core::HRESULT {
-            unsafe {
-                let this: &Identity =
-                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
-                match IIsoSessionUserResult_Impl::Error(this) {
-                    Ok(ok__) => {
-                        result__.write(core::mem::transmute_copy(&ok__));
-                        core::mem::forget(ok__);
-                        windows_core::HRESULT(0)
-                    }
-                    Err(err) => err.into(),
-                }
-            }
-        }
-        Self {
-            base__: windows_core::IInspectable_Vtbl::new::<Identity, IIsoSessionUserResult, OFFSET>(
-            ),
-            AgentUserName: AgentUserName::<Identity, OFFSET>,
-            AgentUserSid: AgentUserSid::<Identity, OFFSET>,
-            EphemeralWorkspacePath: EphemeralWorkspacePath::<Identity, OFFSET>,
-            Error: Error::<Identity, OFFSET>,
-        }
-    }
-    pub fn matches(iid: &windows_core::GUID) -> bool {
-        iid == &<IIsoSessionUserResult as windows_core::Interface>::IID
-    }
-}
-#[repr(C)]
-#[doc(hidden)]
-pub struct IIsoSessionUserResult_Vtbl {
-    pub base__: windows_core::IInspectable_Vtbl,
-    pub AgentUserName: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-    pub AgentUserSid: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-    pub EphemeralWorkspacePath: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-    pub Error: unsafe extern "system" fn(
-        *mut core::ffi::c_void,
-        *mut *mut core::ffi::c_void,
-    ) -> windows_core::HRESULT,
-}
-#[repr(transparent)]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct IsoSessionError(windows_core::IUnknown);
-windows_core::imp::interface_hierarchy!(
-    IsoSessionError,
-    windows_core::IUnknown,
-    windows_core::IInspectable
-);
-impl IsoSessionError {
-    pub fn new() -> windows_core::Result<Self> {
-        Self::IActivationFactory(|f| f.ActivateInstance::<Self>())
-    }
-    fn IActivationFactory<
-        R,
-        F: FnOnce(&windows_core::imp::IGenericFactory) -> windows_core::Result<R>,
-    >(
-        callback: F,
-    ) -> windows_core::Result<R> {
-        static SHARED: windows_core::imp::FactoryCache<
-            IsoSessionError,
-            windows_core::imp::IGenericFactory,
-        > = windows_core::imp::FactoryCache::new();
-        SHARED.call(callback)
-    }
-    pub fn Code(&self) -> windows_core::Result<windows_core::HRESULT> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).Code)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn IsError(&self) -> windows_core::Result<bool> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).IsError)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn Message(&self) -> windows_core::Result<windows_core::HSTRING> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).Message)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| core::mem::transmute(result__))
-        }
-    }
-    pub fn Remediation(&self) -> windows_core::Result<windows_core::HSTRING> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).Remediation)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| core::mem::transmute(result__))
-        }
-    }
-    pub fn Diagnostics(&self) -> windows_core::Result<windows_core::HSTRING> {
-        let this = &windows_core::Interface::cast::<IIsoSessionErrorPreview2>(self)?;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).Diagnostics)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| core::mem::transmute(result__))
-        }
-    }
-    pub fn FailingStage(&self) -> windows_core::Result<windows_core::HSTRING> {
-        let this = &windows_core::Interface::cast::<IIsoSessionErrorPreview2>(self)?;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).FailingStage)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| core::mem::transmute(result__))
-        }
-    }
-    pub fn UnderlyingError(&self) -> windows_core::Result<windows_core::HRESULT> {
-        let this = &windows_core::Interface::cast::<IIsoSessionErrorPreview2>(self)?;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).UnderlyingError)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn Format(&self) -> windows_core::Result<windows_core::HSTRING> {
-        let this = &windows_core::Interface::cast::<IIsoSessionErrorPreview3>(self)?;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).Format)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| core::mem::transmute(result__))
-        }
-    }
-}
-impl windows_core::RuntimeType for IsoSessionError {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_class::<Self, IIsoSessionError>();
-}
-unsafe impl windows_core::Interface for IsoSessionError {
-    type Vtable = <IIsoSessionError as windows_core::Interface>::Vtable;
-    const IID: windows_core::GUID = <IIsoSessionError as windows_core::Interface>::IID;
-}
-impl windows_core::RuntimeName for IsoSessionError {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IsoSessionError";
-}
-unsafe impl Send for IsoSessionError {}
-unsafe impl Sync for IsoSessionError {}
-#[repr(transparent)]
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
-pub struct IsoSessionFeature(pub i32);
-impl IsoSessionFeature {
-    pub const Unknown: Self = Self(0i32);
-    pub const LocalAgentUser: Self = Self(1i32);
-    pub const EnterpriseAgentUser: Self = Self(2i32);
-    pub const AppScopedRegistration: Self = Self(3i32);
-    pub const DeducedEnterpriseAgentUser: Self = Self(4i32);
-}
-impl windows_core::TypeKind for IsoSessionFeature {
-    type TypeKind = windows_core::CopyType;
-}
-impl windows_core::RuntimeType for IsoSessionFeature {
-    const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::from_slice(
-        b"enum(Windows.AI.IsolationSession.Preview.IsoSessionFeature;i4)",
-    );
-}
-#[repr(transparent)]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct IsoSessionOps(windows_core::IUnknown);
-windows_core::imp::interface_hierarchy!(
-    IsoSessionOps,
-    windows_core::IUnknown,
-    windows_core::IInspectable
-);
-impl IsoSessionOps {
-    pub fn new() -> windows_core::Result<Self> {
-        Self::IActivationFactory(|f| f.ActivateInstance::<Self>())
-    }
-    fn IActivationFactory<
-        R,
-        F: FnOnce(&windows_core::imp::IGenericFactory) -> windows_core::Result<R>,
-    >(
-        callback: F,
-    ) -> windows_core::Result<R> {
-        static SHARED: windows_core::imp::FactoryCache<
-            IsoSessionOps,
-            windows_core::imp::IGenericFactory,
-        > = windows_core::imp::FactoryCache::new();
-        SHARED.call(callback)
-    }
-    pub fn BehaviorVersion(&self) -> windows_core::Result<i32> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).BehaviorVersion)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn AddUserAsync(
-        &self,
-        optenterpriseaccountname: &windows_core::HSTRING,
-        optwamtoken: &windows_core::HSTRING,
-    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionUserResult>> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).AddUserAsync)(
-                windows_core::Interface::as_raw(this),
-                core::mem::transmute_copy(optenterpriseaccountname),
-                core::mem::transmute_copy(optwamtoken),
-                &mut result__,
-            )
-            .and_then(|| windows_core::Type::from_abi(result__))
-        }
-    }
-    pub fn GetFeatureLevel(&self, feature: IsoSessionFeature) -> windows_core::Result<i32> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).GetFeatureLevel)(
-                windows_core::Interface::as_raw(this),
-                feature,
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn RemoveUserAsync(
-        &self,
-        agentusername: &windows_core::HSTRING,
-    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionResult>> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).RemoveUserAsync)(
-                windows_core::Interface::as_raw(this),
-                core::mem::transmute_copy(agentusername),
-                &mut result__,
-            )
-            .and_then(|| windows_core::Type::from_abi(result__))
-        }
-    }
-    pub fn RunProcessWithOptionsAsync<P3>(
-        &self,
-        agentusername: &windows_core::HSTRING,
-        processpath: &windows_core::HSTRING,
-        arguments: &windows_core::HSTRING,
-        options: P3,
-    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionProcessResult>>
-    where
-        P3: windows_core::Param<IsoSessionProcessOptions>,
-    {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).RunProcessWithOptionsAsync)(
-                windows_core::Interface::as_raw(this),
-                core::mem::transmute_copy(agentusername),
-                core::mem::transmute_copy(processpath),
-                core::mem::transmute_copy(arguments),
-                options.param().abi(),
-                &mut result__,
-            )
-            .and_then(|| windows_core::Type::from_abi(result__))
-        }
-    }
-    pub fn StartSessionAsync(
-        &self,
-        agentusername: &windows_core::HSTRING,
-        optwamtoken: &windows_core::HSTRING,
-    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionResult>> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).StartSessionAsync)(
-                windows_core::Interface::as_raw(this),
-                core::mem::transmute_copy(agentusername),
-                core::mem::transmute_copy(optwamtoken),
-                &mut result__,
-            )
-            .and_then(|| windows_core::Type::from_abi(result__))
-        }
-    }
-    pub fn StopSessionAsync(
-        &self,
-        agentusername: &windows_core::HSTRING,
-    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionResult>> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).StopSessionAsync)(
-                windows_core::Interface::as_raw(this),
-                core::mem::transmute_copy(agentusername),
-                &mut result__,
-            )
-            .and_then(|| windows_core::Type::from_abi(result__))
-        }
-    }
-    pub fn AddUserAsync2(
-        &self,
-        optappid: &windows_core::HSTRING,
-        optenterpriseaccountname: &windows_core::HSTRING,
-        optwamtoken: &windows_core::HSTRING,
-    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionUserResult>> {
-        let this = &windows_core::Interface::cast::<IIsoSessionOpsPreview2>(self)?;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).AddUserAsync2)(
-                windows_core::Interface::as_raw(this),
-                core::mem::transmute_copy(optappid),
-                core::mem::transmute_copy(optenterpriseaccountname),
-                core::mem::transmute_copy(optwamtoken),
-                &mut result__,
-            )
-            .and_then(|| windows_core::Type::from_abi(result__))
-        }
-    }
-    pub fn IsLocalAgentUserSupported(&self) -> windows_core::Result<bool> {
-        let this = &windows_core::Interface::cast::<IIsoSessionOpsPreview3>(self)?;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).IsLocalAgentUserSupported)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn IsEnterpriseAgentUserSupported(&self) -> windows_core::Result<bool> {
-        let this = &windows_core::Interface::cast::<IIsoSessionOpsPreview3>(self)?;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).IsEnterpriseAgentUserSupported)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn IsAppScopedRegistrationSupported(&self) -> windows_core::Result<bool> {
-        let this = &windows_core::Interface::cast::<IIsoSessionOpsPreview3>(self)?;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).IsAppScopedRegistrationSupported)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn IsDeducedEnterpriseAgentUserSupported(&self) -> windows_core::Result<bool> {
-        let this = &windows_core::Interface::cast::<IIsoSessionOpsPreview4>(self)?;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).IsDeducedEnterpriseAgentUserSupported)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn AddUserAsync3(
-        &self,
-        optappid: &windows_core::HSTRING,
-        parentwindowid: windows::UI::WindowId,
-    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionUserResult>> {
-        let this = &windows_core::Interface::cast::<IIsoSessionOpsPreview4>(self)?;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).AddUserAsync3)(
-                windows_core::Interface::as_raw(this),
-                core::mem::transmute_copy(optappid),
-                parentwindowid,
-                &mut result__,
-            )
-            .and_then(|| windows_core::Type::from_abi(result__))
-        }
-    }
-    pub fn StartSessionAsync2(
-        &self,
-        agentusername: &windows_core::HSTRING,
-        parentwindowid: windows::UI::WindowId,
-    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionResult>> {
-        let this = &windows_core::Interface::cast::<IIsoSessionOpsPreview4>(self)?;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).StartSessionAsync2)(
-                windows_core::Interface::as_raw(this),
-                core::mem::transmute_copy(agentusername),
-                parentwindowid,
-                &mut result__,
-            )
-            .and_then(|| windows_core::Type::from_abi(result__))
-        }
-    }
-}
-impl windows_core::RuntimeType for IsoSessionOps {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_class::<Self, IIsoSessionOps>();
-}
-unsafe impl windows_core::Interface for IsoSessionOps {
-    type Vtable = <IIsoSessionOps as windows_core::Interface>::Vtable;
-    const IID: windows_core::GUID = <IIsoSessionOps as windows_core::Interface>::IID;
-}
-impl windows_core::RuntimeName for IsoSessionOps {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IsoSessionOps";
-}
-unsafe impl Send for IsoSessionOps {}
-unsafe impl Sync for IsoSessionOps {}
-#[repr(transparent)]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct IsoSessionProcess(windows_core::IUnknown);
-windows_core::imp::interface_hierarchy!(
-    IsoSessionProcess,
-    windows_core::IUnknown,
-    windows_core::IInspectable
-);
-windows_core::imp::required_hierarchy!(IsoSessionProcess, windows::Foundation::IClosable);
-impl IsoSessionProcess {
-    pub fn Close(&self) -> windows_core::Result<()> {
-        let this = &windows_core::Interface::cast::<windows::Foundation::IClosable>(self)?;
-        unsafe {
-            (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this))
-                .ok()
-        }
-    }
-    pub fn ErrorHandle(&self) -> windows_core::Result<u64> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).ErrorHandle)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn ExitCode(&self) -> windows_core::Result<i32> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).ExitCode)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn InputHandle(&self) -> windows_core::Result<u64> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).InputHandle)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn OutputHandle(&self) -> windows_core::Result<u64> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).OutputHandle)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn CloseStandardInput(&self) -> windows_core::Result<()> {
-        let this = self;
-        unsafe {
-            (windows_core::Interface::vtable(this).CloseStandardInput)(
-                windows_core::Interface::as_raw(this),
-            )
-            .ok()
-        }
-    }
-    pub fn ResizeConsole(&self, columns: u16, rows: u16) -> windows_core::Result<()> {
-        let this = self;
-        unsafe {
-            (windows_core::Interface::vtable(this).ResizeConsole)(
-                windows_core::Interface::as_raw(this),
-                columns,
-                rows,
-            )
-            .ok()
-        }
-    }
-    pub fn SendCtrlClose(&self) -> windows_core::Result<()> {
-        let this = self;
-        unsafe {
-            (windows_core::Interface::vtable(this).SendCtrlClose)(windows_core::Interface::as_raw(
-                this,
-            ))
-            .ok()
-        }
-    }
-    pub fn Terminate(&self) -> windows_core::Result<()> {
-        let this = self;
-        unsafe {
-            (windows_core::Interface::vtable(this).Terminate)(windows_core::Interface::as_raw(this))
-                .ok()
-        }
-    }
-    pub fn WaitForExit(&self, timeoutms: u32) -> windows_core::Result<i32> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).WaitForExit)(
-                windows_core::Interface::as_raw(this),
-                timeoutms,
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn IsRunning(&self) -> windows_core::Result<bool> {
-        let this = &windows_core::Interface::cast::<IIsoSessionProcessPreview2>(self)?;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).IsRunning)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn Exited<P0>(&self, handler: P0) -> windows_core::Result<i64>
-    where
-        P0: windows_core::Param<
-            windows::Foundation::TypedEventHandler<IsoSessionProcess, windows_core::IInspectable>,
-        >,
-    {
-        let this = &windows_core::Interface::cast::<IIsoSessionProcessPreview2>(self)?;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).Exited)(
-                windows_core::Interface::as_raw(this),
-                handler.param().abi(),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn RemoveExited(&self, token: i64) -> windows_core::Result<()> {
-        let this = &windows_core::Interface::cast::<IIsoSessionProcessPreview2>(self)?;
-        unsafe {
-            (windows_core::Interface::vtable(this).RemoveExited)(
-                windows_core::Interface::as_raw(this),
-                token,
-            )
-            .ok()
-        }
-    }
-}
-impl windows_core::RuntimeType for IsoSessionProcess {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_class::<Self, IIsoSessionProcess>();
-}
-unsafe impl windows_core::Interface for IsoSessionProcess {
-    type Vtable = <IIsoSessionProcess as windows_core::Interface>::Vtable;
-    const IID: windows_core::GUID = <IIsoSessionProcess as windows_core::Interface>::IID;
-}
-impl windows_core::RuntimeName for IsoSessionProcess {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IsoSessionProcess";
-}
-unsafe impl Send for IsoSessionProcess {}
-unsafe impl Sync for IsoSessionProcess {}
-#[repr(transparent)]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct IsoSessionProcessOptions(windows_core::IUnknown);
-windows_core::imp::interface_hierarchy!(
-    IsoSessionProcessOptions,
-    windows_core::IUnknown,
-    windows_core::IInspectable
-);
-impl IsoSessionProcessOptions {
-    pub fn new() -> windows_core::Result<Self> {
-        Self::IActivationFactory(|f| f.ActivateInstance::<Self>())
-    }
-    fn IActivationFactory<
-        R,
-        F: FnOnce(&windows_core::imp::IGenericFactory) -> windows_core::Result<R>,
-    >(
-        callback: F,
-    ) -> windows_core::Result<R> {
-        static SHARED: windows_core::imp::FactoryCache<
-            IsoSessionProcessOptions,
-            windows_core::imp::IGenericFactory,
-        > = windows_core::imp::FactoryCache::new();
-        SHARED.call(callback)
-    }
-    pub fn Environment(
-        &self,
-    ) -> windows_core::Result<windows_collections::IMap<windows_core::HSTRING, windows_core::HSTRING>>
-    {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).Environment)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .and_then(|| windows_core::Type::from_abi(result__))
-        }
-    }
-    pub fn InteractiveConsole(&self) -> windows_core::Result<bool> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).InteractiveConsole)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn SetInteractiveConsole(&self, value: bool) -> windows_core::Result<()> {
-        let this = self;
-        unsafe {
-            (windows_core::Interface::vtable(this).SetInteractiveConsole)(
-                windows_core::Interface::as_raw(this),
-                value,
-            )
-            .ok()
-        }
-    }
-    pub fn RedirectStandardError(&self) -> windows_core::Result<bool> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).RedirectStandardError)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn SetRedirectStandardError(&self, value: bool) -> windows_core::Result<()> {
-        let this = self;
-        unsafe {
-            (windows_core::Interface::vtable(this).SetRedirectStandardError)(
-                windows_core::Interface::as_raw(this),
-                value,
-            )
-            .ok()
-        }
-    }
-    pub fn RedirectStandardInput(&self) -> windows_core::Result<bool> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).RedirectStandardInput)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn SetRedirectStandardInput(&self, value: bool) -> windows_core::Result<()> {
-        let this = self;
-        unsafe {
-            (windows_core::Interface::vtable(this).SetRedirectStandardInput)(
-                windows_core::Interface::as_raw(this),
-                value,
-            )
-            .ok()
-        }
-    }
-    pub fn RedirectStandardOutput(&self) -> windows_core::Result<bool> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).RedirectStandardOutput)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn SetRedirectStandardOutput(&self, value: bool) -> windows_core::Result<()> {
-        let this = self;
-        unsafe {
-            (windows_core::Interface::vtable(this).SetRedirectStandardOutput)(
-                windows_core::Interface::as_raw(this),
-                value,
-            )
-            .ok()
-        }
-    }
-    pub fn TimeoutMilliseconds(&self) -> windows_core::Result<u32> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).TimeoutMilliseconds)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| result__)
-        }
-    }
-    pub fn SetTimeoutMilliseconds(&self, value: u32) -> windows_core::Result<()> {
-        let this = self;
-        unsafe {
-            (windows_core::Interface::vtable(this).SetTimeoutMilliseconds)(
-                windows_core::Interface::as_raw(this),
-                value,
-            )
-            .ok()
-        }
-    }
-    pub fn WorkingDirectory(&self) -> windows_core::Result<windows_core::HSTRING> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).WorkingDirectory)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| core::mem::transmute(result__))
-        }
-    }
-    pub fn SetWorkingDirectory(&self, value: &windows_core::HSTRING) -> windows_core::Result<()> {
-        let this = self;
-        unsafe {
-            (windows_core::Interface::vtable(this).SetWorkingDirectory)(
-                windows_core::Interface::as_raw(this),
-                core::mem::transmute_copy(value),
-            )
-            .ok()
-        }
-    }
-}
-impl windows_core::RuntimeType for IsoSessionProcessOptions {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_class::<Self, IIsoSessionProcessOptions>();
-}
-unsafe impl windows_core::Interface for IsoSessionProcessOptions {
-    type Vtable = <IIsoSessionProcessOptions as windows_core::Interface>::Vtable;
-    const IID: windows_core::GUID = <IIsoSessionProcessOptions as windows_core::Interface>::IID;
-}
-impl windows_core::RuntimeName for IsoSessionProcessOptions {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IsoSessionProcessOptions";
-}
-unsafe impl Send for IsoSessionProcessOptions {}
-unsafe impl Sync for IsoSessionProcessOptions {}
-#[repr(transparent)]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct IsoSessionProcessResult(windows_core::IUnknown);
-windows_core::imp::interface_hierarchy!(
-    IsoSessionProcessResult,
-    windows_core::IUnknown,
-    windows_core::IInspectable
-);
-impl IsoSessionProcessResult {
-    pub fn Error(&self) -> windows_core::Result<IsoSessionError> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).Error)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .and_then(|| windows_core::Type::from_abi(result__))
-        }
-    }
-    pub fn Process(&self) -> windows_core::Result<IsoSessionProcess> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).Process)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .and_then(|| windows_core::Type::from_abi(result__))
-        }
-    }
-}
-impl windows_core::RuntimeType for IsoSessionProcessResult {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_class::<Self, IIsoSessionProcessResult>();
-}
-unsafe impl windows_core::Interface for IsoSessionProcessResult {
-    type Vtable = <IIsoSessionProcessResult as windows_core::Interface>::Vtable;
-    const IID: windows_core::GUID = <IIsoSessionProcessResult as windows_core::Interface>::IID;
-}
-impl windows_core::RuntimeName for IsoSessionProcessResult {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IsoSessionProcessResult";
-}
-unsafe impl Send for IsoSessionProcessResult {}
-unsafe impl Sync for IsoSessionProcessResult {}
-#[repr(transparent)]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct IsoSessionResult(windows_core::IUnknown);
-windows_core::imp::interface_hierarchy!(
-    IsoSessionResult,
-    windows_core::IUnknown,
-    windows_core::IInspectable
-);
-impl IsoSessionResult {
-    pub fn Error(&self) -> windows_core::Result<IsoSessionError> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).Error)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .and_then(|| windows_core::Type::from_abi(result__))
-        }
-    }
-}
-impl windows_core::RuntimeType for IsoSessionResult {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_class::<Self, IIsoSessionResult>();
-}
-unsafe impl windows_core::Interface for IsoSessionResult {
-    type Vtable = <IIsoSessionResult as windows_core::Interface>::Vtable;
-    const IID: windows_core::GUID = <IIsoSessionResult as windows_core::Interface>::IID;
-}
-impl windows_core::RuntimeName for IsoSessionResult {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IsoSessionResult";
-}
-unsafe impl Send for IsoSessionResult {}
-unsafe impl Sync for IsoSessionResult {}
-#[repr(transparent)]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct IsoSessionUserResult(windows_core::IUnknown);
-windows_core::imp::interface_hierarchy!(
-    IsoSessionUserResult,
-    windows_core::IUnknown,
-    windows_core::IInspectable
-);
-impl IsoSessionUserResult {
-    pub fn AgentUserName(&self) -> windows_core::Result<windows_core::HSTRING> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).AgentUserName)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| core::mem::transmute(result__))
-        }
-    }
-    pub fn AgentUserSid(&self) -> windows_core::Result<windows_core::HSTRING> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).AgentUserSid)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| core::mem::transmute(result__))
-        }
-    }
-    pub fn EphemeralWorkspacePath(&self) -> windows_core::Result<windows_core::HSTRING> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).EphemeralWorkspacePath)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .map(|| core::mem::transmute(result__))
-        }
-    }
-    pub fn Error(&self) -> windows_core::Result<IsoSessionError> {
-        let this = self;
-        unsafe {
-            let mut result__ = core::mem::zeroed();
-            (windows_core::Interface::vtable(this).Error)(
-                windows_core::Interface::as_raw(this),
-                &mut result__,
-            )
-            .and_then(|| windows_core::Type::from_abi(result__))
-        }
-    }
-}
-impl windows_core::RuntimeType for IsoSessionUserResult {
-    const SIGNATURE: windows_core::imp::ConstBuffer =
-        windows_core::imp::ConstBuffer::for_class::<Self, IIsoSessionUserResult>();
-}
-unsafe impl windows_core::Interface for IsoSessionUserResult {
-    type Vtable = <IIsoSessionUserResult as windows_core::Interface>::Vtable;
-    const IID: windows_core::GUID = <IIsoSessionUserResult as windows_core::Interface>::IID;
-}
-impl windows_core::RuntimeName for IsoSessionUserResult {
-    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IsoSessionUserResult";
-}
-unsafe impl Send for IsoSessionUserResult {}
-unsafe impl Sync for IsoSessionUserResult {}
diff --git a/src/mxc-sdk/src/backends/isolation_session/bindings/mod.rs b/src/mxc-sdk/src/backends/isolation_session/bindings/mod.rs
index c7c7076b3..e7a4f8815 100644
--- a/src/mxc-sdk/src/backends/isolation_session/bindings/mod.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/bindings/mod.rs
@@ -3,8 +3,11 @@
 
 //! Generated WinRT bindings for the IsolationSession Preview API.
 //!
-//! This crate contains Rust projections generated from the
-//! `Windows.AI.IsolationSession.Preview` WinMD using `windows-bindgen`.
+//! The bindings are generated **at build time** by `build.rs` from the WinMD
+//! inside the checked-in SDK nuget
+//! (`build/isolation_session_bindings/*.nupkg`) using `windows-bindgen`,
+//! so the crate is always built directly against the pinned SDK package rather
+//! than a committed snapshot.
 //!
 //! See `build/isolation_session_bindings/GENERATION_INFO.toml`
 //! for provenance details.
@@ -16,4 +19,9 @@
     dead_code,
     clippy::all
 )]
-pub mod bindings;
+pub mod bindings {
+    // Generated into OUT_DIR by build.rs from the SDK nuget's Preview WinMD.
+    // The outer #[allow] above covers the generated items (the file's own
+    // inner #![allow] does not propagate through include! into this module).
+    include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
+}

From 2b14ecc0b5e19fcf47e242d8c40dab5da9b7a02c Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Thu, 6 Aug 2026 21:40:12 -0700
Subject: [PATCH 06/26] isolation_session: align runtime identity to 2608

Match the OS SDK package relabel (2606 -> 2608) so MXC binds the same
MSI runtime folder the package now advertises.

- regfree.rs DEFAULT_RUNTIME_DIR: ...\Agentic Runtime\2026.08 -> \2608
  (this is the folder the IsoSessionApp.dll shim is loaded from by full
  path; it must equal the paired MSI install location).
- Relabel the checked-in SDK nuget 0.2606.0 -> 0.2608.0. The winmd and
  IsoSessionApp.dll bytes are unchanged (preview winmd sha256 still
  1A9DBDC2..., full winmd 193B8BA6...); only the embedded nuspec,
  metadata/GENERATION_INFO.toml, and OPC core-properties version strings
  are updated. GENERATION_INFO.toml (external) nupkg reference bumped.
- oneshot.md + the three tests/scripts runtime-dir constants -> 2608.

Verified: cargo build --release -p wxc --bin wxc-exec --features
isolation_session and the common+bindings tests are green against the
relabeled package.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: f5cc2011-5308-43d6-a8ea-2b8ed9b6ceb3
---
 .../backends/isolation-session/oneshot.md     |   4 ++--
 .../GENERATION_INFO.toml                      |   2 +-
 ...ws.AI.IsolationSession.SDK.0.2608.0.nupkg} | Bin 83219 -> 83219 bytes
 .../isolation_session/common/regfree.rs       |   2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)
 rename src/mxc-sdk/build/isolation_session_bindings/{Microsoft.Windows.AI.IsolationSession.SDK.0.2606.0.nupkg => Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg} (97%)

diff --git a/docs/development/architecture/backends/isolation-session/oneshot.md b/docs/development/architecture/backends/isolation-session/oneshot.md
index 209da6cfb..b0c928ae4 100644
--- a/docs/development/architecture/backends/isolation-session/oneshot.md
+++ b/docs/development/architecture/backends/isolation-session/oneshot.md
@@ -194,7 +194,7 @@ folder (see *Runtime folder resolution* below), then:
 ### Runtime folder resolution
 
 The coresident folder is `DEFAULT_RUNTIME_DIR`
-(`C:\Program Files\Microsoft\Agentic Runtime\2026.08` — the fixed MSI install
+(`C:\Program Files\Microsoft\Agentic Runtime\2608` — the fixed MSI install
 location) unless overridden by the `MXC_ISOSESSION_RUNTIME_DIR` environment
 variable:
 
@@ -419,7 +419,7 @@ The following were observed during VM testing and are accepted for v0.1.
 - A Windows build with the IsolationSession feature enabled.
 - The isolation-session runtime binaries available via **one** of:
   - the paired **MSI** installed at `DEFAULT_RUNTIME_DIR`
-    (`C:\Program Files\Microsoft\Agentic Runtime\2026.08`), which MXC binds
+    (`C:\Program Files\Microsoft\Agentic Runtime\2608`), which MXC binds
     coresidently by path (preferred — this is how a packaged product ships a
     specific runtime version); or
   - the OS-side inbox host binaries in `%SystemRoot%\System32\` (ships with
diff --git a/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml b/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
index a0de8aa3c..7111ed9b8 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
+++ b/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
@@ -13,7 +13,7 @@ target_windows_crate = "0.62"
 generated_date = "2026-08-14"
 
 [source]
-nupkg = "Microsoft.Windows.AI.IsolationSession.SDK.0.2606.0.nupkg"
+nupkg = "Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg"
 winmd = "metadata/windows.ai.isolationsession.preview.winmd"
 winmd_sha256 = "1A9DBDC2CBFDEDC7FF366939DB4BA1564179D55B6EA3E70B99BD82C532428147"
 namespace = "Windows.AI.IsolationSession.Preview"
diff --git a/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2606.0.nupkg b/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg
similarity index 97%
rename from src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2606.0.nupkg
rename to src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg
index 7c7d56c6f90c6ec3f0dd0b8b6bb7877bd6f69fd4..dc7fe742e2f6371b2a5da9b99b38a2ed9fec5746 100644
GIT binary patch
delta 1462
zcmV;n1xfmoiUpI31(5p$uMRt;k^fKvhN6>E0Y!gh@_P3DchiRFpZOYrj!Sc#Y^-fw
zWtqu0SaZW_k!xjCX<4r7tUF5x+0o?1kJ;p>Otz-Mob61J5E#I;M#~Fsx&KDrMKL??
zF+K@dsI6i11zQ+ZaZ9-^(YO@Z^5pkvMyJEQAJP>5?6L=|DXsy#L7;2l0?a=wGTllm
zY6J^WApK+aFmi{Iqo1=N0`v<6L1cqdlNb&<f9vC?v7<@>e6&agETC#qA;J1?fh~8t
zr`<iUzkO%+j)SCCD<RopXWqPd^Je%6zlM`=)?19GlhtT4oHD1=<o&yk_<?7m4?=Mj
z3D{@@ZYSUmsbYP!tT$pKs}t^|R&!x3{()I;9lT(GR9lPD+`;(kfPk)!uTf3Bis%|5
zf1PGB5f=ECOJyB{#ZFql55Z3-Pv2mJ@09tIJ)^zkGKrb7gk}VfEnq<oN}H4?#Vgcm
zAe}G34Hj5CZnna$js@jaWVjP+xJvn7+OSk&?lr-cM11|DHhY_KY<OL!t-<GkR4_n1
z%@Q5$fvXrYu4IJFH<bAXv5^~hLx8ANe}trwo)KH21m>eW)TjW4uxSi-C$mh%@FJ{?
z1p;9IzU@*6sj}QbZbeLhPM?vG*+~?XWBr+0#-zz~ft@Rxr-b^31VI~&;^qz35fLv$
zTC;MtgCf{i5U<Yg$X$?d`hh}#o`g|6xh=)0*?4~|Pjj!?V(_>BVWHD-IV{5QfAdps
z5kj;R(H>b!g?;&<&#}EsGgLI%v&`1PI-X{Q5??TB5dJoOdJJb@2=Ty^9H+Z6I`sjG
zJc!Z&I(H-+`i_vm$y9vyF{SD#95<4@X9Os55QYHJFsXD78GX+OuKZjnwt(lx$qg!H
zZy=S%XhTCrpWeW6C!^gN>+D+`e-Zp#D4U&^=><tDT{@1KUE@?J9k*+?fZp>6QsH>a
z9WQcAIIzOOky|)<A@(w0a?#%}@Sz+O<C0Z#D#uia@SzM|WkwvNIR0N!8CE41L;dG|
zTx^x^>rC-{5&S+fIGKqaFpLntvTq=~a*>YD*XCS=0(_wxu=;YdFfygPe}lUMoS=R{
z$JuE6J-w7W^dQ+wT2@^a5Q-M}^!@vH|8_n|t$=kJ7ef44&xk~DtVqjCj=D19y4u|f
zUlddG(5KWAoYhPCS+2;#fF}a~ac_kgDr?~XXknTXRys<zV=%|!XwbrtFrJTUblP~5
z6o<r=fE%5}!jN}8BU}hqf4!0G;dx5e7vEQ-`E(x6=d|0i-zSUFI9xrBW@Ol+eVJy7
zNRgj+&3VO&5z_J#0dhSpQY>g)O>v{Bke>xAa>)*9(=Dfy=A&qNaG&{BVATo^#cFhd
zE=pDAtzv2D+fVqjwKY5)($CDN<#H?|qpjY!<+6t=I~kpXT`o%mf2uyGn^O?0?of4P
z@FZNG804XGZ2lXpn5(_gM^&ws-SI}dLofCFX209-b^6VAs~HR%L8I5Y>$ir@L9117
z1?~ICyZbP#w;vmg`(ZHX587eathc*iry2I^P4Zc_NUPjMzU!dTsRi9yaJLAW5B2+p
zc8fKFPP5yo|LJ@A0UNVR5|UvAZD^2$li_n;e@jaPF%ZY^g5M$J-kEF<r7YPkLNBEV
zLJyupGP@0K9we#y@tsz!9_R6Y{PgZKEaII?^(hXr10@ATo1BmHATMoNZRKu!e9$%(
zdMPPWX`ZTJRjj?UgFLsEd&GPx3#2lmvq%dCimhS?9m?<D`(w3d3Z?>EMZQd_1k-qA
zP-!;y&CG;rr8XF-8E2ZoYw{}Jqb0WyLOa`g$02_5RK{m-OR8yV@am&W9~GVsaHwf9
zjk!)#uXu3UA2s*;FT8pE;ExK{8?^<c@pr@Ex3dp*XUzn!4m+fmdO`t_1VLnjQ<o1z
Q0sjPTXpn@r5<~$30q=LvP5=M^

delta 1462
zcmV;n1xfmoiUpI31(5p$F-4_?k^fKvilLKH0Y!i3<n`?P@1_mUKl3#L9hc@f*;w1W
z$}*F0u;zx<BG<~O(z0CDS$CEYvZKk1AG66%nQTpiIop{cAuxbxjg}YOa{rCKi(+=(
zV|)^_P+P<13$`$-;+Aq-qH!s*<;m~Uj82DpKcp%A*<}w_Q(OafgFx591(<(WWV)4B
z)CdcrK>Ek-VdM@aM=!G=0`v<6`m6|#lNb&<f9K<;jiX8de6&agETC#qA;J1?fh~8t
zr`<iUzkO$RkAtLDD<RopXWqPd^Je%6zeba2)?19GlhtT4oCa29>HBvd@dM9V9k^sN
z=CDy3?2f}9LMG~Hg5D??8I>|Cl$>*8@DI!iW8nn@gxng8W){X@2LyC=e2r`TmB-f*
zf2%APDL25jOh{t`SnPxW{1E(f^7IWh_)eKWnKRl;A<`t!hR`%;i2*FgKq{TF)W1Tl
z2Ew`mOk;tyWqQl)>gXx2V$CdH!&S!qQaZ>4=3WzANyODZD!n&3!-m&o+8SIQ2nhqk
zQ$ecYJusO-&ZLNu`GzvzAkkuDZwL^ze~OVb($jp)CC7Y}hZ^M&AZ(U^*@-;o3A}J4
z5{>}aziYeHLCCzYP#B&NpjBriWOfn-<ye2FmN98EU0~<Z6d9quAwf_YqnLh!bxg#)
zNb8`S?Z5|X1N_x$7TXIFRy|M%&=c2^rMIORHIwXb#cA#};|G8H9~L?dm%$<$e?LF<
z77@fd9`BK*kl2?S`W)NKRe*}d`ye-UFqUPxSK<pM4Wi$sPmj^;3n3m@THtgyT4gRE
z6$f4#Koyo`L*Ee+SdsD1E~Zo+g=1Qf_cRB|4_p%<8YUCgBBSs5z?GXT#d>(At=OPa
z<_0pMwbC?X^yv*8cOu@MvCh85e-XjYUfKM-OfN`Ms?u@9>>8&+>9}391@xXrka5cr
zW|_||;lOYUM`qyUg~Z8#$-ci|;6pj6fQg`*Q#mFt!iO?=m1}+w{P=%KWmuK$hx*U`
zxY#P!*O}t^BDj4F;AAFxz%WAm8hiupl#5kzzBcC~6yOTofKiv5g^?NEe;wQvU<CC8
zI?hI!@9AaCq6f)d!UWZ20WN8APv5_P_iyKe)Cz-6<3flZ>uH{Hh81af$x&CDUst<(
z;R`=C2YpH{!Gn4UKPx1881O{kKlaU=p|S@4j~1pWVWp$6y8z}`91ZFX3FG;wMyHLX
zsXrvT1l*`J;hMbb7~w+Lf9j1~56@G&zWBZx&8PEdKBwKD{XSWY#?k6=G$X_M_C=Pb
zJVSoYHRl!cBc$ag0_1vHq=eJDYJa1skedZ6a>)*9(=Dfy=AvkMaG%+hW7P@{#cFiI
z4oX$#trDT>+fVqjwbd*e($CDN<#H@yt&G~(<+6t=TM?gxT`o%mf2uyGo8yU9cc?lt
zcoHs84DwJoHunuyEaYCQqpViT>{z4Sp_h8M*}w1iI{jw5)eMJ?u+eMX^;^T{pw+6k
z!glxZt{X-5_G6>b9fpJcpdCfcdiy@=G^2jKNj|F<X;s+RbsaW3weY?c-YvrBL%sXZ
zZUv37)4cE0|8%|l0S&WD5|UvAC;|SUli_n;e@#mRF%X9Dg8w1p-Xz<@B1?9Q;H8Kl
z^x!!pv)j;3CS+3e=R2)hJ<iAb@z~vGTE#n5ikL^)DI*1Bk0It|l;<{Y9^`Jizq1}I
zyjCnwTLcoU$}|K&%42I~(7K%Ks<19PcnvEg$c=QTIxW9{Z;#}UkQ^zt%6yrzCf9gm
zP-$`g<QC9dV|tySx!{`9m*h>kMN4iYgbjX(fkWaPp-wN+S0tR9dW$*W2dT%s+7qs>
zG1md;f~O8o&zAfB7hb)7@F%0Tz3G*)`gg<N*Rv0GXUzmLMWuz8dO`t_1p2H9kCzWa
Q0sjOj0sf%35<~$30nB&T@Bjb+

diff --git a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
index 54ac63b33..17957fb0d 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
@@ -69,7 +69,7 @@ pub const RUNTIME_DIR_ENV: &str = "MXC_ISOSESSION_RUNTIME_DIR";
 /// openclaw packager installs the MSI here; MXC needs no configuration to find
 /// it. An override via [`RUNTIME_DIR_ENV`] takes precedence (used by tests and
 /// side-by-side validation).
-pub const DEFAULT_RUNTIME_DIR: &str = r"C:\Program Files\Microsoft\Agentic Runtime\2026.08";
+pub const DEFAULT_RUNTIME_DIR: &str = r"C:\Program Files\Microsoft\Agentic Runtime\2608";
 
 /// Name of the WinRT activation DLL inside the runtime folder.
 const APP_DLL_NAME: &str = "IsoSessionApp.dll";

From fb0b189fdc625a126c6a10013b64877e9f03ede8 Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Mon, 10 Aug 2026 12:15:17 -0700
Subject: [PATCH 07/26] isosession: activate via reg-free private CLSID, drop
 LoadLibrary

Replace the LoadLibrary-based IsoSessionApp.dll activation prototype with
the real design: MXC loads IsoSessionApp.dll from its own nuget package
(staged next to wxc-exec.exe) through a reg-free classic-COM private
CLSID, letting the OS loader resolve it. No LoadLibrary and no
runtime-path logic in Rust; IsoSessionApp.dll (C++) owns how to reach
the MSI-installed runtime binaries.

regfree.rs:
- Add ActivatorClsid trait mapping IsoSessionOps ->
  {6EF3155B-D1A2-4A34-BCAA-089F8A6D9916} and IsoSessionProcessOptions ->
  {36B03FF1-21AA-4F3C-819D-2430EC830DD0} (contract duplicated in OS
  dll.cpp and the nuget .comClass.manifest).
- Replace activate_from_runtime_dir/LoadLibrary/OnceLock/runtime-dir
  machinery with activate_via_private_clsid<T>() using
  CoCreateInstance(<private CLSID>, CLSCTX_INPROC_SERVER,
  IID_IActivationFactory). REGDB_E_CLASSNOTREG -> None (inbox fallback);
  any other error is surfaced as Some(Err).
- Add CLSID-contract unit tests.

manager.rs / process_options.rs: call activate_via_private_clsid and fix
the stale "by full path from the MSI" doc comments.

Build wiring (isolation_session feature):
- mxc_build_common: add embed_version_info_with_manifest so the reg-free
  COM manifest is fused into wxc-exec in the same winresource compile as
  the version info (two compiles would clobber each other).
- wxc build.rs: extract IsoSessionApp.dll + IsoSessionApp.comClass.manifest
  from the pinned nupkg, stage the DLL next to wxc-exec.exe, and fuse the
  manifest. Degrades gracefully (cargo:warning) if the nupkg lacks the
  reg-free payload. Adds a zip build-dependency.

nupkg: repack 0.2608.0 with the DllGetClassObject-capable IsoSessionApp.dll
and the .comClass.manifest fragment.

Verified: cargo build -p wxc --features isolation_session succeeds; the
fused manifest (both CLSIDs, comClass, IsoSessionApp.dll) is present in
wxc-exec.exe; IsoSessionApp.dll is staged next to it; regfree unit tests
pass.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: f5cc2011-5308-43d6-a8ea-2b8ed9b6ceb3
---
 src/Cargo.lock                                |   1 +
 src/mxc-sdk/build/build_mxc_build_common.rs   |  35 +-
 ...ows.AI.IsolationSession.SDK.0.2608.0.nupkg | Bin 83219 -> 85500 bytes
 .../isolation_session/common/manager.rs       |   8 +-
 .../common/process_options.rs                 |   2 +-
 .../isolation_session/common/regfree.rs       | 513 ++++--------------
 src/tools/wxc/Cargo.toml                      |   1 +
 src/tools/wxc/build.rs                        | 158 ++++++
 8 files changed, 316 insertions(+), 402 deletions(-)

diff --git a/src/Cargo.lock b/src/Cargo.lock
index 45c0d289b..7573d4f0c 100644
--- a/src/Cargo.lock
+++ b/src/Cargo.lock
@@ -3333,6 +3333,7 @@ dependencies = [
  "tempfile",
  "windows",
  "winresource",
+ "zip",
 ]
 
 [[package]]
diff --git a/src/mxc-sdk/build/build_mxc_build_common.rs b/src/mxc-sdk/build/build_mxc_build_common.rs
index 5b6034ab2..0cb0dbf5d 100644
--- a/src/mxc-sdk/build/build_mxc_build_common.rs
+++ b/src/mxc-sdk/build/build_mxc_build_common.rs
@@ -17,6 +17,26 @@ use std::process::Command;
 /// The `ProductVersion` field is set to `<cargo-pkg-version>+<short-git-hash>`
 /// so that every build encodes the exact source commit.
 pub fn embed_version_info(file_description: &str, original_filename: &str) {
+    embed_version_info_with_manifest(file_description, original_filename, None);
+}
+
+/// Like [`embed_version_info`], but also fuses a side-by-side application
+/// manifest into the binary in the **same** resource compile.
+///
+/// `manifest_xml`, when `Some`, is the full text of an application manifest
+/// (e.g. an assembly manifest carrying `<comClass>` reg-free COM redirections).
+/// It MUST be embedded in the same `winresource` compile as the version info:
+/// two separate `.compile()` calls each emit a `.res` and the second linker
+/// input silently clobbers the first, so the manifest and the version info have
+/// to share one invocation.
+///
+/// On non-Windows hosts / targets the manifest is ignored (there is no PE
+/// manifest resource to fuse), matching [`embed_version_info`]'s no-op shape.
+pub fn embed_version_info_with_manifest(
+    file_description: &str,
+    original_filename: &str,
+    manifest_xml: Option<&str>,
+) {
     println!("cargo:rerun-if-changed=build.rs");
     println!("cargo:rerun-if-changed=Cargo.toml");
 
@@ -26,14 +46,14 @@ pub fn embed_version_info(file_description: &str, original_filename: &str) {
     #[cfg(windows)]
     {
         if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows") {
-            embed_version_info_windows(file_description, original_filename);
+            embed_version_info_windows(file_description, original_filename, manifest_xml);
         }
     }
 
     // Suppress unused-variable warnings on non-Windows.
     #[cfg(not(windows))]
     {
-        let _ = (file_description, original_filename);
+        let _ = (file_description, original_filename, manifest_xml);
     }
 }
 
@@ -64,8 +84,15 @@ pub fn embed_version_info_for_binary(
 }
 
 #[cfg(windows)]
-fn embed_version_info_windows(file_description: &str, original_filename: &str) {
-    let resource = version_resource(file_description, original_filename);
+fn embed_version_info_windows(
+    file_description: &str,
+    original_filename: &str,
+    manifest_xml: Option<&str>,
+) {
+    let mut resource = version_resource(file_description, original_filename);
+    if let Some(xml) = manifest_xml {
+        resource.set_manifest(xml);
+    }
     resource
         .compile()
         .expect("failed to embed Windows version info");
diff --git a/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg b/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg
index dc7fe742e2f6371b2a5da9b99b38a2ed9fec5746..e15b464765647188367c07473375e74c3315ab37 100644
GIT binary patch
delta 54960
zcmV)3K+C_AiUs_e1+X7=x8*<qLID;71QY-O00;m}VG3Ql?Tcjr(EtDd@RKcdAb))e
zcvRK3@Jz@+fW$;(G=S)Ug9cF>2-+Y-Cm8flLk)@=EkYEb!6$_YMg=7uP|{%(pY_>l
zeN=7jRjZJowuvAFg$i0LYE^u-I}TQSgOAR?9($j&&dix4*!$o6fB$FvWY#%n@3q%{
zt-bbIYp*@!%$2@gKA$fa{!gWRzJC_@#lMLD?doqA{J+<MYxeRz-gon`7Jv2TVbkj8
zE(pz=fALS}pM7Cy*4Y<bba6Cv&g{_qhKoXTFA7zibV}&Li_e{XL_tBnu*UJ}k4G1*
z{=v){=KnvPzG=p-8eRqe|K$%qnfWLBoj&t1dOu^vo1^e~#>~g*{TVYk-G5B|d*;l$
z==V1||5^0@<hirz5vQTOW|Gf$?p3{gdp$qoV)JgNZ+NJG&Rz%m?(#ze!2j@9+6#V*
z2wXyM5QhKz!H@Z$Gv}Ce(4KXb+@d<Y1ng%9BO`NskHhb0@cS7T$$yXJ_=-Z}d3%m;
zCw#B{)bE?;)fu1reI<zV6Mw(Ya^dm&@=RlU{2dXU-57=6;I+D*EA9H)e?UgvoQtFN
z=NqE2eavrKx+CVFdv^3}C^pGuL!<Jq_=B+(If9e<miI?Iy6y1Sov!VOd7O~i0@}n^
zs(;h*&7Xb2#j^lk4!0HI+n$kbV)mB!{_p$0@BhC4`~L6yzwiIP|9|`b@B6>+|GxkG
z|NC!K+MgBMQEnxw!y)wv?6{T(5;x@dtk}BpwHe=s55w;(vVNaP-|x-*UScJJ1zTa8
znkYC1zN$0!@gY3m8oy61{u1EWx)PIIr!NTN$GY^74!+MB-+IK?{BUNn^z=u*Na^pV
z^1Dx8@I(U2-~NS1`G3vT;XFzduMU^0!-J3{UKK9QhA=Jtw*$LPKP_BjGL>5!s=_7z
zPNh<qCt@{Mg+o?iTG&ElA%$CB{@^sYD?b%lu1X-G72m=X4DoeIfmeQ2h*==B757=q
z{+`pX^LG@A@_(}D<u9lFMVvpm&mQNuWd0NPJb#I#|H%P+oPR%0=D&Oo@|R<lh-%s2
z=PO**wydq8AB=|(Dp!(u2;qb-T!n)|%((9HE&uPrr|Z`;GW&$8hA~_0&Qy&=R6YXZ
zXj+&kDphk1%7&pDa)k(q#8Dex8ompNh4&E);9GD|!2_UM8eXX%V7M*~FV_!1>eBEM
z{SZPD8mplf=6?YV^+-dVdaO6mP`mbjsr>nU{&&kCliS1cPdnXe+Cg{$WrxJy=HOou
zM$K|HynF<H<2QyMpbRUBY_$rsdXTOrwkTZVyRsh;QUj0ElKUbw0`<}bK3^YS;Tm-y
zzK6Hd;I|ftt;NNrUcG+^t|8Uo=~jHV72nyK4_H6F7k|bu>9LV*mJ^Vuf+VIbz8kHV
z0spm{)?tNb&d3;`-t80H(THWV$O0dc1wNn)yo(E@{)5-pb!wz;9H?y#*0D}~c`(;@
zTKBb`X4m$+6~5w|R0=x*Mna=Ub+gwO5K)s7!N+TYYq}@6=07C(^{=6OvJl&2dT$=_
zKSuBG{(n2@{YUtJjNZ%lnBLP{A|Ms1cm4%fMr~iuYzJsz{8oHd%RBJfiluz|ko_7^
z%tONK(U5{~(IA6w>+o%@FHgS>@Y|ZgRg8Ff6^cW^=ui?f{BVhWD2J@2Xzs$7jX_cW
zc|lSC`XJZ8E=cvSC82IbxCW~+<XE4ttSz?7AAc>h5}GBP4wjK*gP~wqTXcdI4_tpW
zNWRUQ<Jz28v*W~#Ou5Ej*tAM4_4^Qpl49F)08>ESHq}X|4xcR^wx0(NP3y3AXRhtG
z{m=Q3+8-$ESPGPttwUl;;fw5%mEJwF(z8cOJ$s~d&wIrGAN5Fc1-x4tz7debw)>&Y
z3V*PLs5$>Mm(yW2t+Gw(PdhSOtf%95_zu&4%VYnKwO`JE)P9pEWNp7I>fP;kMY8+$
zOPB9J2Eht!@EKNwW=bFixK%aqqmsw`EQS6YtatGaH6E&uRD&oG@+}?%c|-6RMkM7`
zkT6`G2%P?m-?!#ms&t1Md=lh?6v-iFD1XBKh5o&Z3x)J0R&!oiTUG(q>2EKh$3bgH
z2U;YSMDy`oP2rzlf;a4qsB6^>zus{rFU1!%s$hz4bl!)-JIfl?Va3~Zx8N5*TCzYR
z7-}OZ#}<LULJkcpJ&Dp0_3c9ZK8;b;s%v!e5Ph|J5oTA__Pjo;MScF@ORLYF)qi_d
zp9_6m*XM9|ePBuGrarm?i^6%D;5<E&?EP)m-$f%(n*NjqN-Jv4^BNF)n%+v!P{2fB
z4$C9Uo~B=(mYnNYxC)Xl_aew^fA;{4n!;7cN2r}G^;>Fo_=Io$UGDH06_%N8|M$Q9
z-D5v#oe$%$hPI+SqN?L<VsH6@zkjO@_y2Z%y8Diw<=5r#j2&oRq<<GpBgdJZDG^w6
zxHU|MwDv?%6NE)*&<#Gnqh4yu(@X(JQzveSSe+44n?#}_%_NYK<fiOIC2DmqClMgo
zRo2#8%WI|cvO`toIO?oYv)pK^;5F!P7KMu-YmJ??D05LtA0L^G01uGB%74=6Uiyt)
z-`aI4Rj+@@+PJLx8<)OsbF$0S-sL?Y%lq9Pm6zC~@<_iJGWtbWK0DM7*#9weCS9M}
zL=qJ)1FZOyy2kFtTUYu}r)V`-7ZLF);=AH6X~7XjjWS28EH^}Q&5$moAq~~N^V>aZ
zFXFGa*aJ0Da7QaBmYE(L$bZFpp4d9t3(SIV1!(&QWuD>8hD;uuUY<r2QEP2PiGoAC
z3&k$PCo?xo)5<nWxMgV3)3ZJ&J3*OJg;qnG0rT}&f*Ty6o6}|)x;)+5FF0vSRF0EY
zlq$wEZCgR!bGnGJ^zEw8(&rN<3-E@vL%l@}Vy_JICTFe;mV4U`DSttBvf|NjEsOW}
zk`Sd)nue$~Md)VOPd7YjQOeyLXE&>*+@;W?H$7wbsIDh6$s(K6>6f^~#o7Vbq7M7a
zAwJ~rLCG({-r}Gw@<N-*K;6@Ay<RLx9<p*hW}V&Cso>USu$R?b>xopBKJw}xy;We?
zS)xFqj1U>+w(|ZW@P7>Ka=ME3RG{@-`P}roSs{$cMi9OVwG?dSsrO*hw9<2axT>O;
zvVHXw#}`0)hgv3H&>&uiL&S6ZY7H-@uG6|3{Kt$n#6UWoNOCV0rJdCoi3RCA6g`W-
zutu2v(X$_f$`W6cP{KxurZ7!XXlVSN3Qhxs1Pbw1*^5ACDt|Z@o|7Gngc~&3EVaZv
zr`PhLm$oRO=mj>t(AxBmi{1$~z2$Ctkw{!I=fEa16}%<Jw3lnz8{s+m6eDEXJ1@fy
zmP+ol^%G2kY4*sp^|hPt4>SJn{GIkwp5M8urD{BEn_c|M%`fxR(dTIE4sSK+-74^d
z?pA)#X%F?te}8jN^XuW>+u!5#G#geSOYcc~dl9X2q<UQOI@Bz)+^g2~HtfFq(@3P%
z3(jPG=wW_)X+fXvuI97kFSwjXd-sT+BnmEnDt%?>P!mwK>P?|LKkWBlvrqG`G;Zal
zf=7Z=dspM{TV$~A?{YyX%Cdj5^AD}-dVYL6Gs|}^T7N+0&ZDtb?u+)wIBD|37@$v(
zukVK3FlFll0O!gLL#E>F@?s(|_845x1NZ$5RDFrS7vt&a*Zj2WBzn4)pAIdjryJm@
z1&i@o4-<i<X!C6j1US#}^K%5g<rn1`d>I(*_EL|X=Ht(<_HwV!xGu+i{oAo|^H|JH
zTc0zw7k{N{@@_Kml(X`$a808<b57aX-SX;%Z}-=3d}w;$FTK7KzP{hM@olm3{c+28
z!S`SqzG55StnTrN@!zzg1qI~|tfl3t9Jt^@TQ`iS8OY2?sc5}{aodQ^n+pDZv7a=n
zZTJz;mEe%ZPgU^_&~V=O2hech_QY1j_BsJA3xA7n64cm}0Jpwm_$gO6e4I+Htb~og
zfxbzg?*sz_W-Hs63J$vhi`v4;R-9!roD9vtR{uWhQ3sz4;15g=Y>E3m(jTMytG?i)
zf>u|~HiSpZw9Z?B3evScVrFAyE3`q1N}mR*Zc4rhM(s-0dK0N=UN%+Q3Ccy}uTU1Q
z^nb9nM|_J<#d!~pRb--q)<LCj6*S2?zlSCnMQpx9jTlEt-zu~MV?p!O+Fek8F0&Cp
zl)^i~Ux!Kj9sS#c;zPYJI@<0PKwVGF)I9s*z7!~nR_MpR&Hhfd*C1ZszfvhwqVu;c
zc0C#oqk1&KXOwH85X-mtWRzy$v0B!n8h`3>+wY(rV|6{wg2@31QA;tM>+$uMc0C>e
z5I#;%jwbT|fd3XQn+I(S?Fo#P>6)iHoGgnuOC4FOb69D=@g-8)BMsTtQ!x62d7^N2
zBvggkGBj1hYl_LHsBYN-L)(}RX%dyFY0$5>4yZ&egWWX=dyY_7BSbzD>h_gFD1Q=*
zRY-2pg+*xB8c7A;xfB;TXgn0%A}r=uso<0F8b%g8%$w6(8FIkkj9^0q=P@$JdN2NI
z){_WtS5v{ubur+60?%9w%DecQCBz6DPxXVPv8OH2S=RGZ@asm{{dA~mY&)zi&+E+(
zLg&BH7Y5COfaijrMRjkQo@C(dy?-p2m^f=gJZnQVYeVWI(DoFr>QKK#0~4ifS2<ey
zsnrIH{!YS-T`JiNs+PM8ZQAhw4e`LQ>TPbe65gOi3K<p*#(nHL1EzA{5+JCd)cG78
zYMFzC&TKk}wELRhM0`Yf1hmgc){&a>H(+0cQw#^I&Hs?Sss)uc|2x;_e}8BL@<Fry
z0aV=X<Y@WU$?NUp%!3T!?c_{iITeA<yV7tTJYq%`JDAN?zJ>iXv#BOL)wB$w<;`W&
z!V%C5_;0l)q6%j=G(8~1Y3iRwY~suhh)uAs%i?nET;i@!=mVNfOoJ*d_$^e4ZO0wz
zsIkN*rgi!a)9qkpFcoNant#1;>08_$_y0D%Jq8|Yx5ou`dt6}JgKDeyVU5JUsK)qM
zODSu6UgKIb*cw&gDOBV7PO9;AKs?>I_()`FWc3s^t^=Z*?gye1MxHOD8rLNUP<5Z@
z>efJYapnW#)y!?jUx>LOo~-_xso=p4X<}|R{(!tescAxY^AlurE`Jr4>Ttf7sPXvS
znNY%Bqj@T*4vKw+%l@jx)kf?llm=RW0r=)%fot&0Wh*Kq)VJt5hoi-6t}GVWm)>M@
zWaWTfyxUTL{|EDK(AUy-1{e2RKy0vCd8yiXGC!6x?=CUCo7hb`nfIcD>>YQc1%(b`
zCZI@7Zgz+y0i7jn9Dg!e)JEH_;K^vOz&^nbrR3l69GFb$$=e<i+X1#?_)4rbQSjcq
z;D~$48D{YzD{(YvuPn?W)$z0Z#9XZmd{v(Qb0sw98}^|k$599#3#75W(xxmUYdum|
zL(~DltAy=%1DWfQc<^9bVw1<C49%mk#If)QMK&^%$OrzsGJky$bJ1^DwJzUMBWuOf
z#JPmxB-vMy#!zJ|`WxWP1ij^!R^MP0KR=vL6C$&Hg#PXfNP`Vhs?{gsIFGxJTuYVS
zbm6>+PtM~_s(H-U`ofZUBsaD_54t{MUq;E}`C)C033=_&GS!8+xHjX?r(FHlzFLxR
zuFTacep}6#MSrGGUvIT1BQ)ncUd-8<5)_}b&RVgGk7og|i3YJz3jP7Gn%mdRpT3T#
z6-^zQaxk<&s$SaHQBah_<5xJJiK(97MjHVt1z0wEYoK=z4h>c&(7XjTik3DX+RNx;
z2HM`8IzO1PNP)+W+0fQN^KieJ)ZoWHEeyP(L%s605r6%syYy#5`v(XZhgQJhie-W4
z2p5O;9~@BXjhTKVhQyEl9r1RyF=NS*5-oznBSk`YSGcU6R9+PyoQ=&m6NHSn0iu;g
zI;+;v)*dJvWZu%a$<gA&Fcu$%QRQHq!#qPF2Xa-1htafC6M?jq+EH_Dm-3a7+-zqB
zEh}v&!+!!o$N$h<JHzWs;i|ywb8@r`_3+A8ocpkz?G5i>lq3qu!TV9I?FaoEm;mqm
zu;u?8>)f^d8Fj}!(3g?23&wqy>szKCAWM6oEAL%;SG(NV)!sbAB?nrur$|CW_Xq&#
zIDSK)vbN6kz-j0Mj_R_FIAHMOoaX!-=<?Mwv46{tgXVe@AQ-^FW&`&CsQVB9L6OS{
zfF`@WPsXK2op+YsDFZ)YlET%wu$eDhb{x4@1<LR6J3|Vy#vS+K=zjR)j~;+OInhb@
z(<^#Gav|jFZSp1S?VN^P?S*=v+s*fU)C1X1M|-Az&z1U3*VEt4lkge?Q;ZLAeEJX!
z$bV@@G;?7+(|MCmLSwArHs~5(^jK)g>#&nhfWvlb#J<9%rLqML_eLLJ=eNL-gcGPi
z(?Km>?O@I$%w|C$QI9Y<lT)uLCQB9MDSNTiHvm_b8$i620yKH6nO>w`P2`d=LV`DS
zYpfBpbR-UPFE24p>ZRh{5|^_!5sGSpkbilsj$7q0>2ACYi?^rn(ET+P$zwe5i_FUr
zKjdHJ&i}>`Q41!v1zW)vJyhgf$$4wtdG9uPQ^7x+@5cdX*D)T!b^Kh}rsdkHy%eQh
ztS9`QYXpT_z&_ZG{kTlZKn80VE*?>$5s$bE9RxiIxO%&BeL2_*SM(6kw#ATZ`+u#j
zT<spYEO#yoay{eD75B&mCLMbQ!FoY*rtH{KKy!~9O_f2DJjGST=*YBuF?YUvJKqra
zxX}Iaqe1$kdyldF8QNnYU(B$NW;u^RvLG_gRPZ_2f7<G;hAFLg02=lFk4dMthetAw
z-HO{ESY+0;AeLk<?@Qzv4R3nNZGYxkV%z2Pz``}pX@SFmVpva(2lBi<!i>aQt9gUH
zA7oXew+Ji@kDfv>lR&$ZT6Hv=#Igv$%cZ%z4)itLx*=BLv|>0O>&uU=_%pWbGEcj&
z<aSWuW|Lz~hT5b!lx0(Bym5JKAVHC-s1vN}zT{?m<Mu8*lES!bqnfID3x8Pkaa}1~
z3PK`{rkYkvp|;}I%Qk=_YR7Do%j`Z^81!AT>V^o#;IU1omeul({<9m?T`}$9NiG3e
zfYu2TkbpgQXhEc;cyI>)*=ZF%+Rqvf?;3v32%yr*9CDbg^K$V`Z~wo}*|YZ73c^y;
z{#rif_Aiy~PsYQ}MSfTN1Aia&kwF34f9v41_W!YV=csAL6l&`G-2S{LblShftNlw%
z`?sKCgZ3=2vo12}2XOivC;f&9sKt$%%_txF11ZBz&ahWWq&(pbJQh>xfMZO)v6=b)
zUl<3T{>4o@K-tNYUki-0r`ZByo&Lo8A`llTj#hLGI)4KNH_~$}n14S(csL4Fd%)iI
z#m&`<@N)Q|#{V^y8q?PKFP$0R;c8*yA<YEf0R<EmM9#@LARQwi@mTn#M*!qReG7~i
z+%i?Ru$m0dR$-f^g15~g8gj?9B^TLRZ_ohKHXbUM(leS|m`j&T$n!NMwQ;s8S1V2^
z8!Ao~GG8hDQzRAJHGiEQNJ^}fW<{?c>x1EWWB3*ty0GM6mGi)!fX5+MaNEHO)cYw~
zfv}ac*oTFZgmy9LuhKBivfBVENE<V#WuE#W%nVQl4i-si%25-9%&_4vtX!!fr<a+Z
z>KVm5T^hxDyn3h-vW^$mfx$;yyX&Xu>=E=$9<AW+lX#>sq<`NU+78npnA@SsyzA5-
zV~wB=U)tf9=_5ip1l#Y1At>ul&GCV`%;(!#*q)ba2h}uAK{T5338YwKjjsWASNc3s
zqLJLbN{F|k+n4>mKK(r%tip{6{<2TIk$258tNP6GRG%@P(oi^!z`u?!er#7x;WaP1
z8g#my4(wTWR)4YZ(NUCgLxICc${h;IDKB+?W|@v^0LFRE0zOQ@`<s6D0$*!y&+Blh
z2l<x_E~sCiGXPvcwcqhfT%Ehh>mw<c2gv|i`Mr-^I{HLZ*zJ|E4_+>&2hW69#UUr-
zmg#KJ-y8stYDE`UAqr?Mh*tN4RYUWJQk4S3qSQMcpnug=IDrO;rG+L@rLDx0Q^Tct
zsAsd&yi{-m%yc9HDM&SVn05xfXbiGcXgvt8Q?CVm`K{C~9qL}#4s`wstS2NNws1}M
zZi1g27~^Ct8parh5yoNanXLw671(WkOH@0&K=TKmZaa{QL6fd;2^99;HBi`Xy0G6u
zVJ-Nf^M5c?;#2hRa%g2>UNCuB*Rz8*M(}P8d)iW6M}uMpkc{Et#zNAuz6QHimt#S{
z(FOelmiSII&Jgw|Ajx5=Hpp}s7?~x?H)l}ul>;uA-2+p>Q$a~kaVVsqwj9pdqTyt0
z8m>CFq}6-_yucaiS@RDPKoFmp=ui(2HZ>oU<A198vd)1yjzElcE|mmU0D+MG7%pf6
z&^bZW`D!fUQC-AqunFn>tFiMu!Qv6t;vnw7gQ))wQaS0h@H6si&sv1Bh{tph{~Tm$
zfwmw~i|f<c^{TVv-UZtA+n>mG4RgDOsa?Zr-V13IT?{Xfe|S=K{R*Jy2~E+dHbt-b
z+<)zAPm!Fn(x=D>ZjcewAS2Yre=)@mF%5eJmci^8?DN2(lUESdCwYD#l7kt^!Gz>s
z^?Mr$6RLg(FHj-kS%<&G0e`E;e_gSzLvj!m@@M+@Cep@06%Nzq(A*mvqdC_qaO4<J
zS}sgnkW2b3xpJ6+3YS(wv*S}B;)AEv@PE|#H~nhg97sCZK!r;`VN|(+f2Vd`Y49mr
zSg*bZ7sgre3KWy62g!QqUjn<i_|m3YG$izDPi@E4SL6c96Ae_jbi6L=7%E_@emb6>
zUh(nM3H0=`ewt5D{{>H-N9g4F0epoj4}3Zao}yzAYNhuWDik^<*B1?ReuLXfZhw<b
zJii2R0T`1z?_l_SgjX`WAHqu+1~XY(XCuQ$BYXkFU_Wi^tYaAFX<O$shQXq?q|;(}
zR4%-q!0>_`fJ+%Z+YfM<VUP{mI*S=T2=U}Id?ms@hQV^#M*Bv9kHqwfVK7>?b^e`U
zNZHo8h2hv;0Iy>hjOlHiEqWlJWq-X0Mq&{@6t3C1e{*iQ^LG8QeOJ+l)Pc}oyZSU#
zQfds7u&nLMLi+(aJ}<ey{piF|fPZ|*M(LywAWcqoW9-{7nie>U#DL>5Ke?Zc1~T`x
zG33MRe8kX4cS>Bl*1ZR2(QWX58~pzO{9kpt&sPrr*TDbN;s0;o-7WCz^MCiX|8gAg
zKl|&I?L)2&1$y`G+vmTlydM1JIr<X|6yQ%=r~q%60n*5W0Q!)z1nvUJQ5dME<H@!H
zFT%-iDtPi~xG(YYg4CT9hCU1XD25A3=9Hj>wmPe_%II1?D#s)dZCptcJ#O7-SYjXb
z?T4vU68IRT-0XR(*6aK<NPqj=Nhh>4j6)tbDQQLmJll^(0+&S$-Q3V3hSDc(gy0=k
z2fVUygOc`ga&EJg4;8MW7FkMdgljrkc1hW9`J<)ylM|hYKfRc5b^b%k&4>**IcMfm
z#;VTEX&>6nhsVVSl>HVhVx?Zuct@#+Ji=D$75T+c>^xM#!b{{9P=9p{qK%b6=BH*n
ztrdKKF!(_$aR=~GNykR;z%!e}=E{8e>0kYs#N<Hvwne|S->u-*u^Vwigo0J$V+q&E
z&rUi#5F#`XB5LIZGY|&Z%@6YKnmoM#&U;x?zY4Zjr=O6qy)q;h;XaQJ{YOh&mK=P?
zmK@wEI|t-zc)!UiMt{5GG2BJ7Rh$ae05f;6hvd*8%SE$QE~<_V-fTteH{e~^Y*ooj
z++9|Qe3!@XO65E5<K<>2YhGhd!fRu0Vf}~pA9I?mp7lG$TEAnzuW`MPRlHM$>;cpW
zfmZ>dtrTsQ)HxH4J*ls)kd=)C+b%L{0FJ8&2h=C9xGKZiW`FA$$hww~SYs8_DF@h0
z0;g1YS(R`AqfZb{UYw^65^YpkS4nvGCp@6b3hYzWMK}zRn{3=yaqc;k`($)*Du>T7
zvW~aA%~*pG_pur`+sjS(BNJc5!A%N-LlL)}y(hzH#QD&R<iScF^OZE_E7cwA*fFi@
z4R!|5bCMi7#D5e!@(b6TRKc&zR0#vO|7C>Co%XD8nX)HxffI>KPXtxQaiYEj`0_Z^
ze6nt%V!=dgl9K@GZ2&<E7`cI&0AhVv*`a^+rXPC>1sua>WqZ)(doa9p&BBO13mb+~
z%m|&EvG8}bj$8<cHn4T-x2fP0CxI>T$3W-vczQQl1%GsY0uZ1Y2Xw9m5b0ux+(e+^
z*h{eUV6C4a4qvLp$2y%wt(FU@`UBP#gcXcUv5M`LW`?|?@l#+Ybn8PDM<2_60JsEo
zdp?+!FVYvd^sJ=ObL=Oi4ye_NkgdB=wLxyAb=oVeMg>qeO({V;QrqBYM@o|uY?wU{
zj0%R-bARM`6q*y80JggiZ1<TO(A`#wvs7Xw?}7gc%>vv1yat`j$;Y2P&f;_ujl9D{
z>YD!o?<4eCz=y4mnlXGL8l?AvO^BJem96-M{;c3zzJ>=zhg#X6cfgdAQ2h9Laz`$u
z4FK<F>EAo>b3`4uUOO&_)H+Zbkf*A)Q`7g4K!5iOcuU%83r0IXb`UQ?9e^PQ{Ra;N
zS}Kv26E!WlKnto1P{Y8;25hnmTm2l7HMaAYE(dY;t>z?SfgW_1!iG|PHnZNRo-viT
z@nfy=yHWr6Grs{X7rh2g6!I-s54RbF#~seIhl3mWosdk3apCheZ9|y0@(j-v@BT(l
z5P#BoMEBR{(ScEEmtWFQm#aZ<c5!~m%O8eCrg8SkJFPL)K{{|ys`p_#SWO<yFM)-I
zj4q@cRMXJ~%XMDc*otrpmD;g!N^QHwJoY#!b@_p_K9Yl0L<(02mK~ErzLFF9{ptuf
zAA)d)zPP;ZabB`7*61hOWdM9EXyW3!ihpDN(}yVV4C=&7!H)FmaE*ZUzg7{lwZl-Q
zyae_@{%8sQ<V5@8Pp{~h<nh|$5d<HOyVIdAfuWT=!g<dclnyl$-|y?Z&(-fwfcIGp
zY|^!l4XtcN-t;40?J1&4BeXXuYr&8GclrYigNlnPkQ2hh2+Rh^ZFP;<QCRq3sDB!M
zG_dMRft8Miv@iuO0)@aum-&H--=$F++uR^45xfAt&;UyXo9S~P2ePdXd^!Ognqn3B
zOHL7i4*;^A$;jB`1b|@^g!=6`cCs(YwDZz<k@`~Fn*<6b5RDU|q}}7qerYE_!s&DB
zII~|8#vj_p(w>NP3GA6__C#SXe}8^46{JxmFu+~fyRbq#af&EB3-}flmAwcfYA5Uv
zRwi@cKiZo~er@7&GzXqTe2Kt@@o92$+IcNI{bS?34wyOLf5G^!?kT>LIsHjpr+0ZY
zL^wXfzs<TZnk3P<5A0dwck0*A98d_?Lw)}FV93(R+GBp3XJS`n9vmV!fPZpz1I)^m
z+3_E5Fwyzaqd+^ZDi5(&vQqUKY=K#ISf}z}1Dgu|;skbQt<&zT=fN}a+){Nl2zi;I
zF1tS8@g%HzQ1S(9T<1GJyad*uf8zO$8(v~Z-i-4dS?pokXq&(rM=A!S(p|JiDqwFE
ze4x-3OT%a!!=w1Iitspeet#p48Vu3>;7N!H*u>R3IWDZ|TxKv4Ur+}eB?s{on5H2-
zF@VCSx*ir^bHvFNR?zWSdn$}q5{WNR7{2M;L3^2so6Cv1W~Qzgp4=X#R#((nY6)o1
zaKaJy07_8KP+vp4;=>(YWZls<S*J2tC;ZSRi>7NOsNPp5eaS-*#eb%*Q4D~8IN`Rg
z6L$Jc!uPsPh;nW+p9pDrgb4}bf>qZ=o)ws97^b=)d#dDIPSV&#lH*a>11l@G?A<Vl
z@L{P}%ks-?ctBXe@#_&2(j}#o`WpJ<Ji^ViFFD#Cr9~EK4_OWd^&z~4Nu3`iL*$3x
z*AUirNaGhPMHz4WxPLGw$999CrR*J4K%&Z*<5>hBwTHgh9~9XhQWOhJ6-$rAMG2Pr
zz~umGX$b|Tr^b-eyf|;=<tj#u)p3%r{i=-hRD1gxm#OkJzp$$xWM1RJz`V~pbbDw4
zy)RHtf<eA}bZ+4@O+vccmU|VARbca=TVkT%%msd*dKh_jbAMnCHd?G=#*t=eKlMo0
zV!Lp($I@;Nf4j7ra^)`9Wv0fOGS|<CGRJY5AHZAGuZ%T<%d2B$nZ!qF??uYk&p;RD
zF5bhqYx>vn_65{derVzJa-1Clmv)sd4a-ROCO^M$w*JkC*9DTH?j2^{bnrrZ7V3V*
z(;2KorMI@XnSVP~;p)jCW?RJ>?^pF*ZVeW>Z8sa4%8EC$j)xU#X`k5bmGx;Fi#|AE
zR76&}`ZLCw<rTxuNZO_Q@dNEfq<e))Gr3s3uM=2K0;i~0W5gHT#~}&_`8dm30K62$
z58f6>KjWgy_3o<1NzO+|Yf`~-R8HXjf;<>m+Nezh_kY$p3xgc}up;i#=$wY2rf?}K
z$kU1li5DC`%BhXhrXT{rPRz6$I9HTA;<g(4u<=-Ml80Q$d6(qmNd7)EN4dLzVv&4>
zQ-C?^<2Z=GkOskmo!jbAo4IaY`j#h63L=fr2G(HllzED523GuWT5#>4OJ@DGiq&q^
zhno?=Z+|D3sMzj|5l|x%l&W)df*L15tw>O=Ds_TdCqbP^V5yK!Q0FA5cM|YO{RUk|
zXky!G<_RS8)ayFIJSRb;NYJPT>rxsWKOi%gbedXqGa=zKm`<|g?qqf91)YpOxF-fR
zvK_r-A(#PK#2=dZvH1Y_1y{k+1;=E5+%%NOv441LD|tz_*Qc1ms31%CWlYaTzpy1J
zw-qfPYM)QzfwP~ZG;=BxVU4&rzHPjF&@(Johh?CmVr|8GY;VgP+mAdXrh-mh;!a*7
zl0W)jX7W;Z@=}rf=N`$+-O1%lKE)%s<xXyi<l&6u0oL1#4CzyU=L4BV%ySnpPb6>m
zNPphwPTnYzpW{)1T6gkVk$jd1_Bwa+I*~m0!K{49*a0*vVig>4qo#GpZPH{`w|^F?
zZeoo^zJ+OaQTP`$M8nWGY#0kby~t32y2L<dAJm{jnqjE8$CJBV1XmdUI}uz#AJF|0
zZ-rqdkB=qb;lShC<A5&t-<3qQ->{?dL4Ts+lZ(b#xeEu{ZyI6YA7|w?<RpKZeB2N<
z93x&pYFO?=w|==BT({HD6%Pl~K#gWnmBqGl2Q_YaF5LlDPs@ass{1n2li%J?r-HX?
z4N5%lgHbs?U?`#JnV^t37#>_mW4m$}|B!6lf!^>9Wbr=R+#Y*{wzjiGjfZ7pLx14a
zL;31g!1p%*cc${P1h~zV*GO6=rsQT%q@=h~do7dSG<M%6a9qZYqus}%@pela>i|oT
z$ifo&Q;iPcN^*uoeMfwYIu8`^Bx|N=_PeF85}b`vR|;Bo1|%&9dz5A;{hY1irAe^G
zE&|)(LiYFtr9v7Rds2R+caO_&$bZr0576cJV=18qG#uUy(T%+(D^b65HOl1lHOJU>
z97So!gWQF>kL)d4kLk`5k2^cPU*}4C53%jEUSz$s=dGB9o?@VfeE@L#OaM=<3-K4k
z<=NCe6#P7T2E(A7=iRjN6Q(u{6|Tw;FW0`W{66IJdS|A^52OmpGu!)QoPP_&Lu{10
z!_J+jA8_}Tdl^}x;0x)%NJVWz(_w9zQNfv;CBWC7*8gX^{&Ts`7%ZKmDIz?l*)%|`
zEl0G#YEUki)9?CAkK5pC-3ABg>?$XFBXDnrP%GHeX7H-IbNZeZkUU-Wk-9P*&n0_h
zk}qhI(Fg2w>>DQLu-JsKkADvt&_b5yuteAa`IGrF+Nbdw>tTOkHxbpyV=|d_Nty~p
zQ;Jgv1R8x<Tt}up`Ymzcz@mKgjSQi9Te6T8RJ87um_w^I&IEII???-FNAg%FbHm6U
zW={6wOvc_)r+cwZw-feaxU2IOS^JZFQMWQ3Mll_ft+BJWH>v8eb$@LGr#>)<<~OJH
z2B#mPPkc+J+Yonljp=Mwo%C!y{?F<oteO@79EPf%5uoaM6Cfci8c~a;Vu{K-(5<t}
z#MiWg-L^n$joME#+`e-k3Ua|G@AvB$AArFFgiK5+^_AUTjiK!z`o@Ic-9a|+@Nc*w
zySf%5G82psd;>#=>VLI^?8xEdf#O<>dv#Q(?K%1+m_OZ#&*^_Bl1<YN4q?X|GHniv
z9bljE!qeUCyP?nxZt}0$?_j$V_YU=iTVzNl^2E6d<U{X}c2JquXZX{SPyND9KFv-}
z=j5yPr9ovcwqi7*RPf**ux6$a8xsCO!EpYy+Qwd@E_qnX>VJjH&?O$yAMOXY*BmeJ
z$J_5R)~=}_dEN<6fH#V*iHb@N9W|+JBT(E94(e;ze9)nmen3&$*ei<)&4Jw{PM*#t
zb8_InbW}Qx1yEdpDA@0?Lv7VzlQ{d@2PymXPILe=evbAomy*<h&jVH%T!K2(4dAnY
z@!O#@Y;j`okAHCPz~fj`CJvpkP;dYXen}VH0R=<Cv83=I%*S)#b)C-|KaN%O@73t4
zv`xpJnuLyxiNK*}rFYydpi9dZx+|^YE`*M-H5`c>^)GHF{+O^`Q!Mq5YfPscBU&#q
z9ZG&xSK<am6(^SsOD%iA?)=LD#3i6}Hx`Vwc#zW!>wm}1M^Q(ofr%c^d;E&9@WB#_
z=~oVq6J+yEfRfk$1WJD0=trPrNH_r!Uci|9IHiB{Tl#o`K8T=W`dzO5PAv6z_>K!g
z1SaW$w(104R2hv9-j}0i+FQ5tOf!leO52|o*%dth$kSw=Ge#D1`J{uQs0?MB)B`bM
zR9GR8cz;P5OE2iruQ(I^1R4)Dt_O+W3V1_{T`D+NzcxCW!)+!j?2;IdsLl~(*&KQ8
zpp2+QZV%#E#qC3kE93P;Jb1YFz9cqYN!Thz?r(C007@f6<|tQ%m;-hM5%v|~`<qPk
zGn{LEbA4?%_wczT&-l!3sLHMDLrB0HMr5{NkAL_Y23C^6o=0s&Ex|MUGZ0@dnR*s%
zq8ZmlKM<8)XTE?M*nG%weGnlmYS?d%@Q1KJ(;VHL^)%C`Ay)DE5MvqHaRyjME-pZ%
zf$i9`v5IZf)IWfRdm*!_tL^?X-B+Tv?3WpJi$d4_ly~B#kK?vIFl;b69*lW{o?ahB
zPk(=Xou1y{r-f9zz$KirgbvaNKIU%^(XsBpr}*Syk4psRwornHIQfZd>FHj6`tVVD
z`U5{5hyi|@11<36_$#?hDNg7yn)c#IHY)<~MY$O#<-mXu?{62{b_*xGg9VF9jZel-
zs6&$^vO@fYul49ibKYRnC6~gmQ!BvG3V$S?iY*bVn1Uap2Sb-s4bB|>7y*=f;`n{J
zCo<IS9`hL`qbG_@SO2~^18<dErsERc3;KPnIOsQzbO{jpo&DTJXbeY3E2CyP_D*Lv
z9!axzUJ~a;&BG+tUA&|J^t)qEwX#@oiNX;W9)}yxZ7Bu*Sb4D4d(n|>)E!=ZQ-3Pe
zgkEOAEuzOT*Zd*Az?{*;@vJ*GPqZJtYqL+iV^o+$;M1_?hxyvy3`RFCE05{8cs7py
z_J)X0=a!`NLDsUP%i=GtGL}j&gQJ)KAt@<e!fWf;R(7zx3xzJ!Aunj;=!4}Lo@{5T
z+xS;;uZWImr7lJleHZb?D>&S#SATqQlF_H!X+nIJAtrja5k&25;(vPn0z3ap$iV1b
zb65E}-fH@!aIAr*TN-Kf;IKE7pq`dYNBJ`x8XP^-k7j4W9`6syqFLkPE8ik&2#nN6
z{GCmD`qj`0W-L1utR1e`^y+xKcABaf?poU^O2TAf6?zlHzN4CZ04l!ckAJo~>?GQu
zM#7qA?-SXnRNV)h_z{11_sx{pw>e<n4okl~A$|NrJmzrP_}Kh)*W;(V?-f*M@9)%;
z9SX)343Vzm^LI7gUGWw5xo%sh0?juWRXw`B%fZzVeO+jxQ}7Z<K!<cJQdMQ{lgrxN
zg{D8diVk%jO#i#4ckY|`g@0GKZpwZ?z@c<kgR^MS%OJjVE_}&;fq7PcPa2<K&-~Vn
zonEfifdOHy%G326Zhr*tSYy1=!@ETN?dR+r;}vf+^ZpxXgk`pmrE}><CHXW+&f3HK
zjv()B4}7D0hR@aBc%Q;_;}}j}n`EWg7;lGF=TLc93%Dj1AK)2c`+wu1c8G1CjIgcM
zuI`RXn{Q{K1v_)TWuNa^_^oEF6m_2!6zL4MF%{gY>DN9W4g0W?gY5d}!VVO8--J}~
zgZ=%!iq$CYr^V6N=59)UBqX<QnyOK~|E<|w#(?m+ze2}NkNaZf{)QgSrxvhS`qa-F
z%!ReD<U7%L;0rA__<w8Pp0fT9TOsm+PbARcC09R8XA0Kv6}2eeJo~VhznUEr#_iaP
zHZ$<L#k&YbK;Ij|Sdc&#McVc90UAr?ngdh~eL<i;tr~pQ=VxZpPB%5`<*&Tx!KH<Q
z;o^AApygKRxJ;C_+K)&5oGvF@!7T>6<ex`rcZE&6HhX{B*MCHX_}D~lIN2X6aMNTQ
zN**lO?O)6@pyK$wa1SsL_5i^Xaid*0ggov`;Wd0M!LR7~K&py@!SI+0em2-F%w4iO
z+K&N_zZaMiE(d;<3O-EP1MA^6jF&&-PdE3;sK<y+(jW)HAc_b)vY6)K^W=R=ZwYM@
zM8G+aUbsdb2!F3V)~77~(#Wd;Wg~|j?MHsSq&v@kJo+$5aG0-QNGezlgK&cnW2UP6
zuY-*|LY)-64U)|BMQPz|L=|&=VeEG8J5a~U`+9U^qEsHyu2J7=E87~1Q^9}lZ<jQ|
zl$4z5pr22NwQVFcd2nfW;-UbORzflyk$edno)(0XgMS&<K13P@Afodiji2623SG<g
zYRGzjVA&iB)Ze2^b;RFtkNa8l`5BUSo*HHzyvI+PYFP?OO<q|&<iEmI!LpO|X%vO=
z6!xq<it&xySqJ%ktxF8u=Le6Z|0w^N*{;U>AIiUn^t<kS)W^O;Y6OfN`mjC{^1K(+
zg)h^z#D8*teTr-j-g(bUK}2mlkmqo$!|%v=+4omH!GD^>KX*^?&&gDv)EjL)%|P|s
zOtYZT<M}^<N0{qYLqHt}#tn1I7rFrc0icr8y>zNxf9xw8rfRnzu$rM<VQ<ike#CM|
z@odCCC1mr|Ra~Viu2Pjgf#wxcv%0(Lj5?D=gn#4qGSnEE=It4FMfIC2G3_XP118X#
z1p#%$NnGJdtgxMo?pL6ynp%{)H9s{n0xEBev2x_$GfzEuKu;@|JwB^G7HdQib9*QG
zAexB0dl;Pc6H<Vrt4ut~Kkf9E<tU$RJ>SS@KkQ}8XY)|n02yVTjt32opFV`vGXSWq
zNq=dUXA&8jJBkF&ZAF6SmLd^*;t_a2jno4q1>P9Gi%LW4vB$|F&2{pF_cSY*Dv*J$
zK$4r*A^9F>J?#3X%@OkK#k1I~0Tt0P_=KZ50Zrq9TC-N1fadUVWYECDb0Tt@Sj9o;
z##y-ZDjKJOec?&F*6OslrWt<&9jSqQ?0?Y<i%w4hb&b_nVLB|k6=$6Zx8JCG`_T}f
z{b|#W!tl$dh#dD(7<>Z~`(oS(oXi`6lWF{)4C8+)0#iYttz3gKln_07Ijcj_TnY~>
zyvkbPS(dSYqJ^?X?T(qfT_K-Hg<4Hhu`+GldJWWvC}Q-AR%r-!5t^3hX#FaeUw_qL
zd^!Ef*Raq~d|~0Lz+Y1oe&!q<raB_Kk%l0VXojGPctS&vV`u0ghz4_<)Myrm5y<8Y
zuxDXY9N3UbCF}lgmhkifZJYM7$;+2MkUi%saEwO4L|X)!EelcYmoZy1_1VI&(?mPa
z6q`VhL@|zoYR!@`7^tS09Hqyz27juttNGR~y|};2q}TSWHLXo?6IdPmpA$ZSck^k4
zd(hibkKAzW9K#Jq{@ZW3VGVpSe5+dXEqfPQqdq!Xn!xR-3P_OThqp+6xKi>%WMs6$
z6cPQnw=?Wc4VcgSzZ$duLjs%DA+etEa2>-@OC$*SKbcJx;<$0gV9D^7!+(B&s8ul^
z<`byOVP;+a4F#Ot%T9vvZwfZ>nL85A`|Agm&KX{AjO50>Ss$!tqow_tm?E@MJq7HC
zw-f_}I4W79^7Pw)UfmHr;su69O6lc6F+P^)hjPceYH7GJC|Y-3P_%A6JWv3UAhm8S
ze!~XE*7++~|A;+dweLl~$$z&o+D-$#-T_|FV90?_V0{Z5gF_=*5E*b6plWCgb}*T7
zUsFIRyZNI5b$kc&Tq^0+*Tut%x8b2_9rmDC`0Fh5jiYV=<HYIYyRtw}ENsx^ApMZG
z+r^mY`sy!OkLYs6dUe39JWp#g=BeR*)DPR_Jgv3Id57zY1UXM-6n|al362w^YkVGG
zhdIqVz^b#~KZj&F?6UnVuq&0KXfi*a_Yh#w@+J4xet-JiW1t(?5u{z`HPiQg&TZb2
zNyIU--w#e+=g>A3)Ry(H{&dGb$3Su&iWT@y{r1P^ILnV&AA2);%22bJ%|Wst!(){S
z!kY^h6x(Xj5c%?fIDh;ZbWL)TLr;fI52@y}+GAW*L1W7yLh41Qwo3x4WFiaSCF-IH
zx)ZgQIVYK)3bw=2M^ooB`u9C!YdOS<ZQo9{GOh`vq^2_`V96awq^0`=dzmsxhGMF4
z@pup~0|3(IEexo$j$_j5)Vmc%`cDMz(+A<mPD@=7VN=))+<(HLx}?t~vuv9M$X-^F
z9XFjFC$y57j+fMv|IK6+UognWaFG!k-&|re-~?U<LMrcA(BC)#j%}nmNJgDHfv)eB
zW=>1pL$-gt_25__h!rE&dQr+May$!(BlWbtY{GKrz1K4IhB-+Y-U=m&4%2;~#~Y$g
z!3&1H?ALPZs((H_(Tv<dyjh)2Xi1CHp<aN8<YD~bIQp=KPcNQ^He5#=NWOmYzO3SR
z?`zY_Tby3rjyzG`e~I#5$`j@NV_DD3>(2h}c{P)I??;9(VlNSO4{WoOhaxAkh!ere
zfmD(s%q4gwv!m)-QJd}dCXaX{rfBj6w9q>r|E}cu;D0>Ae2Bn&Sd6_$3WKfNz3+#z
z>(gC*v)OMw?&l=-fh=w>=q`#d1*AL!vp^f6IEGHC;DwXul4?DWYt+F<iwVJlTV0R(
zZkL(sE}S;}K)j9Tg7#_Fb0MUD)LWZRv}-U0;HXnKjNqwX+GpXxbc>wMOT4~Z-Ai5M
zgq+VyQhxyL8Xc&<L(L)^8}UfVu(I4&Y6JqYcc*{&?lE%nB3a;#$*iF$x5o3XACwf$
z)Q2W|9L{rjsF=}EgBrhQjqBs1ghqtkyr5edoDQ|Bsa}oOr&Ia509B1GZ&nk_v}vgw
z&5%dz7utPf9-Zsxv+yG0Hlg>z*uXE+4NN*-I)7O?v_OszCQJaG76BHd*ZMa>Rhu57
zYVZ#QMWEQrOP;77_YC*XZ8fm*p}dO>jJi|2!&&{O{aIjT_Gjya@7ABgj!f^*)KQuJ
zdH$EK{#;bvlm0xoSNHvy18E9ZbDPiUVVnPISZ06z=t%GW+*8~Who$%DmfhX=C+J82
zqkj&aaC~Nms-wSKht`y(cjysEW_IXppSwErcSrT4Ln)Gs=+Lu0I&?I}QRH@>lf9jv
z3uX4<Rb}aYc#PeL-JrWXl-_NFc6HHh++SI4owoRHhbcCrHkUsTRisV_eHxlnk?*UW
z5x2BTH-}KOhU{30$v)PGHd6R?u^x9RAAkJ+{yp7Z$3DO+wkVs3)uq8VE55Stich=7
z^45tX;Az!-NWBS;>{`qKM<snc&0Jp;TUVO7rS_r^k*XUm&!Dexb>BJN(g(XrIz6o3
zL3t>{q?P6VBI7|%8rgc-<UopQ7{%4T#d|@~)oLjicsp<Ki&Q5Ae%!sw06G{gl7BAh
zX2XO|iTe}cI_AEU6F4i~(ZZn-G&4z%pTFjgI^L++q2gJC=|<T`cLr&8I4>2v8C4t|
z>e}smj|FXTP#)y{`XS_$w`h<}&?PAGVE9?O-29TX``EQvitIKZZ;$00%yrg9U?^~I
zFYiy%Wc@)PieH8%8ElWvPeEYk5`QP!*+xK#$Qdya@RYjfAug;3GuB!<#Y$Lf)d0jA
zP6j&fvGEny8J0l?s^yO1+1H}3?kC2vJ}z%Te;%6XlF*kw8Yc}I3`%$;Wa2Y^c;6LY
z*Zd&MdAvp^zEM1|OKF8EG_0+eqm9rE(1)#bY+WHVc)%vzET!g7P;Hmn4u6^;+w)-2
zI7aakDr1WY8=}sKF^0<vTi;4K(P{l0eOz)ew8vN#t1uh3GBDWRga@(=iV~nI1I0cP
z#nFUf3ygcndxp%rBiAGEE424DYC#Oh0{Yq)Ygqs6?a!!v7as1$eIPyk&^=6_=+Zd<
zpQqmwdbFFx2dE>(2Qbxp`F~rar#~;?c`2c|@=hYyqxDTI!I<IUoWEw2-lkIY42;1_
z8YMLT(zGpAPf;9hTh*Tkj>HpVw51$2lGh@=<voW2?xt@byY%<ul5MZeA}DJm6E=dj
z!X2vOBRjgTF6PM{lqh4P+QoTFJ$>s<fMzF7t&vk#9ZJd-9Noj!8Gpyxy7{W`L8eh^
zY(i_*Z|Tx_W1KNThMjmgR84b2NnE6BM+`{>-WkOzygFNjM@RpLsoN<&w2m`Uy5L-!
zTU-xPIXVS0UYv%d;J>6hQ>Xb8c8O7~jsC!n(}bLR0ESFw*<UN*NXK;khuj<bK(184
zVce`@uNAOdjnJDO+J8v!y==J@rH)&~sJuJWH)DmKPRHtqxKwm&#xVCBrXGP_Sm}hp
zN@pdm`C@sFpufB(h88fZ;N^HWjt26AgPHakHO_OOX7{(+X#4GU?f*-Q4dj5w>@)Ja
z@)Mz&8%GKR>a0xHAFrb#XdBgAl!EHRaNIeEMC?l|vrzEe=zr~rJnlFn=h^pR5KPf3
zv!QVF%k?%jZGf~xy{VO0_ySUNsLjrcF6ccSlfbxN6fOcE5M;V6Ll<=$zdnP^J>thD
zd|uIZR4!E?imn<YyDFQ5etLh~nD&`#YMv-~VN_O3S@YjxuZ)R;)m`N`SrfrsV3y*{
z`-;q$WzXytPk)hmB2kd*<SOFc-R15YEU4HFUZ<ln*VC_<nRIi$L62`b&ELiO6TFA1
ztMA~Z-R1d}?!ITm&u)N)t0Ezg@b-0l0@-^yq{i+|88bF%neD;OyFF}=3X1WpbKZrA
zJTmNsZu-A#{hXr{U%`5iestorBeKz)mS0c%qa3l08GplwY=>O3*&{T)AD-XMd8N$y
zrdthaRV@fHq}gfcL+cJ+p^ght5$>fNVa%@|?L!irY7Hv(P56{jHU6LM2Cl`S9k6T5
zE)99pWBn_Qo;i$b$uMEGs8x6CNAf$>3+$bEG?<lVtVz_KgwVv-Yw{^rZmBqYF?UoK
zBxdD5pMRoA=5gNG-Trt#R+jTAJsRIbK|IOKj}8WPD2HuefkyB9e6Kr>GWZn(Ig|bZ
zRMa511Z&=8FE-jZ{ShYQO8aT{5A>ksYX$B1QwVd1dUhZ4ec3Si9q)&qQ`s_|rBl94
zNhypJ&U#O6ImWve2hi~fG><|$^jJ`JkZz@&YkxRiyJ|kYOagC5D)@LOUO<<MmfA(G
zq4Ql^?Aon?C3MajpuoJCi>CMs@DaVm)Mc<Q(Y}CMFG{IC)x}X7iXUsf>>gz+O6+%^
zgWy`Y8Yr0_9pEbL8}J-hX_Gwz@O0vd85JF1xWr&pLT*G3#d$z6UGQi7-|$rwpy&GZ
zA%8nm24A3aBVYrpy?0boUAXQ`8dZw)9tG)Lr8f}~6cGUd=_nu4dsWIxqKF8Hih}f}
z(wp=i1VjWuiqc^L(p%_(B;>^J?0d&P<BmP<*!S+gSQ*T$_0H%0Jx>^9uDNb<-a(yJ
zt1+B0>Ir`}h(wj0d!)tTN#&!&9<(0DL*k2@Wa-WZ*x!^sqGo92eEgb8cs%}?n)}#d
z;wdSWY5WS5Uh*o_<y7vIX13Hm^J8|sZ?s7ZR?K@_Hy-CB4|xll{1k?k`7<PK4=;q@
zMv(W7hjimUZUUr9Y)LBY2t4=fO;3-sNyREhn{kU!lS}-J`DHbu2jfP&GWbVpnq8*T
z+}slHjQBsa>3hIAX&3_-F4%XBUI-~bzzV#s6E<tzW@RR+7rGxz#%*0&<}5him8KUN
zxr<u^QW<T8@E`Ub3$`dtBJMhK$TqQojA+Gj%AMBFeSnyPl_ucHi&F+QY@tQGU1?OK
zwPNXeLjix$rrea7va>BMhgS+lnhbU(FK;}5b3o4i9`7f4G$U)(KnU?${Cc7I5!VR+
z3gW`WZBM2T_8e#9(qK*C*@}0nW8T5{i+_!M|JKCd20!SPsQ2))j`lRXS!!DCK2dog
zIfeHbdGHqC#a<n|6ZNe8<+?h4`AgLcfLgEV@)giAX(7{W$@GYCl_B%s@kvCgh0{jj
z{pTo+e(KJC1P3ZU5~Gv^>WWp|%Zf)fb@Wk(=RAvFs!P(^ztyfP!zRplOSl~g-q2^W
zCodx(`Smb7qnC}T!xrZ`fPsH{Zwb!CAG)nxzZC@x8jN7M0-5h*wnf}Ofn}-ry2Q7i
z8-Zl4U@tAMQGeFu%h!o_rY>9jlGPvVTYf=6O^>hnb(^<qw3^%v1T!Y-nqcSso!f6u
zzWN_X>C)U!0L^|UMeZ;R4t4l5zL?bc@+3Irb}`M)oxtlB%U>`xLy?VboxYQMn<0CJ
z%W5Mz01aPo<QtOL`G^IM*i65a+67j=;tR!kk31K-^VI?_XDg|4KHg{4h>4y;R%+x{
zPB|}sS8Rye{@6e@-H^su-1{IW@2!eJDrQoGtEif}c6c;c!eJbina)+n(N^QJ8xm(G
zJD9pYz}l{_nD*6B<!;%hUqMmLtuGi;2@$vWlz~1viyM7=wAVR*j#jD4MoqZfBk--M
zH`T6$haQwkE~V98PRe^7nf9{dm3<;kCQ#pieF_>SoXI!<vUHTM92OC?xvbo@NrQnN
zfw`ouo4i*A)}rqZFValTJ~+9q<^4YRReNngLbfk`KSNZ~{hSyq{h8wh_FKg#{>_A5
zjX0pLmvMaiWW}Ex{z^u#>(#(yfKGlB-pnp2cg1t>T9EcPjX|o6PGc2FKk;sVj*r%=
zJCogB;d@=5Z@I~lnO3BX_Y)UFSJ}kYA7?qlou9}K=lqPwesCPGaxRjqE<>HP6H{`3
zQS9@xDt?O*d`!t4DC>a_(-CcWxV*c&%X0$QT`uiFbbe&-;cWX^Td~gOcu#w2^v~qA
ziK_x!tlWXoCm!Ec=ydxF*-K4D+MzywF16mYbh@_hxjg;&`alEE{#}l;BzUR7novQR
zA*Pi(H9os+rLgkIFX?0*T{b^9+qZI~Fm7G5cf~CtkLJ@T*I6^8?gkHc)4Nux!Q+I7
zK&eA8X*gS&P$#|G+dMqr_fgJvb0y!^COyZ@-(%?xAK%eIzF@DDm)k_^PhGo4zS?f_
z4{prIiuGK}a==r)N{^s)u2vdt{{>xjCLrY?180}YF{?Gbu)ucCb!Qeva2aN@ey8Jm
zZLssb34V+A_x#t)+^%0-o1><G2JD7XfCLZbF8x^Zr}k8}!#|DVseAR7^Tow^$0zL@
z4&tNvi@)<5Uz%B#5AWK!%rNcX{_~3auJt4LuV$V;BIaXL$V97m<;(WAWy~>&iCPx0
z5HXPo)`%Kr+Fh=}tqNVE#;A$v4}0uvzLmPO44bx|ECr<4+Hn=ukHIH{=f~H~yMTaO
zv>saa7(4FQ`^sa>llt>9A38oXKe_M@dP7_94X5iHLBhw@UbZeOt{WeSRpm8)J*7)!
zqkJ`B&O)?eQJ6CCmkmSFoPZ2<(+vi*5obQd!H!R~d;9akK~KN?-w0G?A&pU;J7G22
zuT$O|yS1fPtz}HsqJQ8utk$>Cu3Zhd<vsP5(7$x0S;pQMUcK)rrR58M=3O;^JkS-e
z_Z8u;M2N7Ad)6{VM^&)i4(BN5W_B#P4;=1jaX#GI#nOf%VxBqWVqd$(#lEyi-x_7`
zu_VSE8deX|?T@c)ybcw3NaCO6O=@5k`by6r*?bFue6on-os+L9$)_Lx+{y~LbRTS+
znW=VXCl3+&*QqXThy5(vtf(05@#|ZDjrydQt2)SM<WC<4d*_IA5_*0O%`jWpg8Q*~
z?)it1G(NhIq<S+#<!bDF#hN&MVA5xCsszDPy-bp-Q=%oHq{U2nBpvvxi>kl{OCx8Y
zz<|Bmk#p`gGu88^8luzNJo*VB3vp8!Ez12*3Wo0eB1_<;A$%lYe1V4V_YLCC2c#c=
z4(rT!xp9W;TO0%@(qK+|qRWHG2KS%%appCP`tO&bH3Qv4S3IqKm@{Zs!wWVqjhF-u
zx(Ft)$L$2M>s@Ux<EhDV8Zts;IR}~l7H17rsNVV%Q_p?5wAe2sQM36zpu#aXo^uTp
z<(^hI<1Uar>nf@;5OZ@eA}ggLzv(3m-TA<~<M;B)x@+#(>qoD-+(vKDt1d;_bNifp
z=NaX2t+{>S)V;;)GQr7dR}0WQW7p!fFV92PHYUG{w;M`OHg~6AtNyw)6m<CNi@^Po
z`6xztcFyH)7#|fDniy7N51{L{-51aOR;lTMX3=^}f>!3`{f`oZ5r~1(sFcfL4pn(J
zXV{z+n=#dT^4c3t!`-V=$z6<f^$B``;im@0MQ@BJ?P+$^CU|87FL@^Nm*Q)-*Tp1r
z=wR_TN!MFWxV~kKB<-^gjaHB3(%x~uB~(+i<(JMLyCQkM`KoM*D4^wiEteNn4fo}C
z;^{lHC%*xiXy~vVKay`XQwWIJeG_dhtx<lmXA+M3J+_$RGV}QBR*EV8@;<xXrCr4{
zpXI{kCZES%%Jj<^PR~kAPjJIMFD{>R)KGcelVdfz(YuDWj<~`(T%0xi`lg7KUJ<8(
zb5_5Mx!Ih$0PJIVrwcGdSuIP$BWWQYbY~k@!9>~2L#uJdKC>qVR5&gPtQk3#{}7tZ
z-a*LQIBF;@Gj#We6ArRWw&tqIb4;AFc~<1pqf=Ab(bv%a`d85TfeFK!h~5VpzBdV(
z<>N6JXs7|gc;aTqOObC;`g8b7N%?V%?q*lU?;kMxBm0i~KXZWog$pa^R`MrohaO#t
zZ2Z)6jpR=&^MKZZCcbgupGXC`3&g-wjt8a>Q>9KSnA@IwiN1S?8@>2@gVlaEo|Y=t
z)YnAryp-+6yTz4|=H%n_*Y>@{Ob0Kwffd1N57jw|qn0G{(RN;_>)_FmNno9Q(yOl#
zehS}-AL?UN_>Ovk$86CxjkN>G#p_<N)9*|2Q9Jy)GZ=_;<4{cW&-A6K!XC>oUgI|*
zapF_RFYae%_F?L~k1|Jo987k6OxNO>K|F!ghc%t^h}1sO{KKloP9(IQ{K)~^V&eko
zhq)V@v=df-YyOmI^*n`dXyzyB8cvj*oDJZP&eNKJO`19asDAd?s&owq^7Bir`O89r
z9rgt+u>LDZwiQP;F~^8wg<kD&EF3125}2ns6f=3QXYrMV{}{86qJs5s*soYEmngj<
zQ?H5hce9i<%g+(qhWB^QkJtvz@A5{J6kOgLbC$`J51LYPtM|2wGwn-A8VgK*M$X)m
z<k|5In=j7;hG&20?FSP(=d~D`V*OU9GuaP6OnHAd`xZLKzqoy8b0D@u0;k3+>&EDZ
zLadZZ@0br=|0ttSu;4lnwc&&kJbbiv&+aOh4tLdjhZ)-{Uh8q03x0?c_4#<XfnMbG
z`>WYe>|a?oZf7;>pH4lf%el_U-7`luCmzV(5R_dX2Uw1+FAxH~`s+TOkHr3ZxK*du
z!gv!B>13<u_0P&|a{4z}ohK6BVl<%i5L)OmAJp0~s9x-n+Htsg5`p{dg?Y(5<*fCm
z-G78K;|%sq53PG~$X)w#_ZH`~&FVRWH97%3LS?uIRTjgSzdz@?!sUOCq*|VBArwkb
zxNhV(^ByQ6o+~Y`7(Xp=;!Q4Sn0?Qb{Uon?m%F@z_Z@L!v6j(jY~rE+X=-0d=gF~<
zdGM-vaZvKxZ^H24Z0aBIO&Pk7`n0-u5OlZSNgR$2zH#{G{r725@K@qRq)1}23lZ8g
zYj4PWc1D0aVriB<gu2=h?GYg|`U_*$2HC;i_625l4t+LWIOI#M^qSLozsvbEq-cNo
zCM8;{Mk-_OtiT$4dfCnJ@imgl6Q9s`<tw4LqjyO?S{gadH7zP_+2S4=tjixNlp-PU
zCugn+oiXz7c~=tj>8RG^OyK;x>d-fKZq-b_SDG|U-z4)jWwCWTL8WswRKAAZkK?|?
z7ruE17#-q7{1oe`9kS_O6RVRvi}^rLz%E=xB!s@vEcA_-`&A+_`l+YnU1r5()zCk-
zf$o~!+eJYU$u+INd`43%`gRIx9$M2>e;l32Yh5fdMt0ZwTx$QrA_z2FejbuN_kj`n
zrDZc<3fq<yrRd0peEaY^h|cMB6d&Xkx41O61FTrLHve&`#z`C!{56WJ9yiVBy)Eka
zT}hA%yd8Z4c>|_%$&J!jEK(g605NM$PSXi$qC%g(?NvyN(D;Kk6-sMnYr^zZ;?IZW
zwfW`WA91QM-v}~vvD|Cm{-#L$XJEN1W{TN~Cn8cVXY%rD_Q}l%A%pU#CBLg*Ooh-V
z6#zD2F3+fo{GzB&Oyw3||8caw>1L}o=PtY!x%4!1_hs65rh{M0-bIeqqDA54;4C90
z4}I#}%w(W*R2Mk9>pPt_EhAa&sItPg*!&)4xZ(xWE}R!gJP3_=3{?CqDO+=X)|1fq
z;<>p#LB9E@pJ@tnk-L<hjlq&RT_yif_B&t$+#EekhXu==^VVGxzcI)CBhIe8MP#e*
z@bOkv*+lQ27Oy};^v6m61FG2Dc9|}pkC1w;-cB1w+2N)JRi90!*bM#c&(_LkWxzS#
zF2}y?FxGopBAIShucoX)ld77J_HO*3n61L|q59Mn{VvxO)V=Kw6BR#v?-QW0oK^)C
z4A*Cp3k659{?+xXQ{PN;XY^VcMkAy(Rka5f2x0U?3BDg99O6o-KiS-_r7UQPZs|Vz
z$4mgnm&URcasxhKCq_?wpdWkPtY;ZjWEtkJe!cTRgxO6;L4(H~&HCca6I^#P|4)pr
z_ITFF#U9(1bxC`5mybyQ<#saR3popjT-sxdav-+dA*YhtFg_^<U5D7Jiz$i*Z9dMo
zCaMaNGk^Bc<pXatdDGpF1I__~$fu9bKYbrgov6+5X*-h4peXnQYS5#_uECJ4y4$g#
zQz^Ws1y}F1up}yk37x-|L*+lGf1>du24S!ff7#>0QsUP~d_CP4r5O#+EUpOw8I16A
zjb8*tUzP{Dmrqt|Y#Um-hW+-&aDRO*9GgN?s2Bam{``-T;Z*99>~!J6x9gWK2CBMU
z6dTtm=EZH?IQ&)FS7ms4K(_Kxa11!kFZBB5F@0uylgs8c)9?3gNxfaGc-i53hW}pN
z%U@K_+}OyB#IGkIyQ)hB8s64zEioV?;Uz5fAlA$FH)(}&1@AH<EVAZDy7&FZV(W|4
zG8j`ztZBtrD<>PKe(D~XaAAz>P#14dPO9SCxj1Wi39D>j&d=02Uk!eJusxx9G^}P4
z*C#R{f79SsHOmE_^SSTYC!*s2d24p=hCl7jjCGRn?}{vSrQb#7ot&CXcbwhN1Ljg*
z;z9BR(&q4(947hdC&7!oq$@gM1Ka%mO-#aeK_S|&k~Ibv7wFi}U&wiQ_@*T)b3c(e
z8?rC6{2@hzQMRW|F*s-j>zy3*?Pup3Cz=<>&T_nZat);(@ZmYBvHi!BeHyx2y^jMe
zs+9vu4NR0tI@P$S^t<@30_I9Z%8qX<RJnbv`z1!jSRwl6w;Cr!d|`>TVso#A$=u{i
z^4zVE->%!;8-{8<6Lw{%>o-C+UiPhy{UXr?zDp}ZZ*}lY9opGuy!z#^s~JdjfD3tH
ze)*J>w0H7Va-P<9FuJ6a`^ImZ$biiYQaEfxNiH<tdiw`KZiZLfQ5rv{Ev*2iMw*}7
zGUf9Ygw}UPn8OwNrI3D+nTayKlJMDE%ZA>UsyyUyZafbSZVECLULP;~)M$E8XLjH=
z&S%S===`{dTU%W$61H-A(YdjY^;hR?Xknj*ksD>f38^}qmm71Gyf>4#qfh~`nZ4Q3
z{3p!vjkE}LCkXp|40~j(y*mJyTKeSKH|=U|;BDWRIX+;ruZ1aar8CQ!wV!)6-*@5m
z<vYO=!T<c2PN8qQ^=QmMlqJ`NB^Fu#h8r?nvn2DhMwII<|DW2V<O`(=3{T@U6zA#W
zn?8=xcrJ}ReAM8s0&_EYl@lVBZSk@%k(OT~>k<xa1(^^lzt{4OYD8;25}+QE3sX>&
zJw$6;W5^qPgzwDu6~W3yEmuTdohh)q(nOaRKVwAgP1lwIPAsNDAAC2ee=W1xDHymk
z9_ZS#Bwj1Le`V3_4$GNp<Dvy*ve(^FSpUa!GbLR;ds?2NKqaFO@p;K%x8%dwSU+4+
z&gjZBY$5K-V1wwD9mC07F`$qOD_xKY=|Vq7`fx+E)m=?rO(e?Y==QVl-WLA#+x{&-
zycP_=LAFc3Y*&GVXDH@ZLhA`}H%Rl3K9jE}ed2v-A@f|mHD1<4{Z+pQOUhtG(Zc%b
zr>8xBKaciJyV|JRzF||th#C_Tu0i2yyWQgcQa{;r0-j2`lzi;<G6&eQ?N;5nUPN;q
zcWs4cLtaUHG<`-XTvJ)%*)V_(&pmmprC)bT++xQm^!4zaPmkv$qTAZFZXQG>J&#wR
zpCM%P0&weI`#9n};^5+{Z*5_V!v5gIAJVO^QP+pnJ!AiLwby*$w0L3Q7r;0n;pkzU
z!JfiD%R{DbbQ_Olj9LIN04aVpL}Vr<>a_qXn^~pZsbLYy`1Z=v+M!FyOj9C9Can%S
z=t*C-?3EL48OZuV`IX|rG^{lke)5qRI61mxCcWr`KMzVj@o|=$uag4PNb>Kbnb0n{
z0&#l5!|273tL6E*=zB$$9hFKmbGZhM{Y@#Cl=h8API9<zCIW;pw*;Cq=}O~G8$m>F
zhgg9jS^?I=^z)aQQTe6|t3SLoGa}AcO_yb~!Fmk(<-!CV^P@$(L%JNQ=8+v2JZK9R
zPMp*|pSS%phyAS2awan+LmS;S0}{o~n5ec9t_*amyY|aaGha#z`B9X9hi>=I3|1m0
z+|kaf>sO1~iXPx2^}6k!n?fN@pX)Dbsm}7Y1x1p-hdSGr2YV2cj*k<aHbu<7hForD
z@L2j2+EnPd9DhH5%9$^ZrtX$18?p84ak~T03(OBcvqwKJIJP57N%ueW^SE$u&5YIl
zo_T}m_S~X<tM>cmtn)ocw(hfW<RC<gr{ZhKHJYTF&1!ne{)Yu^z1tr6QSK$h1bm{y
z_r~q+V?qJ4qxvS3sl$_pY@ggaPWO2uj0pv8$fqGA565nxcGBm>z6K<wwF%9Hu;HW9
zEolncc65;kl2kncg7qU=bFtPia=rH2X)D#S{bkz{^$6wLk}F5I%^CiD8Ke8!dZ^4k
zNLxFfR*I*t0S=X9(g&B&G#!X<w{tr=9j~RsN*9;*NOV^03-Pz`inIBnDGacy0$JIn
z(6yBI)e}zdXq{K6H(U_VnnCHyGX-BN$Gu{KW7OJ!)J8B*f#5=PD{Af$RU)!p5~+&t
zX!<Z;>YyXl?cjxX^Q<Gk*&Fd(5l_eT+WTBN_<n!`%muX5X|H|v=~&KNQGE=5YpRrw
zo5vEi&qoLp8Z(riNoS<H@>7L561SrfX-lQO4l}`z8ee-F`MH*ZJIk1nYW?+lpaNyt
zJ$dkr@$SZHNKwvUs<}Kf)jfWu?kxKO#rQlwjjE__KWD#=>NS%A_OeX1pD#4cJP#(U
z>l@!J0e6Cg$g0JU97A{UrGxYMgx%uqx`A!3ELyh0$KjLV?*j(jUYNybA(n2)a5hPA
z*u>q@=I(BpQ;vRClh+0+5xR=k?tudo^ar;-mMia9mN8`ph#iQJ^kxL#=wijsQw9u9
zeUwxBQyk+rPhObozWh{5llCUf6>7(f@-HZ$HH;;Yk6XbWlQi&TbnPfQpuyrkM@5dy
z1?acq9|Etcd{_Ne8eSv|a%`ZuGU8w9zwF?<(}(w;d{rw~ht~Mh+6HMgj<Nir66x(9
zE_J;BA@=!|<qs+bR^{ejXQs^sX73$G$<?W~DmEI6;B9ZGm?shzYuD^;O05Kb(RgKO
z03MqO^RW9)5w>S581X%X-0!o+@)OA5&Qtr!O?C8wd9scPA277aHUHdx+wtM=j?Q!%
z)<=0sH$=M!sOGg&SZC>m*$m(oXZC8;{A|nAxI&~7ue6+WDdj#IdR6;fuFm|xz1TX~
z);n-}4bNaUzg~);b)+u#a}6^}tGUYR3s7Gm{YWtjJ?HQfdV$@%166drRpH~tf&17t
zmu14l#gD%8hE>H2goG>TN8j<uoEz%-pH~HD`z2x~Bh<|bzaO;VygK^VRQ^Qy`&Dgv
zDkDyJ5D@^~M)fy$AGy>$=P=1%po2$^kMtV<%&ej@D|)HU<l$kH+b<{avnt58uYf}o
z+(Ba@fqF!uvvKtMPVVqmhc3urvl_Jd8ZPwWmw~xWW*pA=wog~<ZN0GK*!wD;rlWIh
zOXUINJUiCUGICMBr=pakL9V(Sl=f!bK8{-an`t|2+ohe6N2*yGYHHRVdDy%1PJTF=
zg*1?lahTSBupk~uZ8>olmxZUl06ae@`fSHUVL@qL;nJMgBkYII@%8$%_fp=k86&c;
zRsTST-+~l&VCe&NZbB6NSlHuD-<Wc%!MmX`(>W>DOwH_nDrMIW&WznKYu9_OWx|sE
zIKwxq*nV-}KaO<qvFyk~{br+mM}vL7XULj)!Fmvts382Hk^Vc?eEC--ZwYWMvk6mv
z|I-py{1yz+_N7xB0S%fsSG%k{WY}3QIz%5lgRxS+9+r<0-ZHWQHWZ*KwO7<Cbag(B
z>D*gYdVH!X)NV2q6XFrN*c3IC0b89%ufzx5bLVM(L1VcPt+b*XIzAP9;f%)No$(jT
zp+yS~HuGpne4uTB>_|X`T|Y1+z4+Et)j@~j!9oP%aph^@ALbFH$#0Ulk`@Q4PxhSs
z9mtJ#wzQ>A?8{Ivo)2tL<r=MHc04grwQ%nwp?dr3Fs1nOit|d#0&Zi_47|PEdWiqh
zoBpu!{7)@(nfGlSi@!1?ttX)V`0~*$csow%e_XKt<i}k2w2R|<FFO!^o1NeJMIrV9
zUX^1ih?(Qk89~SJyQ1#>MhIkgNDL<1Y~KTSy>7bDBAiA}wMzGuJ3X`uwUYJJmDMv>
zjN>E5MrV+!Xl9VMt<U$tO$F_?gn`5ta|rp8&GW@)z|S}IEUcRJMimw^41Vj>PoK#U
z@w_tJ(beb)wxQ?O(e;2>H*u-7!>4NxvM{P-d-LfXh01ZgD}#l%&X&LugFj)qd0$Xz
z_20SMIgrny_mj&k*!=}6^@jQ-ad(-3?@wyjZLh<m$`{-$oFW<!f|EOEl|q%~R?2}(
z2g7HxV=87hTj`R<2v=O+1l)><Ns75=e~*-gzRbYoyHe-FrG_2@o(EqM4y69(bGwGM
zjamN=X|g(x@yS~2#0wkzUEi<M(wf~_vl^dkxPF9;JZXJiQ|392vFTsshVcrTwTs?O
z>)h@n?38pGO@3Qn)gtP&!eAmC8gyn<t?p96-u3*ZBDDcUn;K_zuGbqY&`wHU*YWm>
zfwwOCYK(yeeVxA2Kuh5_X92Y}8u8KO`#T2bT1q_U_Vm3fuyT2Ms?3%us)6ZF&HB<0
z%C5q-=$r8P+RyQadcKa;=t#YRgu4|`tvAP_92)Fbz$b`vmHK<E7IHz#h4;5<eRPmj
zpMu6-J&@kDa{6#am`+6Wck!G7z1ByJ5423K=*uuk22}c!2AHYP9r%{zeax^_>oahd
zxAHbdbf2cC1=~s)RzG6Yu6Srw!L|PLqUX2Q_n%Z+{NoiS)0a^5fK~>%5mrql8EA+&
zcXpnecy?n(^Lx#xgcQ?S`Lxl3i%h+5SjTB)Z)^bHVSE<rO=38~l8Y!@E9G*(VpYoF
zk43d=Z;kOmzB*8Nr8O<Z#jz&K<29G_g=bqZ!-97O-^j1tm9$iRh6EuuEq^arEzG8p
z(f1mg{hFhSu-Ce31!VbMj^NQ%UQ%B~Dsjr@JBK%%%PqScN<1eXnFJmp-Wg@}wYVPs
zDZ=mVWYqs7xSTZt7|!`frfF&2Kh$H)=1Ly{q`;o|?dt&Pyg2I~U*v->`WYiCeSylo
zvAa1n=W!Yucr3Cwx3q4SOQx`3Jp*?5`NbprB^BJaEuSktSR3IQgC@s%L;iD`n+((z
zT`(k!8S;Cx+?|OC!~TN|J))+PsW-3`DJk#Xwhfej!}#=Wmr3Glk8k3(d)~7MlIVd?
zbThL~5+i`#g*%nI%c`(aw!k9u-{Wq2>F^ZnN_1WD7F2uQ#%Sd$L2M#p5U829E_Xoe
zp97lO>%ZxK-eGhI+n;zgyny~g-zN9_b=`R!FV(l3sjx|^BH{xtacjYKS})q_4&kkl
zR2V>A(6zi?^KmWP%Y30uv7$(^IpRz3dv8QY`zT<r_cLvdCM>p$=DBHpO#P=_S97b$
zdMv#GV~2*>47O))c(SG>ke8~^@ek9kq4lux=;%X>6`X+oKlEYoOK+XF9S>mRFO?FW
zt`0L#m>&ExNl>`Rd3g5XJO3qpw5T;Tw0zDu0PK9nugqZE4;3>}jzcLMe0hdNQ{9hH
zf?o&Rzoj2x6+^g}re3WNP<GGYii;DTUz>XMi0<n=#%)RDpArJ!*D9w0x=CZkZO!ah
zfr}9pai1J48+L<>E(!|E#)sU=I6|1Rvy@Ler@>~+{-`CdsEHLMp#hL`-F=VBOpeji
z$EP@Jvw`m(m)2F8W?sw5+v_BY<A3yC`STiBjYQVk36%og%|Aqya$_<W@a!vW8%#x3
zt6SNdqpXz+@5iFcbRJmRJ3S|LDc%wykU4TbwS66Z<-%XRb70Rv$Wf%-uMJIsUOo3T
zljiuJntrs)%Vy=DK7?EMTUkCV>6V3ufxh9<!6|pc_$~55gKq{iN{I^%j`;%-Ow!9h
z3`V7(<rk!YHHa|$*`AAsyC8n;h3f!kaqkn^GF=nT>C!PK<9Yw=i1QBFA_S&zW0$o3
zH%7@fuR?80{k*6(MKV_MyLc>&9Azr9?F?2vJt2#V-~3S$m+qe`OP=!8Wb^f|XA)OY
z)?n^tTRawibLZJ_<A@78a)n@I>T^FP;4J^ouje0Vwx%zOUTr@~nP4$olz#m7+xxkK
zTS{nitLpfwhM@KsFrwTk3?3P!otIg4T@!Zl&5)S(A)Lc={&I4|(7s#gh3gf+i#6Ws
z{))l=(}#+jZ+C*EY7}|x7Rda@yU0SEOu%?W+l6#?tGiR{n&CiW@ivOkF?wbz1aL^K
zzyFKju24tLyX}0-1~31(u=ga=)9URQtkH9>GaE6E>E{ApaFcE4ekeKBl*xvsE!CIG
zd{y%5wzvUzc*L=Xk}dS=`LpB2K+{nyc?}j^GWz*)MaEHZh<!Eq$IqVZVRt$FanmIJ
zcHn|K`+z`OQH>Q^n+h&Ny-EGpcMW*8X0c5jGDq}JV_2R;?b-4zr^u#{os}6)eHO{~
zr?NWoDZL2vi0up0+ms22v;Lf%kuFTCjVZ}MJn&3k&=#Vy`D4#>myU2_xZpU()WTWt
zP#7JVpO(Id1av+Mtmx2h>>(fUNe{II%YC##>3>}9x|Y&^JBxR)VWQbMz8)~fj?&>p
zAqkwgJCGv|+;TBL-V5Tx>06B2X2S(R?WMs&XyhRsP2^o{2z|X3mWv*L24YDY`T_L>
zddPt9=oY}6L$swpLxhG6)(l~L9()aDq92n3naSecIdH?!nTUi?IoDPjtT4Q}4%PO<
zw454}B?C%Wt?-{;*#TzPr!$+XKy6)YB3#27tBaVj#Ae0%&vN1(Lh9)8T9B;s-~f^>
z6y9uwErquJEjP3h6-}oie&V`tz(g!TO(KZZC>sRvDGJGf>wrey!5-1!y&<y_pba8C
z5mnCSdlmZwYA*_kLgYAcAEDkXxB+;04r-Y`v=#*naN?|>TDsVL`p_a&K5gh{lo(yT
zDYn4!5>5qzlmG{zTDDkWgvM2D2VCPW_6eMy9XA7&W$|@@(7-piaCM`qIBy6b3nn0l
zIVc68x9C|e+$1zo7h6t`cZT?IQ0C#oj;n%tb5X?b=D@K*DN-^s;B_FgVqg=12+v1R
z1{pzHZ)52o$_$|?s5E%<J!~?4y$)8J4HpH?lmf@0S~gf0I*RgHl9YaA3V}V)%nRVn
zzl}&oC9vaMAxK$@@Pg;T`%pniP>0fjP#*{vZGAZk_P0%w?;a2t@Bt7&8e~RHNq|QP
zVl8Tx1y>9}BdxGD2#UCTi2uJ@{ufemKn2A>ih|bIXa)*4`m~|%QPK3FuP6Y`*Z^1r
zbV~|Ep-9lvLu-Xo1hE07&55I|s$|CzppiCMA6g1uZPH*VbVeGCheldpH=&W%6ci$_
zViV}`_aWNiAORj;huUVxQTVt);X~y-_z)t;=9`G(V!)e1lxguU(AGQHfWL&gFyN*C
zB4viqFvps~H2^CLceWBBJtTn*M-fm4>_BLkQdrfvMPX6H0ILJpmI0v@YxrKlMnZtF
zcy2QE)E0|m!0SRn=<yMdHW^SEPAoz>aN;Z|#=%|x>xN*6whU+i(LN9ABZw6!Bs(qw
zO0fXt4Hl5u3*b6DoyE5bl}uL;+`z^n!V6J+aN;G1gE-g#&6EMF5aCIv0Tvvk(~_VB
zG*cS90WD+qjY4(P;SK&;bq*>h0iJ~lih?;%!3$tE>WI@9jUv#ioO5hLwHZC%kpl-1
z#7dMlyKg?~|Kf2azzs}BG@E175X~mo0s4A7tT6*nZ;myl#hXC1r9m1*T(ALbRt8i@
zgcqZHSSj|uO-r$SFMR3(*adC9i)DnKrl925akh{FPWcI4#{Wi{*JmwYGzdxpFu*Ae
zhd{{4!x^|%5g_EjSN>GM3W{N!!ocVyxmmaaZNIoX-V<s%^D6Mo?V+Jn??&|t_piWc
zKl8D$E6343XLA3?_NQNrIDI{ffJq>GUf%7%pE?dfKTVFa%nqg|^V7C&-<u&5B4?A+
z9Hy65^Vcjgti7ij&EK`sVaT5~C|gbu!`j=<5~bSPSct%-c5P0gZu=}-coyhGf7%E(
zA!a4;3>a-GyctGY7N3WqJhlUd@nI#}w{LS2gWE^xTW{hxFmh+ZbHF`#mQ-jVsD~L~
zZ@%N34Bl=Rz!<X;t=q+DBjdq5I8qjWr=5mAG73zlpE1VGV2;?EqrqwTwh-P5BgQae
zf&+pvb)3ynpb^}dg_!Jo{xlDqWjKuo9q3M@z%07cN)SnZnn@uXFvE=^W@YfV+Z|Yl
zR_$4=M89?<2l0G6k|jJ5Jfe@R1M3)CEpX<Ta+dHIkO7e;hPQ1uM98s*e*&X0P4E!<
zEtc?9aFkw42j>Atir{_Qqv^GPJ2)wL+g)5F=7_U7AJl|zi-vNw53p)j;a+0u*qUoR
zqeEg2<@Wzdcefg7Z{s5JwYRYn8QQhkh)(U=>_pA>Bf8U1U^zpp4K4%Ic5bubQfC(H
zNjCzxi;IT0+1WPTSlQ+vdh^)hYB1%j;ZdL=+(8_#(Y{P?FBuBF1}`Dx*r!D5&3vQ5
zVR)Mbjt=7>j2CZ@X3)BeLt`Ay<3D1K*qZA=O~m&3Q04X}+Q=lZ2NS~HoB@_1e9nim
zwX?y=&M~fJ3?PSB#sDICE({=w@5TV)_%O^i8_}rUfh)X@LN%a+b3p(%asN>pa0O=s
zU}mN8)0kOVymh-JUF%hx2u6-QJQEB+P*&O-;8HML^joY`67{+`H;jW69^PJlHvBCm
zBao8#EA8bhMALQx-HZ(`6LZAUoCey#wGDCqw5!w4+{XRJ)Uh<jfPaNk`9GQa&&UD)
zJ?7GteQf?ms{=4(|HS`q(*2Jp2mHTCC;nec_uo_Qzi=z?-?Qug;nt{J62oZ=I7@r_
z4s@VBO#zV%r#av@U8^xp83EYgrZL;>L_~WQ2T`IO$wf42N3s$j?aFkK<zNUyWE1Ft
za1a6T^zF&Ct#@#bFasRTcX2}PF7)=|^@hIrAX9rjU1TZ925-BLGr=%(g%^O7{}5fp
z86vjDLVeo9=x20s-k6ZHMCtZK#I|^-db<t7%vGEyMvV5fH~v2*Nk7@ab7uffzDK#K
z2QbD(VA>?`>zHlM@O)4XprvdZM>Ixr0=77P1m$i38u;u5d<%w>G@F=mj_`M&6x=}w
zf3<y?PRkN!+8ztfk_gQKW!p0_>hLU4d<}+@TfFW1bXvB!91Jr%k-nW`oGh>fu`LnG
z+}=btqlc@48*?`2ftzq2nNWuIG}_E_csYh^1g^g^4E#q9|7TD9k2Lnb?rYMM>Dd>;
z-?t?`GC3RqGdSny;pB*3?Sg$15%RS$ds4Y0ar=Jn;f~L1t>#f8T%VWBZ>UC|b$xd1
zRl~iraMU2aMq2HSyy<Xgv}we?eTNv!L*C{i_ZjX@#N>oNIq9|&$}1V3iOrh`o1mK{
zYzYr;L~O;g)f_$3&mC7^{Ch+!I2093XgP@v1DLd(BbkmSCzOaH`OXB75UswXwj2QP
z{qs44n5O^sOX}!?wcvd@tDA>w1s++UzdCL3^3qvPSO<6PPag{;jZU5p8sy)&OJHsd
zZaySebaxVd>JDx=>`nB121JH<PVQVLn7y1lJ$-&uTspWhd*Dvma5!WoFU@@uS(R82
z1y%qvBV_Bwos$=sw}GeVTBL{141Mu5KOuItcV=-cKVXBw{^mfsmJu<aFh(xo#`QM>
zVyAoWCh+tQ`TNe>zwDi@_^zps{;pNni6T?h-E0s>vvS9e`ZE`5wllT$s(c11M?Sai
z5@c1p2`@Fcf3zNjbl1wchim(Xe-elQNH5&<)5ISVH!5EynSu4B%K6#_V;{k!XR?T4
zqUGBQzsjx=b%ThyjSnl2`P)uk*zQdnik|NGi4Tr;pV~hsSJC87wz-VPjFZ3iik?O>
zU#lZG+KD}EquB|Gy-zMLPk&GHVj=g-3~oA*Z)y<M!v(!#4mJ8B7oTQD+vI8j%r>q5
zxdYoRNBWh@5$#(~C!!t7qJJoC%Cu^~Xi=Mqk?XEhJ=}XDwK_TBv48aXa5T74d!l1O
zTYdea>e}AIo9P<uR@eE`3I5GFzuEqKqNC2+Ezj#51K7iY{A}&=fB1c$tR<U%$jcos
zA3k3Bc%nhIzR|Wl&R$B+BoFNz0<%s^dh2b3=D_BGWMRI%v3v#)8*AcOGTf@KbiLBJ
zyKc8jT<PoPY(b_)i{qNx?$?!!w6gAd88*$Q@j$@~wYr(-WL(6cdficQ=jznjeRA5#
zLL9+kbeii|q@BE;`h(>hS%QnuDP(YSbSES(F}jh^#Ms!z5EOJ$w<Tc>>~(BU+5J+Q
zMcX*HZwa52*%koS;(1;t46l!j-tG^58R{Kbjo-HZ5|hgOthMj+z=Z+H4{9cs(<5a(
z20@>1DE5AECqKTKam;8;&I>a-(R!^#4!;=^MO?3*EiZDJ2$})xZzgQ6_A8(Nn3(%z
z`%CFtR*}yY->(UbJB?TYUO*7hO!c(Ig1B3#__=5%$g+HYt5AM1Icj(P<)8X7{Ie7A
zI5BOei$h`0a$UW)dhOlJ-cjek?7%?A6fwS`yB}GTV3`2kI1u_=e^pE@@sSB}H=>Uy
zpm~b#KKbVVXC(0I<3A(jV%LnXddE}_7lbv}X$41^YliKv7jK^64}f=sjT_$NknaB3
zIhWg!r?Rc;k*7Cb%KT`YB->T)jjq-2g#?DBv)^21JT;N>J|r$|O?im?o;l%4VYPOy
zzIJssy5g&P$n}W?X6lsZ<t%6QV=sMbIhy4enDNQdvJdO-tUEf)U$0P}*juh35syC|
zI)wNV9+_)nz7V(~CXav*_#XmDuj&_gqp9D^vaQ?=Uq&_W%1fz2B;~(ji#70bXi=f^
zNXd=yPi<#R26k|Sht0=Mn_Wqyw^y&Vebk@W%D>9<{Nk6Qz2oMi!}kNr6CZpD3FYA$
zb=}fgc9ZL7T05IQeBGy*O|kaV=+Ulf^0Jum)TzSygGpdCQLG&}E%%9a1J-U-ke4PO
zOgfM{Z&b8d-Xa{}`$^ZPH0}_Cr+7vN&87--`cF%3j+d;5Yp#-O<ux5J4>ihY<{qdJ
z*B0)_{BupBfcv;dMN)fM)hO|2@k20vl_gOjRsCi1z3IIyj|Qz<egf0R4m^S(amPPh
zx1CPJ`d6bi1O><dzX0&|^rWL(sHiz}uQca)yZ%rvV&mE-+11FF5H{ir*eyh-jXupx
z>^RmR{*hKBs2zT?td<}AKnnnxM0ZsSos^Y#KWig<!|&n=pp3%iuOmzM@HD6L=o!{Y
zdx4#%$u&jt-DJ}86e|$EGHHP%EX2`Rj%sTEl#JxnKLD6_zDhY+Op;cMbF~5$eZuz(
zc#74!ne{EAw#2NM8=nZe2(j0hWE^UKmi!daX#HzY>G$$!-KGFrw|xdy^WDzF&b1v4
z>4akqeoTQ=$o4^~U{ZIaVC0EG^+|EZjFi(vacmy(b-mK4+qS-PcUIO7&50$aM(q}5
zeH*gt9u9~p1JWY{st*#x1l0x)5|%BmSB3o66?6AF{qB008S&+?Hr{=E*v5EdM$GbB
zm2%j6%y!*9a(2p4MupJCn;#*7+RVY}{pUx?i-Sp?TPMRk6Xm`jB(Z;Dac~3qXzEbz
zYP03F8gdhjaT3WzI3uDrciiC++?gQna<XktIRk?m+xEtU^|kVTD^9PL)drfEAuVp(
zL$2#anST#gpM4zMSO+MJZ1{h*4%G3NM<8Wl9?lNQbbHMHFw7kfvEnDJS#P&RR=Meu
zlCC+hhOM8n*=%d`?QGldN8IQG$T6Fiq27rxZLWTS1UVHQLcZ|nONEWus^iWLa!?)+
zL*7Ztoz#xliy3bd+%c|~Xe70HtGy<1dilIK)R?MVrQ~#Mt|oK&WFRG``}8UgZK?|s
zC;{!o`NLjdn~l%dv8}6{@7AK175C=cPIP>C)9eGf`5*TvuLi|G^#qMi^6dz=D*TR&
zC2Xtn5M+X9J%%LO{=P2WQkMV-GP11-)?`x8vxUtzZEKcNvVF^3XqKF^-1C~*`R}eu
zzcrEUKePm9M~?)%BV%PbK4rQu>u*naCvdJRY*>cQ39^yrk16?UxUE@9;$-Ta)odg+
zIv$$ylOto{ooycW8zfH3{#zBZLIL*EdlCo^vCp$Y8ZE%Pu302*56~0~A>p3YuZsMZ
z)$UoXk%_H~EUS7SZcG~e=~PahW(gtLirsB!?N{7a+Y9)`7*yg?uHCR$cXXn%J|2=q
zJlN=4U%xk?ReO2en;fuE;*#~27_}|ec;7qXNZBrA6zD$vBpk3-)wa5>zTVVUShnw7
zX8Cv&>Gas-kkB7f2b|83`xoqhSweUH`ZjXLFP(sRLFOKq`4z%n-m*+duc4E1K9^IU
zU?O3!X3}`~G=IEud!WS0u-Ja@2>I^oBy&#Fj@<9A88(w;B8l;%-;vY`oHG_KbX_87
zAUeyAH{et&VmhYWMVrFLY3pHaVnwEA%Y{#*0B?0aLIS|vT}$puyiY!vuU|iF<5TLP
zsntrd?5cH`1%*2n5{9(a-;+~0fR+VtqH!U?Mr(B7g;m?4hjDY{K#UjQ<sLq{KEqs@
zR}e`!FK898d#D>HTjZqOnH?JQ>-ZF3?$}I%x6SzH66m~{zD^ta9?6K+Bj@Mq4--`G
z6OO3ofeCWg8ru}JpYFNC$mj9J34nIzF<OOiKC<nk{z!M@pnI0t&-K^NX0-U>XeDyK
z*1TI&`$E>X7pd}ydEYK*gFus+#p6Q8&h{oeBBMec5=pSdMX_2S+lxOe2+D<Y-c#73
z+3(tzoozktJYtU9>DrooqKxc5MLV?kWsL$7J6>f3a$ECGR=&AZ!slayx`6>YQd~ze
zrcF3>`7KNGoc7t~c-p<hpJYjVgWXjPW85L8?riu|umg^~fOmcEjcm_iTh)rV9Y}hD
zX_LkWDa_w^yD0p{R&<|)*cQfLYoFE5_g3eM!6$#ZHro5xO%h)xlnKLZpC!_@D+9EV
z!EuN38yhRf@8;AQPH|Sb>4-M-&MF;W%B^gk_B<yedkO)^5z{|kCyySc^Bu!x^hu6%
z?`$RpC+^^d6-{yzPp506?0j0a2asx6SB@m7KRA3U=T^)PUfyimwR?Y2W~i}XE~19;
zQX>4j!q+Sd!nnWzleYi(&z{v@(SLvsa(Uqz)kmYk3`?I1RDam>r20EQsQSFmVH6qO
z`%=o<-RLlin4pzAk!;=MV>f-cI&;UN()0e_wU71|bi&CpcRPoYOEpWhgS92|4vl^8
z+`6UY>1>+O`k?Ed-D1)Y*oCrtm3ltk@d^>+Ir-LSN#*gYQk-i(12*=TWskoe0`5a=
z84d}=DxTN+hdi)Cn+Sy>lh>b04Cd}K^rYrbip$n<AWB@F`$DB(@DSp867&?D*0kOa
zw#Z%*k8t`*uatL~yylP~%`*|yK2_$v^{ZDj@FU*vUYl>MQl8`so^qZ`MY-=Q54_&{
zZBGWJo~?QzI;sTNSq}c05N5VEuLj=7OEx+11+BQ|Jxdxp@r`A&<}3{(+*{9A7dt-j
z$T_j<rmw4<TNYQU_ll@z)Ro~=<F8^YO#kCs+dgF@Ra=o8TveO%=*yteKjSC9d|N~*
zPjRwGAm7!x{N-{#?*Z3jX+G;$t#PKegh@Xk7nsg{I1j>89|-E%>khjsE1Ll?QhB-}
zx0>Yt?1$uuvK^dm+Y|7qPOAe$9$bQE`09x$&6gwU8X<xLO-NllhjVlMLgF4}<;9Oo
zj!9Kw-SoOZ<c`8K?Y=q7QEiPQjhgX;Gi{!(YnarhQReL*5d9+#5=ZO2!@qpG#Vb~h
zmn}}cNWF%$De7xT`w)Ebx&V-w8IYjQ$S)N+9rRBYaAxt{^WBpukLdE#t!5|ja>$6=
z$ky}6dLy_D%3m5M(W41ZH%_80yE$7A+R{V{CKzWPM+2E11WFlqbv8eFcbfvl59J3T
z>a_%)J1re%fYLtqMh;WZpBJKaad*~MXHHftiVvf8^j9h~u1>GG4FfOVpYFePJFD=?
z>a4UtS8=PvaO*c;0agEMmz$eZL&*!)lO497g|vxp?t0z%axt}(XS_x|CFP>O-a0GI
zfGN{~Oxl$eQbEbY<|EP8yKb?qTW_ZKs4tro6>X++CAF|b5bHq4kfOPlMg`BRlGblG
z6JqrV%tq(PYh$N+8xF@nns6nN;74?`n=9AfBKz>aUL@%WTX(<R1zH&s`CdNDn{!p+
z{eS+zYj4+kG8&y9RNzqIbro1Hy|jDIk%!nT{3RpUqkba+H%s3Dt=IfQj-ULpsPo)M
z?I&Y;+iy?}WCAU+gZdIGmN#k1S;Bt+#&5GXv-wV~UWr|QdZg<k5OQtI0lhDUE*9QU
zjl*r89mqdB3JAWQ5qvv3iv5anc(J}j6@l%+-gOj{iUc8@0iyG(h+DA+M+#5d#J`*t
zecO#9IzMeCT@ZGl;-|Vra~r+{eS$s4`a2?U_rXipQPeg}n?{hjHZ_h2Yk~oCFecbb
z#6yTCb{%bqUPtkvCsFDsA1ZCCQz}nD=KI-D5ns6PMR~4!P+R(D82%iN4rFpv#Ib=P
zR}>M8R2yeBn8&!@Q}ffMpOL0IL65>Lq1#m65O10-NGoFrB$CndnC3}7qzOu(8b%4D
z%}|2i0rn#{2>S!ujWP%REy#oNjU1n`o+e~~`VhhdyA8LeNoTZWDxuOk6V7yxk;os)
zJ@zoQo!!v^ln2?tAS^5R0JOuFVkIe+n1ROFq+!2Vm>Jp)8-umYMurOeD*6ihs{3-`
zsBq_SE{?sos<lA`wihLg8b*&o3{kyk4y+ee09yy3YOqRH1=`>>kl#_&7lso7BOMKC
zCLr=0DuVB6q#-l3wlq^`!g=c%@Jy6TF=H*p3%EeNf6rxx_I9N6RmCxZ9atBX4}_VD
z846I>_UJ^S3$apYVRRz;5%wJJI_M5kgS}W|v{3+KCJjGhI(;*f3ST|zJxDlk27eJ3
z0qSJ?&udXren&;ok$#`57v+IULmN|`h^9>y$#|>p(imh+Ae6`VvOEJfToyV5nW8U&
zwj%x&MiRLRA7cm=k%y@WtU&r9vNSW0a2EWT3SK-Nj>d5h`hj5s!4KzWmZs{bE~7l-
z1_^70htu3+Ao7fT1)M7`Rj60U`Lg(4@D-A0SfTExmZdI(P)1Q}!KPqS%tUs)jQoz;
z7>x#7C<N#4NG;E&!cb3JPkoP41VtAbiY@_Q-4#XHCS;7~?-0-x49sQ@)$|p?$$}OX
z=9E#2*lm>2v;o(cfC|-nrgSJ}{xtQh^^kgi5zmSf0F$vD*rg}~u7BT73$i;xD&Y0B
zp;Eq=eARKzpgKjnSqPgZ^(1Tnafo1o{v|eoLaY>e9sLd~3EEHwM5BMSeAC83!A0zA
z?CKTfiZk`R^*neug@Ooh6zhP#q4kGr45<RAG?pP9VGIA;SRfpVzv!z?nE^BQ(<R1W
zXfTaEH9sVsJ`h$;Ls1ezQS!1cm#=mOC!VdM0l5krfF05>L0-~4gpnw=Qp7S+K>CXz
z70v@3z*<0_xIn`o!>9#x1J(+w_b=ySC^^^>>@VbL)Ppl<J2VNc`|p5r6~LK$OjA@-
zOyN9u&cCO~mb`k3mcZKo#fQSGw<C|Qs;_{r6pja^!RlhO&_7&wHmEeX#%L(>K&-%I
z5oI*quq`SI3y`rQ?qiCVmmq)ru85_lXissfyi<DnlUD$=R$775p0l`%AT9XM|E(_|
zj8mYX8A7oEvIMulm}&8Xz)KP741Vw02j&KNJ$oq4zgOqO!m#C~cvR`bg-ED9yqRBx
z_b+bt%(iqTR2I+>s$#SvrNB<@`ABFcV>6Wsl?v~BhJDyF?0<VL8TIS$8PM7=n;!~e
zbfJP3%<_yXtN>*a6lTk)|0YH&gh&<2f|siJW&6MViq1n*JO=WEHz{tXK~JK6sQ$xa
z4T6izw-EMp6f-gHL&|B&;AJ!xP|CMv5N${#jb}J)LbF2ZU#z9&`BrH9Y04npa4qU^
zIts0Zl)$iXc0Hn~+zU`#YKHzBN$;@qjv~G^I2kaX0&C3P8PUIK1hr@CqgsNvP-el0
znnZ_DNG?aWK_~l^-$OSL&8#Y{DjcB#zDm9l6xN?$H?ejUEwi9)2vON9t!NjR92FDQ
zORC#6C#YCd9aI_mulM-ysyH#nJwCrI2+#zRgHZ+`8Y#({4BLi!L$n}MkP>P^itmYZ
zW8pdNOxOTQoLqLK_NABSqKHL3Ln}=Ia|#-MrXEJ22IeS(Q_r@3N`Qs(;%pt|KxgcI
zY$bLT3(ZDST*m#ci}-M=pe#5^X@T5dqxf7L6ATr_X*dE%ie3KmaN2uJ%?$O3dPe*i
zig9E>2*sO7R6N&0BvmHe2Ga(^ElRmBX>QYSQa!<5q%=l=669XkWmFi7fX<>~hWui!
zrg0PlA7Qm946jlG*)yA2g^v;#y#EFUbv;czk}`jF$9dDY!twxu5?!kQe!?(w!~1EH
zV56`)XcqMrv=#O@dG5$u8l$FED)b+-lFp`~ob2zMgnjuc=<hLx|2>%vSdLBV^>cuk
zp|~J4R5TEMSUyz%T8l!?1CSS_b`+ub=kN55QPC($_exL^|6ws85j{?c3b+cgo<Ef9
zU(!9W%qSWPr;{a5HL(n+2(%?sA1Vf|`uB9EVClcc8pdj3kI)WKfJ$^G?vVL^(e;&4
zaWvh!Z$bzJf`kOO;1D#pli=>IA-KCshu|)Q%M1h=1`qBexDQT%0fM``-+8}t);V|G
zweFwp-8Ef%*M4eCO|KGRQtxL~V*eU6KQYqkpKbk<_I&mkA4<bBq)GmRG)b&`{68gR
z2UzLPTmSh(`CsXB80BRUa2B+IWY~oS(CMFLv_R~8f@1C8qF=1Oczpr>;{I=^v!O0w
zAkYyn|I0QgUOc|AZ=e5y_O}T+5+HHrcK%TH4?iX{@nJdtmq#~zL;Gg(90!GT`D>L3
z$G<4kAtO8n2hKKH>a%}c^57TWH@;P%?OMLIff70495q4cS=RFoQoE{`NK~;K@x9Ti
zFisp^q@q}%oPB$X?8=_T_7}SUkYSR&*hks_XILVzy`>k4>9dHdSN&f9SRo;o`Fo4`
zjg^&n*6Zb?@NZ<qvii0cbQU!C>+`RQU%`xU$^JB&hlbqB7Zu1{_r&|li3@n$j^h8a
z5esQ?6pcjNXo27TmAdb{6%rK6Zo@=pZ3)x+e#S-Ps$d**=6aAx-c`p*n00OpD!;P0
z$NWoBwD^^S`8iE|0d3)h=oeHD{PbsvHda*_r&M3o6J1`M{1d>M4>edevlS(ULp3bN
zU_6l9GbWIV-L*S21iUgS;}6Vl7fxD=PCrUQ*>BF}sOLDU^uCW)j%JT$jMk6VjHZvK
zjDA?u3E0-mS4ne87~0YFK}D0x*O>nlXF;2lI@E3tf%nW3RF6tPZAC4rh+$`c%-#@Q
z;$1d|(&!F-d`byeF47=|eBkzj%ssojju^Sl$aKetr~`Q#bCvEtsDYUc1+^2Vx;GYk
zs?jfuW|F0u2^LOZ65kzh)<0${Py5RgOF%hAwa%D$f~7>KkC_fg1htOkVhc40ASKty
z+;LK(TBmZcP>q+657!0sRqX$kawgJjXkbAm=*MB%D&g13y-#HZzo8QTgUzYzYZ?>p
z2yQe77%tF|w;lkR3_~tU!af<`i_PECn0IgguELa&jSJBvKwHt^flQE*g{UyiAuk`o
zk-yVHl3exHHINEqXOlo|uai^zc+ccE-1tScPMAWGn+eDKD{p1>`a0R2+~5}ylfqHt
z?6;B?jm)gIH4SyDzCNhDD4oyse^lxjN&`+{VJbGF_27T&@q)}&CaFX%t_280=}`Fz
z{-bvP&tq7o3X|0S5cGp6-N@HO6(lIEo7~s#5h}#@m7OX6>V@`9kPkP>+*wF4&X_LZ
zvtL3=Zjw2}ktpy$)VEv<`~|zAWqWhMDmHx1{{Hf-#y|ekPM-K+;F!rw)L;-gg-V9`
zuRfkM(f;a~0zCgR@_6HSyn_qjbX?`WPVVjyTv_{<U79n$D6BA>_Ftf@V;olg1v(W8
z0Qss$F9w_Ef9~>eU==w&Hx~brRgE5BOQimw=5Uo=1bqXo%%#hIVj&*>)51qerPUCC
z8R`t$d*g^1I#evv`0%cxnPO$)EuNOINN36vmmyE+0^XZAi1lH&<bhat71N4mr=|;e
zxSgW6TE66?4Hi#Qm53j&vL<3$s&}?6GScbO+qWj#poD-|F8dlvdpdzRjE4FmorOH*
zCQZp|jmf?t20C!(61|5`k0`vjAtwP~r#u)EjZa(ocD5&~vc%_MuuvoVc1}kd?!2cT
zGOvKRlv(k=K=*0{?^xEBnKX-H@a0mh5X^G5NBM@8M&T)M#h=fNN2owUc1KD~u*cJo
zPnl;5u6oJNcT$b1>)1JXAGR6~3bh_ie?mGv2v_L6ExlWN!0)W&;wA~*eE^@Sp1v`3
zpE54p^{W`{5)OeyxPJkki61TrDtQ+f+ZBh*FYIL{{NjHK5lZ+l3fm9sY$2i^8H?g&
z&N6!~rDPkbj<;?fIxbgmMfP#?uHEW*iw(PV*~VS@KIA-`I^$w4N|;IfF1AM`6?pUR
zi4xb5<o+ei#qYsV;dd>dRV;woFbLghAe+++=XAyQb*P=qEGs3MPDNZ3A?^mLJB|x#
zv8A++TQp+S9ooe=c5u1LugbvXF5tbruRUjO@GU*Yw5$u?SwH3d2T<?EZNPWwapZn{
zlo`}}&3`N^aI9O{^2J7NuyX>M6$P$}&IS17eMCmdDwhSOH(m)oP=o`1w(q@Oz7o)2
z`T;YBOujuPxN*zYKNpG}EB$6H#whAoDS7d6V1r`!%I_fqmS*i^UIAg<B71!mb1vwb
z^Y|P4!?z!~Mxyz_Yv1F(sC{Ymir~v-r#K)#8pck6EQnO(GNvnp@*_YiSDPBQo;@1A
zWL}BO0`sKq8!5`JFWfMYAHNrXWahpjEbp`LYdMZqd0gA<<V5KF55G?WbpqQbkA`zN
z2LH&>ebwL8<cZT)`H-T_mlV}GmW)r?73srN0OI&|N~XACSg=x$yM$4^=zh-*597Ow
z^WOZudBwuo`cUgsQL_K^C2gp0xTVEz7r8{NlwmxDqPe%!z>b{<NKoGn)kK)5X<4l>
zUH-7DfpFKjH}@cq4#?|OB@aD(m%IR&`I3bxOm6dgFxMyG=WkO`D3)9C8wrIWR9)9(
zN%EyZo@JSz_`&OH>mXPdE-9(y)0dKXm@E@y6kAKS+=r;JOGM$@z4ROS_@lik#T-Y9
zYexL7X~(;$8gzAlY6n^(TGDZ7l3Z^~q{k6iL9D<l8DCj(nn}Wd>ZS{aoH%qs#Pl5E
zD2}Aa(HaD9n}%-(Bd+T~hN|(`FKI(Ndjdvhxw6?|foox`ax(E;7iaZ3#0}UsR=wrz
zo-6RSbojV$m=K~O@Y2JHvMpQeeVYe2jgG?UH{WEpIT$d$=H`W7*^q>t=dXKGM_2Z4
zr8!CAKz1VymqK|Vz?YE>3i9<W&bHuR-g&bF4s>t!57^jQS^G<p#7xt9azQE-nx=q1
zpm)KTR=a+D)nPB=7}a&;m0aYV-NWPvWe_XQGJ3!5<#Vd>-PkE=VQ<BU!HsO|tgN4W
zn8p1#|2sfw+vgw99=*>r!s6T<aK697sI2|;QSz$ZY$sbm@X*hVk!1vp8o5xY@z5an
zUA)XyOKN+A5gV}})?QrQy~Mog>-#B^ACs$Q-oJ$6C>pqniMG!QUtk!9rWG0<ypChW
zdXW<<VHjwoJhsQ4lbj@jV`^1l<S2zri60vdo(lqCMPw+(P%G{FWudMe2+8r5qQ|wr
zhTGzyv4E&anY&`PW}jxy)a&LZ*jF2lPXjo^ubM4)sHQl=dB0r*lY?JTU<=F}knyw=
z%@%pL{!SKlN(_f`l+(<+IlLDc7`FB#N&)#ytnYp-NgH((6sq-SF$+FRG{&eycO<=k
zC$tPG2JE_!k3?kpY{zpzUT18|bZvretQ2;LEO%H0G_ivh*`N&GN{N#uf=RuQ!=M{l
z<=mfRjnokMUW3f_CO@8w`_s~}$>fVtX|$9Og$r6g6nD0n{7CTBWovWnC9MO@F&edd
zaSGdS0#wN$GEUtm<$CY;Dm3z(a?4XNAQ)%^8xqd`kqlqn==T&ti?6w75U}L8`4pgu
zKGb2a@gt*Q*}m%eO)ir|jcC=(7bs=!lU<|nmDtx`?bs{U&4MgsBN>^u{ojGH_am&C
zH^6%(5t1h{@s|_l)p}M$@!sFK=j`t*Lxp?ZE9qq3GV;o5q|l3Q+f0lXa1qY3_gny<
zGH19po)^sNgG3WH?Ue*SWwLRfuznUyun`~s6YXt7F>dI^b+1Dm(9g|oJ?KL+!Tw3~
z8+WAr>eYLr_al#)$DcAcxi6^$GFQ1TpV@d$YzJ|J9QOOe$&ux}ml8#D4rY{{lijrg
zXbJSWN{t!1CeJ6_YvmeVoTPM)j#mN9C^sZ1e&1@jzf?e8_`RVV(aqWm;?8rxJ()<Z
zX>xqFiZ)?i6-mgcbU^C&jr+ILYLKGaSTE&<+}nX(>{`-HPu|O6iTg=4N)1!W-9&Ag
zm=4knl!6Qg5OxJr&%q2W!7^2;dFT!0A*FsdhbOg&KAa;R3wU2{Lv%N$Y~up_em|Hs
z<EZ%ft+v+8nREZy#Phf&?2FIQe4Dqg8Xs}2*+1#aaI83+OlEf^x-5^&C;p_AEfti0
zIUyem<J)WR@u(I2(z*8dBf~#mrlshWmj-)drL{}%I@&?%jOy@3qmy-c_xf8|J0g0r
z`8VZZ8Qx<QHYtN4XcM+kkvInlz>Lta2f>ervB8i?$_ph0B6`s&W>(_#<6;y2FwPs9
zfN|f1&r_u3?ZlD~W4Gxrv?;XmDq@k{;F+Enu{d|8?C$)MPGK49_)Vv*bD?J%SH$-S
z3{~!gSxuFBmk8>utGwnol0Rm2;1>d@e-^6=i4LsKc8Oa9OJ|9r1P&m0KrJXxn6NqL
z<s<5o+?et$-3mF~gY0+DiAod!<348)*r?0JU*_hG2C(-H^zm?xLc0=X$@)U(pzWOP
zI^g?{pGL#pbI?!MX_6ru{AIy?kukzfqbJh6X5@PABW$OY#Waf~D*z+4y>^VdSC5?6
zKSrQSiRbYbUyFu*Dib`40;`EO1}=1xa*(z7lt<6zqNw}X9y!Qz&K2fUSGU>Rm!1rw
z9&F`4K|z=HLA;^cN1@NG&=)1!OB+pvPuZV^#78xEy{yLXuIISXBr4Dri=PDIFByzw
zZ=<bIUNr%rEXm0xuk%8`CgeCUVTk^UtqHL_A;hQT&C;X^6Pv&W68rj<@*k)qtgU3J
zn!v$~52dhn>+#A|1ZLNOvMVZ0^8ABeCTZ>n&E&x1=gF$rUdD?pJ8SlLN*AnDvq91~
zZUb#9qaxr-+C+t%Pd1Z7$W@n=kC;t(z85C)j+jkG>q`t?>4plvFmgpl+Ky;YOFTl`
z6`<z}@hnCtk!k|-liq>4k?NTJi*k<4O#$no3|GPq+HzTyQ}~$u5Jbm7n={Qplb-Ae
z$lz!4U?6c}M>g+N*=B%Ttrv*5hNUBG&{br^3T5Dm>0%co-_~RVBlJpYt4xS(N%sB1
zHv$~y`K2JV_1(d3@wad<YbUBEt0k@7fd}~!zxWASJ|O4vH$wVQ)U_kY@6f3>Z69Uu
zEWFk$1K~eUy_QeTxo4Mr8)djdSWA!K|BS_uCdUThy&G1RS2Y-@D~#nJ?^j~*lJ0xq
zLE2QlJ`YaK1)IuX_O<lK77$bMHL<RHCfY3td=8MUxFVh+m|INBjq2A*Sdgs9M2NcD
zDt)&V2iQ^!#at;|pSj|%^Cp(kH^gVVIec%9Lwt5!PQXND=F0c;G_iiJqiqO5$h(%$
z(iLB>PxNEa>3nv4+hpr{cinK}1hwlgOxlxSi_Qia3N+QNm-HXddPN|v*3}PXRTuj$
z60$y3WFz!lwbnh8gd`9BT$#Mo`CW<E=@Xb~fQAG^{HC0B?8G~;;h@pGIK!7suhs|q
zS!s3T4qaS%)<tR3+`Yc<%Cf~GhZ~}<QtKc39jF^($&UJVZ`j+MVwQfwaB^c6^XIcz
z6-akPeeHRsF|T9{H=$$Bo`?jOmdbMB;{jA9u|NKLTTX<nXW2_eiEeY6PG3s+?wVn7
zKqulc;LLh=BfZFcTfSY|M3~1OuP}|B(2n!|lS+QKFKQ0m?~10@Wrf0V^Dp=Z8Xud*
zYY?*ar|WTrdzqOf2Py(R6Dh^6)tQbA{e_koMbw|6i82ZzzOKbd^Y1Sd+6<fGa`WxP
zVjA2jXP9|-7~&7Fp3(AI`5gZ_F=D{k1OjY6#Jby1kzbGrL+}V3G4=?;cf$7UhU8|M
z3P^{WSyxuh>rzac6L04aRs_i_J}9Q;bsb>L?l@1IHlGM09-SB8#q6C6J68HzeU6*W
zw{o%`h7DSCOf!qYQxx1RQjXNpM``bx5RAXP)+<?>_P*$+wKVsyz;n_G*O@^701VpN
zGDJqW!j|ZvdBz#Ni3RxztT|v|VGx+liLctDruFa(l@3Qdd0mdQnBV0-!oJPz82xky
zXVaZrRCTM3R*_F?t4(pYH_JJ?%blJqHuC&WwN8Q+Hp~ytRfkKPbGAyj$57+9ndYEj
zC7y<5-PWXN{tJbomqQ07GCx);0sITsOpfJ5L(rE7l_eI~QaguQyhGk(bY5M-+k?i+
zI-qX%s=lJb=BYO9*Gb;IciC^Z{WjHF;Y||UB#$L^-Z9_T7o=^~KY8^tij%B^f)4fH
z%8B3@gCh2Imh8@Z402k8Yq`h1PHYJ~ZUtmt2$z+=`H<&EGwt(e(;iog4kV0mf95G9
z70Pq?VY{&P&gA)p2di~<?ulXN%+ys4B6~M{L*wlfY&-$1l~b%TVLd=FD${6feIxV5
zwL^OMJmlm<r2T@j&Dn#Q6CZ_nuTH&EYODjECTS9A=Vs0qtqly$$i1BO*ie2engLEb
z$kRE}fOv#PgjYH(%GN3K0~%>Er#G=v#N9&Iir0tlz<#LY;K`qZ{hjvfk>jV~BA$Bs
z{VOj+I~lH23ToMAZiaK+z0aVXmc}_0vE(Ff-k55h15B@W&#`*j@tWBVY(t=0kaZQo
zTS4asu(D~j%RwA^Rylv@$iNo2Hk3ZQLjOj2VAY$MafwrGwXQ-Auq{Zc7Lb%|GdSU(
zws+N;$CQa>PB~4Lg1-^MX3o~~N+qvmks{vlS2YH`T2Nh@t2Z*w;u)<Ub6i_*Y)YOq
zZrk*hS-DH@lZcrKq!tw(qua>x<~)_SYt`GdbFZP9IwMN}jfj9u=kS;oE~M^)_35(n
zll-`~t?2HRPjdPIQ*5c9V#a~j0kjb!VUY<<IOVkD9(=YRJ0$Q<|HNHg)O`YaOoG;2
zjD02BeTJ<<*X(?77~-GS>+UnCC@`x>Kgc|OC5p$SSzG(K`p>@LEGGUevB*)9mCMO%
zvn!H*dj?9#4?~$G5&vX7&O2svDc+A+;{AO}A=y{K2_WS6uj=@O_!cSvO`yrhY`Q|l
z&ZLw@gU|5rsbgExZ;W#V)@UO1z#6zPz47@@+~TGv&))}4%w%n*hIf+^Q#TOzR2QRf
z7H;I_F0|o(;1}x>xV<F5Jt6BM_a~`809+0Vh+Mbg)wZIq)nM5PM1Qa)=`qn@yfs*F
z_;xP3Z6VAFC<=tG(AY6`{=}N8kvV5d43Ks8o3wH!TVRT-U8WAmtE39RnBP!)sNaW_
zd(+%qSwDzWfOfc_zTFO;C5T>WjX{%)KU4Bhs+}TF!0Nm?7=TB=in`N$Bor=(o~lqJ
z6bmvKmO^MiOl=O4^df;eYr)IY*Rq*T=TFq@G+seK;uhYi3*|b)dnm$sU14NPX1Xhc
zY_cx_r}GK@JmVhkbDu{@8JmIixkBC(o^Ol*r~UeE{XC7C(S|0Ww5Y_on_fMH&D|sy
zD^;zjkge28q{o)9ma?GBKu&aytzNaYJzA<&=y-qOO^Miov7KV?$~8s7gSbO|-D}D$
zy(?589z{}cI$3!FIhlM-&nNv{E1$YoD7DS%#0{1c$VLYN6)V$>&KCGbJYIb;ZK#sD
zvXbS?={)VAk|M8^lqh|QR1X{|SL*0Kxn(qdlwlxe-++p2HRKHN-Br>6j}7!WCN4(!
zJ2wD$KM?&^e_|F9a%~N98FEkx7^tNzIsgoy*MG!zK7D^oE3WdFj7w<@?4!S#ce(ko
z_&Rs*yiFQj{VsF%YdeL3aNMW*d7sms$P%MY+5m{<xW{>O?!!$$HV$|w5zT4Y{E2Uv
zSJ}hVgvJE6tiL^{+^^G$euH)WgmP=~a7=Vyb#8D+{NOfrbV&FRXwNX;`E@;hD-Adg
zvf`uEI#=!rL=ar3XFIHCBy725ya~j(F*$Yuo1I&P__GW}j<f4-IK|@AY?vJonm^@`
zix!m?_?KwOTrJ<pnT#vPJegfE2yeF0o|A2e3f7sq8<p)HczwuZSigc4!^5pN-V81K
zjw%4DLcHqaH48UM)!lbQaD~BEDWJWkszXtt9n@VCy-x(6-;Zb?#Zd9Aed|&EpfP#r
z?U)!Zp_1jheM&g#81_K7`iS?Sj%Ac}no-Obm(|A%`RntL5t+5cT!Raz=w8^Ei@3B-
z$?|{t>7HmoTIxsx7HLNCqKl**g)zd*tUc@tNgeFXFQ&Bv27O~Viy}xMKuWysiOf>4
z+R{_!(p8WDr|RNh%@P#R56gW44EOXP$dS{S30U?@HCpnJZ%7t+MWD_s_HM1G-^G4i
z_wCvgt9yVJ*6P86Zcf%1TcX5C+rZN|QoAxcC{<sPYalINe#(OXu$nI1zV^5G(R0v3
zXb0x8e_dTe-6@0H;*gjr;E#G^*Ds8mr`)PcbR+u9X6U5LG->kj?b;2Y6(Z|YV0z8%
z&00}JJ#!aS<9d+NET)E~b~9wP?gSL{@pjzYcl<!|AYmaZet)EX7wti{2PFL{L`7+{
z5GxGsC|B%z-rw*!FwjpD__`QeTLBvGUn8}NpXSqbW41z`&SrECwDn%R2W#y0kDj6>
z#${(EUR6^Z(Pf<&Q-Ue2%eSnqJK$Xt5&LlJyJ)x2k&DlBkdr@l_8KNrk5ZRnZ#*XA
z`n>z?@HbM<2JD3Wr^fWjhqfm5$tfk4qrKS*cz-k%yLw=3zO&o$1<c-t&E{SI^<Zp+
zh9+!%@Ftf($_NqzXpTZRJ(!lxe($NbLNjLz&zEe)!9pt@OpgGqaoX36#0TPwr;^{6
zqW*rz?Na@H9aLUE)BSF*1kUNj>v!gKMq1&eA@)PdujW$EXJdrp5^(zL=)o41#82Vq
zb77a2Sxwo|#(b^>>vvRqfhcEUA=%+}uWp!+ZbIz+P)$jJ&iyv&%LATSqmJ2v8vn|l
zYrNv3yazm<`-^rJr0Nb8qz19)r6V3-TQ?)7$D6C7U81$$pwL8kC(#k}fKk(;`L<_1
z1V{7Lz}B(h3A%`<sgeHI<h}7rP>b82*W{@SMiXMii+W~(yC5!6&Q>~+`0GXjc%gXz
z5Y@t(s|ybBI=Asp{Hzejx-IjDR$TOSIoA4#u$tU)A&#Zl)1C$in$68$5B<fZS54(7
zg5^v3A(xeRZ8@8nSLip_nF#?5ZT9n9!)Z!)`!aU>zRUPjl*?^jD}*cvH?3?Aa^edX
z8=bsJA7sV=)PPQk{G-UbH814WNM$AzcgL;$O_4x}UMI02JemnkhGhb`>l6$Sru0!t
zkDtPcc^V1vZ<X#BT@LtiI(sca)4;H97RU1#F*{mz<v)j}fA&;c;UV1#+k6P#U!z<^
z_j{CX=QDV?&4~0hbe%e*T5a|u&nk`kO;BRy$Tj`bNn`q_N=s&7ZR&{6z>n;Gx+}WV
zB`zRnUQ=9F**dd0^HOfudbawf?Oa3CVa<(x#qw7SFXkpo-@2^JP+TCv5My2JEuef|
zbKiR0uv-7-vVI$(>2bKA?Qsdwp8V})O91WDxfh>3tt>LEU&?KFWHFkphuJFl*eUo-
z+UaUPDz(B`b&IT0@Zq5I(cfaNoOW%$UjR|eiS(m1l|u6MRT6H~RB4E7%Mz5rxjYqh
z#t}0qWg)Hp0ah)}X)Vqkh~f!@#{EEm;4b)6cwPYdD_46W8v~XYMV(nIjp=F}k>LCt
zeLn5-yL!#?KHkDBCw&v#3(#215mZCM#lv3wVAp2)qiKt6=9@PvEERh(hRgIN4uD??
zmmQgso6rIER+z5iv~Jz*f_~j8AG9h~%MCCy$uHx-DaARxer}xtHL7TiGf*dQ$Q5*~
z*z$`RVeQ}CEIH7vzIp2AfFe&7`dQ!3t5?pY@6sYv{u6m@#?mYsGt))m1MSvT(am|$
zJ7VPd#ZLx<yXNZ#d-{oo?<Nu<Vn7(%L|nQ{j-*k*;Aw}D(ur`?9-*G-L1u~P;|ve<
zTHms+-<rZ$$0PLN=+bFXv(9+&M^Q$ljW#Hz7d8)gyf%1(9zm^}*V;^!YssD(E=Zpy
zA5<hv9>m6Uo}3O9_D;wmi-eX$uguR0pB4j-euh0Q&+|RuTr?#<-I<OU0B53$)f7~~
zUh%#KN1flbQ^@J>O!tYi$I*T>7s-2J9!=AS{CfTpV{Tmvy1*q&O}X2Lj}ujoUNoGP
z8`pgfd$OJ2;(ll1H!Ii0-$a;dDS1xEI^^*C2yVpmHrz!z;*almTb?H=^t00UiFFTj
zbPb4g4Rmxi1-UQuA5dKd0m^C1C#0cIPXU#N4R^&)WASH@`vS^+&lk_lsw>?#Uocgu
z+Fx6FJi?x7(FESr1xWu8yw}Mb!fk#%aX@Y4TbXc(Hb0h87d!J_vQgQt*pQLz2woS*
zaP8MydnA1DBf(K@hyKjiJ?}2kov8p>t)gMl*l;3c5=^{DB;L#l#7_jGzF~`ZACc3c
zci$*5keSuST%0T@r8CNiIC_gMGdmOE9D9_@nd=M_pAC24v9Dna{#l@q$61WGVwvbD
zwxv^`_PKc=Svsoml5PSk*G?n!@ICampo>Geketlytt1JGY(x4)Ki*2UtWKv5`XcoN
z)_bGc{1u_)P3!AXpuvV6Yx#zEW9&G`Ndx<T$otWNF0XbE0dD`Tg=7gNsq`;N3Xcvu
z^51hsR%~DjN0M3pORn9CA#2b4zl{Dbp8hx$NU4_KdgQg4jHLa{VK5Is(nbGG|9?sE
zWqYJRw*L`$^|Y{jW1QiwwP}7PkgLc5aIvxC4l60Nc>Z0F$qNoEP*N-5;9%}c)7wAY
zUbK49DjHhDc$xDkezAZHcQ2{Yw2Tu=-$Az=WpM>IhWp)98^6m7_*Z~KgTU@SDyIiK
z?58h`LPx=eOCo+(iqjwIi-&*H(XC<LFMT~(X}kOYn(n%f6Sr#a0_}O;va1a)Hu5w4
zg)<$O?)Qd{c4muHro65ZKVpG4%Uk$z?Kp3lZ+g4sh|08caaHz%x;otH{Sl5bV;OQj
zoPhv}MBu#-UIW*pgbfM&^D*=A=rGf%6@j39OkmZx5Puh&6Yp1&ueAck@k0t$oP!`a
zi!Cpo?><o-9R!nnpwo{mVBiz1H2)UOl?*JLLNQ%QB!?5fr63m{u}7)e5r62Eq)ij+
zRFOY*FvyNxqLzU2+deILpTc2Xm@)+>ln(4{;k-DR-LIYLE8K>|)rd_`Sv-_v*=8_!
zW@h+ZG29lXq<iN`95gF5VjFmr;Vfwol8F}vAgF|5?MCN5nanS}?PHjnIw8x2z_hu+
z+7SCW>Vv$Ion2JoZE`}dyy62@L070o-uTIn9L3-YT}CJ=`J%u3+F!O@`x|*JOMn|<
zX!U;kD)sc~+kCqqXBq?C?#8m&=-DHlRx&Q4TdV$nW|s$UTPfh;-_*9*dj|FOlD^=J
zrDrdJOdFrA-KbBXx;)${sHr`S8&^hek{<ujfkzxtMj1EdhgA)hbHuTyWif!odJbcE
zono$}E@}oHEQL+v=P73)9Y67>0m=;m?sh}~{L(kO1pU;0G1Zbdvf1k4om!8+=lc4#
zQ%ov)<e9Fm`7Vd>C}LQ+V^WSLk;5qOQ8!r~cs={luqMY=Iej!MjnMgJIp(JH*_qIr
zg^Te3x0ov|)AkuDi#Pf&w9jHhw?{@inR!fPGiceX)`e3YYw7qz-V$O&0s({u)zO7g
z^-~>{>U^&v1JZP>l`UYbKi>=$NG=UIWEA4-4|)p1uqs}_p_%NtF`Fe>G(4ktS`{7w
zarPxYwf;Ib^ywLXTB9<!+%&h;kSTHeNb>N<#LT;$i%8W@BD>^K+u%cyuG3q*hG-9I
zwtkPB=>vkRmhHJfG}_(nX&~os^T*<rkZu=*gLy+5@*n|z9t(<S1j+ztYmhI48^?b>
zkJUfwUif*gw4ps%@=E#|zr{7D*D82JBBxvkE)%(I#obOlcqN_Xrp!kiiHB7(LUq`k
zF0qJ1j*~mwZxcO!{NO1^8Fd$wpr}NZOTq2>Gx+(F+?nC-La=S=3LwyWVgd_~SsxtY
zdc$<#oF2CDhemqsa&yvq);T_{*DIdnF#j~4w+1U|)~Mvs-uqYbl3BtwwpzSFHaJX$
zh@t?R=sR&tjZ-m)JqHC>6U|-L_UuFsdfX7Q3b|RT`3Rf2UHZ((f(>hzw>m9s+u)?J
zd@5SRn^%6VyQp0kKyYot{Ih`!4N0xfZ6qoFMUO$Ag~qiHmasJOY=6%%+7D@Iq3fEJ
zpH@i_sE7F{rRptp$xu?uqCSNSQHg^$g3T#Yr3nHZm2=r=cg=~4_@#XBGvt>rBh}TX
z{~BgEeLu6}-HCmf1RL$p$J2rOk|x2j15&&3OO}4p#rw`41HxWvxxWUx0`v3z`1{mh
zSK`gj(PF_%4I5vD#+F0kPy)V~r!Ck7<eYb*V|hiO*^_G(-J&Nk%p#6>>a({_(Y{Y1
z#Nwv5jW0mXtguH4n9E7qDXhG(==V4bPR&iWxMeCB_eA-IB(7{`yK%d*WSUU=GDGlQ
zUH-iGfnl8*P%A-`5Hu<=nR6}H>>v=tK4+&n6EW>`+h!zhsB&T{pFH1M4l_Sjd$Qnu
z26YP~pY@{3VVgVZGH3pSGnScp?Iimdjc~`5X@@`XwT<k(oP4wPqZ#*S29a47p+M{%
zce0L<0qrW2JRYN!H%u;XX#a3ZCBCOSRpNF{TsUxZ2KMY<%<bxsVrH;fe_j9D5#3Bs
zu&lXvdhxJ0yqWFpMl<f*9hj)jDlTY?XueZtl@M(GlJnJ0F+scDe#u*Z!8K@dWr$^r
zeX=CBd_%`Ot;<2=?3hhsdp)q|KrQcllAT2{37soCOs*+I6s@Cfvi2Xmvr<n_q5|==
zXQ9}H9l**v0(Bx^jl4G&enQE731~tpbsjTWx@ZOx>;lR%rk0*+#uSAcXS+_XHS|1d
zC61>;h9p!pJ@jRvl(<DoeINC5D4IJ-PD_-ja)>WW%nkAt=xy5t!#m%<wbCWIYZsZE
zc~@K`j&NMI3U^Q56%eofUht>+tMB|6;<cQPP%to+{k$Z4BW(!0HJ`-HA%W8lnAsJ3
z+`-IU-C!@8=k-NiXe@TFe-nf!?bOXdU+OYV*hy5q&mC>>M=5;9_PLO)PW(mF{_~O+
z{2#h73SOKGFTxOa_YNaQTIPN!@hwe}Li4_fp_!LcJygnkMkR?D<wA{K>BC+YlzA(D
zw@Cm;hQ#?aNqdbehGlVJz2u1U1)n+$PO8~~<+8hoW*sS5lso%*gPJz(tU5uF?o5d4
z=h22V?-fnFPd=hiM>6ac>AWHFj^C700KT~75*bBv-)S+SeDt2mU$2+Z_Y^#1A(;H%
zKa*Iz{%*dh`%)otNhR!)=j39B(IAakCRZ>}!6CG;a`_JbG(4k=hiumtc80GSStMi4
zKXshIws3H)Iz;p)Z$-5OXXo?*n-aKT5%0>A4t3{>G0mspd1oIp<wN#?#;^!?7Ckl)
zOUDdZW}7`VZmy;p8$YF5{ECX4FfWscO(Q~%DppQWDQ?VpsRCaxCp{An$rM1}0lo)@
zM{{e?aFf|)mJfY?P>LUOE>?t1UZmk8Ux-V<zDOfS5&~3470eKsm8Lf&*c-2RREK<!
zL<;2ue&ap17A~6xu8u5Muo#ZJQKKT2WeE47=0+;s4FN_|!>Meff1CJWzP~#4a)!9)
zrcl2z5E6EVi!12#QEc}68-N5`>)k}2#c&i-?$<mn)_hu|g7Om0-{6T|TtY}G7czOw
ztizYh)7i3Es9B^F_&5Ic4;M&>-g{{P6~fUXVADwOp~BMNyGM@&*92joRSP?raW|(K
zTe}^G66)byjPcE72N2lpG;3y-ek|hyrVO}9?${>nr9GeVi~t*%Ehowi&y##8bzem;
z?>N5P@@jT<J|k!tOgc9}*vf9Q9ug=_IJwx_59H5$-y?MMV5Z%hzUQSm8;aH^TurW9
zh+Qunf7bR3@hp<96XkqV7R$&@r!kJ=hnI{k<CL!gpG3zz%+G#qV?YN#;j|{Dd3Mvs
zHhATHS5ZNHR}^4U%O+)=6OeGgaCz{on(J>iK57t{T_RBU;T!O4bN?(i6@#2B+w%Si
zinLVwP<n2L%Y<>&`0c`%3U2JCoX9V7_E=(XnF}SC;>AY?@<RWqQ<C*RfD|h3h!N1c
zMf9<bc+}$kZL8qO1xHM&RxvmjQSBK%s}oU|$OBiqp98x}Ts-2d$&X(LK35(xLtdpZ
z_193vA}P!?rtUK;tlN?jbS&t(xU39n;Zz*54Xs2IxwGC($X@akx8gkJEcgaPzmQKK
zUh&e)B-39lm{=l5$`z>(BVe2^75}<CYoB2?X-tTB*KRt*ZBTkCAK6;!FgJCcWy)#t
zlnRu;x)$E8RHr^_U=^5^D|dz@T+e&4%=HwtF(dyUQzp%EUl^wk&vrQ3d3)?RA^G93
z=rv^Fgm$;1**B#R?$c2Hbc#)8TBZyiAX|N_u$Gti{K68z0SR<NS4g5ZYS6L5Zw<E_
z10UZYTcw}3@^~AKRKlN$+feiAbs7`U|2c0(=(dz2W9?edP-5nh8L1d{sC)Bh`@c{$
zsORq;bRhEx+>465JmeUSsc@Jo5Pdd5<O%6Y#a;Dr%qucXiB~G7uAd$lkZvdz&fRPe
zyaEY?nn;ig9=&1u>Ggwkua!PzK=6~S1nRP^{Q4rlB6czT3TLRbt(`R>9<T3H!;zt3
z?P%woQcPgV8E(zQZNJI1!ij2wKQUH5r7yp}(3^UrZHvT1soJ7q&=cuOmq>XzBuKZ$
zPVG%QfaD3vNBXPOn77@nx-%s@F&KDG$Olv>@Gs}E>NWi23h8dQlFyi*)kAXUUzkyy
zEgF4;cUOcy2W<vqBU|Bh7GR;<SS0WjsfzITnaj9%cVGsK>iv5pQtmi5)*B!mkxm|c
zub}d?J<;P%WU1l1iS6bCVx;RCrxx|g+%)RS`UjLG4@@i}MQo#BW%ZoWNqZ9P_Ri}d
z6^8e7d6QR&d0T_m8%#+kRIt9$Z?C5Uu!M7eAdGJ9cKKCCWjmtZSKtU^<fh1VY`xsX
zh?s2>F`%X2#WnCXQ?<~h9L|DL93<^}0`gB-@!j>QTB(icV@|6zLvyvJa4aroQtc8)
zfR&o(C&t}hjc}nyx(OnZY|i;RH}i<gm&4tKYu+Oh0;2(;YCg~Gkb!MXk3_IS%Cj7x
zjyeEq-JfKBoCwWLw6(2!A4Y-+H2-}5o4EE?Q9F*SS-fKB<nQN_?pK*-q@U|EiB>fq
zK`{m4bB5@kE{hLgc6m&He+wIQR$|)97o?^RTT?vK*S{LRoY=Lhule<HNQxAFYAPWf
z4sECy^Z#CsITE4L;31u8Gi3QFG?Z!vs9Xx}bJR9F*wu8^3Ua2H?d=N1XWJR&@kyua
zW~VB{vp47P{5B1eM4a@$a61||dl6R{oOw_w?=_v<j>Kw@;Ld+@B^}se+`QChq=lZM
z4?tVhe`p3IELP+Ou4Ev42oae7aftuJd)mMOjCs!GH7W5`scgN32k%pS16MWxK9eRJ
zss5qPLZ3sshIPQ6M-6xl@`%s3%IrgZ@V$|S3239Ux;^pDPHaCO`65jni%Kt^VX)J@
zJrG<tzBY3sKEd@$o!-y!HPYq86@uRk{Xp6W!rX4y`>RWO+0}P+ESYL<!=m>?_OU*V
zYz^kZb~?J%Y(*(Zm(OyT1BO71CBn3OMy#dc)q$nP|HcjjagrP;kN76zEJg+jf+Q)L
ze{iAG0^_H$^>x%jVcBG3*Tgo%Mh-F-v=j`tNOhWH|6H0#ULSAQZfNf7@4@z+EgQ=w
z#J8dE+_c|$Nu%}~)qj*M^EOxNW#J*_r25NR&;0RKIxkQ%W7`OjFjBhrfb=NVgy@5-
z6*QLE2g|$M@!`#t83^}Q=h{GAx%!WNG1~R77gfpqS8r(cY?20X86YwaFkJ^sm(!b?
zL=5sE;@zLfvcA~$#8P7wbfX|&b@@v!H$PcsaDj>(>xHjMIC2cw@kwFG*?oj7HH5g#
z%3&_k%Xie815ou5rB%avQodpW?eo+PNpNbnR-oHdb!ruwG4}E{5*A3(RikjS25lSf
z_HbkvY$-^a@k+vSQoFNqr-l;FQ>iba682I3>M-@~C`=pZ_5$7G>GCK8coa9!E4c**
zU*%E;j9{2v<yRVzEXuV}A!90Ok_WpEIsMs%lRn8J5Z_Kmd-+hBJOFO!LIMe&KvrN-
z+{8VaCz*^t{5OvJiFYNoQX*ZwV~(U9Dw=?oagj&2ca?=A{xwUi+Wh<n50&2456W=!
z8a_H?MF7XfJx&y#Q|2ZkLEzUGRfh4i>nI?^uC{`=U^3u<5E<BR)UElK0C_zF*D+vX
zyZw@xYNzQn)0v`ldfC=T7OdNOr}qX<7|US;WPQLZth5;~WKg+Yno!lgcpaAPQS!t~
z;+HjNN|RM?yemT`Fs&kf3VV``JPe1##;|I4e8O9ZpQ@DEX)KGEv=(3}Q7ee+lY2$Q
zTK}F-+Sa|)=3NDy)|zbWlF;M}{Tkpc6qeAqpZWPxC>A(FT5j#P-k47Y;?=x8*<a1=
z#jPzAd>4Xj9ft0g#-!!nc^J?vyxo`kH+ZAP2C`}$u*!9~gFnz=Ed1^loviZ+F?aPK
zp*_R%YEIrBRF=LJx_C;aHAq@I94E$e*il0+2hd^gC`uHsl-eyr$4Xn815(+nFUGb$
zy%mj6Nz`wyz%=KI5z~=>*XLBAC}KFvF$ZhbtL918*^;t8-+$?D$-itQ-yC{@ZX?_J
zNxs>_$l7KY*VyPCy&HyzL#$8cIR>)Bdd9}G;%ih3Ng|D9V8;V3eCG2Lu-iX|a7*1J
z1=u666{Nks+h>~r+3)25-CN2pZkJ6{sfgWbT!zYJ;#a{@LsWVqGx*}0?<%KUnaW=p
zTM(7MEFzX>b$QSAu&QwOE_2Hp#kQ)45hB5&T*o_w9M7bWEbiKll&eWLC!A-8B-$)G
zh4e5kEgNKSQQ3o`(sPJ%X*&vc?<t~aHEb?qNySh89{!otcWVHD))wr97b=1grh%&b
z!VM<(#gS+3Yb$1u4{z$_)H^B{@MEq8c<6`E^Ud_<8AU$4_*?GLi53}|LN;@JLthI#
ztd%jl@8^rF3nk^&tusDIY<%BfV$cm5tRd<F!42Vx_}?}d(|WF-lvtFTGM|B=h%dEh
zpSYGd_CLlPeqjfQ%5M!~zGm9E81JFMHJ(}ew90kJa&e*ZD!45@7}}>FqA76C`l)Kc
zHW6Brq;)+3*=u6@cqak`&>vvCvv1ADZVhRDv3!4oRZ?t>W%o+Xew|MFb2R9GA;L0o
zswLX6%iAn+GB$Us*vhKy=5juNv~!tY|H-dcH?{e!PSFkEGOI^y-YOB|wQYRQICmt#
z3ug`=uB(!FYx`EF9h`;NETyn1;vBoVnNgM6#5Q5TTI996^fHq2^`3b4>=YI16gdIS
zLC#-9`%$%kj0c~Br9y^2JbT7+BoMXm@FS<^yryo_lA2p(VwIa^aH6$CkBUGeT=oxp
z&A99z!kPg<cBY7>j<{M6(zY!7hpQSjX^!;tTVfU3`ezzbkxLcn54=T=b#%NJR0<gD
zjfT6Xvc1PL?}@vZS>>#r)MV*N7v5*s-xDW&y!$BIyWhtum-X<1*6b3L5Hq(xm6BTk
z=H%>#>T#0tPML7Sy~gNOFBBs*3;<qQwE;0GT|+&vc7qFb)}o4>ZKXPSQl5xvNI0E}
z7I!U8t1Uny6fm}R5Q@!KIg0+$wxf3*HF7q^77bc#aR5Uv{~*eZQIGPCYl!Bqn|pj7
zNQ4az>WD&%>-jr&g0^4{+*}TumAr5brv*g$C2<AUy>f&`_E8vZl!utY^>XDE_ZDh^
zJ_z77WN*C365bx!Su_d2P1+86$YVWe^ZX_IjP<m|Abt2j0*jmeS06H4sl=4g+_h|u
zir4(O&PZ)+xkG$SP6Ifu#!$4Uzi+_Ue{DY~aQV_&r0rJUTBT=0vBL%&FH#cA3*TON
zARiy`>073$6zKiP9}O>*8Wk@CNGn#f0P~q^Z?9pmFFw0|BaNWP-(Q<&@AznayPmIc
zK8|maZ8M}=zC1_Y7USJYdd#4k&+K6)?;uikSkZ}AOQ6X#cv^sx*hMy&Y`Gr3?OYd5
zA);^5qUjeNbb2jX(_fky!k_YKGC{J*$&&VgZ4BW&f09$GZ#|kaHSyK`fQbOg3>err
z9xl%yadNOf)ON_&vmkhUTBW7hfO(4lm^L&xE!L38p4i7tVw{fC$5=qGR1RiqVN}V%
zc5I7v|1KOYqE(%GE!HF$yaD6-g)x;uke^^>BMSO(VjrD&NjBn92YWYS(`<6|&-Pb2
z-!iWXx*eenzJ%e3!qVja22yh_fXah{)}BRmYoU5hXq=o=sjZj-*%-n<{$b4=-8)Iq
z_5<a<Vf-7pI<nMR?Dd7z#sGej!Np9HPxww(cKFyXUX}1PVcDmP8ln_!U_|2L+<-O9
zs{b1<G$AdFR{oBY75~=zIq2+OsDCqO$CXv@4pzZ|2kz7%d8N`*`kokobEgh#mXTPy
zwF78BCEvyhLw-zsp>o-kh>1~Bmtd7ko8wUUK~AI-&L64}Zf@(rPg|-j^QRg%y(}>k
znIz1K%y{{^E54KtXTm(an_QaG5tDSYf07Jhv0O^7T&N;XIhIoScV4Og(50W}Y>1K*
z|It87gW9HPJFA}^<tz_GXuJl-k{<r3YOrS9F{#(CF8AbW@ms|)!&BbsTPRWmC?`U0
z>Gjd-0O@=M?()ZYt=-A#=TaxT0z(ldJGnvQEVjX?I)c>V$Li?}CNEW$rjCE%T6wA=
zmo7klM-NYt@@ngIMF`rEc<^eNMSY(-vs>gR@1lLgO8R}@`!x_)5B{1rca|9U$+<WK
z<XGMtIuQ9`apxFo$|z7{Bz)(I0-EAu#nE-N0rQxdAPXniD=@YDB@hR!=l$B-%D_|L
zi?Z~S-v(=d$SVGFR03pktDdVudL6Mv<oe=;0%1#d``i7O1h!RR=h<;AR;m%Eu|IjW
z^*jcAe>7jjkb!~H`Bw+tZJCPlDc$pGO9<))H=@Of{2e{61mDwyndEmp^Hl24Nx_j1
zkwHyOnpnbCP)7F9xW9}^WH<g6Ts#9Qdt{0@e@~XwYTegJy3Ov8lLYee0F;dF<Cbem
zX?mFGe%H+F*Xnf^8jdLMqU(X|!>zDJYtrX{r+t#VssylI9?Zt2N3t_`DRf^Lyu(DE
z>-u;8`=B8uSR<;ghD2_U3q60KPuHs5k-EbxwWLOG)%JZ*%|ehxl;w{uBXe8xGOrlO
z%XLKLkCEB}gs*E`&oj+fM;~{F&q5)YA>|Ixuu~urt7uk$P~>f&z)!DL7M_Wn^bKKo
zNLkpzlML{7MPLjhG`e;Ax+vUFwN8sZqaWSZ`Hn(R;fZ1KCOPdJE02`I#1FP`yQu8P
ziPt1U&JMn=*@BkMH$tJirotBx6coeE;qA->k2UFudfa9n*BuHH<iZ`#>+iKVmK?X=
zHFWtV_HxwLNyD&cG;uZMG^y9Q#y4;X1Q2h9eH#IZ=2sMx7whvKa}treYE}lLYKlj0
zb>*MYq_#*82hLm<NGN`ZtX$yalYz9fpT>8$@1&Jf*UG~S3NiL_w!wQDLn4a0NAHL`
z(+Nw%*KmEi^Ma)=-DP^D9+X<spBI9&zc+roR+Ju2P5RW@h}dlZOQ#5hpj<}cLn$Vk
zEcXDX=Y!v5^t?26D7pksaK4_1pYhWM+8lqHAZ-x-v0m+Uo?zJk>fknxlH5)#+~aaA
zp*L(Bq~Qd~gpNN&4`L3DA{tljKl7<XjR~oU*uF0d$o=%++f^t}B>w7q`eeh4qQAT;
zvXl=Gi}zg$Tsbj$x~)xaI9;0IO?D9gLIPQTHc52`ej5K!irlt!`*>!2uO#Sgjm^$y
z73GX&%^2d*K(106vRG`JGROGhi6|q-kT_8L@)6_ooz93;v96pXrqh#fHo0BbxHC5y
zmdyWiI|23*lO=@$2DG^4G+`lK1BJDUn#3V&u6L1l=(CA{MmIA$B}1BIYt%7{>&`&r
zF0N^*XRSf9H-@R0Yq*MnrcKCX|1>Yu8(k;i>`mo+e+Z&NJF+CK%E3>+%}Hq%FOE7*
zUO4*L(shqtc*WSYjtpFN05j*>(LnD@5K_El>C76qiO|7)j71P&xJ4XyV%MgHpa090
zocfTa6$nRs#n6zu&We+7>)!a}P1$r3S-@~VVk56r4dys-FBGK%fA)4^_)uE(j$s9D
z{Sx$uyK-s{R(wy2&VE!jWk&{fz9N=)U@%s?hH%-4#Gj_S6O{jjC|M{72Oqz0a;=uh
zk!Y#!50E+0e7lq?9yr{hI_9<$0G=qPE}&E90di4$CQ~jEiKThIFxoQuH0j%9M@`Z7
zOO0&35VrxXx9kl5V1)VVbcjjf&|i0WzK5UdNETfQXD3=e`Hxy#bhsd-QzIJ|QriD8
z>_aQuAoOG<vh!*-Q6b-s8GV_S@0&N4=@!MkACEbX>6<2!Rf~{2J%IM}G;V#%Cs=tm
zz=a;&uT<ndgl<BkBQeP##|`I-$d0$~e{U$o7QC0~d@c2kaPL*tRRQmSh4`Nw1lyp_
zhrK^<;O|-9dqphJu6%W+Go%kO;1@15kZTM#6zDNg@(wY?*r0<E9_-UM<aC<j`VLsA
zrE_-rrE4^&grE)N$XWbg)83_awRi`R0C~ZPz`>SyXP&0bckSPgv0UNK0#$LI`xa{V
zav_TY)9OoH=$QS}RU;wM0<RYo8>0<T7v!!nn`kQt=e^o<40-CpB|-=%ln)0GkFTC&
zE53OPtdy>^Q486j!y7{eGwo&R?sdeFyN#Lyz{OLY*OQuS$_07fQ4(WmEdSpqfcXWH
zeUu;nIF~K9J<n>yc_Uf^Hm=3*2s1U^5B=zB^|+?5)wE+dJ|(0;ygG}@Oat*Jo3*>2
zeRsrnp3>Ec;TW`S;Qkfy*^IQVvU1BiP6YaN2?4ilwZiXeydZaoEuTX-NKQ`E9PP4<
zwouD`nAxJ;IAJ>m-9g#0lPZTOFi<79RP5lgc%v6%t8z*Y_xRHN_#D!qzdWV4ilKj-
z?n-!L%|-cOxiJk{GvI(JMuXO-V2WWnd2g@Y>wKiJxYkQvEpKV?-W^>qxDwQfcM~-*
zNjNi<{=A@n@4ynf=i#5!dU$XG_%U`Z|I$Tx`FBV78H}E={vqo-U16{Vyby%`Qv<s(
z!&j|cH_0|<a?nQ0OTwFI)Q6OXdz6BY_5O#jQGBz`y(QR#3(o0{)qJH0T_C~aOu{;g
zk`&b@)m79?#df6?&=E83Dg;Kkd;u@p`?I=u0;Eb(2K?}&S5A%gFT{z1##)6|p0=t9
zRG_k-yt7fd<MJ1s`2YbfVve6}kxFdT_+!)8=5?b|s$j9HF#t@D2M*^Vj}#G55Oj5E
zYc}5`Ll}b0{VXR9W<VL2e<pm+?^bs`oa4}tJa9p3Q|sP-mEdKH%~_9VsB(-!Mw+ks
z$&xi!-&@KiB9*|Gldh|84@s-2Z~May3E*1Rq{~qo9|7-?4Pc(0@CK^Obaj1lF(Yy%
z8xLH5+=_lMZ0dynbEnaMCohI+c7M~5-XNx-oWxuuQ*li5hx|&2^77<5i)iyTBs}JX
z>Ew}g_)OQ0|4eS}z158yW3R}lSgYV;eY4A&my&h(3DYS`daU2NhTQ4f+EwssqDspV
znZY{RPtL<iIMCR^$MklOHZ3u>X{07yqo@m0c7uZbsZ4;f?^Iv0kL<4#RVA3s1c<Gp
z?#=LeuVxj0S2<0%rxF&fn(8L}{iiPEMj}0?E(an53`3%LUSNLQy5X!{wR*Aqooa1z
zbur!3-ZjS$y&U;o;Ck}TanP*a=KN2+_BU<T4Dc`1fU((epHo$K56RGS_m?sh|KZq*
z%Dt2=mwjjQp?jLwef(!DkVy)GJ}5QeY^YQBXgb6FAEjQd&3`C)ZH(JAeMCub(uh?a
zg~K+IDSNP+hBDw;ekk*B)cv0w{rLOQr-<K&jPQ)CI)TBnIidswe|CLisE79rYp>Gi
zNliKtz#Z104^KR4t{8$Y7r}|QR;L?;wAqd^OKw*Ui7QM&4-SvN2pm!s{D*Vep^9Lf
zh27=_$XZaxthT_=mZ?^4tW&qEz=qdyA^Au8d*<vf0A~&@Y5SL@KPD?8jDrKb3S^$W
zfq^dztrr%1F-r55+e<B5_nll|c_z2IoBl&UfE5t*f6BTJs3x|pO;PY7f?mPU(T9jv
zAQ34VO2CRriS!nU7y$t(CenmtR1^e4kuC%xMF9yyL`sz2dr|2~1QJks5-BkuyxhOM
z_1^!_tTktyb!N}ZTKoIv>~+pQ=L2>m=L>eaj8>7fyncxH{-CxoCUa#~C2+pxsWkfK
zT3f*xMckhiqM7pCbz`=xLQfel={H>g8N;p#;?nR;(Z2>D?Dr4p8V$12ltxgVMmk%s
z03EA*-fEQ@%X31~#EH*ei^^PdZ7i6YYj(gFB50#HJ0o;XSqtC|rE`X?;b@{y6rM1r
zO@4*ETrcc|8lE*R|H_}9>GQE9+%rEl)qFkhgl}N}!Ll%RGGEt&r{9f^N}noQW9Yve
zXuZmHZA?c^?^w@x;Z3QbN0QM|pwov?ojZ~zL3524Wnwp3oEwQ|Tv<{Kk9l!SB{)QI
zr6`J{tYe%9DB<=e)f_>zXJ$AUMp&)fV=1)L!Nj_jQ7zuoRwBo?e|?E;i)0$cysUX+
z7)>BBDb!yZ>IyxQfp-=b*Z-nw!P;v(;jeD-er@|whqp3XxVloQKi4si^N6mkTE7kx
z5;R;Sts{h4UGB2V%r%Hh-CWp?$Vjx|?KF62=>yuvgT_*orM;u55xFF^rvy5k%DQN*
zHd{Y$P;M|H%9EI|iiBW$byHoq^~#il+uy#c1k17<)kAs``hX?tSbyA9$T*QX1h08F
zVe=gl*au(nVhtHbQ*SEv`2Q}3wLfelwwWmOz;C&(G8WacM+5&_x4DX1?JJQ_){>|N
zBy{I&<|A<Pm2m`m<;ji>diIzS2Ux8g`wO%kF(%!C7Vb&)XT1klEZcrGe{fgH&&_0&
zX$B%GYQeWlcm2fkv%@8W+CrFyrzXbdMr=l0>65jy#w6(dQucAui&(?QmG{4est0vo
zI|fih!t!Q;ru`)j+nW@_<jxd+1A2x)ur*nfTKaaPXSO;neL-tE(QK;yT@g{6KcaOe
zT*NYdbA9dp69W4gQMcykCX4O}TA)K-q58ZS30k0~Q%D9O%y8sjz5G)C8dqoY5)$Wy
zZJC$3$P)>=61Hs@#x06v%p4N$$ZS09_=YDos&%wFw2!sw1f~1C5gEW5vj?Cf7!`Q<
zC5M+n@b5F{K+0Q7$H!&ny3$v5;mZ(~jiVBF#sD|x$=^#br{fmMnEP?}gGg6sPWzja
zEn(%&WcDt4XDFtMv486)oa7KL5;+?v<lh)TvI=kYA6}d8VkA2r*%DITF<3zJbM|g8
zNBi_qJMPvheMcEVffot71jwavUP?nuH2)vER2)5Xanmev8)D>ZO*S6zT~6@~UBh9o
zxxSoAs;6B@p`Gz>kGZ&IW)E30gFTVujAHh4XtKCHVYF<rq;NL`dmhQWu9035uKKat
zd|f<kf;yk=cw%if0y&o6d#Zx4)=Ze1eX&#N1YXzYOT7WL(u$OJ<Bq3<pKE5Wap+&q
zsE_Ryku4Ua6wmE3(1vOWU5FZQMQKaOJGr&}9kiti>g)-XTB7~AuxqYNJH*p`L+d?*
z!lw}y{?zN9GmNr8rzZf{kndexd#b;W+?7-ge?*SQFit$6^>H2e-yGDrwC&t`IaJAT
zaLq)k3J5>)@jjRb(%@sFAj0tedjys3tdXq74wFd<X0$$9Qm+nC0(BbUzSFT?T}+ML
zeQKR71Z*s%`*8Rdb$l*?ITL~Hk_+8SeU?|tOvQGEk*$>G)XCs@I;Z^FbW;MV&M@#f
z%&np}or)`ByqKJ7OQ~(#>ER@0BJ|r3jerED1;X)}Q}Luc-An0}yp2qmxz}_~!NYG|
zwX@qDCl00bltJwPx*-*>i|&S_%q=ao=Vj7k5gjKeeP-}c4`@qa{t@>OF>Q1#5ItVx
z8OOR+i1;plT6tmCb13%A+OnBtQ+-iX)(_(;%J!pR$|y|(`ILm1HzixIqE`WNmUTbN
z?wr%Rb;FTvBUsSakjt|5f4D>Gh2_xh^=qDs5eS-yN8W+jUmDmK+Tr^1dE#)Cs~@9`
zY-%~Z!o3=QBXX_%45ja7<$M8w9$S6^%o=!+99Fw&)NTf5C|sd~l`&PJ>I<R!M|w12
zKk7!}ijvD3QxG!?r&TzrFaRnqX`0Oy_=t`|a$s}Hfy^TseQ%Q`x8+w-DryDQ>0-ta
zwFCl6q5KM%c{2o1=rNo2C(y--kI^YJVddBSSdF5+#3CZ(iUpVztfj(FPN%dZ`dJ$p
z$u`pw&+fK_V!OP?<TqGBzm$t{u)F3Qx<&%(Dwvg^rLnc$$^uF$=*MfVMN_k?KnVmL
zIdJ|Om=WO!3EnP}bhe=>AR}G!aX4{Zz8C5mvFZzKj|a3AAc|eIdtnQ-*?oCBlIP$h
zyelD$<|~aU+IOnfgP@d_C<M*9(+Qk=G@WfFMF%fjuUA`OpSqW#KGo(y>G0n!4^?ol
zc_Is?s{xFFl$pbjRkNV3z4Zt9F+s!jpDgY`WimBFkkU$R72`jwRC^vBKk9Y~%!-hS
zJ7c(h2nF_JE0AIzh8T3Cv(m$DIkO0^>y(`PHq6}AD7^J`d^Cn3eYZy%CnVWp1oN9h
zB<&~M=KBmncCh62*IwBb8-2FcjHa}4kifiaqIUQZrd4FalP6O%Es#+Vv|~x=ZzQ5p
zW|}sB|HG4QSb&aRyR6y0o~w+}%u@oRq7XA`gD=9k@6-|LcZH1~{oNxse6Hhy-u>m@
z^lEAr^iUu3nlKYfb_TQNPIel>R^}!kAT|u&qv%@Kw4)9R5h<RU&n>}I2*6y)X?2Hf
z(Trq%Y#!GRooI1D!Bb`y5*6HgjoorkCSb;>)^WZ!;F-qg__MQnD9y%gaug8f-G~RJ
z(WTtd@BZ#n6u*Oy?Xxll6m6`G%eGTCO?PSq4f1d}IfHy(Vo<3T|K+h`D%EUv;t<c_
zQ+)UzX<hC-B@sS0fr>6D%@B}lK|dolKcAYLgZX?*-yg0GPPD;^E#-?V2gm8Eb+4~v
zq`1^d+Mws1S6YK8otn#uli?<pk$Kr?W#IU>rL!<4ZC7n6HsZtFh6obGsUs4ZJ7nbQ
zIwUb+%kb=$s_E_H(>8QTx2CYv8J}_oOEyltoy>hK-v_W?b9S0OX{km**aS@13}}i5
zOKl-uaFA%Y^EsnuX7m*`j2SwOk0CI3WMT$n*`Ut01w3)o^3Gfx1SUPlP?GY$#E*)D
z@N8^DAM0e7ky4FQD6~iIl?Et8m@ko0#Bb{M%`vrFWi)Corc`k4Q)ohEEj5Vwup9BH
zP(bPMeGSQ}x5)b%#7AA{(ngQPp+Zk}Z`T#K8K{I&^Lwz>vcO93`l;iLu!9ZCJLu@L
zmLil*j_Kl7O<~Pi&|FzBkI<G#g*2BWCR00A@m<PvpTQ&>p6RcSg$*uNy!$3jDH@|1
z{7V(mf!~Dq#ZJyv)oA{!0RC0o+znU?fjs_Qc*Z8eX1qAJnESQU*3J9D+jF{lcA0X-
zx8@d>uWgjZHWB0n+UGhi&&jE()v9N{b-rz%I#!iP?mibQ5xzBPWpQ7{D#^~pdamlD
zC%jW9?r4@;j5=4obpE90vh;P{``g5YQin+wv&Eeab8I<~Qz|)(*_e4)53`1RHC<}^
z?O124T$a9cc!Qt8kTX)aRQlVz?k2G`coDPVhs~WXSu0hG<6U{9HP)#YDMx7!P@&3r
zNy+8M-A0kDyzytd<D##;)*8Pm|0T{I^=8PgS5H5Va;2I)_(OM7FI;A_S4T8!eEx>^
zsDj^omP#LR0rSD>Uc9bZAH#zJ9U|$dWqDyfj(hj(O!kd?6hcRr^+1_*^V1%mSui*r
zIYIRJ+@zBw@tX4BTwkFIf8DS}>`zDM>m6Uv`Y-H1cj;IZezDh2uKF_mA-Vtcw+F}K
z$mVZ%hRp-ZGfO4xFvBza+&F7ZTho%ZMaN28#j-S@<nZwI!1tN<g(ann=9M?IOM~8G
zhW!F_CrVaJPq?&KrBs{WE50XNi}}$%mE98j@S~s4?nv)QQ|YyjL{ArNe_7QZ9pDfp
z2v5X>4(IWjue3Jslz+YSxMxOQPCyo7flkr(hCdj*+nexuW#le{WBMDXVDx;ap!#>S
zf&H!tDs$)OR>Cf_zTw|c@h?zR)$CCHb`RVz6W${wARw?$z|2kTCc)Gc`%OqdV0o{A
zfLikDKv@9g?|bo{8wLaRb@TJ`aK}7&ZR_hlarz)Hz7?pU_e@-qD7*aVm2}xDXZ1H}
zr5t<Ng$pFrpgUP-EjVkR5=CP4?NW~v2vn_wuI4O+*Ja)OvqdB>)p?^X6S*OfI{4VO
zq`o@nm`~U(MF+uz%I5lN)1_~SbhA1*KGn=*pmz~4{ouqsYJts7w(2e2IQ;I;^O00D
zHdz!w9z6P_v+DJ&e6~@*3@y?i=Gh=$psM?P(Se$M=Sv-aWW?RcyuA*2do&*Vh(pXD
zIFjZgD|+yqrn6Yu5wVAf-Ckp>ds-C5h_1H+BZ(^g%Ev|wO@u{C<IhF~?5Q43%+%1;
zKo^j%0Ko|rT8e}Ihr5PyJYpx=TYCd4qbAGpMTKr&TQYY&79C=E-?ShY?Nu{w6Dexh
zG$(Vw?!h2DM&Z4~zK0gK9_yTxaI|$RNPVOF{SZ^&L58-+@ejp`hN@Rht4gn4Qu^VW
zJG+<cWH_>AEqyk_Jx`}D{h>pv>+ffeV}C4bL_N;}1fJU45(5sBzBpPRbiZ^ub~37K
z&*zN&)+t&C4>_oRwo5KNl<6n&$NDpcA5V1in!kKVf}Z*;1(q-zP)l7XR#fmUdbGx&
z;!oT)fNMiFG!Z#R2jpMfC4GTanuF31+zZlUF~_NrB1V%0(uE|oU#aewMLaB)<Xt)i
z)<5aK)C0U794_j;JFrNC-qjfo(2*(k{-o_I={#pyIP%+u(61D90B-$a?}&0Q*XjJW
zwZiZd`DmA2(zJ?8zAj1c%@?_n(dYS4U%ca|5!s4|6;|2!iMYiO#Ex+lMzcq?{r!GR
zqo}Sk)4~?}+`VLEhAaQk{M04ws@sR*TvUNw`eZ9W{aTw(Gj>fl{3H(yZuAg@9{X0`
zIl5vacgm$$F0jne#xS>X>w3t~y}v`n`8$ifPY_KdKvT5(l7wklE?H_@i%Hpcq{yk~
zsho__4vnH$or8e|KSRre@to-!pNcx^H}fRNx##m-RZH}>$=3Ve08i+KnV^uAz<-mX
zTI+(Kqfk2CL{RE7pC$iuNCyfCAkpskFc9$H*MB$on?;{iV%-IY`1h_03CRAh&3~21
zpk%E;d7uAl@E^4M4})}5K>>82-vcjScgQu2zl}Qv<K^#nJ|F=6|A=|RY_G`QwqpEK
NQ&>QNa$S&L`zNc0QB42<

delta 52657
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
R2>=NI*a83mB|-rJ000jzAEp2R

diff --git a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
index 3cba87dd6..f12b8bd94 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
@@ -81,12 +81,12 @@ unsafe impl Send for MtaReference {}
 unsafe impl Sync for MtaReference {}
 
 /// Activates the in-proc IsolationSession runtime factory and returns the
-/// instance. When a coresident `IsoSessionApp.dll` is present (see
-/// [`super::regfree`]), the factory is loaded **by full path** from the MSI
-/// runtime folder, binding the MSI-installed runtime instead of the inbox
+/// instance. When the fused private-CLSID activator is registered (see
+/// [`super::regfree`]), activation is redirected reg-free to the co-located
+/// `IsoSessionApp.dll`, binding the MSI-installed runtime instead of the inbox
 /// `System32` one; otherwise it falls back to default system activation.
 fn check_service_available_and_activate() -> Result<IsoSessionOps, IsolationSessionError> {
-    let activated = super::regfree::activate_from_runtime_dir::<IsoSessionOps>()
+    let activated = super::regfree::activate_via_private_clsid::<IsoSessionOps>()
         .unwrap_or_else(IsoSessionOps::new);
 
     match activated {
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs b/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs
index 6b86f9607..8d2e20e9b 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs
@@ -167,7 +167,7 @@ pub(super) fn with_service_timeout_grace(mut options: ProcessOptions) -> Process
 pub(super) fn build_iso_process_options(
     options: &ProcessOptions,
 ) -> Result<IsoSessionProcessOptions, IsolationSessionError> {
-    let proc_options = super::regfree::activate_from_runtime_dir::<IsoSessionProcessOptions>()
+    let proc_options = super::regfree::activate_via_private_clsid::<IsoSessionProcessOptions>()
         .unwrap_or_else(IsoSessionProcessOptions::new)
         .map_err(|e| transport_err(op::OPTIONS_NEW, "activation failed", &e))?;
 
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
index 17957fb0d..b9d023dab 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
@@ -1,383 +1,134 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-//! Coresident WinRT activation for the IsoSession client surface.
+//! Reg-free classic-COM activation for the IsoSession client surface.
 //!
-//! By default MXC activates `Windows.AI.IsolationSession.Preview.IsoSessionOps`
-//! through the system-installed registration (the OS image populates the WinRT
-//! activation catalog, which resolves to the inbox `System32` binaries). This
-//! module instead loads the in-proc client (`IsoSessionApp.dll` ->
-//! `IsoSessionClient.dll`) **by full path** from the folder where the paired
-//! IsoSession MSI lays the runtime down, so `wxc-exec` binds the MSI-installed
-//! runtime (and its matching side-by-side service instance) rather than the
-//! inbox one.
+//! By default MXC would activate `Windows.AI.IsolationSession.Preview.*`
+//! through the system-installed WinRT registration (the OS image populates the
+//! activation catalog, which resolves to the inbox `System32` binaries). To
+//! bind the **version-pinned MSI-installed** runtime instead, MXC ships
+//! `IsoSessionApp.dll` in its own nuget package (co-located with `wxc-exec.exe`)
+//! and activates it through a **private classic-COM CLSID** that `wxc-exec`'s
+//! fused manifest redirects (reg-free) to that DLL.
 //!
-//! Why an explicit factory load and not a reg-free activation context: on an
-//! image where the `Windows.AI.IsolationSession.*` classes are registered, a
-//! dynamic reg-free activation context is *shadowed* by the system catalog, so
-//! `RoGetActivationFactory` still loads the `System32` binaries. Loading the
-//! activation factory directly from the MSI copy of `IsoSessionApp.dll`
-//! (`LoadLibraryExW` by full path + `DllGetActivationFactory`) guarantees the
-//! MSI-installed binary is the one used. Its coresidency logic then
-//! sibling-loads the MSI `IsoSessionClient.dll` and binds the matching service
-//! instance -- no machine-wide registry mutation is involved.
+//! Mechanism: [`activate_via_private_clsid`] calls
+//! `CoCreateInstance(<private CLSID>, CLSCTX_INPROC_SERVER, IID_IActivationFactory)`.
+//! The fused `<comClass>` redirection resolves the CLSID straight to the
+//! co-located `IsoSessionApp.dll` -- there is **no `LoadLibrary` in this caller
+//! and no runtime-path logic in Rust**. All knowledge of where the MSI runtime
+//! lives is owned by `IsoSessionApp.dll` (C++), which resolves the runtime
+//! directory and coresident-loads `IsoSessionClient.dll`, then binds the
+//! matching side-by-side service instance.
 //!
-//! Search-order safety: a full-path `LoadLibrary*` pins only the top-level
-//! module; that module's own imports are otherwise resolved through the
-//! default search order (the `wxc-exec.exe` directory, System32, the current
-//! directory, and `PATH`) -- none of which is the MSI runtime folder, and one
-//! of which (CWD) is caller-controlled via the SDK `workingDirectory`. To
-//! defeat DLL-planting and to keep coresidency honest, the App DLL is loaded
-//! with `LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32`, so
-//! its dependencies (including the sibling MSI `IsoSessionClient.dll`, whether
-//! resolved as a static/delay import or by the App DLL's own path-relative
-//! load) are searched only in the MSI runtime folder and System32 -- never the
-//! app dir, CWD, or `PATH`. This mirrors the anti-hijack loads in
-//! `base_container_runner.rs`, `learning_mode/.../ffi.rs`, and `secenv.rs`,
-//! and satisfies the search-order-hijacking guidance recorded in
-//! `fallback_detector.rs`.
+//! Why classic-COM and not reg-free WinRT: a classic `<comClass>` redirection
+//! is honored **ahead of** HKCR and is never catalog-shadowed (a private CLSID
+//! is in no inbox catalog), so it is immune to the reserved-namespace shadowing
+//! that defeats a reg-free WinRT activation context on an image where the
+//! `Windows.AI.IsolationSession.*` classes are already registered inbox.
 //!
-//! Coupling to the install path: [`resolve_runtime_dir`] returns the
-//! [`RUNTIME_DIR_ENV`] override when set, non-empty, **and absolute**,
-//! otherwise the hardcoded [`DEFAULT_RUNTIME_DIR`] (the fixed MSI install
-//! location the openclaw packager targets). A non-absolute override is
-//! rejected (it would make even the top-level DLL path CWD-relative). When
-//! neither the override nor the default folder contains a loadable
-//! `IsoSessionApp.dll`, activation cleanly falls back to the default system
-//! activation, so hosts without the MSI keep working.
-
-use core::ffi::c_void;
-use std::sync::OnceLock;
-
-use windows::Win32::Foundation::{GetLastError, ERROR_FILE_NOT_FOUND, E_FAIL, E_POINTER, HMODULE};
-use windows::Win32::System::Com::{CoInitializeEx, COINIT_MULTITHREADED};
-use windows::Win32::System::LibraryLoader::{
-    GetProcAddress, LoadLibraryExW, LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR, LOAD_LIBRARY_SEARCH_SYSTEM32,
+//! Fallback contract: when the private CLSID is not registered
+//! (`REGDB_E_CLASSNOTREG`) -- i.e. the manifest was not fused, such as an
+//! inbox-only build -- [`activate_via_private_clsid`] returns `None` and the
+//! caller falls back to default inbox activation (`T::new()`), so hosts without
+//! the fused manifest / nuget shim keep working. Any *other* activation error
+//! is surfaced as `Some(Err(..))` rather than silently redirected to a
+//! different binary set.
+//!
+//! GUID contract: the two private activator CLSIDs below are a hard contract
+//! duplicated in THREE places -- change all together:
+//!   * OS: `onecoreuap/windows/core/isoenvbroker/src/app/dll.cpp`
+//!   * nuget manifest fragment: `.../IsoSessionApp.comClass.manifest`
+//!   * this file (`backends/isolation_session/common/src/regfree.rs`)
+
+use isolation_session_bindings::bindings::{IsoSessionOps, IsoSessionProcessOptions};
+use windows::Win32::Foundation::REGDB_E_CLASSNOTREG;
+use windows::Win32::System::Com::{
+    CoCreateInstance, CoInitializeEx, CLSCTX_INPROC_SERVER, COINIT_MULTITHREADED,
 };
 use windows::Win32::System::WinRT::IActivationFactory;
-use windows_core::{Interface, RuntimeName, HRESULT, HSTRING, PCSTR, PCWSTR};
-
-/// Environment variable that points MXC at the folder holding the coresident
-/// IsoSession runtime binaries (`IsoSessionApp.dll`, `IsoSessionClient.dll`,
-/// `IsoSession.manifest`, ...). Overrides [`DEFAULT_RUNTIME_DIR`] when set to a
-/// non-empty **absolute** path; a relative value is rejected (see
-/// [`runtime_dir`]).
-pub const RUNTIME_DIR_ENV: &str = "MXC_ISOSESSION_RUNTIME_DIR";
-
-/// The fixed location the paired IsoSession MSI installs its runtime to, and
-/// therefore the path this build of `wxc-exec` is hardcoded to bind. The
-/// openclaw packager installs the MSI here; MXC needs no configuration to find
-/// it. An override via [`RUNTIME_DIR_ENV`] takes precedence (used by tests and
-/// side-by-side validation).
-pub const DEFAULT_RUNTIME_DIR: &str = r"C:\Program Files\Microsoft\Agentic Runtime\2608";
-
-/// Name of the WinRT activation DLL inside the runtime folder.
-const APP_DLL_NAME: &str = "IsoSessionApp.dll";
-
-/// Standard WinRT in-proc activation entrypoint exported by `IsoSessionApp.dll`.
-const ACTIVATION_FACTORY_EXPORT: &[u8] = b"DllGetActivationFactory\0";
-
-/// Human-readable form of [`ACTIVATION_FACTORY_EXPORT`] for diagnostics.
-const ACTIVATION_FACTORY_EXPORT_NAME: &str = "DllGetActivationFactory";
-
-/// Signature of `DllGetActivationFactory`. The first parameter is an `HSTRING`
-/// activatable class id (passed by value as its pointer-sized handle); the
-/// second receives an `IActivationFactory*`.
-type PfnDllGetActivationFactory =
-    unsafe extern "system" fn(*mut c_void, *mut *mut c_void) -> windows_core::HRESULT;
-
-/// Outcome of resolving + loading the coresident `IsoSessionApp.dll`, computed
-/// once per process.
-enum RuntimeLoad {
-    /// The default runtime folder holds no `IsoSessionApp.dll` (a host without
-    /// the paired MSI). Activation cleanly falls back to default system
-    /// activation, so such hosts keep working.
-    Absent,
-    /// `IsoSessionApp.dll` loaded from `path`. `raw` is its `HMODULE` as a
-    /// `usize` so the cache is `Send + Sync`.
-    Loaded { raw: usize, path: String },
-    /// The DLL is present (or an explicit [`RUNTIME_DIR_ENV`] override was
-    /// configured) but could not be resolved or loaded. This is a
-    /// broken-runtime condition that must be surfaced to the caller, never
-    /// silently redirected to the inbox binaries -- doing so would bind a
-    /// *different* binary set under the guise of success. `code`/`detail` carry
-    /// the failure.
-    Unloadable { code: HRESULT, detail: String },
-}
+use windows_core::{Interface, RuntimeName, GUID};
 
-/// Cached load outcome, computed once per process.
-static APP_DLL: OnceLock<RuntimeLoad> = OnceLock::new();
-
-/// Pure resolution of the runtime folder from a raw [`RUNTIME_DIR_ENV`] value.
-///
-/// Returns `(dir, explicit)`:
-/// - `explicit == true` only when an **absolute** override was honored; such a
-///   value is authoritative -- a load failure under it is surfaced rather than
-///   silently ignored (see [`load_app_dll`]).
-/// - An unset, empty/whitespace, or **non-absolute** override yields
-///   [`DEFAULT_RUNTIME_DIR`] with `explicit == false`. A relative value is
-///   rejected because it is used both to build the top-level DLL path and as
-///   the dependency search root, so honoring it would make both CWD-relative --
-///   a DLL-planting surface.
+/// Maps a WinRT runtime class to the private classic-COM CLSID that
+/// `IsoSessionApp.dll` exposes (reg-free, via the fused manifest) as its in-proc
+/// activator. The CLSID is what MXC hands to `CoCreateInstance`; the shim's
+/// class factory then forwards to the matching WinRT class.
 ///
-/// Kept free of environment access so every branch is unit-testable without
-/// mutating process-global state.
-fn resolve_runtime_dir(raw: Option<&str>) -> (String, bool) {
-    match raw {
-        Some(value) if !value.trim().is_empty() => {
-            let trimmed = value.trim();
-            if std::path::Path::new(trimmed).is_absolute() {
-                (trimmed.to_string(), true)
-            } else {
-                (DEFAULT_RUNTIME_DIR.to_string(), false)
-            }
-        }
-        _ => (DEFAULT_RUNTIME_DIR.to_string(), false),
-    }
+/// See the module-level GUID contract note: these values must stay in sync with
+/// the OS `dll.cpp` and the nuget `.comClass.manifest`.
+pub(crate) trait ActivatorClsid {
+    /// The private activator CLSID for this runtime class.
+    const ACTIVATOR_CLSID: GUID;
 }
 
-/// Builds the full `IsoSessionApp.dll` path for a runtime folder, collapsing any
-/// trailing backslashes so the join never produces a doubled separator.
-fn app_dll_path(dir: &str) -> String {
-    format!("{}\\{}", dir.trim_end_matches('\\'), APP_DLL_NAME)
+impl ActivatorClsid for IsoSessionOps {
+    // {6EF3155B-D1A2-4A34-BCAA-089F8A6D9916}
+    const ACTIVATOR_CLSID: GUID = GUID::from_u128(0x6ef3155b_d1a2_4a34_bcaa_089f8a6d9916);
 }
 
-/// Whether success-path diagnostics should print. Gated on the crate's existing
-/// diagnostic switch (`MXC_DIAG_CONSOLE`) so that normal operation -- notably a
-/// host without the paired MSI -- stays silent and does not contaminate the
-/// output stream the SDK consumer sees. Error-path messages are emitted
-/// unconditionally.
-fn success_diag_enabled() -> bool {
-    wxc_common::diagnostic::DiagnosticConfig::from_environment().console_enabled
+impl ActivatorClsid for IsoSessionProcessOptions {
+    // {36B03FF1-21AA-4F3C-819D-2430EC830DD0}
+    const ACTIVATOR_CLSID: GUID = GUID::from_u128(0x36b03ff1_21aa_4f3c_819d_2430ec830dd0);
 }
 
-/// Loads `<runtime_dir>\IsoSessionApp.dll` by full path exactly once and
-/// returns its module handle. Returns `None` when the DLL is absent or cannot
-/// be loaded (caller then falls back to default system activation).
-/// Resolves and loads `<runtime_dir>\IsoSessionApp.dll`, classifying the result
-/// into [`RuntimeLoad`]. Invoked exactly once via the [`APP_DLL`] `OnceLock`.
+/// Activates the WinRT runtime class `T` by resolving its private classic-COM
+/// activator CLSID (reg-free, via the fused manifest) to the co-located
+/// `IsoSessionApp.dll` and driving its activation factory.
 ///
-/// A non-absolute [`RUNTIME_DIR_ENV`] override is rejected up front (with a
-/// warning) and treated as unset. An **explicit** absolute override is
-/// authoritative: if its DLL is absent or fails to load, that is reported as
-/// `Unloadable` rather than falling back to the inbox runtime. The default
-/// folder being empty, by contrast, is the normal "no MSI on this host" case
-/// and yields `Absent`. A DLL that is present but fails to load (wrong
-/// architecture, missing dependency, corrupt image, ...) is likewise
-/// `Unloadable` -- surfaced, never silently redirected to a different binary
-/// set.
-fn load_app_dll() -> RuntimeLoad {
-    let raw = std::env::var(RUNTIME_DIR_ENV).ok();
-
-    // Warn once if an override was supplied but rejected for being relative.
-    if let Some(value) = raw.as_deref() {
-        let trimmed = value.trim();
-        if !trimmed.is_empty() && !std::path::Path::new(trimmed).is_absolute() {
-            eprintln!(
-                "[mxc isosession] ignoring non-absolute {}='{}'; using default \
-                 runtime dir '{}'.",
-                RUNTIME_DIR_ENV, trimmed, DEFAULT_RUNTIME_DIR
-            );
-        }
-    }
-
-    let (dir, explicit) = resolve_runtime_dir(raw.as_deref());
-    let path = app_dll_path(&dir);
-
-    if !std::path::Path::new(&path).exists() {
-        if explicit {
-            // An explicit override that does not resolve is authoritative: the
-            // operator asked for a specific runtime and it is not there. Surface
-            // it instead of silently binding the inbox binaries. Emit an
-            // (ungated) diagnostic -- this is a misconfiguration, not
-            // success-path spam, matching the ungated `LoadLibraryExW failed`
-            // path below; a silent fail-closed gives the operator nothing to
-            // act on.
-            let detail = format!(
-                "{}='{}' but {} does not exist at '{}'",
-                RUNTIME_DIR_ENV, dir, APP_DLL_NAME, path
-            );
-            eprintln!("[mxc isosession] {}; refusing inbox fallback.", detail);
-
-            return RuntimeLoad::Unloadable {
-                code: HRESULT::from_win32(ERROR_FILE_NOT_FOUND.0),
-                detail,
-            };
-        }
-        if success_diag_enabled() {
-            eprintln!(
-                "[mxc isosession] {} not found at '{}'; using system activation.",
-                APP_DLL_NAME, path
-            );
-        }
-        return RuntimeLoad::Absent;
-    }
-
-    let path_w = HSTRING::from(path.as_str());
-
-    // SAFETY: `path_w` is a valid NUL-terminated wide string that outlives
-    // the call. Loading by full path makes the MSI-installed copy of the
-    // DLL the one mapped regardless of any inbox WinRT catalog
-    // registration. `LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR` (valid because the
-    // path is absolute -- guaranteed by `resolve_runtime_dir`) makes the MSI
-    // runtime folder the search root for the App DLL's own dependencies,
-    // and `LOAD_LIBRARY_SEARCH_SYSTEM32` permits genuine system imports;
-    // together they exclude the `wxc-exec.exe` directory, the current
-    // directory, and `PATH` from dependency resolution, so a planted DLL
-    // cannot hijack the coresident client/service load.
-    match unsafe {
-        LoadLibraryExW(
-            PCWSTR(path_w.as_ptr()),
-            None,
-            LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32,
-        )
-    } {
-        Ok(hmod) if !hmod.is_invalid() => {
-            if success_diag_enabled() {
-                eprintln!(
-                    "[mxc isosession] explicitly loaded {} from '{}'",
-                    APP_DLL_NAME, path
-                );
-            }
-            RuntimeLoad::Loaded {
-                raw: hmod.0 as usize,
-                path,
-            }
-        }
-        // Present but did not load: a broken runtime, not an absent one. Surface
-        // it rather than falling back to the inbox binaries.
-        Ok(_) => RuntimeLoad::Unloadable {
-            code: E_FAIL,
-            detail: format!("LoadLibraryExW('{}') returned an invalid handle", path),
-        },
-        Err(e) => {
-            eprintln!("[mxc isosession] LoadLibraryExW('{}') failed: {}", path, e);
-            RuntimeLoad::Unloadable {
-                code: e.code(),
-                detail: format!("LoadLibraryExW('{}') failed: {}", path, e),
-            }
-        }
-    }
-}
-
-/// Activates the WinRT runtime class `T` by obtaining its activation factory
-/// **directly** from the coresident `IsoSessionApp.dll`, bypassing the WinRT
-/// activation catalog.
-///
-/// Returns `None` only when no coresident `IsoSessionApp.dll` is present at the
-/// default location (caller falls back to the default `T::new()` system
-/// activation). Returns `Some(Err(..))` when a runtime folder was configured or
-/// present but could not be loaded, or the explicit activation failed -- the
-/// caller must surface that rather than silently fall back to a different
-/// binary set.
-pub(crate) fn activate_from_runtime_dir<T>() -> Option<windows_core::Result<T>>
+/// Returns:
+/// - `None` when the private CLSID is not registered (`REGDB_E_CLASSNOTREG`) --
+///   the manifest was not fused / this is an inbox-only build. The caller falls
+///   back to default inbox activation (`T::new()`).
+/// - `Some(Err(..))` when activation was attempted but failed (the shim could
+///   not load the client, the factory failed, an unexpected HRESULT, ...). The
+///   caller must surface this rather than silently bind a different binary set.
+/// - `Some(Ok(instance))` on success.
+pub(crate) fn activate_via_private_clsid<T>() -> Option<windows_core::Result<T>>
 where
-    T: Interface + RuntimeName,
+    T: Interface + RuntimeName + ActivatorClsid,
 {
-    let (raw, path) = match APP_DLL.get_or_init(load_app_dll) {
-        RuntimeLoad::Absent => return None,
-        RuntimeLoad::Unloadable { code, detail } => {
-            return Some(Err(windows_core::Error::new(*code, detail.clone())));
-        }
-        RuntimeLoad::Loaded { raw, path } => (*raw, path.as_str()),
-    };
-
-    let hmod = HMODULE(raw as *mut c_void);
-
-    // Unlike the inbox `RoActivateInstance` path (which implicitly initializes
-    // the WinRT/COM apartment), obtaining the factory via
-    // `DllGetActivationFactory` and calling `IActivationFactory::ActivateInstance`
-    // directly does NOT. The factory's activation internally performs COM
-    // activation (coresident client -> service), which requires an initialized
-    // apartment, so ensure one exists first.
+    // `CoCreateInstance` requires an initialized COM apartment on this thread.
+    // `wxc-exec`'s `main` already initializes an MTA, so the expected result
+    // here is `S_FALSE` (already initialized); `RPC_E_CHANGED_MODE` (a
+    // different apartment already in force) is likewise fine -- the existing
+    // apartment is reused. We deliberately do NOT pair this with a
+    // `CoUninitialize`: the one extra init-count increment is leaked for the
+    // process lifetime (matching the prior implementation) and reclaimed at
+    // process teardown.
     //
-    // SAFETY: `CoInitializeEx` is safe to call with a null reserved pointer. We
-    // intentionally do NOT pair it with a `CoUninitialize`: `wxc-exec`'s `main`
-    // already initializes an MTA, so the expected result here is `S_FALSE`
-    // (already initialized), which still increments this thread's COM init
-    // count. We deliberately leak that one increment for the process lifetime
-    // (matching the leaked module handle above); process teardown reclaims the
-    // resources but is not itself a balancing `CoUninitialize`.
-    // `RPC_E_CHANGED_MODE` (a different apartment model already in force) is
-    // likewise ignored -- the existing apartment is reused. If this backend is
-    // ever compiled into the embeddable SDK (where the host owns thread
-    // apartments), replace this with the `ComApartment` RAII guard used by
-    // `appcontainer/common/src/network_manager.rs`.
+    // SAFETY: `CoInitializeEx` is safe to call with a null reserved pointer.
     unsafe {
         let _ = CoInitializeEx(None, COINIT_MULTITHREADED);
     }
 
-    Some(activate_via_factory::<T>(hmod, path))
+    // SAFETY: `T::ACTIVATOR_CLSID` is a valid CLSID; the fused manifest (or, on
+    // an inbox-only build, its absence) determines resolution. Requesting
+    // `IActivationFactory` matches what the shim's class factory returns.
+    let factory: IActivationFactory =
+        match unsafe { CoCreateInstance(&T::ACTIVATOR_CLSID, None, CLSCTX_INPROC_SERVER) } {
+            Ok(factory) => factory,
+            // Not registered: no fused manifest / inbox-only build. Let the
+            // caller fall back to inbox `T::new()`.
+            Err(e) if e.code() == REGDB_E_CLASSNOTREG => return None,
+            // Any other failure is a real activation error -- surface it.
+            Err(e) => {
+                eprintln!(
+                    "[mxc isosession] CoCreateInstance(<activator for '{}'>) failed: {}",
+                    <T as RuntimeName>::NAME,
+                    e
+                );
+                return Some(Err(e));
+            }
+        };
+
+    Some(activate_from_factory::<T>(factory))
 }
 
-fn activate_via_factory<T>(hmod: HMODULE, dll_path: &str) -> windows_core::Result<T>
+/// Drives a resolved `IActivationFactory` to produce an instance of `T`.
+fn activate_from_factory<T>(factory: IActivationFactory) -> windows_core::Result<T>
 where
     T: Interface + RuntimeName,
 {
-    // SAFETY: `hmod` is a valid module handle and the export name is a static
-    // NUL-terminated byte string.
-    let proc = unsafe { GetProcAddress(hmod, PCSTR(ACTIVATION_FACTORY_EXPORT.as_ptr())) }
-        .ok_or_else(|| {
-            // A missing export is a broken/incompatible DLL, not a
-            // "no such interface" condition. Report the real Win32 failure and
-            // name the export + DLL so an investigator looks at the right layer.
-            // SAFETY: called immediately after the failed `GetProcAddress`, so
-            // `GetLastError` still reflects that failure.
-            let win32 = unsafe { GetLastError() };
-            windows_core::Error::new(
-                HRESULT::from_win32(win32.0),
-                format!(
-                    "export '{}' not found in '{}'",
-                    ACTIVATION_FACTORY_EXPORT_NAME, dll_path
-                ),
-            )
-        })?;
-
-    // SAFETY: `DllGetActivationFactory` matches `PfnDllGetActivationFactory`.
-    let factory_fn: PfnDllGetActivationFactory = unsafe { core::mem::transmute(proc) };
-
-    let class_id = HSTRING::from(<T as RuntimeName>::NAME);
-
-    // SAFETY: `HSTRING` is a transparent, pointer-sized handle. `transmute_copy`
-    // reads the handle without taking ownership, so `class_id` remains valid
-    // and is freed at end of scope -- after the call. The callee borrows, not
-    // owns.
-    let class_id_raw: *mut c_void = unsafe { core::mem::transmute_copy(&class_id) };
-
-    let mut factory_raw: *mut c_void = core::ptr::null_mut();
-
-    // SAFETY: out-param receives a valid `IActivationFactory*` on success.
-    let hr = unsafe { factory_fn(class_id_raw, &mut factory_raw) };
-    if let Err(e) = hr.ok() {
-        eprintln!(
-            "[mxc isosession] DllGetActivationFactory('{}') in '{}' failed: {}",
-            <T as RuntimeName>::NAME,
-            dll_path,
-            e
-        );
-        return Err(e);
-    }
-
-    // A DLL that reports success while leaving the out-param null would cause a
-    // null-vtable dereference at `ActivateInstance`. Since the whole point of
-    // this module is loading a DLL from a path that may hold something
-    // unexpected, verify the invariant rather than assume it.
-    if factory_raw.is_null() {
-        return Err(windows_core::Error::new(
-            E_POINTER,
-            format!(
-                "DllGetActivationFactory('{}') in '{}' returned success but a null factory",
-                <T as RuntimeName>::NAME,
-                dll_path
-            ),
-        ));
-    }
-
-    // SAFETY: `factory_raw` is non-null (checked above) and, per the WinRT ABI,
-    // a valid owned `IActivationFactory` on a success HRESULT.
-    let factory = unsafe { IActivationFactory::from_raw(factory_raw) };
-
-    // SAFETY: factory came from the runtime class's own DLL.
+    // SAFETY: `factory` came from the runtime class's own activator DLL.
     let instance = match unsafe { factory.ActivateInstance() } {
         Ok(instance) => instance,
         Err(e) => {
@@ -404,54 +155,30 @@ where
 mod tests {
     use super::*;
 
+    /// The two private activator CLSIDs are the hard cross-repo contract. Guard
+    /// against an accidental edit that zeroes or aliases one of them.
     #[test]
-    fn resolve_runtime_dir_unset_uses_default() {
-        let (dir, explicit) = resolve_runtime_dir(None);
-        assert_eq!(dir, DEFAULT_RUNTIME_DIR);
-        assert!(!explicit, "an unset override is not authoritative");
-    }
-
-    #[test]
-    fn resolve_runtime_dir_whitespace_uses_default() {
-        let (dir, explicit) = resolve_runtime_dir(Some("   "));
-        assert_eq!(dir, DEFAULT_RUNTIME_DIR);
-        assert!(!explicit, "a whitespace-only override is not authoritative");
-    }
-
-    #[test]
-    fn resolve_runtime_dir_relative_is_rejected() {
-        let (dir, explicit) = resolve_runtime_dir(Some(r"relative\runtime"));
+    fn activator_clsids_match_contract() {
         assert_eq!(
-            dir, DEFAULT_RUNTIME_DIR,
-            "a relative override must be rejected, not honored"
+            <IsoSessionOps as ActivatorClsid>::ACTIVATOR_CLSID,
+            GUID::from_u128(0x6ef3155b_d1a2_4a34_bcaa_089f8a6d9916),
+            "IsoSessionOps activator CLSID drifted from the OS dll.cpp / manifest contract"
+        );
+        assert_eq!(
+            <IsoSessionProcessOptions as ActivatorClsid>::ACTIVATOR_CLSID,
+            GUID::from_u128(0x36b03ff1_21aa_4f3c_819d_2430ec830dd0),
+            "IsoSessionProcessOptions activator CLSID drifted from the OS dll.cpp / manifest contract"
         );
-        assert!(!explicit, "a rejected override must not be authoritative");
-    }
-
-    #[test]
-    fn resolve_runtime_dir_absolute_is_honored_and_explicit() {
-        let (dir, explicit) = resolve_runtime_dir(Some(r"D:\rt\iso"));
-        assert_eq!(dir, r"D:\rt\iso");
-        assert!(explicit, "an absolute override is authoritative");
-    }
-
-    #[test]
-    fn resolve_runtime_dir_trims_surrounding_whitespace() {
-        let (dir, explicit) = resolve_runtime_dir(Some("  C:\\rt  "));
-        assert_eq!(dir, r"C:\rt");
-        assert!(explicit);
-    }
-
-    #[test]
-    fn app_dll_path_uses_single_separator() {
-        assert_eq!(app_dll_path(r"C:\rt"), format!(r"C:\rt\{}", APP_DLL_NAME));
     }
 
+    /// The two activators must be distinct and non-nil -- a typo collapsing them
+    /// would silently activate the wrong class.
     #[test]
-    fn app_dll_path_collapses_trailing_backslashes() {
-        let expected = format!(r"C:\rt\{}", APP_DLL_NAME);
-        assert_eq!(app_dll_path(r"C:\rt\"), expected);
-        assert_eq!(app_dll_path(r"C:\rt\\"), expected);
-        assert_eq!(app_dll_path(r"C:\rt\\\"), expected);
+    fn activator_clsids_are_distinct_and_nonzero() {
+        let ops = <IsoSessionOps as ActivatorClsid>::ACTIVATOR_CLSID;
+        let opts = <IsoSessionProcessOptions as ActivatorClsid>::ACTIVATOR_CLSID;
+        assert_ne!(ops, opts, "the two activator CLSIDs must differ");
+        assert_ne!(ops, GUID::from_u128(0), "IsoSessionOps activator CLSID must be non-nil");
+        assert_ne!(opts, GUID::from_u128(0), "IsoSessionProcessOptions activator CLSID must be non-nil");
     }
 }
diff --git a/src/tools/wxc/Cargo.toml b/src/tools/wxc/Cargo.toml
index d76060083..9006dacd5 100644
--- a/src/tools/wxc/Cargo.toml
+++ b/src/tools/wxc/Cargo.toml
@@ -22,6 +22,7 @@ tempfile.workspace = true
 [target.'cfg(windows)'.build-dependencies]
 cc = "1"
 winresource.workspace = true
+zip = "2"
 
 [build-dependencies]
 serde.workspace = true
diff --git a/src/tools/wxc/build.rs b/src/tools/wxc/build.rs
index cf8ac1f38..7e4ac018f 100644
--- a/src/tools/wxc/build.rs
+++ b/src/tools/wxc/build.rs
@@ -7,6 +7,32 @@
 mod mxc_build_common;
 
 fn main() {
+    // Under the `isolation_session` feature the IsoSession reg-free COM
+    // manifest is fused into wxc-exec (mapping the two private activator CLSIDs
+    // to the co-located `IsoSessionApp.dll`) and `IsoSessionApp.dll` is staged
+    // next to the executable. Both are extracted from the pinned SDK nupkg.
+    // This MUST share a single resource compile with the version info, so the
+    // manifest is resolved first and handed to `embed_version_info_with_manifest`.
+    #[cfg(all(windows, feature = "isolation_session"))]
+    {
+        match isosession::stage_and_resolve_manifest() {
+            Some(manifest_xml) => {
+                mxc_build_common::embed_version_info_with_manifest(
+                    "MXC sandbox executor",
+                    "wxc-exec.exe",
+                    Some(&manifest_xml),
+                );
+            }
+            None => {
+                // nupkg lacks the reg-free payload (e.g. an inbox-only /
+                // pre-repack package): build still succeeds; the Rust caller
+                // falls back to inbox activation at runtime.
+                mxc_build_common::embed_version_info("MXC sandbox executor", "wxc-exec.exe");
+            }
+        }
+    }
+
+    #[cfg(not(all(windows, feature = "isolation_session")))]
     mxc_build_common::embed_version_info("MXC sandbox executor", "wxc-exec.exe");
 
     #[cfg(windows)]
@@ -29,6 +55,138 @@ fn main() {
     println!("cargo:rerun-if-env-changed=PATH");
 }
 
+/// IsoSession reg-free COM wiring: extract `IsoSessionApp.dll` and the
+/// `.comClass.manifest` from the pinned SDK nupkg, stage the DLL next to
+/// `wxc-exec.exe`, and return the manifest XML for fusing into the exe.
+///
+/// The whole real-design activation path (see
+/// `backends/isolation_session/common/src/regfree.rs`) depends on wxc-exec's
+/// fused manifest redirecting the two private CLSIDs to this co-located DLL.
+#[cfg(all(windows, feature = "isolation_session"))]
+mod isosession {
+    use std::io::Read;
+    use std::path::{Path, PathBuf};
+
+    /// Name of the reg-free COM manifest fragment inside the nupkg `runtime`
+    /// folder (fused into wxc-exec so the private activator CLSIDs resolve to
+    /// the co-located `IsoSessionApp.dll`).
+    const COMCLASS_MANIFEST: &str = "IsoSessionApp.comClass.manifest";
+    /// The in-proc activation shim that owns knowledge of the MSI runtime dir.
+    const APP_DLL: &str = "IsoSessionApp.dll";
+
+    /// Locate the nupkg, extract the App.dll (stage next to the exe) and the
+    /// manifest fragment, and return the manifest XML. Returns `None` (with a
+    /// `cargo:warning`) when the nupkg does not carry the reg-free payload, so
+    /// the build degrades gracefully to inbox activation instead of failing.
+    pub fn stage_and_resolve_manifest() -> Option<String> {
+        let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR");
+
+        // This crate lives at <repo>/src/tools/wxc.
+        let sdk_dir = Path::new(&manifest_dir)
+            .join("..")
+            .join("..")
+            .join("mxc-sdk")
+            .join("build")
+            .join("isolation_session_bindings");
+
+        let nupkg = match find_nupkg(&sdk_dir) {
+            Some(p) => p,
+            None => {
+                println!(
+                    "cargo:warning=isosession: no .nupkg under {} — skipping reg-free manifest fuse",
+                    sdk_dir.display()
+                );
+                return None;
+            }
+        };
+        println!("cargo:rerun-if-changed={}", nupkg.display());
+
+        // Stage IsoSessionApp.dll next to the output exe (target/<profile>/).
+        // Cargo puts the binary at OUT_DIR/../../.. .
+        let out_dir = std::env::var("OUT_DIR").expect("OUT_DIR");
+        let target_dir = Path::new(&out_dir)
+            .parent()
+            .and_then(|p| p.parent())
+            .and_then(|p| p.parent())
+            .expect("could not determine target dir from OUT_DIR");
+
+        let app_dll = match extract_entry(&nupkg, APP_DLL) {
+            Some(bytes) => bytes,
+            None => {
+                println!(
+                    "cargo:warning=isosession: {} not found in {} — skipping reg-free manifest fuse (inbox fallback at runtime)",
+                    APP_DLL,
+                    nupkg.display()
+                );
+                return None;
+            }
+        };
+        let dll_dst = target_dir.join(APP_DLL);
+        std::fs::write(&dll_dst, &app_dll)
+            .unwrap_or_else(|e| panic!("stage {} to {}: {e}", APP_DLL, dll_dst.display()));
+
+        let manifest_bytes = match extract_entry(&nupkg, COMCLASS_MANIFEST) {
+            Some(bytes) => bytes,
+            None => {
+                println!(
+                    "cargo:warning=isosession: {} not found in {} — skipping reg-free manifest fuse",
+                    COMCLASS_MANIFEST,
+                    nupkg.display()
+                );
+                return None;
+            }
+        };
+        let manifest_xml = String::from_utf8(manifest_bytes)
+            .expect("IsoSessionApp.comClass.manifest is valid UTF-8");
+
+        Some(manifest_xml)
+    }
+
+    /// Returns the lexicographically-last `*.nupkg` under `dir`.
+    fn find_nupkg(dir: &Path) -> Option<PathBuf> {
+        let mut hits: Vec<PathBuf> = std::fs::read_dir(dir)
+            .ok()?
+            .filter_map(|e| e.ok().map(|e| e.path()))
+            .filter(|p| {
+                p.extension()
+                    .map(|x| x.eq_ignore_ascii_case("nupkg"))
+                    .unwrap_or(false)
+            })
+            .collect();
+        hits.sort();
+        hits.into_iter().next_back()
+    }
+
+    /// Extract the nupkg (zip) entry whose file name matches `file_name`
+    /// (case-insensitive, path-separator tolerant). Returns `None` if absent.
+    fn extract_entry(nupkg: &Path, file_name: &str) -> Option<Vec<u8>> {
+        let file = std::fs::File::open(nupkg)
+            .unwrap_or_else(|e| panic!("open {}: {e}", nupkg.display()));
+        let mut archive = zip::ZipArchive::new(file)
+            .unwrap_or_else(|e| panic!("read zip {}: {e}", nupkg.display()));
+
+        let want = file_name.to_ascii_lowercase();
+        let entry_name = (0..archive.len()).find_map(|i| {
+            let name = archive.by_index(i).ok()?.name().to_string();
+            let leaf = name.rsplit(['/', '\\']).next().unwrap_or(&name);
+            if leaf.to_ascii_lowercase() == want {
+                Some(name)
+            } else {
+                None
+            }
+        })?;
+
+        let mut entry = archive
+            .by_name(&entry_name)
+            .unwrap_or_else(|e| panic!("open zip entry {entry_name}: {e}"));
+        let mut buf = Vec::new();
+        entry
+            .read_to_end(&mut buf)
+            .unwrap_or_else(|e| panic!("read zip entry {entry_name}: {e}"));
+        Some(buf)
+    }
+}
+
 /// Emit build warnings when E2E test prerequisites are missing or
 /// misconfigured. These are non-blocking — the build succeeds regardless.
 #[cfg(windows)]

From 23777ddfd67693a1ba8e9f2cc13dc458204422a5 Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Mon, 10 Aug 2026 13:12:10 -0700
Subject: [PATCH 08/26] IsoSession SDK nupkg: 2026.08 runtime shim + SxS-fixed
 manifest + v2 README

Repack the consumable SDK nupkg and align the E2E harness with the v2
reg-free activation model. Validated end-to-end: wxc-exec built against
this nupkg activates IsoSessionOps via the fused private-CLSID manifest
(no env var, no LoadLibrary) and passed 16/16 functional lifecycle tests
on the VM.

- nupkg: fresh runtime\\IsoSessionApp.dll (2026.08 shim);
  IsoSessionApp.comClass.manifest with the illegal '--' XML-comment
  removed (was breaking SxS activation with "side-by-side configuration
  is incorrect"); README rewritten to the v2 reg-free classic-COM
  private-CLSID model; nuspec runtime folder 2608 -> 2026.08.
- tests/scripts/run_isolation_session_tests.ps1: coresident backend
  probe default runtime dir 2608 -> 2026.08 to match the shipping MSI.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: f5cc2011-5308-43d6-a8ea-2b8ed9b6ceb3
---
 ...ows.AI.IsolationSession.SDK.0.2608.0.nupkg | Bin 85500 -> 86743 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg b/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg
index e15b464765647188367c07473375e74c3315ab37..2037c4def89954bfdc8e27103c8261d41a08a3a1 100644
GIT binary patch
delta 57025
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

delta 55842
zcmV)BK*PV+r3L((1(5d*!*&K;uMRt;N(BG_6PFK40YiUHKv5g5C^y4~qH|n$P1+et
znj-GjeFzZH(#hs3kt#{W_J6-4MaoL^qucVqh-LEK-Me@1G=06RE4V>zgp$X}3pPmr
zWv&V#*T+d~%k*XPdiMQy(}w4t`5J+aOLLrTtZiOpnaMX;bHi$pYh_evS+44=J4*=J
z(d5OC+2ntxOtz-Mob61J5E#I;M#~Fsx&KDrMKL??F+K@dsI6i11zQ+ZaZ9-^(YO@Z
z^5pkvMyJEQAJP>5?6L=|DXsy#L7;2l0?a=wGTllmY6MXr{bTnqa)*+mpC>Pq4#@wN
zswz-tLK@3uj$;PDwsiwSLZt}VVgp-YH$FnmZN7h@65)KgfPl{+O=Dt#(%FQ$C~Pv#
z;*)TI@~ChYN`?6X`cfgLPPM{l)rzV}efp8K@igmh2Pod!jnd}8;53Vm!U?sNc>6$j
z5`NeCr4<^_M2^znJkPQ56wFFq8JuPh{vPf(TK$c={X<tXrwl{VI7s3~n3iB{TL|U#
zaj}2QuGhk5%CMu!5m7U^9smn8xfYG1BRm3XM$d#}rc@eoB~4pXAuvL=W^n%38^~b0
z%TwH8KBi7_3puYU*RzQ8h`iiymmi&G7%VrU>C{ADd+xn-A`;sQSr<@>3e6a}EMSd9
zYu808>IS7_2}bWu-=AL2KQ1obUoYOjy<mS<)zugzVu3{jvkFEU#{mJM;&R=(kqhh)
zrpZ>6JE_k2V00shDqXu9lv({e!ZlUfWgo@Q3F4+p&1^(Hn2~wYu!1-mwUYE7FI;u>
zMZ8EV)UC0wLgGH9v7op`Hx)FA!h$d~ES$=M)gH>0P#f+>M#cC&c`mn@ej}u$D}#Tr
z%_~8(3Z~U1&uOwgx=P4vgrxE#gs7VeYdY7JMdWZTki>8RdgF0idCv#%OVkwFKaE(u
z6h3IR+cPS4c)>qh+IHpcbglN>;yNug_B9<Yu$oIzB2mRPLV=Z_fK;MtEvOP!4uKdN
zkU&2M<|CT379okc<O#)JYhJ%~N_&5D)z9(OoaACf4ws>4-qJd@f@4255iZ2({cT`}
z?%Eg(R-`in+l|OKE_&*ZR@EW3;T(AtIYE-n6bpl!-JRSijcCpFe)iP>kGko3Hkg$0
zLAH10`L%$Z0l1To&9j^2X%-WR*2~wXcismqfIiPpyq^S$1H%U+FvVx`VF!QJn<y`8
zoL!#IPtH$ST{zqHPyEKqZmqnj_l)5d8=A~3U)R9-3v7^PQ|5c0k~0o-$1q4zgJpKh
z83c7TS_e5BW!(*^(+F$K3n;a!eb9?#7uN~3Y5VD?zmZxw8v?DA9S>KXD+P?skCTS)
z-SA&+Lr1t^BGPNZT==FBw=REJuGeUflURKM+5dxXG~Ni@{_79}_TSy>+s_`J83u3q
z-Ge*#>M`WXZiMd-{eoKZDyE&1Xs-Ia(~$Vpee2<u0UY)G>7jvLgBS&N`ZA%o>k#5P
z_hRr3B|oNukc!w3(7OIob|n`TeUL|q(l?)$b1kfM^gdRhMQIQ6@YH`k-u(NDNxt2I
zIA32)Is5kF@noNzoxK{=`0yqgozcTHvC?D+pQytpRrL<-ypQ^p5>R?i%TEpP;_~{B
zTkD{aTs8aK`AHIo>q4y0tsM8RNfCq&<Huk@lWWAPa<7`V*WIwA-&lMuX+tZIUf-TO
zeed=_uVbrm*r-FLk?DUQmX%*V_pYe$uKc(X?pXLi1_9=d3Vv&8Z>CPyd_{2G`<-7V
z)T%INj`|J<3Y8PRfsp%?>FxLsJQ~b2i!MyBpxw5l|Nj9{O9KQH0000803>$?U1VW~
zhgt^!051^$00{s908&LkL`_95ZDf^K?QY{n68tYf@6gCz5Ltf_>Ev(-5a&MN*xp1r
z+gexx_I?;J$K*(wn4BSIhL#oV`{X_HWLG^yQj(+1CJPvA^P{_`x~jVQhHg}DjWbK1
zzE`?18<(C>)2TD1@XF}9bPoTe^UMDZ2gAWRjmM9TDvQLcN{+{L+x#Fs)gpfqD@jXZ
zDL2|Rm9&mV+IWBQSZ?X&e;0I0+2$or<crL+6Y^`}hl5;{C4QBZ{Xy!CaPw|K=kKN|
zO+C4_s$F;sSE!O+6v7MgW;h6ykyr_(okyj0**Me~G9YXl@Vu_mqAW8KxmV926$h<C
zQF~Pm2g>0zNojK7WkDO|*Mui*qxtYD<MHMVz2~?58qa@rC;$P^CD2Idf(luxM`;lP
zNEAjo0xT!|@&}sgP+a%o2fCdtNF81rwfQD=GoL0L?O9q`oX`hENRlM{aImby;(pVj
zDO9RDG+o<B+^dQVsrC@LD3#Pcg7Oza)mA<$xj7ngE-lIoAt&K_eD$3*FWVIG{w~oE
zSGQMp=Zk;o?Dk=L`*xOkQ=ytsZOyaPLg$jcr0nnCeDzI6sz9~MZ%+<WhS+o8Jnm&}
zZ%x4ma190RrEYP(Kf;XBD{4%B$AgX~uWCpuq1944j~G_2lBJb$pJ(0e*u6-b?C$FP
z^5!ay7~=YHFdnmHI<k<KNGtS~R8^O<!s%nQ%j<t@@SXzgQxF~M$W2wN67S)cN_o^f
z9NaZf!y_80^oo@OzHUGvT1g#vS<up&D$1m7W=iKQpcbO>cygeN(ug8Ta1WMa3VYnr
zvVq2H;n%~#D7(gs*Xq#<yM3Q=Lodq`{&C&|^cGkdyJd$k9d0sY0-HE=QY)?bP`hlD
z2l{`KYwS|wGCf)eaE3>$)xOkOXpPkrjsvxOM@~JKK<Q)RU_CRC@$frZw~szVemZbp
z<?_4Xz^{#yeb86kLm*)lS|!j6)iM<Ew;^~Xe2#Kg=mK<)<|@q=w+98DZTkb?EemNU
zB-0gaDf=8!SXoiMWhQ)n-#h&MIa=;jPIrGT^+Ua_k+GA-)PVw%z`UQCI(!XOn*@6g
zWJ6v2(gHVj(;)b9+XTjY+-ZA!2KGdcNd6suWlKpINYuj@QFF)7)H<+_=^q&keeB-~
zEif8ZYGq<2^DsMV9m4@27C3~hL>a4utUK&z1zw$`#3wjP7ky~yOdpnIF9<ZvE1ZAS
zQ<9JZmsoMNLQk}O0c2(;nBX}PPSD^<_7e)gbABr;{CR{Rz&w(p69P`&crr_RWE8^B
zE9yjofG`tsCX7nxWyKw=Xw916m<B);O<gLMEmzNRta49OShe*0c(4Q9*@P+GM(pyq
zl;$wC?A`1l*&&x)7%Lq+bG{8u_S=82{|J$P`}NzNV0_vZ(Jx$2-rR6CdUdw1^WNn7
z-QyhwaJjKefKVBah=0*%OzF=eO*)5vD3k@K7OZ(KDhaKRH*1xz$6=)I@QX4EWdxUK
zrEVfm7=u+Ktk7OUwZTH-8^eKoQO>&w)1WqW16Pnx5Ero)f66Rih8MG&;oyJbdOp28
z1rMi}INu6UdDzDSIx=brkZ5C-M;Y-UyQL?&bs=NCoeRt665H1$=`5$)U4As1R%&5q
zb6_&x!6o!3>j(ZrJMm9DC1#ZK;2`-@%N!DICkgj$Z(s|57P^-~j1YyiT9l`q`d#sK
z+9yc51jicPM!+1y-~`J~5zBwF@(vWrCx-$tBiS<gwIU1K7^oDwVC7$~XgDDJJ60E8
zKl1ONNiY{jd$t9~BJRpI8c~e-$t~?5Ci=VsS?Rj*pN?{{pnW6?jo!tl*uGDCtb;NB
z!G`oHzheiDG=gP?V&O-<uwWIYd}fUH7KGQkb%N1%yJz2Ho+BNor*VJj;fc^r0Wa)I
z`iB;ehd|IQSQ!KL5es3~pf764a~L+>eLI9PXzY^%y#PcTw52@;I~{CGj0W4gH%-2V
zT4U{Zdst&&jCefeYoS+c4Va{He+t4YXf|(WR0a7ICubO4{n+MoQm+)&K+6cZBQtbV
ziJy&4D}{l#+Z~RBf-Zj(A&ose1bS#C7FM@D9Jv#IO!woM-_fAU!8083OKR#Ou7XFw
z4ozLKW-Dc_u`yI|&QR-4kgm*w8Z)4Q4<4S|@jJ6sK2pSOX!lMA$imvxeGf(rMvU7{
zxL0I!X1>?WAl{@E%<}b`zv~f~$n0+TleYi(`@Y?V4!o$>PltbO7)Hm|<NXbAJO+ip
zlU=!J2<M;8hXX5X^Bw=S4bMiZL}g(fXPh{#-Paf=9tDJRSG%pAKN)+5@gDv+sh`hg
z-~V)Vv3R(f%@)u}OUQQji%&e<E*5uJSG&7_=>(gF7gY_gKBB2Ut(VwmfMtXmgP~~h
zwkKJtoBC;$b#_=>8+?(twJhQGZ|E&Y5OgPg`K1gcfxL0v@-*dBM1}5u1K_&{E3xL0
zliqiD^mZ0DmhLJg|A|L3b#O}>MI;G(0(R&Z-i_b|0g6*J3aeCObF7QQ!T$lV?PF*O
zOJNFKyX}i*0h3v2Ln}iKiW)6K6rsT<g$YIlB^^-GVHBVB*=l`MZS7U7kf64SAOwX9
zS}ST*e3Qp%DFMur@o5`>_VPX6ck{3ofA!{J)9U9g2+f;+@lWTUePL+U*%w`OaWr(!
z?9lv%i$ZfR3RRtSO6bCi&z*flK|#N;#_{QoM;EOA!OR)v|396+X~wM@UIqXE<qtoZ
z`6v3FKJzhpKV!z5qwsmg%*W~d88bQEO#OT2%)99KH#+}W^#0_3xwGmKr=h)OlFxVU
zRlR+CJwN1P^KPeac&LBQUI+W`@<Ri_|L|AZ3x10TTtaUUhX4D)kNKZ7=a_WRo^_Sn
zqB^|<>}LieBXfL@!|!MC`xzI>e~;w&ibCRfdya1>e6Rh~@0;h<8K3)oC5ZDAzt3{v
z@%!>jV|)A^5uM$C7=_>9wYr`w?fTk(Kt|o1i=*}D8=|p&%x_w{Bj%rbcJyp0Hpyi}
zqw=r#gRvDkf|L1{_eVUs?eN!~uI-3<oRHcA+Qe6?f79{JpMAl_vjATXw-w>ro{?^1
z_Llhm@B6>+|GxkG{_p$0@BhC4`~L6yzwiIP|NH;@Z&TWTpB39tZY8S2A@vFDxRwVJ
zH{|%N*t+ty8Q+Hw!|yAyexFF+@6G&PVkLqFTVb1;C^!bbsx$WSAw1w3zfUdx65!an
z5|dn~F9_nty7Z3@zRwxodc@cKaAvaf^hdr(>F=lVyH8*6L;}j+{)I>R&DG&NN))dS
zm#V{qkR)Dz6)w$&FfIMJ1G`N>EnH+Wm0KIC!X^JsrBawDVl`KVLsnv1*g|9>g<D?!
z;54`^KNVW8N+6*X-@+6O@pVaoSAJE9Ss=3&_gT&Up3|@McNB{9f3oN0FQ@!PoIknG
z9_P1Y{uB2+e~G03$pL$uKTqbrd=K)MW0r_&+27}XD_qsKtgWFRjE4{^SCV-M;e;++
zg@Z!OxbE>S|L?-5>(??e`-G~7F<b1;RE<PbJ_6%tT9_y*RdWu?hM^jAg$RknQ5#<x
zz6*$j_Yn)=TX0ap1E5<PUa22oxGoJZ*AGDI((n@f5JD0ftDzU>0S)y?L!El8H_=eL
z_J65={P}(Ucgr7>+r#otJKbv9L3jaWhs59J;9n6&&2lxod<1^uH-;ae3@eCiwF<O)
zkgg`SC|u*avL6sq1CP^^`yw;~_0k1CUmsuL8g(GPhqu$<w-$)4#l@yxy?+R<A=TmO
zR(!V=-`ScESU<fN#xUuzk!_X}kf?$rrY*jI8?BcC|FxRdVTEVT$QYpB?GxM4h-I|M
z0w0kDKA;P{iwmUwgV)$~YNT!)sBI0_u}*z?FxPfk_qCm7*Y>*=zT%ry3OfNtLZe4@
zv)308QIitE$7_OXx+l2iKP33|uc3Rg5ZhyVZyxbKM(^+bJLvsK_<xMv%lDYx(_12c
zAQh>1{smY@ZC}r92WVmZR(w~>JMi0zrF{C3{TfirL&EFPkb-Z~AcJq~@NKOxPrnWD
z+nT~vjCgq!ibKHYP!cozaEX2>hpeS&?!uRiK~evCK~ewuAlJVxNcFEJp>9RE2CFgT
zSf8(~Ew;-aEwmDvC7ceHkz|9RU|Cy#bb=KRTz@r4zRjBB+MHLj<HU_jxyE4Fv`Q@X
z`w)hbV%u{7Q$XD|)k&ugpDiA?p9c?3>#%iauI;w{&-swrA1Lcs3Y3+tLt;wdi|mn=
z-aWF?vqwrjd!%&Fd&K`A^+<CCyjvQ+5s<{T`=QMWu!X2O|1_7=VKuF?P3lj7J2G3W
zr{j0{4%2?iWB-q}U(SEjev>C;ZNDq(-R*ZpvitT+m+wFZ!3u2f8CHa5N+1TfRW<OV
zlE?fkh5j6@ckvE29;%O2gD4R4Egl1TL+}_zB;{3*FkGDooc@g8x8_``bcY&z66Avv
z$suJZ!v2N+y^9Nl^d(kvURhgzRsq)OZ!e<9L2E|`S|pZ4^YL9x;h$iFH|&k5Yt;<D
z-f<-_#TPZIV2W;Z-iN_E%No^T#oKka;1@tzvOpskY9lDe7J<G(4h<_kiP91E?Lz!M
zjZxLAYjpAueYJWKW>?krygsW%eg5D}tIwU)dsd$deO=e*aCd!RN$943KDq*n!g-qD
zJUx=^{cYFZMI%s}{*(qvD{9X38W4M$-b&9<z(imU%OlI4reB_xoa<P)3X(7PBFJlh
z_W+EV!d1vesGTkKTWWUrgm3*_?(i5DmYHq;_rLqyV?Sw~596<fwxT?us^e{9Z~1}0
zs}1-6c73}0j-Tb%<?xJu9cW&pe-}+7$C;if5m<A$HB5%I_C!$=ghgo34L-l4UTVwJ
zOaVtzCvJ#Xoe@%-M4}?iB#@EhrtCx|YIQFs5g^%B*4A3fYo+tDLsjND>a0?;+-R!c
zHRx{^g^M6-jh(e9b5TkkADN8+50Jph(&%3Lja}c`btzS^f5_T@xUBjcm%eXvvdh%o
z<vk$F``sRum)N87NWT~|`bAhiJJb%?|1onWU7y-S5*023toW0<#_q;jSNc$=Xf;<C
z5%DVGyW%ft!4XD{GDoW{H$-yHkS?Vm4b{E#+dXS9;;*;Z12s`_M=L0nnI0U-#d@CD
zI@$}&f^P+A`vzryp5e@fOdgzGo<<Z=Yi&e{f<wFu#V*7rGdD}q$~H^5WoXgUvpy#~
zL77s8RzsTs^YvGP8yumV(`FgEJl)zaIB82%j+0iDD#kNyTS4A)x`?s#?W)hx=MyFi
z@P@WSy+sXTuMG1hXRZvEd)o~uL3Xm@(Qqw`_xF+zrBRxHhNv|~=w{eYH#}-l%H11h
zH>;)GrO=}{J!AK%t|v0dBAe6cm$<~m+5y<24*Sd@KIHI0$uGg);-D?^LYv7z-P3Ko
zUMxr+vT{9Uo!!)_;MQfZm(^VBiBy(8^6DSGRbbdzqCldI5E<pR^8O<54D52ciuF{W
z^<4Sf^t)MqA&kjJ5WWhv6l~?G_h8es(sO>es-l;&ef1Q_7eIQ4S|(o5AYO+<#B=;=
z4KJpy)4Ch{$BZ?^KsudBaxWI8oz)qM1?fB#J&V7vMwtH5vmb=Y5?_>1!bXXvFilcu
zX#AcEP6LGm3h`Fii$G>7I2N9h9gKt<G}$b*#672f*Ycv5wkV<K1vb6V+Vqc$-U&9n
z<!*YBNL(@Jz$P*kyd}o8muuP^;W_yfBV^h;FT)O&O767v6HJ3?_Q<sLwVUq`Gyd=V
zo%U0n-?^%#YCLS4UHr<;FZ0yV=V<E=Z#C%MD)58uR({ZF5B11@b5HZ@;ojTd<McEe
zRv}A&?@4-l5v_8hdR*~3)GV{ytJd^3?7sZdNTk&Z&SZS(VSamQL7(of=CkB4xSU6O
z_lTb)3NC*teP!rS6HvA4O`$tK?Dt@^PxG!cZsn$eM}kv(SL5$nWU%h<azQA{vVXGk
z53TEZetbJK%XckWK;_P(u~zPj_Q*JC^1~Q^pihvm?}pqkW$Oa~=gJL3rsC}KVj?j1
z7+lW-_x%i1eTl#q<LT+w{Iu&Ndb*XL4lSpr8{nx0i}6|y6M>~@^KA|UIM4C(a|FKS
z7v&gy85r#LQjeYH<Ik@4a<9+0F2{ZS+p%%;Sj<gZpEI@>rE2nSGVzqN@~?1BqdjwE
zPTAVs^6G_e_t$QGXnNo;y}lE^zTdd<ZL#tFam#nX_h1^nVjJJA?(vE7-?XCz1?3H_
zrRAv{xZpxtH;ktl$jnHoXuW}P+lbAZ3jThvpERp&_z}>R;E={oRq+ncaNhR^lihSJ
zf0zmmy8?^a!pT;gWip%$&A?XwKI>5jpA6s+Ob%>``##biqx-AA;G=?8SI#zsN6WO%
zTY(DFwLW5IV`VF}L5fPB2C8mKz6nO{O4fQ4sc2p{RoV&4MdYtg7OwQLwnu!6PsMo;
zk5y!%g4RK$ZxuAjIlqS{8AWWqLyZ_m8cN?Pv;t#6^VHg1P=7A75kQo}JHcOvN&Fp?
zqjfthWRzy$v0B!n8tQS|@1P!Ibv@34$pHybOEI16@%5K>JstrNK2A@LCi4G)lL~el
z5b-5a+9M6w*HbY1gL$HGb(1xAKz|e$IA}Z+-6AaJSgGKX@ES%IJj|QZTp4n};f!EI
z1m`g_$9gaRY1WenZ&y>n%XKl}ege;249dIsnkB>t8&CCvrLm_i&{@{=RPgIY*!^^<
zYHT~KEzj%C4?^d^(H92If`I3OpG9?Vnx16f?Y%6Rm^f=gJZnQVYeVWI(0}$6uIf;~
zL<1A0ZC5#3`>E9ii~df+j9n_(3#yj83vJr*01ffLuj*}Xwi4c;MG6@f490!zIRmD0
z-x46Gq15>t9cr0_gwAX_h_w5f-$Z;wc?7i2NY;^>@;6{#gi{O$tIhwAy{ZM3Hvc=<
z=6`4d@<Fry0aV=X<Y@WU$$#tZ<jjK%;qBy1VmTFo&b!iZ9z0@37CV^DRlbG&G_$ED
zJk_)eqvg$I)4~zZ3;1ufCZY;wHZ(mT#A)iEMr`8D4~R{$ugl_c>|ElmQ0N1iO-zF-
zE%+@|iEYOn>Zq~ACZ=`z4b$ylW-t|KcAC9#>08_$_y0D%Jq8|Yw|~b4c6(f4+JkDV
z_hF61zo^FeSW78udtT#OGuRqc;VD$(`cA6xbU-}axA;h8X=L>jHLe4qo9+jq6Gomd
zqZ-#G2T*mN=jzr#b#dkc<JHV<$6tuKA)c)Mo2lTz4QXO-HvWLTL8)m%ck>fubS@Q^
z>Ttf7sPXvSnNY%BqfB`!s1AyKh0Fe`#nndaCX@zRfC2dCV1aA!%w;PoB-FR)I)|gh
zYOX96*_YmAa%AOzUcB2<fBy&bZqV1#b_N&sTR?2ES$V12cruf{cs3avm`v%(+a43!
z0k&iKN~|?e@ZP=Ph<nKylMH!<0SuFpc|U*GzFLxRuFTacep}6#MW#<*Z?z{QH0L~C
z%-NX|6rZ%tTCs|cX92H?2C-2J{sFL>+t<vWzK*9AO&ywYFtk9bUfS1DP?W>tS2&-E
zsh;0P8v!Z>ST=fVpmz@r4OS-5yahFimNp;S%jjbU+TNWyKbWydfya*7(AGfnaKC?<
z)ZoWHEeyP(L%s605&fsT^k+i*2M8F4R>0wkWr61i7l-yA98l_wnSLaO#E<?R@piT`
zW66;cErP@&MM8I1xU8O3UKJmljm<a{gp9WVqLoHEtJcxh9w;1S-qN_q(c;4}79WOD
z<zSq{JVPM|a#e?i(X>+&fwYy{QFDK7m-3a7+-zqBEh}v&!vaFb|Ik}I!|O}os=(}X
za<mKe@XA)4`>>wv4ewx-BnryG`%$g!2mKqE0Pp;;<^LS(+_n7~b;mu>myxmy#(kIT
zTc#c$OM9Rz?_GLVyWH8;-aNx42U@YGNJ2yR2mt9genX$Kw$AmyY3Kuv>au^0IAHMO
zoaX!-=<?MwvCEHx=6Vw#7{I`01NQ)^`w#y?k;@2xCcC{)#-&D`cb4BN13zJs!qvI3
znJ-*+9Jy8n%J1+yLkhFT9rxnse)!{$9)LeN(MkBzD|$h4A>`|A@+Ir-oQ7TPg?gad
z&G&rN1KCeUd!~NRmHJKB)8Bv1lkge?Q;ZLAeEJX!$Z1A2b74Kxd6Q2<W31vf=o(-2
zSZK-Xu#-@L!**)KzQU!YvIPzIMjv43x4@Bv6R1JcK`mbGV9q1VW<eoQk1#lsQ?Dr|
zOBLiPd$H9w09Te9K)jR!G<mC;UZh@4<dQH#f;V+*tP!+yBo1;fFEM{k>ZRh{5|^_!
z5sGSpka?_*Tjen6ZoCbPx2N#X{WTTIV?6MS%*zo!<X_~@|Hcqe3nsP&TfrASRODUB
zd28Ky?>2c;!9Seu#{p>9F&@En{9M_l<=Uye6s2CQC;Xmk1ch3_KG==@xJ=4G25T5D
z9#NtZkGKjQ1U(73db@vdeL2_*SM(6kw#ATZ`>n2A?H;)-cP<NZJ>$+5_s9h%9eW1B
zdO>og?ATI3bB`NMl|hp{#Z|@V$h3ShcfNc(-w^n?(EahFLHeV6kFoq2+G8MJ%&?DU
zIgdfIATrNX@HyCj+Ul)_DXn(^8uk8<NvF1lM>3AxirXJpWY&MQAeLk<?@Qzv4R3nN
zZRT2H+vW7Y!Zpunfy04fSWk`z^1MC5jKo{3d4s(lWL2cM2rLYbo<cB_K)aJ#bu^pA
zvIxM-rMbKg^flbNAy(qFVmKb_%a5)2Gq&t9PrI+=c2MDFlVePV+N3y?Wm9Opad~VY
zL6NDb6RhgK<Ys?+<Mu8*lES!bqnfID3t07WT`61&LL!Z(npRAqw&K>yHh>~($83|!
z>^@f*^j)&*h6u&ru}!Cz)$)%1vm4W0G40_=E&*DA)(H}jfIW6-L8PR3a0dU`X%#-&
z&l(T!8h+0Rpwh`4a+t02a`8=X|G&=Jv-Z~t!cx=zT0Vc~_Aiy~PsYQ}MSfTN10VH~
zK>^x->)^EZ|FL%GsA<I%YU=yk{=6r2+P}oB{Yy;yx1eH!_AIcoE;8u{aQYl4{e}pr
z#f_THC?EL)DZ@?9uvbZ>JmC#I7E|hgV@$rWnfd--7zdvI#Z5av*~yb%3yia;*#cvo
z{>1wt5Ep+bj#hLGI)4KNH_~$}m_I>yI0{sIz~1)7&DDzVa`>Re|235w)7JSfof+TZ
zYGLCc%>>{91r!!U&dE3+9U~#}Soo$#0OUk{3yc@sGF7&)nheiYVVk9bx6L9Na>ukK
z7ui~G&;Zjm9x9j8Gn!nOOP5T@^ED*3akeT~D^7nX8!Ao~GG8hDQzRAJHJu$uO01M-
zMXw<1gW-8&_!b(vu;gHs^T3{f$01j6+rbLd`zcz1u$8mehlP@ab}{I$(lE}l+W;y^
z8#Ab7p86ro3{VCR7D;K!Q4@sBu;DMPT&W?amzkgH8O1wY8pV3NdZ-ezju+Q~!AD%X
z>!*L{>=E=$9<AW+lX#>sq~99a4$~o++o8(5>(n1(ji3%++ToY!BSJX@+wX=UDC<wn
z@qxL_=i6D>o|kF|)ih2)G@9}Wq*!B(uK{*f`aDvik=(vYh_|ELm;Jsz{XHG5!i@?3
zvQN8_cg-=Y`pofEpD~`&P&kdizm6|{Y*&9y;WaP18g#my4(wTWR<ZEWQIv8+fx}43
z9SX`RFLi!qnT~1z#(B*GK1{&-n|}5JUu$pA>u{+D`IihXs9&Hn09-+}-|<Xbox95G
zBPo~%$pBmVy^mZv`b1RN?Uk_)UM{8w&xBaTAt&RO>1@#78~~7NMHg2g3TQ2eR`-8`
zRYUWJQk4S3qSQMcpw(13fd+`Bg(gv@t;CX3!=-wtXS371RB!~$bR+>ONHutvb_Tv^
z46;;cJqWK;uLXVit<)_Y>R#9mbp8sgCnO)Xa834Zf}b21<76xv#u$eY#$oE2tp;Ni
z*lm4FR6D#t^9P@9JCKS&ldf+G6!w4KHBi`Xy0G6uVJ-Nf^DtB5Q}pk0Xk}ntFnL(l
zvx7E9@NNxz+EQIdgJK4djN#(OLejCm2D?_5V?n>s1^oq<_)av=5cVe^$ziEB$aEMO
znI+0MXHfH%11^}|15?3MK}k??D5Rja9M0OJ;bd$Yt~$1))qDfIz!~aU^ACR#KoFmp
z=ui(2HZ>oU<Er_x&Vf0OK#X-Rl>}A*fsp+eE@%SKIYHF<YAoVWUBqj!3F-W+vGY8^
z;t|&3Anw0|sQ(U9Iq9|VGxBQBT7<EP$8-_@9As*Nwjfc9>(koxs<Y(Y1={u7pU8F%
zbGwGAUBhbL3uzQx3@?y>cv63K{R*Jy2~E+dHbt-b-0f;lk({&Ar^pCykP*}%Bh<%#
zF~tut4SNKZ!R#39^T45#R}j`Gd43?0gBi)egydlLdm9N8s(uGAP$A-3hrh%Df2+oS
zU9ql1au5~rXZrUh(#Aj)4%6q*+#4ICIoB$1<QPy|E=*jIOZqIia+rUC3YS(wv*S}B
z;)AEv@YMM?{c7JFNIKa-g-btSRJnnFr*>Uw@F`qauf7Kt##!(R6qBh3$$IEt0=v2R
z(xzH8B=l-eZO7DC<O0eQ4OF;vye{e(DqyO9I-Z_h@$u6M^z^cRnom#v1y7wv=;ZkU
ze1$3xd^!o9qGJ$hrT2drDik^<*B1?ReuLXfZj(+tzXWgr7?V5iVEBE6S2DaG!b=$j
zGg(__Bg01{d;!B?KW*!*V;JUXTjw-}!J@XL(_(m3F1(+>@PZtGOBp`f4{(@akPX{9
ziy1x$@#HgnCBi<2!E)I~`$m9|#Po_`Fj}>B{+(e++19y*;n;s&0Iy>hjOlHiEqWlJ
zWxWVSVi7(RuGzVNb8fivcKxw^SJ8;nfzV*P`ZQEhY7CRGtnJD|`vE#WFS)<{=)_Tg
ze|*SB>7)=KO-^=W?AtJ!7C4H;fa5Vgxu1;&GWWGH<iqQH#L!1~N?g0vy$5E|ZSa2^
z{Qm&_Uv;|AR}O#w*TDbN;s0;o-7WCz^Y^v?avbnK`|FkML#_=4diU+y=fA7G9{lAw
z`V$Kj;7?nq0B@K9(#V4V`jD{%?gGeB7^tS>$+iM7!pU$dc=BnuFY)q%)SVQDJ`4LO
zh6_pNl%RyRI;*nE=vqE1$0QMLTuBo>Zrx~DVjuPGhpB&568IRT-0XR(*6aK<Nc-DK
zC$uz-LmoFNX+{D(+mA*9mqiTS+|VM1(kE?%;2l;6ys~hElJ;_PZnKpS6|SNdSxRk$
zYdTqWN!f4tqow$h6P<`Zy_j!x{zJ>nhz&P6XXaDJs?N=6AKJ}_$HfPf{T3}^rC!l^
zN2!NA!d8Fk75T+c>^xM#!b{{9P<0HVjg>&=r)E5@6?}g%_(3ai2k=oz$42nLGn>Qa
z%6$3hU;UZH<UskhMZdM*t>D(N8*xK~f>q;V3D?QbPC7ggA~X;pYUKtq5C+-J5AyDs
zJiP$Uds$Pz3bt3LpOCS=G9(w_K93IlM@w9m9DIMrmK@wEI|t-zc)!UiM!VxN+(olh
zoC?+eGk36u<j^3?MYB~ds*VlbY(?xh;9b~kRmn`;T~>*Fm&fl)<vZ@<<z^>qUSm(f
zYh!L<{fG7+bDFK5^*hB{zhl3zalMaKyi<kj0n`YAR{^4}6m6B%ITMXNsjsb&m5l@2
zE;4^=0FJ8&2h=C9xGKZiX6qTqx|WYvV-?dW2iQykr&M`am2d!~PY_OCoTm;FZB$xU
zNqF`rJfO=8>{Hc6I1G`SY}{9I?m3kEWOQ&UhtDvwj<>tbSc4Jwu^Knq%T4$r6JNx^
zO$viU5x1PZC&OsO`Ou5x!Ac(Ul{Drn)g6E9*fFi@4R!|5bCMi7#1uR73)h@f!LQ6z
z2?MwPWrWO~_N;N4vL|wZ6NyVt1XadyqP_+A@;KCdvTmbd!9;A5lK|;$06_{Exq+Dg
zVtrZJp?~$JAA1S~9K&X1d(h^4FuZlm!iYT!8-`NM2%Vd;@OQP2TnLCZuyyLUso;MT
zCxI>T$3W-vczQQl1$2G_5TF_dbgl*v>0*i8M4;i=OR)1`t)C$dU#i8&I-NzWmJ6u*
z1J)IU6^u=>itUwVhP<NjQ(z}_>q8VrAIp9KxCC{3KA4s-(igb&tfbL%>?foSsMU&)
zt-DaQL2jgV+AFL^1yDClDM33@+u(m_M@o|uY?wU{j0%R-bL4mwniHD<w!05(_n8{d
z-ByaTRAMFXf&U840^9$*2A#~w$DcjU;&c*?yu(B4n*RdtBlKCohpmsAF?=E#r1yeN
zh?%&Rt@wogtl(R|h6hH6TG^j>z?70u{P=ltM=qre0Pkn%-#hSgL>;(ZJ1&2R)H+Zb
zkf*A)Q`7g4K=%uHOWJ7*Mms-t5HCR;fFTC`2M+^UDv_2GH7&V73#toH!@$S}Y_bbm
z{Tz`sw)2-R2XXeT<|Jc*9(0$&hEjbtv)-qkF_pLRW3BPKQUCZezX2^5y#`Md@-0^n
zw;6=T9nQ0dgB$sskW7ei;q!ksZ9|y0@(j-v@BT(l5Yl=?_t)pqfl+CfU(!&Qt3hve
zaem3mABIJyarVhOtufR=I&e^`_hCC&O&-lJfrW;QE~Fe()6oUXbza-pif{^*+Ocs;
zZM()i_BbeY`GK=Ol7m)63Ree~9g{=8k`wv;>IgU=f^dhvxV-LhUb25L*61hOWdM9E
zXyW3!ievuMhbZt2>cmUIj`ZqqjezvORuQtb!%(HX1olAwXbJx0MEl}TujrWM@!I1N
z1RsvO)1fYbp_M$sdCwY@4mA_s@9VtJ)$dP$_gM^V(zTBbt!zc!^dnyFDWXavv^Obh
z!H@lS`U4Duii;|c6T*MQ2+Rh^ZFP;<QCRq3s2YAWu<A>Jm5zqAFa<6Gg}_CZ`GJYw
zrBNE&+#o9vya2w?080g%>2n|lvaJt%IsqM;ViovHP7#3*0J5FQ$k^lrfMFAa`t3M&
zvM<TB^U`>c`cm4P1PUe)jT51y-Q&%EX(vF!>2vBhvtJU%AKHJ%(w>NP3GA6__C#SX
ze||9)q){a>z+KwAutGa=iYPn__!bqFy$B;}C+rYbCUf9F+M7v!ZQ^q@2cAQGiNJ>O
zX>xMfc`ZBrW8=LJm^t5n!T7H3DZZ0A{YhP?cX>2KI6lL_&AKp}B+<AJ>{;Y@>etU4
zPzcvUeg64i$kKnw+GBp3XJS`n9vmV!fO2&M%*vJ7@gHw6(fQJ&Ks&A~53yIWQuP^Z
zfmwA}r}AI}n+pEo1a@bw)9$S2!87sPQgt;5d6}UuyFTCXB&>Q+@&#*L=Q}>U1lFK`
z;`xpnUSdbyjPo5?>|xtzo4^}KDh8y|U9?9kU~d$BpwNF6OT%a!!=w1Iitspeej|+<
z4AK4INr(y9#ML@EF0ANWW-t+7PzM|(2k{h`rXf5rfWoJ`9u{A7#K{#_(D7J%DvVbW
zi7!wXzUkaSdzp%x%Za*Xrmh*D+#aP?SJYW*324u7!V&iXN>I*FUqid%!yR5^-O)8!
zr!rY5{Lp_Ui>7NOsNPp5eaS-*#ip)N41j+);kK?5cKS@h_qtAqa&9u82x)nQ2?^tZ
zRo6wH6_{rjrn(?|s^nZw(%40k<5AcHD=W6_-7typVX0Tk^2=;^Kv==?>k$*uC8d=5
z8v5fr!p*cVIockjMHXleSq=vEA-si2ogXGc<cELY*AUirNaGhPMHz4WxG*Qjc7va#
z>>X4<qRN-!Sp*-ohrZb#6xkk96bnohOOM1w36}c6<p61E2?eF6#*ovzIB(_UDn^Xe
zagwn8s*Lqid;1!fsq!?xu&W<rUgN>Qyw5vyduRc@FHlc{LB4x*Zs9XcLb}_QdlijU
zVDo>VTVkT%%msd*dKh_jb6^fOTC8Hmk!EQ>^+?xZyKuC}(rylayR@2e<u2D{rpB5w
z*UyJC$8nh-z+2R>j5UJGt7B!E#7AlGMatOEKo{jM-ov<S`q%RI1=Lo4XyNp7oE-y~
zc9kv-%SiSnKfiFc{>_Nj1(Koe9cJEi@Irrk7V3V*(;2KorMI@XnLAbC>d7ExTg4gg
zSM^<P4Hmg=HyfGCiZ`>4hZSjQpV;k{^=TT5J~&}iL{_=_Gsc?b6~oR*+NJyP1MNnn
zdxc3exmdlg6If0Hr>IzC#24MiAqofiILlf9ycEO_-WEqc<D$#;?yAN~&PPaVQo(<6
zR8HXjf;<>m+Nezh_trWKgB<;^BJR@YoQ9yLa49Ls(~1a*7aTsysg2X7AOgWo%(NRg
zSCl*Awi^1d@mO$@hg`{dm*nI~{ysBDxx0X3k$i<yfH~{qIEcWI2El@z+v-r8xo%$i
zmM2XLB8|`n)?o3Jd5UZXR{U{VaP5DfOJ@DGiq&q^hno?=Zzq?i*zSxGP$LqQs&jOL
z8Ye-mNKmdSb%I(aL7hlosgO=k=On0i67Wd<23<yIV%urv2_*B>>pH<aCqbh~(5MFM
zQW_mUATyVAnp$-;A>lKaPO|0hWOeEVos2%XCk8dL9lc~Bm;qVDADa2G`2c_T1y{k+
z1;=E5+%%NOv3P4Mc}cd{r<lU1AWQdUOwUHYuq7zB6)hiXpHJg~v!A0hb1D>Jjkq|z
zZM=KXGb~q!WuT&BZN++QZ_6Cpk31x%f=*uIPF^CCKl)&1@=|y5Qjz@U9?8qy$>mHw
z#Ur`pPHu_h;f&+~*4v8==~I7y=L4BV%ySnpPb6>mNZ#m9-YAlv<57WHck)`1e3l3H
zI(PCqkv#XotbEAW0W>RO6&!G*rgg||(qvY*e-^23VvR+<g=uzC_!l%p!_YTu7z;qX
z$WVZ~#6V{s)SyF}VW_yrle=96R~Y|05nMqZ(ESo`g<&R-k0s#Yz~g_~<A5&t-<3qQ
z->{?dL89W5i^f^G3kTY78e!odXXQ2IB!8NG+z>S!BVIsiSnfl&ez_Z5x6{uR4+qmg
zjb>7n#kO(>HEww>-2qik%Y>Gy`!ds$-`-EBg12f7N<8p`Q8_+fD52<?ppZBi9$ZLc
zyK)!*kZjz6-tY}%@jids+#Y*{wzjiGjfZ7pL*Ugz`RZ4|_cs7{rt-1`xXqN;NLnSP
z<YrH#q_|RhEtB6gcHbs&T*i*0-N&Nwc1s)U085a_!V>vYjSk^Ta)v~GM|_Jq4;1hu
zYo=-TyQQxZoQ+af3R-psBrOMflx8RWoUP-fNwCE(0^8w2_V|AVr9v7Rds2R+caO_&
z$kF8w(B=1IDWL{59NrDljlCu-QNMFF%H;Gl$JlioMQO-`+=aT2>@8Z4>CO_5J3GB!
z=Sq4HvF)^8WWBZLt(b+LVxWh80C4+E08gz8@fXD9+0;H1{5*OF!=Rk!-L&x&rZx-}
zuF4ND*S@d(KI9(qdS|A^52OmpGu!)QoD0Q6Y?Qmh&Yh<paQBsa8IwSf7$Rr7{&Ts`
z7%ZKmDIz?l*)%|`El0G#YEUki)9?CAkK5pClX{UW0d$k5k<@>49}058C-3*`7axGZ
z1B6UWDfN}zUX7vcAo|9H-`znr@bGWAA-lR3BQg_=4}1edhw8P1?8xEdf#O<>dv#Q(
z?K%1+m_OZ#&*^_Bl1<YN4q?X|GHniv9bljE!qeUCyP?nxZt}0$?_j$V_YU=iTVzNl
z^2E6d<U{X}c2Iwr*Jt?Cl284@PCm^}PUqyS^`${&FScSdqEztUAFyVo5gQWzLBVkT
zwc5sBqAqz@%j$*8&?O$yAMOXY*BmeJ$J_5R)~=}_dEN<6fH#V*iHb@N9W|+JBT(E9
z4(e;ze9)nmen3&$*ei<)&4Jw{PM*#tb8_InbW}Qx1yFxnfhgGTutROtVUsxf+6O87
z^iFgDGJcNsE|-$jfzJb07+iun)D7UXfbrX*Gi-5U@sDusz~fj`CJvpkP;dYXen}VH
z0R=<Cv83=I%*S)#b)C-|KaN%O@73t4v`xpJnuLyxiNK*}rFYydpi9dZx+|^YE`*M-
zH5`c>^)G*JCjOYPT~jRek84b)93xsUG95~ORafE$MHMHP4NEP1!0!CZ0K_Grb2k=@
zwRn)z4C}|uM^Q(ofr%c^d;E&9@WB#_=~oVq6J+yEfRfk$1WJD0=trPrNH_r!Uci|9
zIHiB{Tl#o`K8T=W`dzO5PAv6z_>K!g1SaW$w(2|tUQ`*44&IleXWCo0^Gq{}9!lGv
z7ugj&|H#v1o-;-karvZ!qNogIo74j_VpLcmk9bKLOE2iruQ(HvvXp57sFNI(B>_g0
zLX{~623STeE|YMTB7c;3;-!z{wmmRxFgYHKd4ir^A4E@oeVv}(;HQODyTB!!vV;!O
z2R`O+57Dviz^C}+VUJ4$=C)9RhdB9(Yw77;e){lHdin!D9f$#bngcEH<oGMOO({<3
zF`D+`NH!}1@I|>9C*{C^5$|so+I9;kyn_XcN{vs(PN+kZB!99({DrUe=ty(kVACa+
z!mv{-z|aaLo{B9ItC)fxqX$EmR1MA?{TKn1d*b+gxhFEz?H=<PC8H;bO;`WEI0J8$
zTc+a@-V6GDtvKj6k8}wT`knpUMQ991M=PUdIrdIxHy%l|cU}_bMa{z`)?K`#|Ma_K
zPqngGaf!ka7+fBQ8_#Vi1^!rhu-1Fgk!;i*UVT$4)r4MVz%8Q3FxUJczQCN(!||*;
zHczx4zH75jy<=3EMc~u0=7;&(-wZ}KEh~@dxOg^>{`Q85Pv@4T^Fh|Kqs!tit}>JC
zmPP>)lQWk>0!RFlcb7YV-3Ofb5r230&6L=;Ibh!oOTRlIef&f`=5X5h*!*?Z<EOjt
z6;x;M@6?kW3dR)-k*?$OcQxK!@fG#CZd<1U%{LiUJ-WTi!POCcU1*|H@DfNshjc7b
zRb}pz%i7$9ra!xi4s{<)|GTDl?wk09SGR7;em}sWbXSA3Xwl1mAii`ie93-+c~*Z<
z8lPa#{ML<~Uar=G0b#Am)Abx~e+2JXW4zJByF~r%=j<Kh6>l^1{u^k7Wwwu{bLmDU
z`7}t*+Qa*fAn$Ase4~4Y&(+>|pTczG7*1ZBWTn{{Z--UqP<dAixF#1L;2C23<Dqtl
zZJ&&=t<|pXj!K(<Z)c$eJ9EBepYK`tt!Atgb)OX!=?u0p72K)m*FGQ(`>>LO?E2@z
z4itFbgjDc@{r$d*)hO<##nIR1Zc2V6B)4yxs!_fFt=V11fbh7#LdQ*y`(ow(h91qQ
z7O+_Q)Xy5sg|)BbJJERH3oSPIYu}!-{tjCq@_|nz(BUP2S3gW=3fAxywJ6^_`>>b4
znjI6y?bwSpGw`~_y9h==-y6YLkU$ni+V%1Q8cXGx15^!tL7+aZ8hq8~XJ*n)H#O?z
zue|8NrG<jw;&{xU<yPppOq8|Sk4OESE+<>TEe5;fpGRqTg-yFQdw<#2M1}a+L~c0Q
zA1ZLuWE@IT9xT}HU(7S0;`qIA4=@n+0KpS+qg^<JJnl>3HGD0>uju(es)~Za@R$mI
zHrOo8U9vmcj{%Oq7nl+*2Y!_bK1|sI>)|zwmp|iAH}}b?$B2@e8v#a>9GWHvgAZe-
zs{5~#Nt%Cu8fG56$4{DSSqe%`URgclzrt0)vXk^_6ov5=_N+XL@r~SB2l;-jOAOuT
z2alxxDF2z+uEzTx%D;#7yY76{$G$>p1dJT|us#y<ycg7kFVnQda)5n`Y!2Re&r3l>
zZ9I_YaIC}c$avZJS3SXhn#4bMPw>ylRG`!wZ9L6?K=s^Av!K!A`9Fb2nCn(UKphCi
z4RgvDx&ZzGppw(QbgEu|>?<3lYPTP-nxR}_Z_tc>#BxXRY{Wh#Wb@QjT%{_mQk6b|
z<`q-3y1VL(I+I0&<MuMt7@6kn8FoeWn=3KxD0~AZ(3%ASb;L<r;YzHqos8~RpsJc$
zl)5#4KQ%G}DsPOja^&GNPd#`*Pb-%_KC3<!YeW%qdnfrInuxr67@YMJQh=nZOgzdz
z?ev!AD4%UT-^gb_>}AVm^HACV8D*Z12Mv#(K7`gY0I01=X_jXa8Jata1kG(lg65VY
z5qshhctDNR10)6B7`}^2L+Y`|$sx^k@`Lw(G%J`Ykb$m1lAG2c`5tFI?E0q75%TQC
zv)HTw711&HgrhkDP2+)DvsRpd=J0W3(7?fSB66Bo#X;!CS-A8n8mEDM;YqvJ>a@6~
z8Gi#Eseyd#(F==CPXcv~)mULVEV~tFoe8(!sCxU+5TN~O(~rXN%cqDO_fZ&p0}}gx
zV%!Lv%o~A|Y5boI<9{jwQ$e7uT!S%`5IuT1t3%OT3J)v1%39%Bma%}Mg|bHNj+wn(
zA)iQvT1`{2GHu;@4b+DyV)TkuX$W=^nwIEj{VJDV)nI%%{mR#{&`^9~;i|x2QxtyY
z937@QBD;}>AdzT>pow@wLy%)<=pl%I26LR$XcmVN$mR^NXJJzu*pNyk>;7++@bm(0
zoA$BE%a=ZoJ?ATMj7GpjTLhXd3sLQtF<UbA*}|{WL_5$Fn?R66F^+?3&5|$}sHT`4
zrN^@ds<Es2)-Aobzssc8_N+CnO>q-g9sHjYK7e=gX@q;w+ft9*aP1t!4M+Ze+i$pG
z4SX?tt6K9ddly=xJ~~>O!0o6CNRZ@*w@7}tQu0G&WVFH*5&gKgGwe<cn9uva8ngdH
z0-M$$v7Yg89m7#eBnbIGnN1bqxN*l|$?%rLet@V|F(2j=sLEkxUH%OPoZZV#g7I$(
zHt?A{63zST2bRtmUT%!!#=Tj8AFOAirTv<iBD7IG1?-2n6a$1fDp{iP^xJ@5-4Q+F
z1%^dR>E%H&K9=Z*a>u)BX}B>cT6bPhv~E2-Pymr2wQenb!v@9H`72oeh&^Go??t}J
zw=vpI1HIk>UeI93flpw43mk((BU=y|a2KFzXbg5RnQ>oJKq$NUqXBh)d<XMfD(ThN
z#lwoX;h||A_Mlhz>n!t)qiz7>#OdU_vOrHPY|!K&{gAfX#hB;%>MvN2=yJt+b-=AW
zPir&gso{Op58LECt+mH_hwF+2IZtI2UFZpp6QgT<9$$w!%{#!Vv)@05WI61z{VcF6
zm7-`eKcDvyVA1j=_tk!XfBM~Hpc~f_q+RDV)AxSPZQhYd#4)np4^Cd^&^8p*mi4dx
zbjLr(Kyn?575Gm5_Q&Qp%a2(fdoy~<P_voML9!sjW0eZRn+q2d+iKDf`SO7{{26pj
za+5<(hfNQu=Cj&kTvb71%OOJQMW?n)0;*&p3*RN`q6xYawU#-5Cz+oLw!_j#Q|B}K
z_dR24ImC)>-%hnMt_h^1rZXpC$sI_frTYYXnKDU+VybZQcn~iG0Mh0y45+h?W76u>
zyA?+IPXzAM2jR$0OI;9QQ`ijL!l1gO&n2^Ln+3>TR*@YyogF8%l9-N{)RX_sWE5X8
z$j5Mz5gXrJVl?1?1YQP0D(_g(-#7t|ZKOI#Mx8o=uJ4s*PD|ZGwtv0#;8-At6(iPq
zQOYWEJPU~<^|Zch!gA=n*D~~mIY}Ab3MGjS(|w=E8=_Ca3x>Vy*K+HsK0MKk+(Eoq
zola;;i_@WAfQRH^{NXtIu!T=Ao`yDDM;l1Ke(}Dn;&<<VYtzbGoL=6JJW<|%iSk~`
z6XpG5S<lPs&i?LsHIsVpM}{zBFA;SQY_pSxA}6wl6T!-XRFWgiC3q#Xqv~2wo9*@{
zk9Z@dXz~QK&^sUhuH^aPJi>g4z<gMYy+{g!t=qlthqCL_U466JZ$0kkB=&(UZZGIA
ziZBJFJOi_TKpUYrhEA#Ag_G!#YCVu^)WJuK3BiL~U61;1mznD>oHqPGyp89A_G#90
zA*6oPTboa`YcK`is8ctL;Hh7%y?0O)(YG~98lr%bGXj#cfgD6s6htyeMiI$5OK2Dg
zl2sHW=bST=W{@P3Bxh#GnHloHq>taL`>I~mt5@ImZr#87oUYT=yVqWORfoNIFW9ek
z`^06AYISs3ENfYAL}ZR>=@T5Xah7(ekMOdyAHNu^tzR;6A|a~tF9A?T(q5;$rtpNp
z$~>W#{?lr1;5);}RJ6cHj#2Nx(x2nHpV%Pw3H$2>5zix5I&#ffGijR2%d8S+OAM~s
z2#gZM-Hqvo8Xe0xN4{trFfW9>=gQjOX+ZL>%j8}Do`XtGP`^^JQZSWoe4I!t@QNUd
ziIAyq_F7iWD1$5C2}uijmOD43m0ikxdFyh_^-=9{9?%hYE56O3qsJ6mf;F|VyRhGn
zK+NRyB)&q7P3fg!197R<I19s-WSml~$t5<8*pbr2J7aA3Z3f=y%?ALt^8$feGFYOI
zF1p-KSzf*r+|j@n&}4Z8e~2zGfS5<md@u6fxufyHZ^t#KUE$1M<GfH^_*?wWzXoLm
zpND;Vz=mITa%WZ!mEFavk=<@cK>Tv_a&EiQ_Z8Pqe!k<bOV*}tS<NW7XknQGnN-!=
zMuo4*LfFy`zalEK?zA*&%0}xpL>;_|8C02xlF>)`)^Yg@b7Sy0<z=e@6{twFP{!x!
zqHbByu6jhQPJ92!Obj2~aXR=#Cq?3c*)V|yz#pPCVqwi-Zj%11=pvu?YdO2bSZ<An
zFHC-Uf~;LrLAi28El{YZ@W&>OcU?_~ZT{oj#^YEgmcHq(z96;nX(wTp07Z9XoS`6b
z=u+npfdY&8H;KIuJrS>C(DZ8xTV2WYa-z%Qzw_=qeDLy14rD7)VWo6FZ_V`6?(_NQ
z{s5_?pPVFP2dfbW=ib6$a1zMXLzim<d(E@)y~W{+_CJ21V;hud+Y;tmBYLjMH1<H|
zu6xoZ`>^lKGaDffH%Wxf#CxpT-B{}=0all!Q5`j#Z92h)`R9*g{;*2lL4I%B;gP5$
zdoW|B(5Lyvd77Y??KP<aqVAY+jx|M%v>ez>T%DiIuRap&uTzn5R|B}xcfS2gRb>;T
zX1%2uaPR%vgU|pNqxCH2?oeRIbHOe>rCKe=Na2T-RcQqY|8D(@uJUoQ<arnX6<8K4
z+Ip?)nz~4nes}TIW?b(1F};Xw90hy+XtZ?H5S2MhQ-0hL%MoJXCEYmihOt75z4<;M
zH3y3ztG^XXmn%Ztr$W~^9`TMUKIl(S)NniBEFVI&@$!+A+O0oC*9*+fZ}10)W2GU?
zTu1#Oca^dKlwalSOvvGLN?`OK8#DUIO8NT8q^5(e%nM6YCE<a>d95d}dFKkwwMDys
zuC8W6K73y()<3%y->u2U{}4CPC~l+!=yAB2Pv?*)_R`xn7IDaYo8|4?RE{P(Dt5oy
zes;O>&9!EPSIC*4UIyI!o3nh4PqD39Vr!7|yO3?cLSLY!a>%}R*ayMaRbLHEI5qz=
zaxC{uvkok@U6mu%iuIgao;Xjt?@k2RW=g9?Wd+C?YI{F<X;J8`aqA_?3TvN82cTdc
zsiA?7Dq9p*X-s^e-v+nHFt?!9msbGYx5|tvf<p=w4N9)){bKa05^&JO$%xD#f~Z&a
z^VXv97Xv=H=q2{+$JK_=w@a1pY8Y!R68>dyExbT>y8L1&N;K~+?NFSOwT;YvJ+Sw=
z)zHVeU+R*hm@C}s&2B`uragc4)$@0OiMfytfhZ=a3i#&DvmxmT_*2>i+oMtM+z*#6
z3l8W*zeBuM9Q8)nz`=u)_7nQNbao9&lD*1Tv)nZWybkQs=HJ14$^OMW%;z$XT*DgG
zJIj8&K@sWul#YzXN$e<dCf5}60r%QPGCqZV1Qvf@q&Yif3kAG2G=61z3bU<=j{#3x
zZpxa{cU#(|tPP`Mhg0pw4j6U5e&p5rvcDm+wz9l=#3oiccgw1z;Qs7n&CfI+?=H0@
zcZCsH-xYmFbXf%gUc9_{_2a0^zHiJeEV6=^=L_<}H<)NXNTIO*NSpP64B(h{*ge{=
z?2<$odtB+g5*e*@{~*%s8sd!2ETFgU{`e)-XRVR1empb9S_fUgQJ2Wt^VucZqJEz5
zVJCMsY$UK~_`2Af+Q~?qT)J@HaYuch#wst7O7G555y#u%8ty}Nx=bf(kqd3qcl}4W
zoCDJ8zC6xa=OGE|z)4%ID3FjXAMZRU^|rCp$bVnsL~)wxAS>YE&mZ=cFQ>92{`Jl}
zp9sHkE0eoP=rd%#_hC~tC;!Ek=gQnNE<n{d<y2Ui4W_Q9G&r0@L+UFO?P?SL9Dxq5
zQB1s#VkDMN#t|7#-EARpUU@Gmvml4PBe0=~cD$fH%iVGY9bOucdjruQ{kTs<=B2JU
z5z#pY^Y^og47y&u6pm*Y{ix$A-`~zm_V1YTVbT+Yvp2fFU)+kaoaL<Aom4ts5xHxK
zpaKM~9;e2pEIg~uJGC@FSf~o;_Zel&g?9XmD@IWv?{xM}+0{ypcZHcrYL=-?_vx|4
zayxe&aM_7!9{A^cf|~)YY(i;VoN$o?b|l9e$7E$<q|aImD<h{(Yp;#b6St={eSwdq
zEs^$U7}AI#cl-K`N70bfI@g=ehFFtHH|&l=lh%s%VDOi5?y%~+fhvqH1nx2nzWYI}
zSoZkE+XJ}(!?&tHQmQVdk6&r{<`b?+S+0y1BCzQ+^N)!rMV<gO57Sw$JLuDgjjkA;
z{UJ|TH>Ev2dik-0`+}{k-BWsEn<Goa;^JQLYY_fSXF@%`=n%UItxPArgx`(&HaIAz
zSG&sy(dp!Ew@+9xdZ?iNZeIID92K~y+^4_H!Xo@bo1+k-;Y`9rM(s^?&#Gtko_{Hb
zxYYGI`mos%CcX%et`EFhj6Zt1%~X2MCPv9WWr*AZ(y7gPQH7@;xjJPQL56mW67BSG
z>hMQ3HzkFi-D663+JR58I4T8bnQ?+;Rb-plqpF`;oL&O$`DrWFcRD*S9+ytFzc^le
zc<}k#IX?Gqf~UykiiGJew7=(O|GkPp<|&RH(7pQz7n(xAit$c-25~$5PVEo*IXAzz
z71MKn|Fly%lAI3-w>rC;MZ0KeR_Ql7E!5phO=F9~kH2zdXpB3KjH*f8S43_9Ziod)
zpS3@H47W*H&o<c7zhvK~%0B;i9g=QrdyxG0bC}X7Y40eAF)SezERzCP7p#4glfd2H
zGfWzs7nQIDw4|t<z3P@1r{|-7#n;UZf2l!lh2Q25^c<v$qLheffmRe)!+kb}UU97?
zTsZDNe-%0YVhYOaL#vw&33+=>oTK1jpU{1GiZEvf`e1X9v|gRPL@mLNw0iS*&ZwV9
z%{@+qXY3tcA#M)Q3X(5DwBVGdT)l6PUw^;u_c|9<2gu$g!3}0oLXWA&Cwjc7V;9wa
zfAULvT|suN>+{@r`!~30BD4+C>#=xx=zm(atuU2G#_kvT4eQDivd$Qn?U~lRPRCwx
zui{yt%O*>Sg7?E*8F{9UXVgkD(M#NQO8Iq5cH4g+{fb8v{UTWYl|fxG^e(U9yBuda
zcu|<SyiuOEd2-fI*m|BgJCnJL5z^#*;va7yF`m9ZM%S(JD5GCX&ak?8+BdSJE0#JP
z9rB7@c9_EW<?t!_w@NV%qDa1M>M{83o|>JDa!f9>siP`(+{f7`AA6*k{GyT*NO_wV
z1Esumwa)OW;@YbNJ){)hGDJO(xZd%?2Y(TN*7s#>(Oa#g9c5tYo4@07`qWqTkJ30n
zR<Dj6;V8y%G|ydS*NMjRwCtz4`=9*O&}>s|*3X4|0lV~q`yX?x<9QZxgPH0<x$mwL
z<nD$tw`3_|k7Fv|ZVJ{%HE<YD0jQYDRk(yRDo9P>*N5$slM~i!%ZF7xpxz>eK_<w*
z=GuLFn>VUkvm1*~7oKo3)3NwOUpxQVp->+!W2n;S?<R8Jc+jP3V*B*WWqbMK^RZv7
zXNHW`DI`^#d%UI9THr30^n~2%owB-1&y?%^@anZW*znHFviN=Fp&iGN0)VV|midl>
z_P{S^Cw)UxdB1t|hbn77>}0MOx<zbvsAF=>vq;k7aHqt<JTuS0%Xv$eo&EB>glovw
z)p4QgpSoomd-H%$p(E|pqgLi^Ng(1`owIKya~GMa*SfkQ4Ul%8g|tj(gsCjAuhZXk
zIEE3U?I&r>eyDjo9q;|AcXMA)KC{-Jo!>Xjd^oGWF=jcDmgG#^rx9lqVMWk9`A;W-
zbm-Z3iI5Q6{G!#b^Mq)QioYB>4_3CNg8PmiQY~9M{d??mVixGsZ{Xt2Z#1{WooxD}
zX4}f5nl>gmS;d&xUy#3+E~JT;{DgV@s8(IOEpnl;@RWhxqfQ-0bqH9v+%Cn&HP6e@
z75QC{^UUuV^?AP{cUG|iTe5sTlbzdM)L4rt>?!Q{bngezOVwxJm>j-wp^LhP==%tm
zUlw8-YMML;tG23V*_+^b>(P(OgJju$A7}~Wd1oo=A5a-g*|9$w?<pofJzL}Rjri;J
z(ntO_c8=igHJ$cZi|i>d_v+|bqlyk*h4P*2q{8rew`!wfL4=#I#)HQl;#M9cjb|>R
zDjp<JZVhW!V}0JI{U9e9bcjiOROb=}LFs-s31bBdtxfq`;Nn<?>BG?plso_w6J?tZ
z{puJWmuQ@MG)v`ff{D4%Y8<CHo8LM38o>Dh%K>9c`9;gyPf7J$q~jHc`_m>j+p1J;
zWeMeceHWemz&XOeKz<-Mbpk!QPw)T{^snr&wsw5bb9nn}Sn;!b`Ehn_FUla|A2vu^
z-p^0NsbI+^HT-~WvI!ugLW>O)^O^1=D7A-@Ng7L2K@EHI?!Kla_}t!vvHe~^xsU_W
zlnobPd7lQR__=x8XHkn}%6opDjD6-M=D3jClOvCA<*(#C)$=1pv@Lc#uRGcPUFa{T
zf2eudJ>%BD52BTQoC0=S%-m_S$ajNF4<AhF`Hb6hB{2Z;$G!~Do^)5UHs#n(XoGU>
ze2r#==mMl0kBVbjSsqqZc={(Rcf6HjT%FH*3Kw8mRy1HKmAK;|AU77Hxfzm^R$J1Z
zNF3h#&aG!=duQJvf9`AGS7yiA*K6`yp;j#J*MC`O86BEl-@`d|x;{kP+McKY%C{^#
zUC*Rg@v1ri{!4=8M3StL6XjlG|JH=>#h2flZ!6a#sihd0wg-sW37|yDK}}ZSt*TC&
zcW30928nXW-9+G~Mm3{>$$lWvSXE@&!yxO10`pt+wvRf%jnAZ14{Rp~c12VBs9Rc-
zp7{jhUR0ES(^<44J5g9*lkj=qlFU(sYC`M_isVrM#0i?%=bhKgf3l`h&KM?U8>jNg
zb)8=EHkBWFW-`R>i12hgk*E|<aeJE27S>4O!D7ogeCt%|fN<egkH!3@RF{FYcg)GR
zXfrXTn(I@&;INsw&700;AN!Be^eMN`7@j>id338@GFWo)bKHY$&#cMJoaD?TN95;<
znpGPmIpFhPo+<2LXfNC><T2A^Mb7e9O@7g5<xDT^az@3C3|196iHmA_?I&(>>d06{
zjHP^a5yZ7LHznmNZ7WvUgE4UFt4g1yDV$VcKrTZMy5QjQS5>u^lXE<uuSu#Ib5ns$
z@{)N}x%;46Q&rFKukNqYzC2?KT1_EC@02_=(Li?1d<>W<-~~u$L9-{3|4*dGDymLI
zY96e9*q1dkLTq(u)${gW-st+hox3|F3l<ZBk3-vvJD*~`$i?508<Qopt-lYICb1`c
zp)biwtU)YKno_!oSWFBzyg<(0pE;njf+dg><m-FrN%DwV9Q@ea@$X2z%KU0Igvqvc
zbp*zCxR#yeSA{P-Q}CCFf&ho{%S%0<7ORvm{UM&xe=&uvF>>seLm%m*o7$SkQY-dd
z<CcF`mV_O1sIPzt#o8ufqW@)XEtL(L1hMIS^N$x=;{NS)Yvqhs@gy*NYUF&erzlf}
zbp`Z^xHYK#u5+mBwekj?0s{sOx!%ZwLx8w=AIeFVwszH|of+kS!d)&nk^|+E6m_kI
z>gzk+EYSrj3&e~1HesU-aSfSDgxvLsDr*mUxq7ThJBddhbJOqGC<xkwTuBe9217}R
z#nXHWlqX^q?+$K$G4`6Hb$=vnHW@S>r(z%ZY(n34fyXdMM!DuL+Hvyim}knuXAL-E
z3#lx9csge%o-O6OB;(lXVHvMKoRl)>lNyE3J{4g-b_rUmDVT)K6rA~Cde>B_+T%QT
zm$Mlz3YXme8vF@Z<=8~%9*)KJ2qP8PBpj(d!$3P#V#h`k&x^#ROV=I7A`fiCxGn<s
z-dH|iR%2;c>oK6;MX7wOwnt51BZ2y>$zPQGUw=Nyjb!MjJ9wSbrh!{}*OK>~iDht=
zU{%P6<Ckx4YrM(a{yN&nb+o0JClosU;i%<VC$%PFsIA2#*Y`WH)XYB;YM+GN1j*oH
z6XCoM*@?`wd|L${C|m_Arl48w+*=bVkj>eT7}(&=j(>5ce_=L+<UX;gaq0x@?sO>T
zjW?-z5As$c-!&LdKK%Qc`7yKCU95aft}$-_TKc)R=gQAY%-yPr+Id{5En8~oFW66-
z+)o9KCoDC!Y(Fpyo6XePa|<85aOuO9z1LT~Mt-|S6~3w8|L~Fc<&ut&9Ewx;w`Q~?
zz~N3-$H|k?elIV+{rtNO=bBCi?sM}er`ltP24PlOw0BlG@lz%SsS{yOdZL{}_-CiV
z1`xty)N2pe@rC<AtaXX#&X5s>+mF1BiAPqrZ)wpgO`=(=cR2S*mbV?XK0d|DeR2=@
zQL_{9I{E}VsG^i-*VHKo$rW-|qT4R4l?f#z`E=_k?=5Yw!5@{r#h1-`z%8G(AB_Ru
zEFBwZJRY|z>wimSZ_lA0uq6`9SCZ=wcpK01fIaw7cXoma^iQy-dBS{PPq0Pg4!DpK
z4PAc%N(%U<T;>t7I$bF|TRd3#BfEC7VdA}okCXBMqTDwmwW({`eKx&z__(y`gBe+4
z(d<G&*Jim6_dv7zgYJ#nTmaBvQa>Saw~!k8yYtX{2@1)Hd}Kq<{r$spcz9l~jnFuY
zknw}L;~lfEjt%QZr0@mWOR1vaWBXdc_wt^ZI<%<I>*#C3Z}3cJ$yqYvO@hl(AZE|j
zb~#BwfVcS1X{{JPnHSu=R%Xv&kB_oJ=<}qMDu>k1OC~wmm%du|Ccx=0mOqa$@5i<q
zVwPxaSwli4^A;cO=3Z-t@V=;tsGMnxUGk?)DK!tWk0LGij3m9*m)!iiVPmH0XrZv`
z#J3l^6_I_CnDLk9e0tlh+{R3xJQ(knqb=jCLHe2&5A@Ee1DA##%Q?&9B8@h3JM^0!
zKf|<kT!H3w9?s<R03hTeQ2Vd4de1IuFsUu}vylc`s^fB$W(j<srHYcC%7ivkt|Tz`
z#{v9s7MDrvCw|vWeNX7+D$7W`Wlbml(eTB`qlW5*p;Hw$&ZOv~MXz&$xYw51_Vt(C
z&$`@f4=!_q^<Om9>n+i1d0E|QmdeQ@Vfwxum)N88?0cn1rUB5ZAge@{E?*Mv)>il^
zSB|x?5$6#8BVQk`{@ROJK<MJ9ySLJIMnmajYc{@&YZmI&*t)y)M?Zh%S?90W5HV$W
z)$w(75amRYM`4I{d?jhI`RiufgXQSXfjb)poJjVJ+eiK{NyaP%DM`;Y;+`7}Zikhd
z1UV@_?>*<IbyNeSl~|p^>0-ZqLJp*I`~$12&gV?sAGGM)7qL>bFXHyv?#82k<8wl{
zPN^fUF%VsRIvxUcPdo3sfHvGud-MY0Zue@Tp^STF<1D;p?3*%MrsI|OUBHJs;v-MQ
z&tTGIRjOh{D4yyO*9g&zK@|ois$BV#o&&WyzEc$v#a_VJ1S1{9%kwmkz-v|GTIo{^
z=*2<8L+5*2$^C)sg9G=)sI_iw?(t?(liY3l%{iM`<KtAbSf_;0GI0o+aRamTf8~oy
z!%DXbytm>RnVL)|t<25jEBn6x;J%N%<9)$-wF)-m!OM&3y5R<`hhq|TfqpUYc@EyM
ziC2`_3GMd4;Zyy;Z(fOh->XgRak<6uCO&bRAj***PmSrn_CJx|LX)v|Ayfpjk`js2
z&*NMzX0SWdJ1F}pKK?yV?3=$Mn_aQ#)x<Puar(7)Ol{3+Mo9<7gZaP`6MbyHdFhY#
z?#7!*37h8fG1Zgi^}m=dw74b<oK(<@ALbvE(tI%uG~T|)%9H<-VIeZ%{da@AFTKc*
zSIkm$W@>X3WoF8adYP1IbnTpYj6_|9e5KIX!^t^GaO#s{uKPpS$7(@i2oA4y8a_*3
zf7LIkN@JVr6bwA~@;+RA>x|4kOQy{wJQLq8Oyj4P7=%3X^Id_urTYH)*Za+uEcVJy
zlI@w~FQCeqWO7w>?(E~@u#&pU&_^HRMp^Hw7kaW-wMJxQrXi}Yl(z2CMcEEP{&3e>
zrFI3Bm$Ku#(sem|P;#^2>K8sd3;ux=OBdmc17hGnOJQ)qvKqJl(*GcFcz13ZOX2e)
zqdNSkhjr<~(jx22wDpOy55YOoKi23WjtP5u4fKnwkz0&MS5~pSoG}meKD;N2goae+
z6L~-HF63gN`oa>aG_q`BO4CO64<TN&W{mFop$)#+q1^Hx<zHE-X0Hr}z1r4td(hx4
ziF9QB@IsS|rtJBAS#g{Gd5gih<2<_sOS0X^au!uZ!BFCzhnse7!*tWVuz<2*C2hw|
z91w+V3}#~iU#6a}6dX&}0`vyoj+NgBnS2xDC+&q3*Iy9_>ZqQK>6^G0Shb(19H1<I
zR@=Ozv1%rkX3nIQH0ZwjWo`K0>xa62!hY{ZmeVNPUj@#+5V)Ohe>;x5^&1P}a?_T0
zM3VsXcaDwbl+=4w(o_-gN{`kkq}q#S$y|V~sSkm_oaBfd^}gi!i{=_94kwdy2<JRN
zhMN*D2-dvm{6jFMvL8x1AsHmCAaN0{Y6iw1u%rLdTGjf=mUlkp|8lF;<Z(MiLBfhQ
zsT&0(3%;<KLG<pgcI#L1-Ci!At$81Z&Ml#4zO%=hj=HyRHR_bFbEmo*&JvFn-Cd~!
z`UX!`Tm*nRYIn@%%8LP!53o2-WJ=!bP875Z`FQ-7z~f`B#eBgsW~f+cHep}*M{ai(
zLRCcv{Vxm2l6mT*x7l9vP0v_;=OAf@dm{-ERlgApaCB4{?HAttr1+QEwZMA(^ORz?
zL}T&KQe6oWdWv60oo}a&hm^1H?-oY@gP#8`&-D8sq>w+*^dOAVg0O>cu)@iJkeBE`
zdNuC|5&O!bAy*^%T+3Z2=GbVatG=UvT*5D6&h7PK(of~KSPxzhO|E|WsG`yGO33)w
zHsI@|Zt=%e;b=&=ispG_%I5?*$`y1j8$e<<WEGED1D)UB^=K~Zls+3@*ucI5`eq$I
zG!D+a@9S<VWHOF@;pt7iAZ+8Tlf{t60b|8ewmHtnQAe(W0c--ypMNDS@+&7Dy+NHN
zPOCgj=k-oR^TdNxnkD{Ay)J9D@I?=W+?{I{al-xen#UDo8BjBL@O2T!XK{ARKy1?;
z#RC`n<ZdUq)*=eez)JlPqY3A<N0tgva$Q7k`ah{D$q#>1ZqidHv$C51qHVN2EqSz)
z6^P@UAm^kj%j9`T8&;yfzB}TkoE5^;uw0!5As&1&DjCFOQxYvO;NNH6u*ThU&zZb*
z{n}R1<ul~{DzskX_O0x+EY<M76*xxlmYzHW{djCZ(P31al=eY}|44bJF2#xN3RE~I
z*v8VeZ@N=q=b5|cSIB!!UVq#A*83_q)dg%2-%$MD06VK1KW9wJ)m5_XA-_St|HBR{
z=dF!^_A;04gtsM2cI*XYEwAM1F<t#v-PWwJ;1N%Qz>#}4-JmM$+rm*+dq(D!x#pRb
zZ{Pu!Bl7PGGnz2FH-x$BQS;p6get7H{r*qMQko7MDY?Z<Awvjf)GW)^qa;+aHSo6$
zF>r-0<?d<Jq|vwj^nt$EsRwt)7NUbLg>XmsPkoqs8FrkxD%kIxoB`oo@ux>cW}1+d
zLXOqB&qW9ZIk{S=a#rKai1Dqed$=xwE31bVm5L#<uSIq)UmH<v{GOxe@4Ap>7$<LD
z%cw$;HeJYwXO3@$ll6f9yw2}s0&JdU5?5_*onk3W8P*eCp&r3XX49yMpK#{n>J#my
zb?;s?xkame3H!!O2sfjW`5h(gL11%Q!Fd(7Hzs=E$6Cs@9^DnT8c2}L-73N@4{~lV
zT&uEH6CJR2MLD{(;J=+tx$FpKf`_c!AD{m{M;dXeW|BYs>)x|nup|GG1o*BmQ-WNB
zq7ghHoMk#xHMcUUDIWimqYXtKD}`DRsO}T%p=NcSMugTkGqU99P!sHb{Rz~DnG7tR
z|DiTK!1<Twji(z)(GtAjpc%-q8heyb;HlIQIpAsM+0(eEH^xw%t?(~a*}&y|!K}6I
z+m@~`FJ8VP&?evnRW-hb0+LQD23p1t%sJ%rWgmkVgMWIDeZL0-tAMs%iZiu~9hk@K
zs<I4puF6J7H5EYMGU&dFy*Kc&8=8+F71hX|)m77EdkdZmO$}xFz3ihyt=%jbUn-K6
z*{F!|T*I%g4m^wyRVLRYdrWGRRr5QnE9kZlJBzdxIA!e9?A|31?fuL6En{t-{XL>T
zS0kKX8a#GAcYejDaxor+F=r)w(MarJ*BwTAEq-a1YzbG|=z<V->BN})mJ4<B3KqRO
zD~$X6c)L*Ug=vjZ|H`rvC+y8tq-2Xi*P}Kaew4-QG^1qnX7iqvd6g;WG?{CblJjBG
z8u44(5Q{st)Tlu;kpCA}A+^Bm*Nd~NJ5&r`H%e90V+SU7nb$sBA#6U(^z>$u(FGQy
zyc8H1BUn>Oqk~aQ(!U@vzIEE9;Av5<!0a!Y{J8VFPbNQb;!E>i$rht?rwTJa3pXFc
z9*W9fZNCZyvmveUbO_SUXnI2DL3$56l4cNa*ZLpPJqDv5Agug(mvqs=xziki*(7P<
zev!wTRzt-)I_YtE;9pcK(}7}1{VpeLR5)faMA4w^?|CQEwP$osZX?pmv*FN17KA$n
zg#Z)>jenfnCDTvsf<&g_*3M1tVtX7butz#{;ae?wA1>M*r)`Dq$Z<pZts_aSmDZC;
zr-XakX8#@o`IG(DeS{Ys3Pc@GkpcIAkF6fkB9S_;-TS&;KMSgedn@OnKf4Oqs`17b
zSkl#tOGeHtMaqc5nOpM0R1aIukfcI?^t*`>_TAL1q8(yH`Uc&h7ehNgq$Z<pW5-Is
z*2^02)`dbzO%@E1IVj3|pYIAp9qUQ2%dAO1SQQKepoR4bts1a5X+QULKsiqvN5X?&
z5tj8pDZSM+38g)6GbHGL(`Qj286b*T&Py|+>0sEXlh`}IHTTk>``Kp|z1z7TvpjMt
ztTxZQ;<5KXN=&V{9=2Ka{IV)>@!vBl-S;IB;37G1qx?&-R@2YTR{1o$9bEIacnd1@
ziWmgBDHl@(5&16MZQhoh(CV!bn4t7q0h`J`4=Mrk9ch~b2hv1o&5spo)zymU)ZXmM
ze8kD~cI!>V_&Wz|wnt865$~>r?<DxVaboR=B{Nx%mf4XFm|u#!cT4F)cRqGIpnUz8
z`C7OL%E!W6V#>SLa&$s$^Si#hwHo8Q^$_Z-IsjL;K|95*H-i<DQDMXmOWd{6C4AXU
zpRv^oO$>l1u)}}JGtair+Fa|&8$0!4!-j@iz*Q)oM{6?MoQ`uuStu*XeSfd5Z=*pq
zCB>Z-*>5duD*CBX_LIUkJlHAL-E5XLiq@@)J!#7#`WT-NF$BM6;INA=gT6z_GcNhk
z0*nuCaoGeL3OJ2wgSZF$W5BrvXU@pyEz4!b!DN#14eDQ<D2e*Qc5)&d=v?vz8H>Q?
zYU2duE92ylVUKs3(yEZ8vE<lQkW}R%PsJ^G{mW;@rtQyWrPs4w%&4_4-^${5c|6(E
z*X9C;gs<&~w+aqmwyJvE`%VehXJsrjfe2mcy7_01$ID*bsU%MJD+Uj+#S*BD>KgWr
zmE3;zkJ-S_DK;$qrQ!o2Cvoq;pPCpfo)e4KtUDUphWr9?Egs*I36NRcsR16GPu|Im
zsf8VOQKZbFA3J>Weiagv67$CD4K^eEAr-U7PK!IULipTgzsGz&q<`FBH_<_8HFV9f
zi;V@;pZ2;IV$D&89{tN=$^$ttrTQl35&x-AU7wq(UFN~&qq{7`Y+MH20)`pAh+gz@
zWv}+)pZ#4Gj9M2lF+Zacg#kgAlc=9tD~CRRvv>KS(jB$utvbndefJqn<m7!aZ96o?
z-c>&#QK4){p_=Oxl2Lskgucmq{bIKihF>^InY!tK25{-g=KW6?J%W00bwhF9>=y|+
zbefo8v<WkYFS)*73h?DVG@02lU5BOP!{4-Zcy>gVL!b6Fb4qa7Uy?*OxQhPfuS3cj
z9bde(t1;=bu5?)l)bqIj{m{-C?sT}=C`X+hXSKfP+Rm8*v{v0kGE`LFUOc1DWzL)e
zMB#%8i04=yA-Yrc(06^5E7}AaoOP#jhIvgqNF^l{l)EAysA_>Ri<gz|XAxi2#|EMv
z$RYn6xj!DEYa>w_*SmT);kBxKNJVPgN6bx3OE_~_<3xiYhQ8+xxFjVIZ+&6HUs*GN
zu<()kMjc_;r<eTI`HzsrsT&N06*zZ~?x0mmp$<PGv8{2EkfXcl7lY?`!_uB;9Rcr4
zc35}gQuqu}p*Hmp#<b(Xps*E4pA#VX{+z7&`3%KBU25x~vxTV1_3#Z!h~&)I79J!U
z!5__Z;zfdT%sW>hGp>DdSMp@8KTm<l#imLhHi9yn4Vn`zvq{<6*$>7$NKUW!ltBqw
z-)#{#=fv}gGD#7;le7!^=hJ#g()XDz?%e<3wWSd*U`9$*v#R3_@BP6cOJy-iB&a7F
zA13?acN8?7;BANu$#bVanU~N<{w!NdU-rjtO2wJu<N4P1mc9g1^sj*(xA@<iRifGZ
z8*IlY7Iml*%DHiz_d{yqi>*z5o%ogC=i-w{@Yl_{1nD!}u35IrAcj?MD5UNv2$rUV
z1Mr*ko;lZLGtQ=e#39WL#{N1#*q5hS`6?-8rIsp$8c9|h6a=EH)!vy{*?z|MJ$l89
z#xv#>L;7dG*mE=<pIcF(^B$3(H3y^-J-Hi^O?LIZX*AqEu|xKsJNnhzuG@uM>eazP
zaF5_<zcj-j4&xH|i$5<`WRll^*_4ch(1>lvfaOX%rwL2xe9@EjR?Ms{r3rhn4r5Fe
zL!Tt7)%9GKtL6Y2oi(rA5FYDXel$(6j(x`2H|<o-Cqx!ip01?I{8>9CeXPdXHsZCp
zmM?aSKj8(0G)F4qGriI!@Jk-b^d4@lG(vK+O0)y?n^%0_bfac;Lhc<)mcc{QKYP;L
z;rQ3j^G>-db6em^_jTIBZLLkQkKh0NTrGVi6K-VMn9%SG@a>L)ht${xk%UI77GyU(
zS0=vxqlL*R3}$p$dzkub;>@w?-t*d-3Z<Xw(=pKZ!(pLo-L{13O69I6rQ$OvdkI2Y
zJ$S++i}g$fQ^Tcw<zS$#0uhGpnZ0%7Z=KxwcACnNw<qrhqQvBvt5<x`Pb@Z~5fKB`
z{>*&qAjT#Wxa$+kg11;5k+E&6mI%n$YONCQmvJ31eo0~-$aoqiQRX_haqLP()>9$!
zl-RFww*Fyl)}^1nRU>@E(+clw`7ron`y%SK&$=SR7$>B>$uwM*fJB`1ko2R+-j_XN
z1gZZj#w&wrdo}FTf_*zpB6IGJ_-uMqDE&rVV`u~=z)y5Z|C{D}+5(}S#;T;YI<Y8(
zCgp{Y&#htKBT!vO(cowMo?smku6eM&u^rb1UwCLqM&>CupjO1Wqegjf%KeUAY@*Xo
zvdBD4qiDD9Y1-)P9JcXa3mrNMtvb+I3X}k05))FF@RAX^UBQ8JC3I)<s0c&QBYlai
z#NcHBQRoE)S*Rh@pR&~y%1nv6MQB1EP#E@!=z<E>Gr);5B2*QHYk`!^p#~re9{5)x
z8p=6II4xf2FC%i2XeA^mK+>Vh9Lh)1(Gmt3(XSyT%n^qRo9=M%>>R`Pm$Ta&;Hv7-
zWD+Gas5)rL1ez1)1!F>fAZ(#TsSxJy0Przx`T&v+Q)m@Y*MIB{s0)jxkQ2IgSU;!1
zRE8~rFpXj6AWTFUHzTr#C{!1ENr7@BgbBmVLBYvkHS``&pd&<90&oFBNhV|wk=t$L
z7)fwm*fwQAbJ!RY(v(O=9a=&eP##u79#9`9NYSbfEj4+7lq2L8hL01eB=e1O1M)~W
zLO=qZ1j6KnN%MXWhcP1;i9*$(HIyhjLU+a+Yuy=;4Mc9tH&^V&h@>aF!Hbp(rA7!7
zgtvo&OTuo}XcKk4hEfp9QU#=iWsr2dfu>TnszFuhk&#5%qVRbl6?3RP#SOYSBJeVz
zY+m>vQT9E!=6}G>1j3RSkPd|05;y2_@xb2_af!gyZg388CuAmXtqCLkk1rN~yu(nT
zya@p@I4x*N7=8)DG>5@%BP)nPO`+zX8vxls|4qDj|95~f5+zR#3(A{G<3N~SVX92X
zoAfvaB$_DH9O_Pf!w`rVyozW=44yy~Y79Lj3N^cNX6O@W5+&*_p{fuZoy<AL&Z<u+
zOOCQ9>e7XJ|A$TXR4B0<|HBPH$$DdtfS?2xJQ2<U%1wn*C-kR8g%Co-;j$!{@-S;A
zr11@Dk<b4_L_b1Rakw#|Di2%(gsBbVW<Z7z-LUWG0AoVfJ@`IJ=53FLuvCiHm(Vy+
za9J2T3FZNzwGjLlQMNd|0Ti4PHg+3%gTDw|m?&Ee{*tJg!6PzkfFk+h$USB4&&QJR
zF%YIMOqIc-B<%lY!H%~hJQdVo1kC_-=t0LQTP>kFRINr(9deW&p{f|13>5G8f;joh
zFdM5Ol$r>a7ADDnv>+T~l3Gxw{;xA8JB-`|p2LiZ$v`)8LPc^D2!w=q?u!)?m2zHZ
z_L>MzQz9_k5}24$gylAikHv2%n>W1ex4!s%dp$9+>(-`t@9kq^@_P2$46^a$pJ|-l
zTm18k5u$9p&8g?ZP*CvN=bxIj??1h(9E0<v#gdGp*Kbzv=ulW{hV}Bce94}1mYLf!
z&}Q_bivo<VSLy{AFhSjrI~dV!$ZgDnZdE3XdN+(dI0x=diEF!|G)x#p1y&VB8GuzK
zPzB(dHsHiycRGw!H-ZV{*F8(wrHNz&OWq02gP)S*hz69wpMl31I&?i!;jg<n!8-I9
zvu;81&;)n^3AY4Fx0{SIG!mW)P_F18SHPDH9ntV*5(F>G6f8)!qKEVYw=i`?!nH|s
zZevpIcyI-97!@u7ZcTxUgy&G;>fqdzxNJC@1Ta9(f?(pP*WK2)F{a%)bQsTWZbl4G
zH}~z}WcVdzXbZfBs>>K@1g^Oq90R8U<p`oIy0t)(biu{&NN_tq;!k;WJ2)LaOR1uU
zbSB~EM|pHdQ>y49MM)rr$WZVlQ%4D0nFJvaz}!7Xr(}vu1h>$4G`U3k$6QFB{RcV2
zMxYzQjA8GF&|#>$Rp~Ld-Kq>2<?c%gTrs?cs>>Xi1%})`{PmzWhwgd+1Q;TtNg$RM
z?Jsu_j2OU;)e6}JuAvK#glmyl3!#*{w<)be0=~i@fFv1~_*)G;qT!Py5Mv|-*qRR|
z)E!NwVu%a}Tl1ibz?bwLEpTNJf+s+>yPZ5V1wIJ&XXwa+SApDl0_eNxN$_?t4tOvi
ziIN2a{3vEHAb=VG145`EFoGVV-EGYr479)%L4X?49t3D2|I0YwF;W{06Gbh9VG<~_
zZWD^GCrEy<BtvjE+#7V0mHYyk24<!_qFWMfRYy94twm8J-8FZDzr%Y#+#;yQ-8Hu{
z`rT-X6?0@Z`0{o~2HcWFRSWsPTaj|*HF5^ra=Rl2{vY7vZYT%*k8mzi*4_NSXC3hW
zX`WZ|{|37M5#)gX9&|$gQ_%|i{|ndulW2|1$5P=s;V^RC54bfsE)C92h0B8@D7tiz
zvLL_`xeP`yU_jkDj2Pi=Zh#r1*Ue3bA?%i=2(5wpQ-!v}ok7<8D9Y|s@-AIuAb5<i
z!w|{aZBJ<>)T-rC0;lONp$M&l)004+BlW<v%)zDbn->62kXj&wV1Rpf5ao(G(hcl?
z2P4*<3_=J6D0Z7utvo>rfCb5MLka&6B^kwAyBq^!B=|QsB@loPG6W0}M(u+UOu;2^
zN%EUEK^UEICcpxz0Rmni$w*-LP@Ui#r8xxGFb4mCi;`ILqMmebQ>d6A^}FLpa)bl&
z;1b<gU`3J~0aO$CMz`3yH7Hapka=KQ1`K8QP2l9fJ3$EH0NU<$ij`-`1`-{n4xj*j
zNa8LYK-HZ=o_!Z3N%a)X{67*B|A&4B{!52%9GmiK85Ya;7a?3kV|}rLw2Pih4H;4`
zJ=5dIKb^C}*4SVWZ-*|9-M^}I%wkA1*zg=$3V4`9)Rk)!%klc<FQGl`?og<v^@aAK
zHUmNz6UT~2u;YidP8VYG0zO?2Sn?KBPOiiiECel3ETWJ2#t%Y{5&-(9%P5WfdBx3y
zn-Qk;LVzo&^Ex_+M%6Bq=5ldC2E$)shj#W?8BT%Z0f5IweHJD|<NNRQ*>y9nx00rs
z7kj17IRVqX<|rw#oKJM)$5yzHoGG)5xbYVyFAdSOU49)G_}YP9^gs3S1MAa;!Fqsy
zg7sSWA=)5u5r+dlUshC&AHdF?um{!`boi~+Km5DG>jFD~fi`#7f$nuI_`44-yqVkC
zeTA}OnFAfSJG8PnSK@s@Wu-ZmsiKYXE{l;2dHMVsry%b1#{!Ddy5!6bF>PgM%KlVw
zcBWbSI1+!8L2-bd&B>p?9L-*DLS(BxYj7XG8M(hQ1ke(4Zs<fMmXWSY|AA&nr(jjD
z;9|}YY^<Y3hR_GhL0w{s0lXDkx7NI_<Ia^5B>|emn0&uCUHufJ?u$`x`%rhq0l~#u
zoGx4l;Le7H#%Bj`R-f?=WciB_``MUzeE*ODE|T_X3%<=#@B@VG*gx(qzNRMgC)V{g
zepDP7KeWbcDxvp-x!htdl!ik$BXXk6^Ob4MyS(zp5S^DAb+RGdM-dCr*45D?(ud+*
zs<E94D>0G-b@CUdpG0>T7o5*7zh2DxwW%)jtg9;S-<RJzUH`V+q}t`MR<*!!xatWT
zeIqbyhv@v=V&lya<m+i+Su*1Jcd;3-UswR-&(};|?G#-r5$qp85c3RG_-y>d@deCQ
z=Gi_3-Qm+QmdeLoFjqnahsNo-R8Dqj$ULvp8E84_6O!pagq3C+ciQYZp7ifzWmFHm
z$ujT2B><(d3N0(2@yL*I#g<FI-rc3WxA=_f^?0=N>@xFosHN01#dq6z5@>r~96&gJ
zID70LpB&wWZl`X8Q2F{^w;TzZo%SG>ET?5);pTSTM|{`S7NvlhP=V_;)z?ey?`IRg
zCx)hW6A)&<W727(x`yk=?v05QD(IOkPgS$N@U4IOXsFN$|4}pRidqL>5Tt#r@>K;N
ztmz+#*>8l^l-n=(t^ih=Nr$_mfGkf@a{h0`@2c-~{PneepK{LIPMHF(z8C{}T&FSS
zr0h|B`HHVe&Dl|z)Mjer$$sKS>l`ZT8h(|WvC_vVeQL6=*xb1HW99U+cMLW*mbHXQ
z_%$%f-IQdK1b=zXTi^ObP%t@A4|5VSjNw$qp$4x1cx_DiJo&gWWhD3%(0Sq(Q#V-}
z)X}2i7h<Fwbh2M@c#S&$fj)TYhW8&Bg{|7Z4#i1yDTd-S6U9f`7V(yKr?Y#lr~W=c
znGBlS)Hpp+w+qbr(ULR&%*r)$8l9P4<I^Xw=-Pfo|K|%yw4`aDYi{4sh<i}nc?n}3
zTXD}(u?iaKZMnQC*{_ua7EZTov6!pk3u}K5bfA$c_&1t4Wbv{PHNwg5+8B${UYgmK
z=wkWxdsf*{N>rXuMCvcJLJ74RF2Gw8DsnJi47sH@c8o-S=(w^y>`TFZfASPkq_J>R
z@`UyC{om!MR~?rZKgYHg3O&$CHNi?P17bOri~9yD$A|9h12`~nDA<jQp6zSIZwu-y
z;iUK9EdsO2H~VVb;~as#m$mq<#dnL=*xr}55R+HvbJQsI>5`Hz#&3yrYTRI{EN>K7
zWq!3~Hrez9-z=qU4gR21O}6?@4zsuZHs<|P;Zl~XK{*lCNqOz$e-$6#3A?wGrPCD?
zQ{OC~<~aXSc?EcKF6&sca{0$!{c}LrUJH)yMjmi+;yE~h@3`xp0p9YC?9-~eD@5ys
zWXQqOL%f5w1v+TT4zOI0&X|qJPVTwVm>kI{=TZ&6-c~5_d#3^b?E)wAWwx@iC-th_
zL&1h9G+bQzaQf23DLBKnCVGW#(Tel9eR1y*-Y^vlY%kFP!8?n_-01aqGLu<l)qf(P
zY#QgZ$Ni$V#*5h9ihLEHNAAIArK}YS1GE~(kw=22v~8cb?0Fel^s+9L>qUw~+RUcM
zWoEW<Er*=+16Em3<sZi%diRc%#FDO*IKZX0{)qDcu9SgLuF&fjjn@@DE26dw6>$Za
zudOn`tRq50b|5F`rSig-ZJTPRtcE$>;S?ED4P=ITH=ZX6aw&|TCvBTNZ}6W{7j$yR
z{dKs=4*7l2oZy6*G}oD05j1()ARDwFgJ^k!&rO@is^wkyHsTK`teoTCe!fiI98YmM
zx}F?dsPTXkCXX&`jvsIbE?r1I=`eZPgl`APbW*VPd|4qw`SaEn@Z$yi2@^eH$!`1r
zVWorK->VrlWpeG@{Y94O-|2{$aM;(*{?BkXs%ZRRAGk@E;F#_jYvHH~;TDhi0GkjW
zaE6U&<<I+@a-jFj5RlLYM-6PsQ){}QeH^_xLY4g(Va^fqau~qJ9GV2UCC2~|2Tvcg
zq?{VMgb$Y}eE@5?>OH{w7R2C>Gx8TzLr!DnAza5gt-@_sh?~M!ER(By?1j=&-R_M{
z$KA+u&7#kZOb<V+yD)DoOS%zgSEdmwP6R!>jt!)5fc@2`t0~Lj>Tz_!Ks)Rm#oEZ5
zo7uQf@u2VgBKt8{mozXF8iz(GvZBTPV9pc55b2wF#gU>gT3n(_+6<2!j9Nd0sG8lb
z!drE&2INS}N`7vFt^IY7nNj9u7*XMb&0ca1gvLoQ7H2zcYao`~l9+a-4@?49x#;n0
zS2y~rg;1`;GST$Hl-savHWx-5_|Q0#UWl{R0hZ~e^9)c6<Mp;$J{1Nr3f9ATl{$eR
zeK2n1sj{Fy78%vL%ReKbI=I^;9@i3D-S9J52Rr-Ewg$g^+aGHoX!xsZ^wF8ZsrNLs
zZ>4>W>aWd~%WJv)dH)>D`N8o1{+ltC=9~Xc<Gt4_?Q_0kA`y~pZ{0#JWi9<@fdO1G
zpZ8t^1lZkI+;4}JRiC+4n|z$*w*9DgfgX)%!L8s&*DV1UdZ2Y5!M);{i3Y{uS;khT
z{W)qnw{O&I;(DIl9_Q|dL7z4)>YU(8=Ian+m9|<HR;QQTKl&GG^V*LkXZlv?^|mos
z>LSle(H#<|I1=9H!oFkCIhJhRIF*p)m>R%d^@bd{u8Zd6+HB>{d&O99H$_i$62m|<
zemMCp{(7x-|BktPm9w%+7uKY&*%}7t>se2lP}%>9PiF)=*Wn9o>q+J+vtzNQkWFWu
zj?l3fSHRUNcyWJ)wyvNw6wSkB>V0yd9xqXDtJ<3z5Ho#+L)F-HU`Ze=UioN%!i}bX
zS;ym2T(FgUZLRepN$xHBl5}kW-?vA<MC+-3_agLjLPZjw+Itl)hvo@|T(@4TADj=s
zXgwXKj}N1TE@tbv*P4w6lvVHLAY8F^m$YY=z6WTs>>O5mJQOyR6o?P=|A4^~Z*B@U
z1G%moLB2%H+;*qZM`UMx2LKG#b=7-G8-Lt)1p6e*J%9_h?)1!=6+U*YM&ltJ$2lcN
zqDl2vFIvXND6sK8sbC0S!1njssjI4YIugiFlmFpGP`@mnDCr<Cz%6%zBj7zG-1krp
zU){L7bLe+fLSFk|KY<})C|~Kdm)|$}ep?8fVL=E!)YER5YKfa7z#M~0Eq*#X^wCiS
z)xw)i3`X3+P;|?Zhx)}|NF5yPT>V&8q{1Oh^D{vZquvHJkDH1i7c185sZ(k1tB~b?
zUsGo<GTE<)S2VCT6hF)t#us!^e2?_<lX1(<k(TaVs$<*=Igc+zmJ6+mYgiuT`fVRV
zPAq@k7oTV=T@7gh(22sqf2I3#jM4L)=QOHb^Zy2ShXmdiN)`kwHD1p0QEe5M%8yvF
zrhD1FYp6eC)D8_EN)$D7(!PkqB&p;tq?)z6TP|PhuIO6Vxx77nT4ZHR!Ivs-*gKJ0
zrCh1%rz%o#q2sRm>XnR(oqkr=yT11)71$Btd)061p1J=;0n#D!c_n6dur&$0qD*`4
zW9C*5C9e7}oF?|NtdlSetY0-QSc%KbL!`^~z7|)$ST&>?OfOj!l4xNBRXW%W2Z+V8
zq7zt?o=My8sr(%8lz1Q%V%twCQ*e>GXPqR*y5QTrRPA&$JtW{$gwlEg@raWt5Q$~2
zVSP}Z|FiDg75M3iSoBT5(-12#D+5@XjBhOP(V7`G{!9>Qw`TX<aVUsNnY;FgqcLNu
z3PQixFHsb{x^~XHHXWdBsaxF^l4*4fX{A;dXIJ28pf1bY@M!K{G8b*G&G&0)&I|lK
zF7tl=+JpTFBkCfAclKd_(o(Wr<LNf$kSfM*_N6OcA9%%w{YQ9@=58SmoFx4n*E1{i
zNheuZgV=P|zR;s~sf{!L0s;DS9Ks5XO1Iq|n{a04GC(yhL@FmvDJuDMakg`-qZsWv
z64sMXZ@#OKWHT<xV_KH?IYW=7qg01iO=eY<E|r?*&u>9o9QMHJ5s^mSg`m+XYvId%
zw#jLCU_hvL=W5#+=ZYQDf~6_$aa;MLD)u?Ev%Qlvs5wMKmwn&o0Jk=Od_K93bdIjU
z9d+0W)eufOP91&z_-qQ9b#te29X*>Aac~`NGQiYz4$0szU7%k17!73ipl{4DR68to
z8_)+Zg*E5?ip^+u-Oe5ZK<13)Adkj(BNh;7iPzoRUAf+^t+<F*)7YuYda}IZIGOkp
zclO=!j&!l<9Wl<niZ0>Fu0I}}@?MShnui1vsq1EoJr?!6s+ezvuDZYPr&qDgHz}s2
z-S>L7Pe(SUPjfDw@wgLPTDfo-D9~l-7}s_5ZTXb+p<a3UVLEe4=j{+o3*5%Pd^Hi!
zE{$qP*?--Ej?+NXYTw20&EcLMSYKuE)nU+{7)Q(18jT~oJIB{e>@z;If$t|k7j-gw
zVpPGZgB;ucdxKI%w7O7h^NdR~%CR|cZdW}xxog9U8RGk$<>%abkc5O${vv8s{*6yq
z{Jp96*<AtnN1X|ofh)ji;KsSW!%4N<hvfJiz76U>FwI<coaq<A=Mk6c?wtNl=d8oe
zM8hli4&>vJhj+$G?#u#QUst%k&(1>ok=C*MTLdA{L8zgPplB$Zu-98)Z5Q+^?!~2a
z1mx!LeC2;mA~ALmUD$hk)&v{`ugG4LY!Q8eUO@pb8xZm>`~h?}3_+|)#zoqk9*-ez
zCzd3pAx;E+AXJ9#hiirJhp~q*hAD=*6Q~m42wVX1zjp%oJxDz6OEJG8vY_lBM%_hH
zz-eqAA?e}%j~{_H2@Y;4(atgdB;}yUyd_3(9X?BJLWCf2BXlD>BJ85BBn+i?xgz^i
zLI|`Ip$R6#_`(gsxZvl|BB(EP1Ue9A^ncmoeDm3gUFVrH;TY)!Ar0|s5-YMyY73f5
z0+n0AG;gRe904qIAJV%SY^>o@a0a+9ln(w5ZV9b|iriRY0M~)0OnSnI4Z<CvF;I(K
z?f^cIM;?40iXO~J0_0t!z0J_8MnDw~f)0i8g-wRf5^9AFg)>53p`6f`uqLRCX{jpw
zDV)Pb-h=pm5%!i*aWqlaXwX4|gao(XA!u+X0fM_bB)GdvL$DCs-GU5*2ZvyR5ZoOG
z3-0cAJJ0*B@4IW=ANS96b#>LLI=l8hRj{hNj_FqXjpZQo2<-TL6sZtqge5e62>iJ(
zNh9VpHrNzShvr-{;mXJVOsNIh8>2h&A7ig{byx&AAmBX1K?G3i`#$&w!aA4&X#x`h
zy*geWORiY2paLrc9ZG=;E?C(RGOSFD7HmG!Mm%i<-{;pH$9^jxa-IK*pn{K{fjDBE
zKN|?J3CIXk0#CpZeddoPKgc<YFiY-9?8wEANrcRbxP$=5C_`*R`45=4ln2POn4Wa(
zNPOhm2*U`hkR=3P-0SC6B-iN25aTn%0?d6BG60zjhxyqsY6W<x0VPr!vM)p%^PYJ2
zk69IGm0%T{Bd#N@BQ-nbHtH}cD{2J-SO`@F362EExqo%d!hRw!3lVzhiE!*}jLJ^R
zhuMhMh^h^C0>lLZ;^MN>@SYp#0AZH+Uy&8d71vxGPhm&8W7ZW-kaD~M+#SGCfWo3Q
z;Ve1dvsCO%M9_aoBVHpyBi1$EG5JbLM_0#Yh&17U)zMa786#97H==nmIdVD*9-FNQ
zg3v7^yc9-VKpH{0M8QV<$5=m*u}pz`fk_>2SM<OFVSz)fy`sm6D;phg9Xs!Fs-8EJ
zG!kDUgDmh{nE^VC0%b(j31=z!kin6~%tX;g{%>RvuQ?n=K@V^`ia4>{5#1q%sALG4
z7_LZ_5D-Ze5J@gaLPyamg6o%6O_V!GBS@DJY=mftIno0tEA9>~kVpS$`0UtbWu!wB
zA;<#J2Vo*$EwHIWr{m*)G-n84Ljtal{;@m*b!;inAn+kj{J#>ftDb9P!=J&ieTlCL
z{+Y;qEA|-3*kSmOJ|I=?jfoxk9myS;j)_+w9pW81fkPI=`_F_3XCa^)DBDP^C>0QU
zq{C+*7Z7Gkh;BeFZzBBDJ9h^Lh&`xOc9YCsL9qaUSkL?p9G@4*94lxmrvC?En&WpM
zGd(~VP?jC9VP$K6yCVTHdVYN-QGnBg-1y29@?Yzu9Y`IO<<|k_=4<|lhR7{sd?f$q
zW{9JYUiM5A(c@WZAUD{--=cs05wo#cp7A~7BT2<PN7_RAAE^N;0aO1>1d1Z*4ZWL1
z_oS%8VaMXb1DyalTY>s7VzeRLKl8-BW~!Rful-N1f%$=;##YEyWI?q<0v7@up8c=J
znkY7K<WUUKK`mjQBUC~vkSidXh^3$iMG^cVw!TR7!c|QF(VCf^bQ>}Z0V)vekws8_
z(LuV(fe}N~%<>9^c>q+YTHwEkl+=M?Oy>wWW?6xD90i1*J*WQ{jSvm72cK;sSb$!T
z1}p^nfK09oY)4!e<V{7~M`^(W9l-Y_cjR$o1i2p6anNA^Vwr>3jzZ7+zAexKiR~Ho
zv*>4vkXs-iBA@}07x6#skzVs3GZ>$dI^`hzi@;z3lx8q;rXU?5+9QY{z!Az&DL~!d
zqtE*0{le~W0mBKGF{&d5J0S=b>Jl0=NK81Q@AF0^kTpogEXRVmy1{oyo+QWm#%wEQ
z9iKXWbnJ8>=2C(pBl=H8q`)!%3hT-OI0S6}l;XfKOW{d>EM!ax%H{uE98DX$1+x(a
z)a7$fI4mm&pf)K3q6pXgpJk)(WA9_igWZjWC_)IH1$A(M149nRal4MK0H1)nz?^3|
z2vc~q5MzcFuMQEA!#iL=w#~)iBW(oG8cF_(7^sbqMoQ3sLF2!wi8SmeVCdriZ-&7k
zLLP=BBh4T+Am*SRBDNv@i#*CKoU^E4N2&kUE9P7XXzZU)G>)WI7}{9A|7_{4RCXi}
zI2j?S1rQ=Yo<R_#kf6_80!2XPd|n}0K{cj328jQ2Unw9g035!u0Kfm$SVG_&7%GtY
zC>zN<3IAidO$SZ@1f=OgS+H;iW`JLy7NQg)17gj8=2Tb8{}a|khj7PLpb;YQjD9Kd
z5=V&C6QN4<KRy$KtVh^-mV!8gz>Cy?08;W9NJ%W<9)Grk>;NkjvE|t;<^Rl=gGi`>
zXMr1_!7dO$hiA(Wf9!jLV$EM7#ummN#=r{h{~dHzlqC!}8XWb1xIuyZh-}+7Zwy&!
z0#^bgj$Dp!tDf;;f)gK><NqkSApjC!gouMgy8O9H7(^KWX9zIFW3c0FLy{5xY4V_h
zH-PtV>$Pl410}ef7$sH^Ap^0U)TRm*L>0Rc-xE@Wabky@jAVgy7Vr`r%I?NCWbJ2U
zm}JQNNc+zQ#r@lU{s9?<@bwD4*W;N52)WeCEoJ}<3-OEx>Z8yvFk)E*?13K6b$sXm
zDmsGRj7apR&^$EcRw7q`lid?fhXd#HHY8uvMl6tV6pcjN5dSZ}3cv4v%f-r--G++H
zSQDo9{D_XgRl+#t$aN!=xT}s9H|gByS420v$6O&OTKvq;gh&%pKwEerVvNF$pNb%F
zWl@E3N@ctr=Y)Ln%#S4>s<&)nEkX*6K-J7gVca>lXN(C-HrK99IoYcdQoi%sg%jo?
zQ;!l*wwrSq>N)l*oiD?c!<oZr!}Y^8!>Pkb!*3V0{I=Eel~SBy2X@rGP#`k-YV+@-
z&1f@{2ik0NM!IJRs)xm))*@zA#IUnjlNW@Sc$bYKG};62o|62Qi`0m7-f{sxIdce?
z*I$RO)6!k>b5wymwYf^y@6^*9aw;c`buY~Jlp~N0rV}NZ2o_FY;$Q4>*59QoPWj3b
zi$gg?G|m{ggFcE(9Wx$~2xuJ3L=~zL<dj?|az%d>(KwZff~ukByuB`<uVVX`%MnMj
zp@x++PCo|AR0_LJ{PR?%2mFGH`}Q{{v#qI(zaqF%?_;=tfR}D)A`E=L1pB0qH!6Qi
zZQix*ixOj6CT@;80c2H;J7=7XELe$g4*Yo=20o|DiFejnR|ET>nMsmkeVv%x!*eFH
z;ld}Pal#k^tmQ@iYj5@M^>v~vxn2i|N#QWKMXY314M@*eTT@e|>gj>XiqLso|L0Tp
zK*|X$RLM%DKKoxio&=NC2`Uk@YkmR|Iut&F|J?5VaSTgWV*I#20DUV$H}pA92?T{@
zlk3{`s}k{jWoMGFYN0J-&fA+rt_%>2GscUUOw^o`n?#N<5C!fW)h*`&UxD8Mv}|uK
zNXd%V(bre@ui^LqI?5drbj)ZXqSp_dL?Ofc=Z`y0gs&<lKleXFZZCX}cW`q!?Ei9I
zC;o01SY7*PF2#{g1Xh?y`w!^qNW0a4KqrF$kpETtgTd<l-&Hm`TS<o3h1s{{uUfaa
zIp}`^&>W_;3#V_OmAZ7=k1NE(e_D7)sqi<L3F?@z_re}CWT058@!?fPGsWuoOFRv4
z;m)K<PJQl>1-uv0IhKdNB@RTxsu)+@JJp@Y!))X|Rq`bst+2S`tAu@c6xHEVAOFm>
zhKD=6fBDi#Ga=Rw-DzJ<VNc6H>y5syaAzTRIbhV3sM46|9jvD{;#i{d(CPLKFM7a%
zf2TYsCjy_g^5snTx5^T)hyFsfh}$_W%@M~v-QamS_@&gU?**DiWA=`DZJANC2nKI1
z#VWxJXWKXL(9&;sid!+~(_>$ipuxLCB}Uj|Dd1iDnVhpuqT}7i#^iPEEWEc{jR%Dq
zz{BZ}oK82wReDcz&zA1&R~9nS6NIi_UX$HDqi9}boZ9PGk=P~d{EH*L1-wQ+xFjg#
zU1Y3R>{1=r%L@3#&kErR_%I6Vx9hCIB5rAmVr7m}dp}FbHk9peUEa1|uHp*s<K|tv
z)bSMS|JG(5bLM@Ug)n)>$y5|O9rs0a4<P#JfAi{z64##O9+l?eSAVI{tDgyfv8eR}
z(JcBhIZSX)SG}Ky*jUZ5P?Bj?L^l!QZjid-IH44qOM1CPz=vI-UA&_Qmz#Xb44kg~
zp4<DHbEbL$sga+`y6_!!lU~0~__J~A_eF9H{B{{-8uecDtXTz)<xkdp(P1m>EI*)G
zp8u-ooS#?LOL&;9a+!Z>16|;OBFxA7wFfFXzZ&Crm|@Pu%VUBYmrUJr!Kl&F07KC?
zBKDOM7w`HuD0Z)W9@1bbmR_b6IV@Xb&#xlS1)Q@Ue__83_?~MZk{`78CE8fUxW(fu
zZ!R0f0r}A&c2drQa7FH$RJjm7c)}`hwW)UN-mT_M<`K8dKTqnqk)-I1?1GW$zW^jM
z^&DY&o_$%%vbV_N+-4&uLgRb*b>gq(-!^eHn8n^dD?|5LcT=4^T36|9k|J;Xx6aW-
ze9EqHFUEod_JC6|`BnXb)q30|jN(Ptd$y5K-n(ee&0m{W%q%SrwGI^}`%lI|%0SQH
z&!0BC;2S`t3}Z<Y&3{VuY}mMCRkuUb;if4X7ORYx-z{o#xN2ORyD#xq^ZqE4haA32
zTmVeG$wK8Ow)xzc>SOWqw<##(%Psf}1ViD<&TG;n`H~6lW$Ewvve#AC6JVjZq@?Cg
z#w9T@X~vvkYz^shFQUROVYvX{Uh>7r*rV+yiaGWq=d_sHPwlV1)u5?T?LbRJO4<*N
z66>vrblAfyh~;=BVk#?6(@7XmT(n1WPV72!M0M<<DULppLmK#Rn+9+Dzh2iT=qtxu
zqtb?ScKZ#_aAvZ>{MSNRWTav^FV5<-h#Ro2EdG?Yxv!42rjCqxhYG^YEBr6r94K2e
zMPIkNanWeWod$R(y3E1G)?7T$DjVXl^L({W>gdW|tv1KY9Y}Aa;8G|q_<6q}gC=-;
z7iXIBE$_V8$@X_`_VwG?SzTKpiD#neJh>nh3`vp0@6)+>lTy2WeAS-NctH&?xR7m~
zmGzPjGP@q<f1$MQ@%3wq*k>GKc5L=L-(P*BsQL6x;;P<cCsR(~(8uKs^ALo({SVN1
zs2B7qM(XNka$AD|E3p99UUc2P_`LG-`$>}T6Ms!SI|QRC8n}vyw$BQYG4w-H3iS`3
zM>Am|XN8FC`&%fE?y+Sh#!KM<pDZd2>_1{t;zxyL&jrGY$dC-77Mk_Tf?Yc~B*$Cw
zZr8qQE{lhT{31qWuJW1cJ?h<)&zqZIpRL&6_u&kpH=FNJO|pma1Y87>XQNYK^Uv#%
zakml86nVD%N)&R43xl$k)6Bcry%z2pv~(v*O7I$A-+fn-GHfp(SnJCSm;{~08Di9-
z*^}PC5?q$|+jSxz`kL;w9mAgUJZ)2|Yct`-LT-o1e21A|9Xn`|70TeL5I12Y5dSCV
zFz|*}G55!4BX!QmUW3&2CLf-Y>(kPp(FAg-BqS+V?t<0_$(40FKRkQ#vZXodlGYAp
zAA$0FaT42SJfV_7c#OIS_~?A^gB}uoPPyeS;1|@Itxq^JD-pK5(d#Y<iK)3~;5X;9
zdhe%>HqdUX_C2j(*|rMtCYRB!Mx<)m7)qJ@WYcJPCHlFe4SUtHS%8^rC@uZA_X{xk
zdWa?c26(L?O!6cuhB|&;tz$tH;~Bs;XM0~6BGmm_K`Z_C4Ue=MkVG%CZ8bhtz)3j6
z)_w6leVTIvv0zR&K_qt5Rzcu>IxE)+%Ljp2E3vWJ2u~}DF?|otdo60eUM@DvelL=7
zw)Y|dT;aBVuU;Fx9(qhaexJU{bxG}){+H_#!ODGnJCG~EZofB-9L(pr6fc^yGokF9
z_+8rviKWj~XiU=vj1b3NYh@acPm(%^$Eui+Zb*=P0&2O8D{_#1UQiBcXY2)X<=Nq$
zj3?GK*(3agjN4X)6LKgVkop90{c`vlDDN`*hjK&aW#1p{TGDiPp36b;`w10FwNI40
zahf!d?W7w>1!;B(*cDJ6I}=E(d9p(DzzfPlO5NY=?$pA%zzBOP7Vx^<is)`s(aP!9
z>;8;sd-=zJ+FBDwj(vo2#ONmMiw_aJo44qVk2scW?{%fvR~?NeGTY;vmd9k{eo#u6
z3P_@k%Lc)C_u9JMY6Xlt*B-y8`Q}UgEJF8CV{5Fmbo#RnIY^#X9=vFDuq^+*{!-e8
zh@NczMR{nNCooE3mDC>$8Mpoxj&l$@EjZ{#@cm)5KRBH7LP3s*USyJqg*f%N*hn{&
z<3`GF%sckOBx!jYvBbmZZ7K{h2`R547Tyh-?v50Vc4f@`onO)^Bt;#w>5y?Qh@f^w
zd=JM^=8BzBSDJVFO1*WJ*BnhUYeJWe%#Sj=SWQTD09c;w61Vu5&Jcg&KghwWP4E{Y
zY|cV`M0t`KRlKEJC8v9k{^CAfiNtT%<Cu_b(B<SSb@M_E*b7K_cQ{9(SqU>|L6$mb
zJ!if4`||yV!Jy|H^!;^;MDPY*Sx`@Sq>#h#iR2#>avj$p*3-&jnnjXT;0?8{W~8e}
zw~WU#10dm295LqNbJ4&LMS@3>zj0Q2PIMA7IcqUVkM7My-|lC+Wpb9Yt}vgvew)l0
zcc&3`V=MLu2spL%;|<(C3VvXLBA0A0Z8Q}=WquG88&==-uo%0$p5uauS3nkvpZH@g
z84RUwBP@~7n}CE2iHRnU^Fp5{aHSVJK!3&B1i+Wa1$h-bnVZyMqT|?cJ-rI~4^-lo
z7SdEr*+Fj}N?~o5W0lEp%&tB~XB3*m`3IkL(%d1MiN3`T6ID@v-dt?iShBrRxL~20
z36#8X>1$OQ7S6t;jg!lIZ#6LhzBNbrh}neaePJYPkJ)6fzQo{>sxRjaBbT?QZI4L!
z3B<rPodJ5@VE1CU0;&4^gr~oDxGHAvqKrLLli#`s!<CSorc6fVBtB+u4!pgu)sg0)
zNk{r5LGMRmzdvzddnV6h*`}XNtw#b+4Rd=&zq9a$1ybJ?<Hc@*Y-^JNjL;*#wK6v9
zXQH<;?+|d9=aU52)OF2njkz81uymjTnk<$ycKaS=hkRnjX?e3Qf59aWMV#B?eGVOJ
zQ}&Vi&%$aw(%`=H)NA?V9D6p2x8L-42y5x#d>^nFQe;?jc<u%jWtH{%>I$RS$$J$T
zJS2ON-AJ3t*XOg7bF)85VfOs&jVd6f;%#DCcaO7K;{V_$U2#P`Nieq<pZl#B(1=}-
zs7Qy4I9n@xu@+-Z(ie56a7J*(U+0M{rEiGIbg}!=91Z{Ayc~-OPtTR@<!)m6P)FMk
z43~8-pP?(hTp#bnqSN|d|FX&2`R=;m!~ts4TNuA5#Tt>BpwHh_w_ehFK<n`pezmT8
zD6PEMYZjaFz9JK@>#VWv9xo^X9QrsjdZ_X_6R*?9GSM`|>f<+Mtz*aCW$X7Fyo%OG
zZ9-q~?`5IYk~ws8=3W<}Npbb~vMbFR1uiH=oIkF=?X{zBh$1`c*}Y+Fb%<R00mI3S
zlFy&dV38x;5%IR=p2ED6(%*!RI=aJSoqkr93mx~ND2UGb>TEd>wwz@GO9pW+bLtMp
zCA@ddu;@<squ-h3?nY{n>9%Z}q>&J}EnZ;?8=(!y{d=YS-`*%$biXQ^T9)Ms$4rg!
z57gc@i`BrT>rdCC3-{8~OAeIyyT_A?ovYLB8F~xNF^Z@^K;xw3guR`M<L6&r$hGP>
zMd#+*h(<QJQcg2*b2G#MhgS%+ycS-^vnK`&IGcV}Z=+nTsK_tKgmUl*>@oHT!gfOU
zYzAaz7z;=Tn^{&@&+C#tHOJk~AFK+HSG<)^$?H16nAvfh`qX?P0Dp8`d=<HOE@WTn
zYw;m^Cf~xrauC*U$v(v-I+7&kVwQBIk~&O#*93pl;jv!H+_Yy5=%)N^?p+<pN+n!p
zOnAnisVPNdfGcE<7LsR}_9w0&Uyda!TSzD&o7aK2+O4ML(3nb#J%+q4OH$P5avyHn
z>T-;Bx`VUnN-m<j)k-VR`*EvPe)ms?V?>uLJy}%v`E0dTtOYjA2hUlHQ<Gz+N~l|3
z?U#vqzkVg2nt9z8Fd>qUELVg&a8M%k{ck1yg>yRla-4pGaf8wlGi<4iT_wgYZz3YE
zuHfZCV`Uvsw|iAz(Qfrr8`^P_H}6^Y%Vob+xmIYC1UKGoNtI{R`}qZFYxNHv-L&F(
z%fP@x-Ip@LIED#d_qCR6&b#%pehSrcjeZ{A60+a&%e)XO1Ik~#&2yod@_Mvti>^hB
z9p(DKT}UdJXZPKDVe6F<;)NTFWoGV)e&_V$RSi6IH*7=g<s@t@Hd`aBSZUm{k6>7;
z(bDop%GkMGa`!y=<ZZa^f}+*ggNXw#h3OxydWGaDJ3MvL_=KICId4d7c6M6s<%HXY
z;!BaV?39B%E#OEk$1UV*Sf#_Fbe$rfT8h-^P1GduZ^3K%>%&*sJ}Bhb6F>TUJ8jp)
z$4<k9-F0+(S5ZSc8LpHHYFVdm26J6K&!C;=hFKI*<RmVhm@4jljOe@PSby5^npqF5
zgP|HZ>q-K*0*(*ail3^T4x-UA%K1Wu`nI?<q4b#*y1<QM-(OFrH%lC%f9on_tPA3+
z`6VP;^-kESZJo8|F{PrIl1`I9j=T`WX3Es?NG7jl{z$yzt8AEnzM#A`S8rgN!983*
zYQMJL*pxV7*t+Q{wR)G>BOW>JPc0%eO1F{W$#E)v*P^p&<61*Ac}5nSFeIGtX%3HZ
z;o{?6kS;)%nIG@NrD;KTuXvKx^9lRo4^cz^Yd_kr!lB`@O*rMW<Zisy@7l%jPG_U9
zF6!O`-9~|HPKMqRZC-;GA!{~XI1DjQ>vi{OR1}!i!*8V?KNH1Z(yXn$`}=HPU<MO^
zhFJJ0-ookRxycntuPp;*&UbyOcwyf}JdQgi(~msBy9}}39);k{tDx8f2hQr4*qEPG
z0EEBEz+|dI$;POZS&di!@Tq-U!e^9Y71n4Z_`u@7FtzdFPR#74D9_gmB5JfYUBk0U
ziK*?6d#a7mGc#h~;VQV{df*e~<iEWnyFD)LCNmq~>z7@g;1|Ab!J}zGU#rHv<B#@W
zP0|e*slB<?TW<(B7uhxw;*jSLS*5XI?EHZ>T_bhQ80RPL>@#8ENVdQjUAs)}msd&U
zhcUmQ@=(8@Q|?J~cV+n?T#>ND^%QVBa26|ar7;SPH~c`!O{sDUo~_e)bI>;uf&T4I
z{gF_p9D1rm5nC+4pkJCplfc+&7fvtiueAmQEl*ubr#qZKQLoc@1jcRQojOsjGrWev
zE!X9Swxp)Ig2^U&VsSd3(9YBD@jmpp1(&hvS)R+~J>hvr@^jd(-`3C5m>6uR6H1DR
zue<2f=dijO<zgkPG!?RzS_pSr6V_4|bm_^6%(2!hx3ookY!N)(UwBa>x?pG{|7R7r
zrYLw2v#YOrPMM)|g%X1#AuyGwI1X+XU(@kQJ=e&m{v(*&YH{KM%kpQX%Sk9!q#2$m
z@csID_4ZRkmDH7mG;dbtX*<<N@=6Ku(x-4$|GsjC_TMMBZww!$7|7W+pu$@XS$({B
zl{CO(1AUf}lL7wD4UoO>k9Mm&J_84WuPt+&2J964`f4eQ4)mbcv!XlizdWWCSNTdr
zCpG%_(BI5E-F#nsp1XJ6Dmha9Dt+d28-<=w^!xgGuhZ`E5`#`!zZ~;1xAW%Qha104
zoa})(h{Lk!6Yn68qT44U8Y9@U?)IEwuT~4%4c7G&(yiIUG0}m=x!xV|gUcvzbV&H%
zZ_6;>`FTBNE9E@Uf|pX`T(Qd^PH>%?X}6vhyXBJh!XM+t=-46K<lHRSmw6z3j7@vP
zAqt;n!{mU_^eKy6q^PXGw?sqgYWYsaXiPEk$>f4TXtR~}oNPlxpw7hAplt8J<83;_
z`c+QxNSNiui-BeDVL2dKkVh3DuUWW>ul{{UG$PmE^0BR^s$E{ZE#Y@b#6Ho;{QlRr
zVGJer+LvzC4{8&ap7wDu;z}9b+oyyR_Ms1Se;@H4RIv;)PSc8cqceJ#a#p+^(!w*g
zm}+oGD1I+&%zeGIOv><m`r#U9Mp|l5lP%l~=Rp%rISPF<QfBF9TS#gL*qUBUY5Mhh
zM{*Q>CCN#O(LRw{3Q}2m>Rh_&_I+Pn9Hd@?B=UB-$B*HjJ|XAGVbmyF`bs%M;*fVh
z8bBvdWfFb0*4^u5yRQ9mZIZ>+PXp`k!Gd;H#wcr?_(^NuQvj(=nGKYxr^wl#7B4?(
z!FNzad&IW(m*){;!a_(pfO+g&SJzN?%HXm%Ao|G{<;JF02;7O>qDXWj(qT1l()B5R
z;_>C$4WR`*<CK4D&E>^f(bsyWE~wgdKcz`z4Rh^g@ZY+Vgur*VW2W9?2NDOd3mGx{
zL-o6m2j%Vr$wxsdN~?t^q3rf@`5wgHh7bP!J`%v^#h}`Xgu&i5fYd5xidWl($pSq1
z$>6&6&&BI(wY}cqQ%GENW=7mqHN_EK#)%<iHl=0xmc@1ZNZ0t+{SoTB2$ztdiw|=-
zC$l!TYDSZfA1_5;xQ$2mc=p=hZzP@d*$DYgj_Q&RY)$BrQ;IJ~c(NAod~YgtcEi|w
zWwYZAn7j;~$-7>01KzYkLt?kydXmc?r3H%89EEJUF)p3`+EZ<Trq2|fFIkIa3$D5`
zJ_59cDWB8g9*8fVN`9G(`1%~TeeCUNr}FTc>UBZqKc^R~-<i`IY8fdFwjEeTpG!WU
zi4=;C#p$u3&o-+hehNdI3%#t&Xv&N*<aH)kzoX*yM>-P?1~S8J&~KQIZh~!nP(G1%
z?zc)_9&pbXw9gdO_*VW{;}H|#IpB8RU$m(pRkf=i)r&eW9dgUIb}?XlytyjcC0hHH
z5E3`iNp!^2XVA20y6v8ygQJe#w{@(4f+p<#$w2pW;@;S0!cUjk=j6!?2IHc|i#jI$
zy9t~k94&OhF~D^r!APN4?*P@pnzIwm^W4VSm>IzY%hvQ8S}~E+<tWQ1!fJB+g=pqx
zcUu||G^?8xH{Hc0^rrF?f%2vN;LFOp)~wC+E3}*I^jJTJR@?cl!4!qNeJPuL?`3={
z%H`J26@q4jn-*3FSuq8RjSe294^pE5ieD#1{!#cHu;u}N+osHj;_kSmw<)|tr;}J<
zB!Y2-49jT5rc=OAh|)_THD(eg@@Xj8w?(p7WZBR7bmm%|rh#GIB%1s2>&$T3mG2xx
z_w1>*!cDRhw)qgWzec%;=JP1o#;f;mn-=b^?>u=%^|#rbJfk%F7eR@MJ?GR92eqjm
zN<Y*6f!gFDufFe@`*c@yr%RlH^Xg*Kik9ic>6bEtmNV5qtmhh<4r^|7E0#ZFcrZ1Y
zd)H-LhTsCR`WWk?F9F5tn){aHhQIYMF6+19>TZV%nr@dlniIb~tO=k!TK8fzr<Fze
z^-H;J_RIz|^)PEWFB>_p2^($AM}-y`i*}I(kc2;ya6bG?w1vZ_^%wFtra1axno2?0
z`YLgkDXJ9swRs6r;ar}Q>YE{xkBWjCy?rbi98($`-8u3n3~Kj%egeDM@5A!^(9oT2
ziLCUPBjvSbEYzl|afE~NcXW9*%kS#d%X@eVuN-uZa4!-@BafhJ;!bY1Vh6icQ|~_g
z1gz6vyij7U*o)L(rZ2JcDdDssQ*aSHpxz4Awx80j+g;GDJLQE|MQOMICPw*Xd^e>y
zr`L#<Nl=4|=4d@t@`hXi`-&}}$RU>A&CQYn?dqGS-|SHEjFlhtZ9F>VoVrdw1<QYc
z2M{dHure`TG(OO7T@~G&7ri1b61jcS1NwJO*Y);v;|^bq$K{BIvW`cmI%P>1`1PN*
z3o4ulecL0{5jjXNaetiVhF<HM*Y#Rb7;3qNJRDs*EUMQTE`BdctF+Qgi2MVa2i%_P
zJwcD4md$IeMvAp$PYoBOPZJMH;zkdmqgqc6hjM!-WZ^}EOCndM=Y&s-en&q-<)4=4
zd7p4Dn&O`BJ`L%ei7ZxAPyu_z`)2HQKGzPxr@zu&$Il*zdrh1q?uEG3KRx8v^OYEK
zX;aYoFJY?7+&;V;uX^;L;h@~O?g3xiL?8onHe7|<V~+25ej>)p^|H|Si2m+t@9Gon
z>TB<83UpoQJ)pV@R7_buAq{zY@~hNuxGR1djXBG?FQD9aM@BTMu5{T%W~@-Qy|!?B
zgdu3q_}|s}Nq!f&*GeD2ZGJv}KyBb%8G8tsA5E)^ntm<OsAyBH|Ay>nq%NA_+UE~Y
zdn9!5J=R`yhyKjaHSaFmm9YS<SJ5zGs6U=GkxjfuB-YFlGwzS_f;Gl<NJfj^b)!H}
zYDN=taiXA<&LHjU(MxQpndz^NQAfEPxsEWgnK0KK+nP5)KMLgXIEwLB&ExDvx3mgW
zJ~a0wN`7m+q#MV|wNVQ>d=332;A97c3Cc*#+)9ujNjId9_u{QqOKWvnp)FF6W4$)0
z&0iH<-n6_PZm?p*TE5}g7(LE%P{aN|$@^iyE{`@helFjwg+y^MsqimJIua3j<h$qm
zuO4F<n9TUU$+bICu=e!-H3a;BjQZkKfUTNm*Mq;!WF&28cKvx^vgrRW>A7qRHpu#a
z8oYX1SiUh#^VHZhJ>$=nX8<@^S#Spx<bJxZtViYrg%&8Nl(4e{Og$+&`={HB77rRl
z18W$lS&w2D3%Db$B{k~i(W0q4Xy(Jr&KrZhuE~vGWcht7vO@y1UA>e}4|dp2kqttI
zvk#YqeXiuE-q9Bi{-UE>!@OVme6rel`8Hvy>poh{qPZ(!&;6E7rGK%Jk6~qm@wjyV
zPsng*rWj??^BS=ufEn5>Yv#?l<G5wI>FJUsBGtypS=pP=)$U5~3%8dVO_TBB@JAB&
zzxTpx;G7V*A{qH`%rrPW$arc&ARrs*Uo|Gk*Tw3<^O@vxEx%#RfSd(Ke}atJmWS6D
zuW#+`1QWaor|+1vf%mY|{9A}KS+-CT#Z)Dc3{K3JoJ`DDV2@I{J?79MUXv!up(20s
zpq~w`L?ssKmu*VWK84-75M>ffFm-1O2l-@XzjnH(aC>A#h4|Acvzvl6>of-U^faF{
zhRfol<exbbJM{{+s0MDu5$2Q}l5u3c1gN-t?MCN5nN)|)_AyLGm5}*@f67#EZGi0@
z<w4fK#^zfbaGMzWM^^rUs-P=GEpP1PdzO4qh4vdLDfyzW>)HxyuI-JihB;S`zQyb9
ztK`$CfcZ87jueIwn;Y|H1B6FBjYM4dZ;ko`nqBS@>q>qn-=@~hKW9*H56KJOD0;S%
zoGHVzwHwuO6sLz9ITe+MF~iD;P1568t&y*Xl-~@Sfc(&^{&Mzcwv-HpY|-w+s9lH1
ztB)5o{dVR;MzZsiGdb-)@TVv@2)Nqdej}IOnI&kawu{N;#No{r53f|Zb=}w3w;dvr
z(ZbKPtxb2?g@)mSLhTbWG;!<(d5_wOs=)IZRQ;MPYsJ*zj1)pg)N;&C$+I)T7Yi3-
zelC$$0M@6r>5pbFbdfdBB1N``hTNIBjil3P*{arslI?5hc!ggQVubq<>QzS+eypEt
zuT<ql5BE#au2wXIvHW;3P$021V3$^iuiNh~0K=+49)YH_<wkCnWYBOA<7rg5@kiU1
z{LomjZ|Kp{f4@ehce!b5t|nDt|BmEg*2u)O4d5hFwh_-PdDPT<Tcqvq60ae`O_H_O
z?PltL;Ogi0oIiwi_xDuRO7pwopTWPK;C7}BDd5-L`MAv}BH&1U30wWVX<RtI^LZ@3
z-|mGFb0zg{vn8%1ukn96XZ^7V+7Qnw7aWlaU$)?Cqwc?w%y3cUB@V~KDjA|W{GBSk
zhy#%0<PP>)MT{LkxXVy}y9<n!SD?zJ;Bx*Eg!m+LroX!oWL>(--*RFE3yWOuAK-k!
zc;T2Dx-d&4xpuiZ;W^_Nlk&$ShU75+G@qviD}KhH<k8l%BXP+jb{ktIMlUlvREdb9
z02=2#eoT#1F^4?|&8{YzyR7Zr3Ga8iAp}?iUCdRygiKs6y{4tJ^=p^6I?b$GM@XZ1
zl{APquY6i|QMxXIY8&Pe`qI=SG(NPFB>5IS2D%p-);^fSQp7TS-9u^Lrlf?dt5?4N
zO9DqZ%s(kr{aKd?B{eVVk-HEPKX@U~oHSV)%imr(mw9&A94C)o%KJJ^b_p|FRTY?8
z(NA;ua%RD^6NMTN8*bOd(}H@F#=|oGl7HiuEd8L1@t!#r@=(d`=<o8+&-dZ$QH5QJ
zH6uczvX>e*J`0X62S+3M8JngoSovk0ccEc<e1+JOYZTq0#WT#nkGShIw@x8nCgGyd
zliP+D363nVM+%tJN$V-Bys+rk7yuig<|13%`XmtjMEQawx@>y8al5f(ics=0P2gTt
z_Pq9iVVzo~1R^eAP+~OaT&&(sAb@?&Msp_osmEpe4S7SA19SPr`POo%>AA|285aW7
zC6s)|gDQ)4?x@R@X%=TRJ^9)}`U8Y;=M&=&pZ{|!>3bR3X3a+vt`7{tGXS%oKlY9*
zS$lAwW|dJMx54TQMyD6Fvm77eUelc_a5={<9Jn~{*&@&FYLQ~5u~>dy|J)wYOi-|_
zzIS@@usFDx>FPo==J?w`PL)MWz#86sr^+HO&|;kR*+xEAv)*>eQ+L5RaAI|Ud6aFU
zB&vKv%QL0RPWbGYRc(9SzX&)`$vdB5W0sFc<BSNEX-X4;wAW44KEpdJb$2H!5IaK%
z!6s~9eMO*3<gJ$X!pui7kvA41s8r`RouLiU6KCUBl=@`uu3|`0xN)}Y@LWyDy;l5q
zGI&5-N!?9X8cK;<q|ozDCyS!FljO8Skt&P$vcyy`Uyk0oO(3lE^-I7)o8+!dcw+ih
zag7+<e%T_-HF1|;tolpAZ1ZRD`BC_D87;w}$xOtOh>eti?5+8DCU$Y0Ho(ND*zFEx
z>g)nTZl2c_Mpj$wTn`W!iQlQ4gQ99Pj@yV=z0MtO@I@*_VEs_YS|^6ww2xTw6aTw5
zjDiQ}!h<l_)wSK=4K2Xb`%!F5UAWM+XMA89b+VgEk=LLk4x?PK(Ia)x!;CU-)#o;z
zJx%<4ilnW^8N<BTzg}WU@q$+sHbSc2j^(tw2(b(oD9WArut7~5eO4VSPj@Cr_2Xzm
zlIMyh#w#D*s3j4KPCBnoyyG*e;D;|Ju|!7E+;dt?C>yb-v;ugbM%+_yj|OA%efdCQ
z_WX<KrZ%cv_>xlSd-sXOG=qK`lXT9Y3U<MT)yr4-r(tPb++@4furqw+@FFQozRBZQ
z)`f#(<pH7>d8^9pI6J2g*p$ExvshQ2WQZ$g<fnWZ?pL;vlU`(RY4nS5XV9Yjv9wIU
zJnPKKF;f-gC?IB1xfq>_oG>q)h*j;Y3{{kjyh8M-<5C5_Kvrrx9%vOn+xg-j7Qv-P
z!$oGDUOw>QK_O<;u~;59agl-#K97#YzDOYl6Z}*L6-+r&t4%LRus5FXC=Ymni6qK#
z{Kk814O~_=TrFwNAW<AwgGPBO^I)z+^^Iga;D!LBso_*Q+_zQiFyB{|dO1zZeN(X4
z5C{%E!^IVFcqcmZ1vI1aYCO+u@Eh3f=R8i9d|J>!S@Gt8k+?2SLGbZ~R2~z{;AQhv
zrZg5x2I)Bdjj!#)1*qpeR6VF5js^j%TC5ipmhRp?T2yvTAof|ckb?<VbBZBg>2erC
zsDpPg$~%|oM_{wlte#%_u8bF$)Z-+%W1X;-bVuMG+DQL-qS$~K??tJN9=^O|kGkd2
z?Cf|((9j=$t_Qc4-efr>kQ;Y!va#*UpZ>B(=;FpiyEk>uLvuC|p-cETv2G!1y>JYn
zwF8b2&f1A|J}ix8;G)$SP4OM@kg|R==`F`A-aZfWv7OuK)54EEtx0O0+4QmwT0P&D
zmlN9+VN}T^Wtrm_x5IFHaIc!{Z8kh=;GbC{ko)fK*Ri>OmYa-0&Y5X`{{#h@Y8yh&
z#c&xrrW~_fh$`p8_K5@h*PAVt=u4(TiKQ5^;l8|(XLSnFz6Uvl@;iVi0lmxD9+n}u
zTD+Ck3ijOWuanAE40Z-od-@1<!m8qV+10M+y9%7#Vt*4KKlgp8JY>p2Phsq>p^5@i
zm?@0E&#16&OG?nNpyy)JQYeL!(O@51h{khgJQ=}Jau>7UIOZq_fT3N;rVg%p=%kbB
z{w)|^A_tolt`7wW-b|H>eO{iiO|zIVB*eRG`!v9%S9&QM-co8eH+i1%iNokAxg7mk
zXtz?8`lx}0e@3R<F(>wV-h+9ryQq~3{5zO3eva$HFm-UI-NDAwZO;KThr_JXkbx8O
zyA5L7l-j>fL-oTUDv@!SGOUm6?@PJ0ygbAUa{woSAKbjQO7d-^1`R9hR)4$E|M3Ob
zE#17;$J+?d3tvVqef6j3ptm2uCHQSAd)nHyfWG+jBNONtc8F{9aN9p98dUT54%)$K
zWW<Atygc|A!dN&+<&QQKEBpj1sko~?nrT&vG44v~lk@ur22h5gVO-6&0D1y{h!G%8
z(tq@V@rTEEmc17G;68!((&8w~(z5G|eDc`E^s5{pmew|wVlld2HSB3>mi9KTNyP-8
zIKnI$xokHXS2<9u@W)5XCv|1l7ycyQXj+4KC{&wO^t*#fx&+(HA^}y6o%|=|ASX{i
zHr!XK#<cbBuPbAm1B0IXxU3&g9m}_z#iG;jgERPdn}uxJ{EQB0o^N4Vd8TOi1>Ri|
z+8nf5I=p41&MaH-HVOp3B3XXqb^0<c-d#3>S@r%s2$U<1mE}ePw{R!7u18?`*`CO8
zCzz}MYJ9u-fEbjXVRBKg)J>zdw69-DV&C`@*upjvRz~+J9U$pWu={6T3v_s-m(!EH
zLe$eTd%fWk3560?0R8rQG60J`_YI|6yIn?4t89b!dh;J)4BZqtkFJ*+84$Bh!22|G
zyEywkrz;m)m5(qZ6$eT>pCtIku6pl!Rjt-W_AsT?nn0W_DeQ~O8I`-l;Moez^W$T#
z=tG=n;VuFIJl^V@uX8hxxO_RxRjB4QEmQ9sJwoMt?wJ8S>&R~LAh{%jtU78xtaV?K
z`7t7hi%3iB?|m2vCeZu?@fUIJt-NM5XR}zv&dJJ$lHcg*XQUtM(~177KPE&Lgw5%r
zC3Km+4YkQ*T=^xW*I9{aEnASBJZMRQpsRZ|csafcSk%{ayc_sPiZ(eJ8#4lJs2KJA
zQjR(FRjI*EGR|ti{84Zq*+l75V4uCV+0Le>t5$#`$z*R=FecN+AdgovRXa0TaU^qd
z4$o&(FJ9O|*O<%Ru-SvSLhsCtN^!60+<GWVa|m}nz?rmf>&@n+?i*U@DOw-2MfJP7
zU+iK9kn6vi1`ZM2KmXkT-`m%;{(Ttp9LsAT#r}TG)QNrYJjK^@W*wPMkq%dVTW6-r
zu35v<XUh#9r;*?mlW&pUgYw{gBMIZzL}PJz;++}aemwF9sg6aZ6T{HoY1-zWT{yNj
zeIqu`iLOfTWB(kKoS0nDi-GSTKj5Y|gMjB}r_{2mFKAd&)m-{TuLo?Syc$^>OoeQ;
zw5wT*l0eO8*v$<jyeSc)-7{b*6|43yHT)Ml^u$QApxk1cZ)Pykkl-Zo5q$j%on{z6
z6fLj6EfkhbG<J<|Gi+pmvEXOH;Lneprr1B0#uL}a+B6%QdwRREy=TfsGYRnlEBek&
z+Z|LIm0u{n!({2VxgSvr4>2cHQET1v$NtiJBqY9R9f}<)-FpBP#S$BFaJ33yj(RY^
z%N-lsT%FG0+Ui{Ei!N9FzAs9<{`sORvG?i)&7M_!KQ2R#lpRdl4%6xMrX~)9Jdk+z
z2bk9rwH{Y$sDx$^=&dSy$qBglNHb*@D9Nx~cq@g0YryvRas!U8L!8OM#AOzCbLk%5
z!<OvIULv$ASWk*qj0yYPbpzrYnk^M*R#lxEg(h$Q@H7$@NYGUyaj*n#8}4?qr|E6U
zNt*CTz_OBmXXH)}#GWTpUwn(*NAan{)U~1b)IhiA?;1mwN9o5czX_aIa`E@0=TiC&
zVSKvEuhb)1lxd{`gDPpf8=Dq6{n>?sF3Dm{8y)TCLuq1Pc0(5k<j6Q!o<V*S_h_DE
zBIfX49Q6_Fiff?+rQSYA(gqcY#Y?-$quaa6Koa|$AzE#E{+*jj=juCUm}w0!9as^-
zv2u+T!RL?yZqj1;JGQ9O3=yus0l_x46+8tKeg}kLWV=zd<XZw{b@ZG^$G6)qnW%P}
zo->}wOQx1>y<^6@op*Sx=YX*s+DFy{pkt*>dw@aZdTCr)^Wu4EqFc!m4~b94+$Wlh
za>HFID*h=Yu~XQSbogOdPE;g|X8U`*g_y}osU4uPEJnhTpP@vhAi75eor<OYHJzlj
zYpK<%3ObE7>8K^a31r=xmrz)2<9_;wOTj4M3}kL?z@NzXdScZ)-I<?FZN)6j<h&OG
zt?dTxmqsOJU%BbgEWF&8`4_t(QT{9%2P`t}uGw$tFcyCGicHkG1)Dm%k<gyuc{C?(
z1O1AUmx32hiL`q0ONV2`cy>D~;MRUE2DhR(vC5CTWoTF_OLNJrmKUR2?_Y|1Rf^MX
zuD~?qj1<+9ebwVoATO*x!#)RV)~V)B)Y|%JdA^V8YR<Q8Aln>rfo3J$@?N&t%)ruW
z5ZBP)6}=0Fuw9f_`Z)$TVBMpm88J1=Kp{!Ep%m=6?<cS6{5b4(R)54?J6;a<$YYVy
zR{z^;n*kj7a=Mq4#x9pllgaSiYFviOWn%Q8Zv#|1!qfO-o3AP-of*qf4b6zkQHzKr
zS)5*TKKzwCdzHTBiDX^X{U%48S+S015?s!t4lV9l50$G(G{>H22FF<~Is|tEZ<dzz
zGPkH~v!Rl6@N!8T3Rllbq6igiPB5q92VXbe^xs!&d>LD?6CS8AMyMK!BC-oi#@L>F
z?sE%fpchZ_<>V_Wr|idEv+RNIUWl8ih-pP$JosC#5piZ|>4H{syaS&L+$<F_f8Wm+
zR~JgitXrnN72o)>!N{N;*k1z>btjDIkI3T(Y`jV7zJ5|*R%}W~$cDm=Ya#DBm)Q5;
zMIIWn5tZNSMSf1Vax&b5jHn@)d$q{4OLKCf@W{C=J?Pt}9zx`}W_*-2V4HA_3DUZ5
zzsxmJUAz;10_gW_o3nssLzjk>o+#c~A*CcML+QPevyRhAU-kxFV<G^{$f1^K!zORD
z$idLmrD7|i_BW^F`J;`~INJ|Cow~_QggSW_PLq20=B)xDUhBq}v~zm`yfCJ)!MZA0
zm)3wX&7cgt=8tll!j4g!n`u?aO|0X3EJYr>OQ_+L&-cVKXC|poCdmnC4zgC@ZAaDo
zQf|C*=5lGeBbn3YL;e6t;o&<D_jz^g_$3vW%D5^Q^Po6OyKW`^#u4dRwwf{NS;Cq=
z>FFZoI^t@boYrOOS<Y&d_&L(kfVe8i`Ujd%!k0>tZ+VLB>*#ncsN^u#8})ZTN&h*P
zdQIHL#3Ezyq#{jEy6`&9_MSNY-Q7FsKl?o_G8qrZv?iAcv5|AY0##COK{f}+Z>SCj
zDbJ)4*NDd`z4C?pS2aC=hgPLe6iU}nzjlKQb=05=pJ|~wc~Ttz))0F-86oCeno?T;
zA>=o-wiArXR62?<Zr#y2|2A|s$r_Qc_|q;MdN~U(H$*wgH>@F=yKe6GdLR+fJE$WH
zDX!;h-wE7;HE;o(cAJ$vBWex{@bXLI3eJ1QuWFe`p|s!JMCGoRE3de=Q2cZgc=XvC
z@3Dlohjtc?{BYy910V8OPFmeNq!Cz7f9j<UK8Ry+(RcKKla*3r8O`0#&0(>c@7HO`
zjX&?;pA%C6_N!4O&8aUNFt(2E2RTk}TC<eh>RXG{OelaI+Gl@}6jxsO^1=<gf5fN%
zIYlK$??e8mf1%JQf9XeBv8rJ@eeLNn=wa-&>oe4t@c8R<^UNJDt#=pV8pq?<CfPPa
zvN`HG+O{aqR{Ucc-F$jC6L~w4qTQ-igi0(;y57?Ql*A^y!D!3*@MY(^P!bXSPYs%0
zp?-(wB0x=VX?ieU())>6i6#eg+6UHAxa0guR;jM#aMI-XXV(Kp0w|N7mHpxJGzgQO
z?V+Y!+MXG~<I`VSstuUC*!L-Yz0+bf@yzjk-1s+B(YhE5XqAdVtUuo<WntU5M!9|w
ziV)VQPQDgx5(wIWadu!#rV-@FT3CrBygjjv0OBsmhTQ64uZFCejgFpef0pqs^QfTP
z5!~R79sF8Yn%LVwYRXCFMnP-Kth}{QJtsIu&Y{p+OaXR=aMm}pnf>=pe1vUZxpyev
zMy{4Lbp~5~A+;fZAFp>Y9q$#k)0G)Ex{FsOG(}kU{-TB`NfQ_nzc|-p$*|}Rz=g&F
zDWSBocN{GEx1NXzXZM1=n^`-~EIN0v3U<8gPAw92rS8(##3NkEgX(1@mM(1o<cGw|
zD50G1lg3m|yW)|N3aa8PGAVQHa^J~`w8Hp8<ibp?-S}urHKk^&VN=WE)8X;pMv+b2
z{M=P<O1m>5?mwHH>XKh4=w@c)^`fu<r;;lts_;|xrDVPxbk*<L^z$4I-(<wTH;~ex
zw5nUr=w^O%l>Msq92kv%m{nF|NxNfIt^K>)ovXoT5zRD`^itPMp2|-#F6WkB7g7gE
z=F4%FKgMY6PD~+wJlW+R_-eG18#u;n9dxQCKrMExn#y2=s;n@1+<|N1uHxSYOyvBE
z7@Q>K(bVPqDquz8#-nEP?aSnu%_1Lp7wscf{IB~zpZ(W^KIhGy#YMk&EKW<XFaHzL
z7yfo}=NN0!z+Y`BZ0Csrn&f4{-gUGAbDJI~3nSSp_+-<;9}TSMb?j}W;mPrSGxw3*
z&Q?nxt5{*L1jy$8y8ji_X^$!*2Xw^>`9qiR_P2X439PHK9cRX{Sg3{=M`!bD>$&xK
zXVsA-$+Ao5(GNUZ)8%E8e$T5c!KoWuh!)55cXT*oy-#DO6JK@DQ>j8H1cu&*2R1dS
zV+mP6->`*5ue^yTyYV&S<nBw_Ba_EjIayMvbzLL*ZE^?h2FS|;kkYn~fuGlulJqc<
z{jTZf&sFQp)a;R7MbrbChg+eImZXS)yKTIzviNp+5G$t+$xi>J;C*4x4kLN4^UC~}
zetpVpwQqGbBr<!PX!#30+7@m0)a@S0B{e#KtzQS$ECiZ;GymRYU}|kz<`J2Lx(*Nj
zK2%!(_jYdWMo^Ek_i|<U00;)B2bbGHLr;M?tfCoyLgAM^{69SYGINjbq;3ew=9Gml
zJW0J=<sVHD9Ns#8UKHk|T&F>w){Extct;^1_r$Pxlb8~~!u?Th{5xxy&9}_Q@#iE1
zj&|P8nF8j`H-aI%pM)-QkdXA#2e;E>-PR<>>v5a8op&fmz;|%muYoVMIOgoPU(~dD
z$M>>S)=5LLXw-4lWz?zHImb3|2>9VIg}fWZo6#vIF4pJU=fuNzRV?&|RpgIc>dHSr
zK5mg7_MJH|kWh38uU_EflO<?qK8@{e-$^Pcua$=t6k_aUZD;SL4G7C?AH5>(OeHK0
zTf_DKofq`+(p9Sa;{%}3l8RWEo%yBl-L<^rU~>HXmPYty+X|gLGzaN293M(C(PX~o
zfY=`(rQ@NlMbRa2g7f)A?2M1r-|G1NIBA2>_w{Oz^H}qSgmx~&ZxY*ag?pU#CG`5O
z{WKg2QXykc5&f70!|=w{`wzTI-$n(Mgsoqf`Q^U<-!D%9isNw|Jx}kgc#w3LH-(q-
zM?zz~m;6^xjGk_56B|yKrg;*b_=Ejfel&gT^nXA0wiNsV>-O>V*j`EC%Nnbl4@!z@
z%j%KD!~UG5G-OfOR%P}v#pB-$?1Q5d+Ln*rOx<Y>ITUNlNMJfV31yPobd5Q3kzq;w
zp9}Cmw<o|}T%v@aU!Mk-j5;j1tFN$DUY$6Y)%h;`4s9k*?Kcw|B}0lt%eP}B=bgUr
zUEEKl?zMV}o*17*ox_ym)UARidZ&1xo@iRJXD=#W`{uwaG{Z|mtL%JqTOAZ;@S>?x
zWQ8J*&7Jr7gjNlm>&UXJ4q&F7J8A%0PpqK)Epul^-_2Jo+{Y+50fx)h<4)|_l(6%E
zR>`RkX<EYIpE1;At}~)#TYqo7_oQq(2`^x{AF`6wsLp0Ta4i&}%l_c$#PGJX=oP~%
zWc@PX5qI^}G+X{PDH_{R*`y6ww&NACtQ~`)!gUU(m2k{ysw+YHN{)h=93T{Q{JP1x
zS}IHYXML}q)QS4brDQSx!Jo>bE<1kN<K@%^bc)=$DBTlDm+-jKJZ~6n8GVZ6ZKA!p
z$oi#PrcSU+pT<iz2H$MB>EEefqqu<;*O7cTALpSAx)P2~NH6*KT5Gfsft*gYOjvMf
z@57)Mtx$vDlZEgO`b?Z$K48OywoJ<#;EDBVi{jpg+Z5;1izbr4X2Ewl0PTk<-1?vI
zVdcL$(IR>kid+ZKjA*pPC)j1UMmWD_#@P10*8j*Fw3qI9{qYsy9(u-A0Z*Tq*lZU3
z|7q*WgPKU2egH*R5OhJqjf#K@BqG8ZPH#kx2q+*#B1TR*G%S~dj0%E6IOH&(fe5I8
z+#*7hOKu2|Rpbst$hC4Oks~C8FI(>)TkrRMGgUJ^HQoKpO#f=S>#2UaA-%50=0^8Y
z4(K0<crtN#`W9Lnp%dqE%KVLoO??6a)`7H-j6>{VYL@`ug?XL2+}7KB?)P{*W}j${
z&UXHk6}O`&*T%a5;xc;(?X3u?<i}F6y`NL>8k1OxO^=p$qbYY`RVm@~-i|_>xXGR&
zrzxYIGTlQ}{c%Y!*$KP)B*gX!n{^q|;R^70L{l!pxHjQj9Qd2VVh>gH+t#Iu2a&Mp
zQU>IZ*&Sdfr9Q6rMc^fEp{td+aOiCSSlOzL*m6W?t*Cb`r5`CxKJ_C}Z<|tJV)Uu6
zMgekx#xqZT)$d4?+vEM^3Chv!SocoHk9)ji9bJ--pH9mnMzp>y^TO^M{N&Ou@hEuT
z-S2L$xZ}M6bthY%oI$D9R#vhjQ!I+MR*89y>;{SesEHs7sO+f4P-1Q_Y3wk~+Qsa%
zFdj8|=PS5rm-a&0a>$kAmOWLbQ^i5|Ci&NK0dTGkCG2LqNRrs>PWyg+W|#X$HX6+L
zGt%7jVGa@L9>+`Uk}~MuOYGuZ^A*+(xEgABuV2rcDgRs-IXf`nv1aO;8fxi*OyeOg
zo|ypLg+cnsb77eDhQ$RA5PhVL*5XEuz_dS!_88z8jH-2Ur*#7&s9?<Zo>^SqT0<K@
z)1PNkRPVD2<|l36%$g8Ny*B)aSu7dYhiaXhD%rdz&*l4$S6XOe_YV%IG4$;(9Aq6_
zOB}BFyV4hE#tos(@}yR`QOf2<XC^rS@cg`HOhL4c!}BD}8~K!?WZ%b?+y+Nj#dau1
z(cfNRgs~hxMqI%yOR!bXF>5e#Iv?`ew`;<8LmYL1qoReNUlt;bCq)@WGgIu5LS&9P
zQSAHmIdv$Y%n0*>G8Vnz#z;86h)~B)Twq-j2F~o4&hqDVSUz^ZdF0^lI{}<2Kcg-M
zO_CBED?NywQCL*1I<(Q9fY?vD=BG+aWEujI{mgM4Fu%y{=-N7GW!PfvQYx@&$WGcs
zkXk7qfpe4KvXu-<$gj(;vvPJw*Q>IwSk@X<Uo+EO<*dI{V#yK{aGawYk!l~$E%X%6
zhJL`8A9|$IV!*1wR0MqdbdMfk@0Y+i%9YAaj%GO9a1}nx<jp*Te_m4aVC<+qu~<o|
zZ~o(`!rWo}vt&|#O}6vfHknII4d_-GOtXvYZr7#uBjjLZ9s~&_*B<K3i8$csn<}Ur
z0?)zY6RtcDHGfp?M&zH%#?|H$t${vbqVYBvLpJ}!hZ)~(G~m%e`ryoDc6cB<H+pBe
zm=Vj!{JH#aB$_o|eZ6UKqn|G2<{?kia#u(dp+kjCYrk10h3QMKsGQ4U-<!XyP8Mp(
zcAer)69+Y5T}6k$BacJc2eNgAqxPLfERd#&zh~psC`(m7UKuVjk7s6TcF2*)Ih2>t
zQsb2E^VL9e_rCcgF7?ae5lYU>T39b{OexJ419kT-3X9|$blMMaYO<A1#@D%1o^d`^
zkc((<Da!1bp*k}c$g<44jTwY;g;&OAkf>#U&~sZ%Uv5*8U7q~J?57DL{bBQn3yjS6
zy7nPCq#X@oM$q1<8|n!42seQfxrbGoZcdFNfoY2)y*(zjYT=z&tn?ediOJ4grG*Yn
zr9KVwA@@r1ksEF-3^~RZcnECDvtDoZSS%tL1q09knedKLE_Y#3D~weiw-24O)baX+
zI`;RP9WPXc%T|0(HFBjWeS@inOyt*x3mG`>j-wPP|NVWYezWpEQVY01AI~>=jRul5
z&p0k}lSJ2%3|ZonH#?NhdA7W!(pz0|MF_?S_L>Dcud*!w#uR*Yf}@Fd5^w~%QS~e2
zg(j)%sG%9_s_(}AK>r;FLZIC-YU|}NouIJ7J(bb?3~?U|k!deF0Z*-5;+W=8+Aj$`
zTkxo<O{ZypoHZ?Ke+D`Me0(o}>fV$;0;ac|Q%YLp39h8s3YE(eMci|vS`m>F3&jZn
z&68FI8d#b1`u&K`7ul}nv5pIYJhe_HgxJ_NVkn}nr3tPMEYDS6MRLs(bL!ukKP3>j
zB-*bPJvFj?*lqUg@==<hWoJV-{MAj-uk|3>&{}qz&{#3+=W?hU3qbU&H3WB^E`wpD
zpLa!a>#95!x%p<vS*z^z*z7cC(PneNOH(7OzpNB%%lk%9!z$@$UpX|M#ye-FJJZB6
zt1=tjA(9(+jEBbb8E1J2n>0zOw<dpRMJV&!^diZr{lJ`4QV5nBIY#7uh1XY%JO6-&
z^}`qZd0(xb(ry6i<dBUL%g*~9#E#QyWcW?bMb4~l?nv0tW#>z%#r{&&3`4mFIb*sr
zD;CSDO(rmFk94gtb4N7<z+%JbQSf@~=)Nwr6gew|_a5N!t`4BZle-$hUZ)qiw%{^#
zL->06R<LYgE=E4QBa&-=Y<!G9>^$troM@P_Dudkv%K3-Oo+X(-ti3lGr5D~6(?vlM
z3G=J34P4F(_yJ{!T;X)lB>5}Ya!DDbi(gOk&DF!=*@p9Jw$#pwVxp0FM(YGd+973i
zdFkFG0{=15xc<N@kLd<xGoi0g{r;R(L-5=&B!>`fKD?(%b*^wpcyjeT66+t+#!@;b
z0;Iz)Mz3Fs78WOQruWKry=YNzdn?*CVtAk~s-L%b9mWjtB660vWPpj_)ZpOfU2`Pi
zKc-KCHP_}2k15f6@QcRqc_`1>O(SO73`_SFmj%r0x>;r={IvB!x+f~H^X-wg=&IIg
z{uX-kYvM<a%-T<QnJY#*ekM#Zq~$J9=7?zz8Csg^;bge&Uz60_G-IR1*?G6-pWf-G
zb@?@D{6Ja2o~0TSpy$U#nazn$#sAQ`lBd(>R&C?gp%y_-)mD_C`ApxaC2Wk1XAU*J
ziE%cQaU!HM@!XoN3v|KO@{zJ&BveMgP{wYHX5?1OOZ7ry&LFv$_3<?rZQxU{-LmZS
zaT+VvO=oE)7CDOVJ61zjY9&x-o^94%hb)_ln{qYmQzvy=b;S{WF4=k}qklc7J-jxH
zY_l)R^j#kXuV|MtC21*+q>j{rBWvqFz-!vzZgQ039OHNPmYpVJugKsnqwfR?_ng4~
z-K3Xpo?ws0rvf&}_nw{rx$eiXpS&jKL3K(fN9RvQztC0u(Ba*4>+XFQqBP9^S~@Lu
zulqmUgNVTTVo1D>HNW>BLF2pYXXx^yl`<nZ?GNVk>LNA3-4@s%%$S}YuKw0e-EJPj
zax}760W+wF%O`NBV`F+$qPEi>7c_9QVtS&h9X05B)sPe>AgHpL`jU!jG!J`X=~dH!
zr(ugZ&nBoHnGG$QWI_51glPw&MUK=472Kg~`I6$clltUuAv31~znoI@30~Ij?)ApX
z!bs#w*foG@PQw|ad*LWM2L~gT5<Ushr9<ksg^&2a+KLMIdq?gvLMH)F$BKQEc{hs?
zKU9xv0_+*zuSqAC=4~CmG!-Yj{M(93T7M8h8e!-o<H`^$>uRS(^r9@!X@Ga_)b)yG
z^Wk0#%kb}!7nGZR^M)~ts$jj#Homj52!^yz!S04%`Z3RpFs7^mSvblwm{VD8?J%_<
zyp(b!eyQ^WsXwQd^_sv;syYkdQJ!T)H>_F!owg8;+C?TrGxTGW9y>~Am~3GAcjIt!
zaYkiJCSsa>TuY#B2~(A~&J}__p%ah-OS)zlcfWrByA1ht)rHKO1_?dpF00rE0s*B~
zbrHh75ecY~ZKpyAOj+VXbmnw)l}#|OWk(;em<YXS58*`^YKgPZNu7uR-b!``;5-%k
z*sm=rrpJF&b%huHOS1%P>1QWk>ZhVEL3pW#`fKa$ymAuy;Zl1sbw(Q~g`(prXKWyx
zST|_Ida=B_GeZp-?@@@w${LHU(AW~A$L9O|$;bo}_{Cdi*TAd27pCGxuKrS6a#Cn<
zXDxM?ZtW&8jMSEZV7PY!*CF`_@O(!_CWL*tNtew(7MQ6=?eHOWg{)Uasd?8wQid^g
zId?Os6`+f@;XT`%c8f!T=JnrsLP~80EmnfmPHW#KR#tArLZ^&)ormyZm6A`GFYiS`
zeEDi+N%teodeJZOn5%*rgwT_!;=OKZXKjILf0Obwl(WwdAn(IU%9AZDgQ<vg8Nw~G
z(V*3?4x)jEi(9)!9xt_`NgV<t%QMXgv!Cl2-~8wib-E2Y0)}<XN&bUGROa-Tm5oEb
zeDl}nr%M+MdYAJxLk$WvAgBbywC-QeqJ<TD2)v(^)q{ULa`U%FA-Ljb$d^~t8Ss76
z&^H8NI;q+n!lNJQwy<2Fk3+$HOB`9<v+>KO9yn6Egv!b<#gPc~(&Kur>pQYD#G!d|
zCv3dU6$Q_nW~Zrn_gQ)6p-w|MBZh~?)_}jTLZ|#OvyIeh)uBQH3o3?vNG%>!4#D@f
z;!tA$p49JX1*khaT2-!Ru3B$4NSFZySgeX!VGuFA+)zAt(x_G)-<$YV<oY=U^V{<t
zZ;^(y7@IXcForpx(uRIaY<)td(=G2z;$<*KkThrPuDL>4&4^@U-QMMe>`adad1o}s
zeW5*^)NL@IHi0>P0a=jyhY}puG53e1hLNX{A|LUAz9NkT3mS<;?j}%;TwI2xrLLL(
zv8HW(>+qB_Q{L-Kbk_8pDpv<SR<^TR_)xW<|3<L+<+Gu70+de(?U@Es8J1aX#Ivq)
z&9}d0lcz^s(W1FgQ@BI|cT*{mqRa<(cd&895r^CKMyTaJI!8k><h(d44#)9hn)`W2
zdMq^RuSdbiy07#BaHN#D-9@qZUT;vIwc{eE#b7qGM(C2skgRO0N3f!=q@bcS6z=KE
zQ{N%)=@TFHoO(WTFc}qftarV!q{B=rnpQ}TsZ$0P`j(F!=0xvl*4#utt!yhsIp<l=
zuGJUSFNM=9`$U9}G#a$EG%bVHt&Qu^WZwBJ-C1P)3+Q662xDY>Z(uc^hH6Lr(uQ{7
zR-wU36Eh#{4gT+Gb?fe2B=q4%(Fx~R=dqIf65;pmt6l+rzB^@Xa_xl*@tvK$!y9Lf
z(N#n>oAIsD-*<xgaq;8hpvIt%&s~ceW!`tr)gprGpI0V--&I@fUSa}x>W%0GWR2f8
zD7PPRug!7)Y~nHZofR-Sezx3o!ozlUbHy&EDz99AD0F4|ev_pW^t<(3$A(+uRn1EL
zoWjcGnD=?ZMRVmFc8xcP<q@-?E5R}OQ>9Dgy2+x8Zw*JgP2yEZop-fpO8$x}g~_*2
zWsU*3KYEj&UVLLXc1d**NOnQJ{Tke7Vwz04SXcem-^QyZ7^R86lRI9Hv91`6s0FiL
zYW1HD{ct@n#n`r=<3oadEjy|E(m(XmSir!^iT*L4BG|~h3HU`LYs%*v&k~M9juU;p
zeL4A3?hWbBQ~gC+;swI?Nk84(FLw>1O`o}Z>p5v(H0WZQ@o{kMLk2MLX7bO2$<=o6
zHizuOs$P`KT?-wW7AMC!8C<n4?U;3|y{caMyi{T6a@hM9E=8r~vv##Na?8Wtg$@OW
z<&T#xmg{(Qe$1@13oHp#ZV3H*fSTJDasN~Bovq=%;V<PjpNPI5F$0w!f9rxoYCuKO
zr<rh(sP$rdvq<w-j!&SiclCTKvM2`V-qG3o8%K0&72c$Y+~NqVH?V3JPc~oIZM2%X
zY@uFk{#;AlLN+!3f1vnSzex+;+I_`VYMUYm1lkF*_1blVU~L^UDG372ZwG;NGratj
z@v2S|d+T~lCE_H2Ov62UUG=_Q%P89WB3SOX<;QA&KQb<89sH0EJN8WxB4<v~&0?3R
zs|6K5SQ5~1I(}wwBbdGcBJTi2^_5@Qpk=Kc_&Gv&cHd~?VVb<O#RQ@3Y`X5REbj}_
zKK65}9^Ihj&&D|>0j{p+Oe%KImcjf^j@><}R2A^qC`jI&4mcDIZ#WYMG{Seoot|wU
z*6b5rKeO(nHuOmKsmE5?l$J-Kahb{6L6y>xCxx&eoZIJN<(m67j=8w;<k?8Xrq#z#
z1G0AKdl?6dgq{;qQuaH&{gsr4Y7e!>c|5=5^<gL<_4*oqqMi1=p^#zanX2%p00L?8
zk$@eXZ0a6aaQ09+=24;&R_W$!o?p9mIr8WBjVM`hU8?t~JF*C{OvC<kDaK2Wm%3}S
z>AANRtFz9~1lc29`o*uh{|bBkGpbSwCz!hOxwxBoqd<O4c&5NpyVTUE+G!^o5J}=Q
z;S%--+rp)9RLYsXzAXOw3cEp|<6^t~yDfk~_%tU8BQps}MbLjtb~r-%#%-_o1os^v
z5OgmH^xMDOV(PIp2;_9(%z66@kf7UFZ2u8^#!->|mq%I-FClK0D{1?ChQs!g_y<=c
zj!AwxB&K!ogI6S=l9W*VHb;pVvwdM85EAVj7z%~_bNr90e?jwkA<0|ft61%_BuM#R
z?P3ZUj?XuhP&$4)Fz|m1{TI^yO9*c*fp2t_0RIC$1;y>+mjHowiFX4j5QubHLVWc<
D;eW|?


From 654ee371ce6764164f19cb100e337f5984b67e86 Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Mon, 10 Aug 2026 15:34:37 -0700
Subject: [PATCH 09/26] isosession: repack SDK nuget with 2026_08 reg-key
 App.dll + fix probe network policy

Rebuild the 0.2608.0 SDK nuget's runtime/IsoSessionApp.dll from the OS
commit that pins the reg-free runtime dir to HKLM IsoSession\2026_08
InstallDir (Eric's authoritative MSI contract). wxc-exec re-fused +
re-staged that App.dll. regfree.rs/manager.rs/process_options.rs drive
CoCreateInstance on the private-CLSID activator; error.rs surfaces the
underlying HRESULT as error.nativeCode so a broken deployment hard-fails
instead of masquerading as feature-off.

E2E harness fix: the backend-availability probe sent a provision request
with no network block, which wxc-exec rejects at config validation
(code 'policy_validation') BEFORE activation -- a false hard-failure.
Add the canonical network policy (defaultPolicy=allow, allowLocalNetwork)
so the probe passes validation and actually exercises the reg-free chain.

Validated on iso-sf2-repro-0 (interactive/Abby): 16/16 E2E PASS via
co-located App.dll -> HKLM IsoSession\2026_08 InstallDir -> MSI 2026.08
client -> IsolationSession service. Backend probe provisions + deprovisions
an agent user cleanly; no leaked agents.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: f5cc2011-5308-43d6-a8ea-2b8ed9b6ceb3
---
 .../backends/isolation-session/oneshot.md     | 106 +++++++++---------
 ...ows.AI.IsolationSession.SDK.0.2608.0.nupkg | Bin 86743 -> 87229 bytes
 .../isolation_session/common/error.rs         |  72 ++++++++++++
 .../isolation_session/common/manager.rs       |  36 +++---
 .../common/process_options.rs                 |  13 ++-
 .../isolation_session/common/regfree.rs       |  27 +++--
 6 files changed, 177 insertions(+), 77 deletions(-)

diff --git a/docs/development/architecture/backends/isolation-session/oneshot.md b/docs/development/architecture/backends/isolation-session/oneshot.md
index b0c928ae4..006328bfb 100644
--- a/docs/development/architecture/backends/isolation-session/oneshot.md
+++ b/docs/development/architecture/backends/isolation-session/oneshot.md
@@ -158,55 +158,65 @@ The runner calls into the WinRT API namespaced
 Session service (running as SYSTEM via `svchost.exe`). The API is gated
 on an internal Windows feature flag.
 
-### Two activation paths and the selection rule
+### Activation path and the no-fallback rule
 
-The runtime class `IsoSessionOps` (and `IsoSessionProcessOptions`) can be
-activated two ways, both funneled through
+The runtime class `IsoSessionOps` (and `IsoSessionProcessOptions`) is activated
+through a single mechanism in
 `src/backends/isolation_session/common/src/regfree.rs`:
 
-1. **Coresident explicit load (preferred when present).** MXC
-   `LoadLibraryExW`s the MSI-installed `IsoSessionApp.dll` **by full path**
-   and calls its `DllGetActivationFactory` export directly, bypassing the
-   WinRT activation catalog. This binds the MSI-installed runtime — the App
-   DLL's coresidency logic then sibling-loads the MSI `IsoSessionClient.dll`
-   and the matching side-by-side service instance. No machine-wide registry
-   mutation is involved. This is what lets a packaged product (openclaw)
-   ship and run a specific runtime version without touching the inbox
-   binaries.
-
-2. **Default system activation (fallback).** When no coresident
-   `IsoSessionApp.dll` is present at the runtime folder, activation falls
-   back to `IsoSessionOps::new()`, which resolves through the OS WinRT
-   activation catalog to the inbox `System32` binaries.
-
-**Selection rule.** `regfree::activate_from_runtime_dir` resolves the runtime
-folder (see *Runtime folder resolution* below), then:
-
-- **absent** at the default folder → fall back to system activation (a host
-  without the paired MSI keeps working);
-- **loaded** → use the coresident factory;
-- **present or explicitly configured but unloadable** (wrong architecture,
-  missing dependency, corrupt image, or an explicit override whose folder
-  does not resolve) → the error is **surfaced**, never silently redirected to
-  the inbox binaries — otherwise MXC would bind a *different* binary set under
-  the guise of success.
+**Reg-free private-CLSID activation.** `regfree::activate_via_private_clsid`
+calls
+`CoCreateInstance(<private CLSID>, CLSCTX_INPROC_SERVER, IID_IActivationFactory)`.
+`wxc-exec`'s **fused `<comClass>` manifest** redirects that private CLSID —
+reg-free, ahead of HKCR, and never catalog-shadowed — straight to the
+MSI-installed `IsoSessionApp.dll` shipped **co-located with `wxc-exec.exe`** in
+MXC's nuget. There is **no `LoadLibrary` in this Rust caller and no
+runtime-path logic in Rust**: the OS loader resolves the co-located App DLL,
+and the App DLL (C++) owns all knowledge of where the MSI runtime lives — it
+resolves the runtime directory, coresident-loads `IsoSessionClient.dll`, and
+binds the matching side-by-side service instance. No machine-wide registry
+mutation is involved. This is what lets a packaged product (openclaw) ship and
+run a specific runtime version without touching the inbox binaries.
+
+Classic-COM (not reg-free WinRT) is used deliberately: a private `<comClass>`
+redirection is honored ahead of HKCR and is immune to the reserved-namespace
+catalog shadowing that would defeat a reg-free WinRT activation context on an
+image where the `Windows.AI.IsolationSession.*` classes are already registered
+inbox.
+
+**No-fallback rule.** `activate_via_private_clsid` returns
+`Option<Result<T>>`, and the callers
+(`manager::check_service_available_and_activate`,
+`process_options::build_iso_process_options`) treat it as:
+
+- **`None`** — the private CLSID is not registered (`REGDB_E_CLASSNOTREG`),
+  i.e. the manifest was not fused (an inbox-only build). This is turned into a
+  **hard, actionable error** (`error::regfree_not_fused`). MXC deliberately
+  does **not** fall back to the inbox `System32` runtime — silently binding a
+  different, unversioned binary set is exactly the failure this design prevents.
+- **`Some(Err(e))`** — any other activation failure (including a fused-but-
+  broken MSI) is **surfaced** unchanged, never redirected to the inbox binaries.
+  An `E_NOINTERFACE` here is mapped to a version-pin-mismatch message (rebuild
+  the MSI and the SDK nuget from the same OS commit).
+- **`Some(Ok(factory))`** — the coresident factory is used.
 
 ### Runtime folder resolution
 
-The coresident folder is `DEFAULT_RUNTIME_DIR`
-(`C:\Program Files\Microsoft\Agentic Runtime\2608` — the fixed MSI install
-location) unless overridden by the `MXC_ISOSESSION_RUNTIME_DIR` environment
-variable:
+Runtime-folder resolution is owned entirely by `IsoSessionApp.dll` (C++,
+`onecoreuap/windows/core/isoenvbroker/src/app/dll.cpp`), **not** by MXC. There
+is no MXC-side environment override — the earlier `MXC_ISOSESSION_RUNTIME_DIR`
+knob has been removed so the runtime location is a single authoritative
+per-machine fact owned by the MSI:
 
-| Variable | Effect |
+| Source | Effect |
 |---|---|
-| `MXC_ISOSESSION_RUNTIME_DIR` | Absolute path to the folder holding the coresident runtime binaries (`IsoSessionApp.dll`, `IsoSessionClient.dll`, `IsoSession.manifest`, …). Intended for tests and side-by-side validation machines. **Must be absolute** — a relative value is rejected (with a warning) and the default is used, because the value is also the DLL dependency search root and a relative value would make it CWD-relative (a DLL-planting surface). When set to an absolute path it is *authoritative*: if its folder does not resolve, the run fails rather than silently binding the inbox runtime. |
-| `DEFAULT_RUNTIME_DIR` (compile-time constant, not an env var) | The hardcoded MSI install location used when the override is unset/empty/rejected. |
+| HKLM `InstallDir` (`REG_EXPAND_SZ`) under the runtime install key | Authoritative per-machine install directory recorded by the MSI. Read via `wil::reg::try_get_value_expanded_string`. |
+| Hardcoded fallback in the App DLL | Used only when the HKLM value is absent, so a correctly-installed MSI always wins. |
 
 ### Apartment initialization
 
-The coresident path obtains the factory via `DllGetActivationFactory` and
-calls `IActivationFactory::ActivateInstance` directly — which, unlike the
+The private-CLSID path obtains the factory via `CoCreateInstance` and calls
+`IActivationFactory::ActivateInstance` directly — which, unlike the
 inbox `RoActivateInstance` path, does **not** implicitly initialize the
 WinRT/COM apartment. `src/core/wxc/src/main.rs` calls
 `CoInitializeEx(COINIT_MULTITHREADED)` at startup, and `regfree.rs`
@@ -406,7 +416,7 @@ The following were observed during VM testing and are accepted for v0.1.
 | Risk | Mitigation |
 |---|---|
 | Bindings tied to a specific OS API version | `GENERATION_INFO.toml` records the `windows-bindgen` version and target `windows` crate version; `build.rs` panics if the workspace `windows` crate drifts from the recorded `target_windows_crate`. Regeneration is a manual step performed by a Microsoft engineer with WinMD access |
-| OS API not present on older Windows builds | the IsolationSession feature is OS-side; runner reports a clean error when the activation factory fails. Feature-unavailable test exercises this on CI |
+| OS API not present on older Windows builds | the IsolationSession feature is OS-side; the runner reports a hard, actionable error when the private-CLSID activation is not fused or the runtime fails to bind — it never silently falls back to the inbox binaries. Feature-unavailable test exercises this on CI |
 | New Cargo feature increases coupling | The `isolation_session` feature is off by default in the workspace; default builds and existing CI are unaffected |
 | Manual VM testing required | The OS-side service has the same constraint for any consumer (it rejects network-logon tokens). Automated suite covers what it can without the OS-side service |
 | One-shot lifecycle is heavy (full provision → start per call) | Inherent to the one-shot path; the experimental flag indicates rough edges. The state-aware lifecycle is the mitigation — it provisions once and reuses the session across `exec` calls |
@@ -417,19 +427,15 @@ The following were observed during VM testing and are accepted for v0.1.
 **For end users:**
 
 - A Windows build with the IsolationSession feature enabled.
-- The isolation-session runtime binaries available via **one** of:
-  - the paired **MSI** installed at `DEFAULT_RUNTIME_DIR`
-    (`C:\Program Files\Microsoft\Agentic Runtime\2608`), which MXC binds
-    coresidently by path (preferred — this is how a packaged product ships a
-    specific runtime version); or
-  - the OS-side inbox host binaries in `%SystemRoot%\System32\` (ships with
-    Windows), used as the fallback when no MSI runtime is present.
+- The paired isolation-session **MSI** installed, providing the runtime
+  binaries at the MSI install directory recorded in HKLM `InstallDir`. MXC
+  binds this coresident runtime by reg-free private-CLSID activation (the
+  fused `<comClass>` manifest in `wxc-exec` redirects to the co-located
+  `IsoSessionApp.dll`). Without the fused manifest MXC reports a hard,
+  actionable error — it does **not** silently fall back to the inbox
+  `System32` runtime.
 - WinRT/COM initialized as MTA (handled by `wxc-exec` and `regfree.rs`).
 
-Set `MXC_ISOSESSION_RUNTIME_DIR` (absolute path) to point at a specific
-runtime folder for tests or side-by-side validation; see *OS API Dependency →
-Runtime folder resolution*.
-
 **For developers:**
 
 - Standard Rust toolchain.
diff --git a/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg b/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg
index 2037c4def89954bfdc8e27103c8261d41a08a3a1..3aaafe00c3eafea16240ad5cb0e40ff179108487 100644
GIT binary patch
delta 55353
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
OEfwYD5<TU&djAC=iUm>t

delta 54836
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

diff --git a/src/mxc-sdk/src/backends/isolation_session/common/error.rs b/src/mxc-sdk/src/backends/isolation_session/common/error.rs
index ad6e3c9bf..bc9e1c61c 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/error.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/error.rs
@@ -61,6 +61,13 @@ const CLASS_E_CLASSNOTAVAILABLE_HRESULT: u32 = 0x80040111;
 /// `REGDB_E_CLASSNOTREG` — the runtime class is not registered at all.
 const REGDB_E_CLASSNOTREG_HRESULT: u32 = 0x80040154;
 
+/// `E_NOINTERFACE` — the activator produced an object that does not implement
+/// the requested interface. In this backend that is the signature of a
+/// winmd/MSI version-pin mismatch: `IsoSessionApp.dll` activated, but the
+/// interface IID the Preview WinMD was built against does not match the IID
+/// the MSI-installed runtime exposes. See [`activation_error`].
+const E_NOINTERFACE_HRESULT: u32 = 0x80004002;
+
 /// Renders an HRESULT for the wire `nativeCode` field.
 fn format_native_code(code: u32) -> String {
     format!("{code:#010x}")
@@ -307,6 +314,14 @@ pub(super) fn activation_error(code: u32, detail: &str) -> IsolationSessionError
             "the in-proc IsolationSession runtime API is not available on this OS build. Ensure \
          the OS feature gate is enabled and the platform supports isolation sessions."
                 .to_string()
+        } else if code == E_NOINTERFACE_HRESULT {
+            "the co-located IsoSessionApp.dll activated but returned an object that does not \
+         implement the expected IsolationSession interface. This is the classic winmd/MSI \
+         version-pin mismatch: the Preview WinMD wxc-exec was built against and the \
+         MSI-installed IsolationSession runtime were produced from different OS versions, so \
+         their interface IIDs differ. Rebuild the MSI and the \
+         Microsoft.Windows.AI.IsolationSession.SDK nuget from the same OS commit."
+                .to_string()
         } else {
             format!("IsolationSession runtime API activation failed: {detail}")
         };
@@ -332,6 +347,36 @@ pub(super) fn identity_refusal(err: windows_core::Error) -> IsolationSessionErro
     })
 }
 
+/// The reg-free private-CLSID activator is not fused into this executable, so
+/// the version-pinned MSI-installed IsolationSession runtime cannot be bound.
+///
+/// Raised for the `None` arm of
+/// [`super::regfree::activate_via_private_clsid`] (`REGDB_E_CLASSNOTREG` from
+/// `CoCreateInstance` on the private activator CLSID). MXC deliberately does
+/// **not** fall back to the inbox `System32` runtime here — silently binding a
+/// different, unversioned binary set is exactly the failure mode this design
+/// exists to prevent — so the missing fused manifest surfaces as a hard,
+/// actionable error instead.
+pub(super) fn regfree_not_fused(operation: &str) -> IsolationSessionError {
+    IsolationSessionError::ServiceUnavailable(IsoApiFailure::new(
+        operation,
+        Some(REGDB_E_CLASSNOTREG_HRESULT),
+        Some(
+            "IsolationSession reg-free activation was not taken: the private-CLSID activator \
+             (IsoSessionApp.comClass.manifest) is not fused into this executable, so the \
+             version-pinned MSI-installed IsolationSession runtime could not be bound. MXC will \
+             not silently fall back to the inbox System32 runtime."
+                .to_string(),
+        ),
+        Some(
+            "Rebuild wxc-exec against the Microsoft.Windows.AI.IsolationSession.SDK nuget so the \
+             activation manifest is fused into the executable and IsoSessionApp.dll is \
+             co-located next to wxc-exec.exe."
+                .to_string(),
+        ),
+    ))
+}
+
 /// Whether an `ERROR_NOT_FOUND` from this operation means "the sandbox is
 /// gone".
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -806,6 +851,33 @@ mod tests {
         assert!(mapped.message.contains("catastrophic failure"));
     }
 
+    /// `E_NOINTERFACE` from activation is the winmd/MSI version-pin mismatch
+    /// signature: the mapping must name that cause rather than echo the bare
+    /// COM detail, so the message points at rebuilding both from one commit.
+    #[test]
+    fn e_nointerface_activation_names_version_pin_mismatch() {
+        let mapped = map_lifecycle_error(activation_error(E_NOINTERFACE_HRESULT, "ignored"));
+        assert_eq!(mapped.code, MxcErrorCode::BackendUnavailable);
+        assert_eq!(mapped.native_code(), Some("0x80004002"));
+        assert!(mapped.message.contains("version-pin mismatch"));
+        assert!(mapped.message.contains("same OS commit"));
+    }
+
+    /// The hard error raised when the reg-free activator is not fused must
+    /// carry the REGDB_E_CLASSNOTREG code, an operation, a message that refuses
+    /// the inbox fallback, and an actionable remediation.
+    #[test]
+    fn regfree_not_fused_is_a_hard_actionable_error() {
+        let mapped = map_lifecycle_error(regfree_not_fused(op::ACTIVATE));
+        assert_eq!(mapped.code, MxcErrorCode::BackendUnavailable);
+        assert_eq!(mapped.operation(), Some("IsoSessionOps.ActivateInstance"));
+        assert_eq!(mapped.native_code(), Some("0x80040154"));
+        assert!(mapped.message.contains("not silently fall back"));
+        assert!(mapped
+            .remediation()
+            .is_some_and(|r| r.contains("IsolationSession.SDK nuget")));
+    }
+
     #[test]
     fn mxc_internal_failure_carries_no_structured_fields() {
         let mapped = map_lifecycle_error(lifecycle_err("create stdout relay: out of memory"));
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
index f12b8bd94..9ddaa34f9 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
@@ -30,8 +30,8 @@ use windows_core::{HSTRING, PCWSTR};
 use super::console_mode::{get_local_console_size, ConsoleModeRestorer, CtrlHandlerGuard};
 use super::console_relay::{create_console_relay_thread, ConsoleRelayParams};
 use super::error::{
-    activation_error, check_result, format_iso_error, lifecycle_err, op, transport_err,
-    IsolationSessionError, StalePromotion,
+    activation_error, check_result, format_iso_error, lifecycle_err, op, regfree_not_fused,
+    transport_err, IsolationSessionError, StalePromotion,
 };
 use super::owned_thread::{self, Impersonation};
 use super::pipe_relay::{
@@ -81,20 +81,23 @@ unsafe impl Send for MtaReference {}
 unsafe impl Sync for MtaReference {}
 
 /// Activates the in-proc IsolationSession runtime factory and returns the
-/// instance. When the fused private-CLSID activator is registered (see
-/// [`super::regfree`]), activation is redirected reg-free to the co-located
-/// `IsoSessionApp.dll`, binding the MSI-installed runtime instead of the inbox
-/// `System32` one; otherwise it falls back to default system activation.
+/// instance. Activation is redirected reg-free through the fused private-CLSID
+/// activator (see [`super::regfree`]) to the co-located `IsoSessionApp.dll`,
+/// binding the version-pinned MSI-installed runtime.
+///
+/// There is **no inbox fallback**: if the private-CLSID activator is not fused
+/// into this executable, this returns a hard [`regfree_not_fused`] error rather
+/// than silently binding the inbox `System32` runtime.
 fn check_service_available_and_activate() -> Result<IsoSessionOps, IsolationSessionError> {
-    let activated = super::regfree::activate_via_private_clsid::<IsoSessionOps>()
-        .unwrap_or_else(IsoSessionOps::new);
-
-    match activated {
-        Ok(ops) => Ok(ops),
+    match super::regfree::activate_via_private_clsid::<IsoSessionOps>() {
+        Some(Ok(ops)) => Ok(ops),
         // The HRESULT→error mapping lives in `activation_error` so it stays
         // testable without depending on whether this host can activate the
         // API at all.
-        Err(e) => Err(activation_error(e.code().0 as u32, &e.message())),
+        Some(Err(e)) => Err(activation_error(e.code().0 as u32, &e.message())),
+        // The fused manifest is absent: refuse to silently bind the inbox
+        // runtime, and surface an actionable hard error instead.
+        None => Err(regfree_not_fused(op::ACTIVATE)),
     }
 }
 
@@ -1533,10 +1536,15 @@ mod tests {
             Err(IsolationSessionError::ServiceUnavailable(failure)) => {
                 // Service is NOT available. Verify the error is clean and
                 // descriptive (not a panic or cryptic COM error), and that
-                // it names the activation operation it failed on.
+                // it names the activation operation it failed on. On a host
+                // without the fused private-CLSID manifest (the usual dev
+                // box), activation resolves to the reg-free hard error; on a
+                // host where the class is inbox-registered but unavailable it
+                // is the "not available" message.
                 assert!(
                     failure.message.contains("not available")
-                        || failure.message.contains("activation failed"),
+                        || failure.message.contains("activation failed")
+                        || failure.message.contains("reg-free activation was not taken"),
                     "Expected descriptive error message, got: {}",
                     failure.message
                 );
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs b/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs
index 8d2e20e9b..c5ea5cfc9 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs
@@ -10,7 +10,7 @@ use crate::mxc_common::models::ExecutionRequest;
 use crate::isolation_session_bindings::bindings::IsoSessionProcessOptions;
 use windows_core::HSTRING;
 
-use super::error::{op, transport_err, IsolationSessionError};
+use super::error::{op, regfree_not_fused, transport_err, IsolationSessionError};
 
 const REDIRECT_STDIN: u32 = 0x1;
 const REDIRECT_STDOUT: u32 = 0x2;
@@ -167,9 +167,14 @@ pub(super) fn with_service_timeout_grace(mut options: ProcessOptions) -> Process
 pub(super) fn build_iso_process_options(
     options: &ProcessOptions,
 ) -> Result<IsoSessionProcessOptions, IsolationSessionError> {
-    let proc_options = super::regfree::activate_via_private_clsid::<IsoSessionProcessOptions>()
-        .unwrap_or_else(IsoSessionProcessOptions::new)
-        .map_err(|e| transport_err(op::OPTIONS_NEW, "activation failed", &e))?;
+    let proc_options =
+        match super::regfree::activate_via_private_clsid::<IsoSessionProcessOptions>() {
+            Some(result) => {
+                result.map_err(|e| transport_err(op::OPTIONS_NEW, "activation failed", &e))?
+            }
+            // No inbox fallback: the fused private-CLSID activator is absent.
+            None => return Err(regfree_not_fused(op::OPTIONS_NEW)),
+        };
 
     proc_options
         .SetTimeoutMilliseconds(options.timeout_ms)
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
index b9d023dab..24327350a 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
@@ -26,13 +26,16 @@
 //! that defeats a reg-free WinRT activation context on an image where the
 //! `Windows.AI.IsolationSession.*` classes are already registered inbox.
 //!
-//! Fallback contract: when the private CLSID is not registered
+//! No-fallback contract: when the private CLSID is not registered
 //! (`REGDB_E_CLASSNOTREG`) -- i.e. the manifest was not fused, such as an
-//! inbox-only build -- [`activate_via_private_clsid`] returns `None` and the
-//! caller falls back to default inbox activation (`T::new()`), so hosts without
-//! the fused manifest / nuget shim keep working. Any *other* activation error
-//! is surfaced as `Some(Err(..))` rather than silently redirected to a
-//! different binary set.
+//! inbox-only build -- [`activate_via_private_clsid`] returns `None`. The
+//! callers (`manager::check_service_available_and_activate` and
+//! `process_options::build_iso_process_options`) turn that `None` into a hard,
+//! actionable error (`error::regfree_not_fused`): MXC deliberately does **not**
+//! fall back to the inbox `System32` runtime, because silently binding a
+//! different, unversioned binary set is exactly the failure this design exists
+//! to prevent. Any *other* activation error is surfaced as `Some(Err(..))`
+//! rather than silently redirected to a different binary set.
 //!
 //! GUID contract: the two private activator CLSIDs below are a hard contract
 //! duplicated in THREE places -- change all together:
@@ -76,8 +79,8 @@ impl ActivatorClsid for IsoSessionProcessOptions {
 ///
 /// Returns:
 /// - `None` when the private CLSID is not registered (`REGDB_E_CLASSNOTREG`) --
-///   the manifest was not fused / this is an inbox-only build. The caller falls
-///   back to default inbox activation (`T::new()`).
+///   the manifest was not fused / this is an inbox-only build. The caller turns
+///   this into a hard `error::regfree_not_fused` error (NO inbox fallback).
 /// - `Some(Err(..))` when activation was attempted but failed (the shim could
 ///   not load the client, the factory failed, an unexpected HRESULT, ...). The
 ///   caller must surface this rather than silently bind a different binary set.
@@ -142,8 +145,14 @@ where
     };
 
     instance.cast::<T>().map_err(|e| {
+        // A cast failure here means the activated `IsoSessionApp.dll` produced
+        // an object that does not implement the interface IID the Preview WinMD
+        // was built against -- the winmd/MSI version-pin mismatch. The
+        // actionable mapping lives in `error::activation_error`
+        // (E_NOINTERFACE branch); this stays a diagnostic breadcrumb.
         eprintln!(
-            "[mxc isosession] cast to '{}' failed (IID mismatch?): {}",
+            "[mxc isosession] cast to '{}' failed (winmd/MSI version-pin mismatch? the \
+             activated IsoSessionApp.dll does not implement the expected interface IID): {}",
             <T as RuntimeName>::NAME,
             e
         );

From c344e7319b6de54d1fe11d538c65626aed9a2b18 Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Mon, 10 Aug 2026 16:09:03 -0700
Subject: [PATCH 10/26] wxc build.rs: stage IsoSessionApp.runtimeversion next
 to wxc-exec

IsoSessionApp.dll is version-agnostic at OS build time and reads its paired
runtime version from a co-located sidecar (IsoSessionApp.runtimeversion) to
resolve the MSI reg key + runtime dir. Extract that sidecar from the pinned
SDK nupkg and stage it alongside the co-located App.dll next to wxc-exec.exe
so the read works in the fused reg-free activation scenario.

Best-effort: a nupkg predating the stamping pipeline (no sidecar) logs a
cargo:warning and lets the shim fall back to its compile-time default; it
does NOT skip the manifest fuse.

Also repacks the pinned SDK nupkg with the version-agnostic App.dll and the
stamped 2026_08 sidecar.

Validated on iso-sf2-repro-0 via wxc-exec --probe (see OS commit).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: f5cc2011-5308-43d6-a8ea-2b8ed9b6ceb3
---
 ...ows.AI.IsolationSession.SDK.0.2608.0.nupkg | Bin 87229 -> 92421 bytes
 src/tools/wxc/build.rs                        |  27 ++++++++++++++++++
 2 files changed, 27 insertions(+)

diff --git a/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg b/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg
index 3aaafe00c3eafea16240ad5cb0e40ff179108487..dc95f6b548d605c87e6cc5a2a32667226a107305 100644
GIT binary patch
delta 62550
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

delta 57422
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

diff --git a/src/tools/wxc/build.rs b/src/tools/wxc/build.rs
index 7e4ac018f..0b8ac4c61 100644
--- a/src/tools/wxc/build.rs
+++ b/src/tools/wxc/build.rs
@@ -74,6 +74,13 @@ mod isosession {
     /// The in-proc activation shim that owns knowledge of the MSI runtime dir.
     const APP_DLL: &str = "IsoSessionApp.dll";
 
+    /// Name of the pipeline-stamped runtime-version sidecar inside the nupkg
+    /// `runtime` folder. `IsoSessionApp.dll` is version-agnostic at OS build
+    /// time and reads this co-located token (e.g. `2026_08`) at load time to
+    /// build its MSI reg key + fallback runtime dir. Staged next to the exe
+    /// alongside the DLL so the co-located read works in the fused scenario.
+    const VERSION_SIDECAR: &str = "IsoSessionApp.runtimeversion";
+
     /// Locate the nupkg, extract the App.dll (stage next to the exe) and the
     /// manifest fragment, and return the manifest XML. Returns `None` (with a
     /// `cargo:warning`) when the nupkg does not carry the reg-free payload, so
@@ -125,6 +132,26 @@ mod isosession {
         std::fs::write(&dll_dst, &app_dll)
             .unwrap_or_else(|e| panic!("stage {} to {}: {e}", APP_DLL, dll_dst.display()));
 
+        // Stage the pipeline-stamped runtime-version sidecar next to the DLL.
+        // Best-effort: if the nupkg predates the stamping pipeline, the shim
+        // falls back to its compile-time default version, so a missing sidecar
+        // is a warning, not a fatal error, and does NOT skip the manifest fuse.
+        match extract_entry(&nupkg, VERSION_SIDECAR) {
+            Some(bytes) => {
+                let sidecar_dst = target_dir.join(VERSION_SIDECAR);
+                std::fs::write(&sidecar_dst, &bytes).unwrap_or_else(|e| {
+                    panic!("stage {} to {}: {e}", VERSION_SIDECAR, sidecar_dst.display())
+                });
+            }
+            None => {
+                println!(
+                    "cargo:warning=isosession: {} not found in {} — IsoSessionApp.dll will use its compile-time default runtime version",
+                    VERSION_SIDECAR,
+                    nupkg.display()
+                );
+            }
+        }
+
         let manifest_bytes = match extract_entry(&nupkg, COMCLASS_MANIFEST) {
             Some(bytes) => bytes,
             None => {

From 4e5d89616fa752d9b99ecba9173b343e4d61da18 Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Wed, 19 Aug 2026 18:46:02 -0700
Subject: [PATCH 11/26] Update IsolationSession 2608 SDK package

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 77a3362a-1fd0-4850-aaf9-ad0d8e0bc7d8
---
 .../GENERATION_INFO.toml                      |   4 ++--
 ...ows.AI.IsolationSession.SDK.0.2608.0.nupkg | Bin 92421 -> 93032 bytes
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml b/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
index 7111ed9b8..c611f9e36 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
+++ b/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
@@ -10,10 +10,10 @@
 # and stay in lockstep with the workspace `windows` crate major.minor.
 windows_bindgen_version = "0.62.1"
 target_windows_crate = "0.62"
-generated_date = "2026-08-14"
+generated_date = "2026-08-19"
 
 [source]
 nupkg = "Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg"
 winmd = "metadata/windows.ai.isolationsession.preview.winmd"
-winmd_sha256 = "1A9DBDC2CBFDEDC7FF366939DB4BA1564179D55B6EA3E70B99BD82C532428147"
+winmd_sha256 = "4D7C49D34778028DA6DD08991765A7E37A0D57564F5B57CA4F7628CDC8917E5E"
 namespace = "Windows.AI.IsolationSession.Preview"
diff --git a/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg b/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg
index dc95f6b548d605c87e6cc5a2a32667226a107305..bfd7ecb1bf8a248b12f066d6875286c0f5b76918 100644
GIT binary patch
delta 84497
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
IU?h<KKONH2-~a#s

delta 84239
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


From d8bafdc9fcabaa30f44b92d6fd17a9ef1614a6d7 Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Tue, 1 Sep 2026 10:06:12 -0700
Subject: [PATCH 12/26] Integrate lifted IsolationSession SDK activation

Consume the matching OS-produced SDK package, stage the lifted activation payload across Rust and C# build surfaces, and activate through DllGetActivationFactory while preserving Adib's in-process support.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 77a3362a-1fd0-4850-aaf9-ad0d8e0bc7d8
---
 build.bat                                     |  31 ++
 .../backends/isolation-session/oneshot.md     |  37 +--
 .../V1/MxcContainerTests.cs                   |   5 +
 .../Microsoft.Mxc.Sdk.csproj                  |  11 +
 sdk/dotnet/README.md                          |  13 +
 src/Cargo.toml                                |   1 +
 src/ffi/mxc_ffi/Cargo.toml                    |   1 +
 src/ffi/mxc_ffi/build.rs                      |  15 +
 src/mxc-sdk/Cargo.toml                        |   8 +
 src/mxc-sdk/build.rs                          |  11 +
 src/mxc-sdk/build/build_mxc_build_common.rs   | 107 +++++++
 .../GENERATION_INFO.toml                      |  16 +-
 ...s.AI.IsolationSession.SDK.0.202608.5.nupkg | Bin 0 -> 68375 bytes
 ...ows.AI.IsolationSession.SDK.0.2608.0.nupkg | Bin 93032 -> 0 bytes
 .../isolation_session_bindings/README.md      |  10 +-
 .../Update-IsoSessionSdk.ps1                  | 297 ++++++++++++++++++
 .../isolation_session/common/availability.rs  |  23 +-
 .../isolation_session/common/error.rs         |  37 +--
 .../isolation_session/common/manager.rs       |  26 +-
 .../backends/isolation_session/common/mod.rs  |   2 +-
 .../common/process_options.rs                 |  27 +-
 .../isolation_session/common/regfree.rs       | 286 +++++++----------
 src/tools/wxc/build.rs                        | 206 +-----------
 23 files changed, 741 insertions(+), 429 deletions(-)
 create mode 100644 src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.202608.5.nupkg
 delete mode 100644 src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg
 create mode 100644 src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1

diff --git a/build.bat b/build.bat
index eb1d6226b..9904cc331 100644
--- a/build.bat
+++ b/build.bat
@@ -166,6 +166,22 @@ for %%T in (x86_64-pc-windows-msvc aarch64-pc-windows-msvc) do (
                 if exist "sdk\node\bin\!SDK_ARCH!\wslcsdk.dll" del /Q "sdk\node\bin\!SDK_ARCH!\wslcsdk.dll"
             )
         )
+        if "!COPY_WSLC_RUNTIME!"=="1" (
+            if "%WITH_ISOLATION_SESSION%"=="1" (
+                for %%B in (IsoSessionApp.dll IsoSession.manifest) do (
+                    if not exist "!BIN_DIR!\%%B" (
+                        echo ERROR: IsolationSession-enabled Node runtime is missing !BIN_DIR!\%%B
+                        exit /b 1
+                    )
+                    copy /Y "!BIN_DIR!\%%B" "sdk\node\bin\!SDK_ARCH!\" >nul
+                    echo   Copied !SDK_ARCH!\%%B
+                )
+            ) else (
+                for %%B in (IsoSessionApp.dll IsoSession.manifest) do (
+                    if exist "sdk\node\bin\!SDK_ARCH!\%%B" del /Q "sdk\node\bin\!SDK_ARCH!\%%B"
+                )
+            )
+        )
     )
 
     :: Copy the C# SDK's native library (mxc_ffi) into its runtime assets so a
@@ -175,6 +191,11 @@ for %%T in (x86_64-pc-windows-msvc aarch64-pc-windows-msvc) do (
         if exist "sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\native\wxc-wslc-daemon.exe" del /Q "sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\native\wxc-wslc-daemon.exe"
         if exist "sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\native\wslcsdk.dll" del /Q "sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\native\wslcsdk.dll"
     )
+    if "!COPY_WSLC_RUNTIME!"=="1" if not "%WITH_ISOLATION_SESSION%"=="1" (
+        for %%B in (IsoSessionApp.dll IsoSession.manifest) do (
+            if exist "sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\native\%%B" del /Q "sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\native\%%B"
+        )
+    )
     if exist "!BIN_DIR!\mxc_ffi.dll" (
         if not exist "sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\native" mkdir "sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\native"
         copy /Y "!BIN_DIR!\mxc_ffi.dll" "sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\native\" >nul
@@ -193,6 +214,16 @@ for %%T in (x86_64-pc-windows-msvc aarch64-pc-windows-msvc) do (
                 echo   Copied !RID!\native\%%B
             )
         )
+        if "%WITH_ISOLATION_SESSION%"=="1" if "!COPY_WSLC_RUNTIME!"=="1" (
+            for %%B in (IsoSessionApp.dll IsoSession.manifest) do (
+                if not exist "!BIN_DIR!\%%B" (
+                    echo ERROR: IsolationSession-enabled C# runtime unit is missing !BIN_DIR!\%%B
+                    exit /b 1
+                )
+                copy /Y "!BIN_DIR!\%%B" "sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\native\" >nul
+                echo   Copied !RID!\native\%%B
+            )
+        )
         if "!COPY_WSLC_RUNTIME!"=="1" (
             >"sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\mxc-build-features.txt" echo isolation_session=%WITH_ISOLATION_SESSION%
             >>"sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\mxc-build-features.txt" echo wslc=%WITH_WSLC%
diff --git a/docs/development/architecture/backends/isolation-session/oneshot.md b/docs/development/architecture/backends/isolation-session/oneshot.md
index 006328bfb..05548bd79 100644
--- a/docs/development/architecture/backends/isolation-session/oneshot.md
+++ b/docs/development/architecture/backends/isolation-session/oneshot.md
@@ -164,34 +164,23 @@ The runtime class `IsoSessionOps` (and `IsoSessionProcessOptions`) is activated
 through a single mechanism in
 `src/backends/isolation_session/common/src/regfree.rs`:
 
-**Reg-free private-CLSID activation.** `regfree::activate_via_private_clsid`
-calls
-`CoCreateInstance(<private CLSID>, CLSCTX_INPROC_SERVER, IID_IActivationFactory)`.
-`wxc-exec`'s **fused `<comClass>` manifest** redirects that private CLSID —
-reg-free, ahead of HKCR, and never catalog-shadowed — straight to the
-MSI-installed `IsoSessionApp.dll` shipped **co-located with `wxc-exec.exe`** in
-MXC's nuget. There is **no `LoadLibrary` in this Rust caller and no
-runtime-path logic in Rust**: the OS loader resolves the co-located App DLL,
-and the App DLL (C++) owns all knowledge of where the MSI runtime lives — it
-resolves the runtime directory, coresident-loads `IsoSessionClient.dll`, and
-binds the matching side-by-side service instance. No machine-wide registry
-mutation is involved. This is what lets a packaged product (openclaw) ship and
-run a specific runtime version without touching the inbox binaries.
-
-Classic-COM (not reg-free WinRT) is used deliberately: a private `<comClass>`
-redirection is honored ahead of HKCR and is immune to the reserved-namespace
-catalog shadowing that would defeat a reg-free WinRT activation context on an
-image where the `Windows.AI.IsolationSession.*` classes are already registered
-inbox.
-
-**No-fallback rule.** `activate_via_private_clsid` returns
+**Direct shim activation.** `regfree::activate_from_adjacent_shim` loads the
+co-located `IsoSessionApp.dll` by absolute path, resolves its
+`DllGetActivationFactory` export, and requests the projected runtime class
+factory directly. The co-located stamped `IsoSession.manifest` selects the
+matching version under `%ProgramFiles%\Microsoft\Agentic Runtime`. The shim
+then loads that version's `IsoSessionClient.dll` and binds the matching
+side-by-side service instance. This bypasses the inbox WinRT catalog without
+machine-wide registration or private classic-COM classes.
+
+**No-fallback rule.** `activate_from_adjacent_shim` returns
 `Option<Result<T>>`, and the callers
 (`manager::check_service_available_and_activate`,
 `process_options::build_iso_process_options`) treat it as:
 
-- **`None`** — the private CLSID is not registered (`REGDB_E_CLASSNOTREG`),
-  i.e. the manifest was not fused (an inbox-only build). This is turned into a
-  **hard, actionable error** (`error::regfree_not_fused`). MXC deliberately
+- **`None`** — the adjacent shim/manifest activation unit is absent (an
+  inbox-only build). This is turned into a
+  **hard, actionable error** (`error::lifted_payload_missing`). MXC deliberately
   does **not** fall back to the inbox `System32` runtime — silently binding a
   different, unversioned binary set is exactly the failure this design prevents.
 - **`Some(Err(e))`** — any other activation failure (including a fused-but-
diff --git a/sdk/dotnet/Microsoft.Mxc.Sdk.Tests/V1/MxcContainerTests.cs b/sdk/dotnet/Microsoft.Mxc.Sdk.Tests/V1/MxcContainerTests.cs
index 19587b073..b3b9ea7e8 100644
--- a/sdk/dotnet/Microsoft.Mxc.Sdk.Tests/V1/MxcContainerTests.cs
+++ b/sdk/dotnet/Microsoft.Mxc.Sdk.Tests/V1/MxcContainerTests.cs
@@ -440,6 +440,11 @@ public void GetAvailableBackends_ReturnsTypedNativeProbe()
                 backends,
                 backend => backend.Backend == ContainmentBackend.ProcessContainer);
             Assert.NotNull(processContainer.Tier);
+#if MXC_WITH_ISOLATION_SESSION
+            Assert.Contains(
+                backends,
+                backend => backend.Backend == ContainmentBackend.IsolationSession);
+#endif
         }
     }
 
diff --git a/sdk/dotnet/Microsoft.Mxc.Sdk/Microsoft.Mxc.Sdk.csproj b/sdk/dotnet/Microsoft.Mxc.Sdk/Microsoft.Mxc.Sdk.csproj
index 99d6ed1ea..f141351f5 100644
--- a/sdk/dotnet/Microsoft.Mxc.Sdk/Microsoft.Mxc.Sdk.csproj
+++ b/sdk/dotnet/Microsoft.Mxc.Sdk/Microsoft.Mxc.Sdk.csproj
@@ -67,9 +67,11 @@
     <MxcNativeUnitFileNames>$(MxcNativeFileName)</MxcNativeUnitFileNames>
     <MxcNativeUnitFileNames Condition="'$(MxcSidecarFileName)' != ''">$(MxcNativeFileName) and $(MxcSidecarFileName)</MxcNativeUnitFileNames>
     <MxcNativeUnitFileNames Condition="'$(MxcWithWslc)' == 'true' and $([MSBuild]::IsOSPlatform('Windows'))">$(MxcNativeUnitFileNames), wxc-wslc-daemon.exe, and wslcsdk.dll</MxcNativeUnitFileNames>
+    <MxcNativeUnitFileNames Condition="'$(MxcWithIsolationSession)' == 'true' and $([MSBuild]::IsOSPlatform('Windows'))">$(MxcNativeUnitFileNames), IsoSessionApp.dll, and IsoSession.manifest</MxcNativeUnitFileNames>
     <MxcNativeUnitExpectedCount>1</MxcNativeUnitExpectedCount>
     <MxcNativeUnitExpectedCount Condition="'$(MxcSidecarFileName)' != ''">2</MxcNativeUnitExpectedCount>
     <MxcNativeUnitExpectedCount Condition="'$(MxcWithWslc)' == 'true' and $([MSBuild]::IsOSPlatform('Windows'))">4</MxcNativeUnitExpectedCount>
+    <MxcNativeUnitExpectedCount Condition="'$(MxcWithIsolationSession)' == 'true' and $([MSBuild]::IsOSPlatform('Windows'))">$([MSBuild]::Add($(MxcNativeUnitExpectedCount), 2))</MxcNativeUnitExpectedCount>
     <MxcIsolationSessionFeatureBit>0</MxcIsolationSessionFeatureBit>
     <MxcIsolationSessionFeatureBit Condition="'$(MxcWithIsolationSession)' == 'true'">1</MxcIsolationSessionFeatureBit>
     <MxcWslcFeatureBit>0</MxcWslcFeatureBit>
@@ -211,9 +213,16 @@
                      Condition="'$(MxcWithWslc)' == 'true'" />
       <MxcNativeUnit Include="@(MxcWslcDaemon);@(MxcWslcSdkDll)"
                      Condition="'$(MxcWithWslc)' == 'true'" />
+      <MxcIsolationSessionRuntime Include="@(MxcFfiArtifact->'%(RootDir)%(Directory)IsoSessionApp.dll');
+                                           @(MxcFfiArtifact->'%(RootDir)%(Directory)IsoSession.manifest')"
+                                  Condition="'$(MxcWithIsolationSession)' == 'true'" />
+      <MxcNativeUnit Include="@(MxcIsolationSessionRuntime)"
+                     Condition="'$(MxcWithIsolationSession)' == 'true'" />
     </ItemGroup>
     <Error Condition="'$(MxcWithWslc)' == 'true' and !Exists('@(MxcWslcSdkDll)')"
            Text="mxc: the WSLC-enabled cargo build did not stage wslcsdk.dll beside mxc_ffi." />
+    <Error Condition="'$(MxcWithIsolationSession)' == 'true' and @(MxcIsolationSessionRuntime->Count()) != 2"
+           Text="mxc: the IsolationSession-enabled cargo build did not stage the complete lifted activation payload beside mxc_ffi." />
     <Error Condition="!Exists('$(MxcGeneratedBindings)')"
            Text="Binding generation did not produce $(MxcGeneratedBindings). Ensure the Rust toolchain (cargo) is installed and on PATH." />
   </Target>
@@ -324,6 +333,8 @@
          Text="mxc: pre-staged $(MxcOtherWindowsRid) is missing mxc_ffi.dll or plm.exe. Rebuild that RID before creating a multi-RID package." />
   <Error Condition="@(MxcOtherRidNative->Count()) != 0 and '$(MxcWithWslc)' == 'true' and (!Exists('runtimes/$(MxcOtherWindowsRid)/native/wxc-wslc-daemon.exe') or !Exists('runtimes/$(MxcOtherWindowsRid)/native/wslcsdk.dll'))"
          Text="mxc: pre-staged $(MxcOtherWindowsRid) does not contain the complete WSLC runtime unit. Rebuild it with WSLC enabled." />
+  <Error Condition="@(MxcOtherRidNative->Count()) != 0 and '$(MxcWithIsolationSession)' == 'true' and (!Exists('runtimes/$(MxcOtherWindowsRid)/native/IsoSessionApp.dll') or !Exists('runtimes/$(MxcOtherWindowsRid)/native/IsoSession.manifest'))"
+         Text="mxc: pre-staged $(MxcOtherWindowsRid) does not contain the complete lifted IsolationSession activation payload. Rebuild it with IsolationSession enabled." />
   <Error Condition="@(MxcOtherRidNative->Count()) != 0 and !Exists('runtimes/$(MxcOtherWindowsRid)/mxc-build-features.txt')"
          Text="mxc: pre-staged $(MxcOtherWindowsRid) has no optional-backend feature stamp. Rebuild that RID before creating a multi-RID package." />
   <Error Condition="@(MxcOtherRidNative->Count()) != 0 and '$(MxcOtherRidFeatureStamp)' != '$(MxcExpectedOptionalBackendStamp)'"
diff --git a/sdk/dotnet/README.md b/sdk/dotnet/README.md
index b78535c95..c1ca418f8 100644
--- a/sdk/dotnet/README.md
+++ b/sdk/dotnet/README.md
@@ -237,6 +237,19 @@ sandbox on the current host. `MxcPlatform.GetAvailableBackends()` reports
 host backend capabilities; availability is advisory and launch-time
 validation still applies.
 
+The switches compose, so either backend can be enabled independently. Passing
+one on Linux or macOS fails the build instead of silently ignoring it. An
+IsolationSession build additionally stages and packages the lifted activation
+unit from the pinned IsolationSession SDK NuGet: `IsoSessionApp.dll` and a
+stamped `IsoSession.manifest`. These files let in-process Rust and C# callers
+load the shim and request its WinRT activation factory directly without
+binding the inbox WinRT catalog. A WSLC build
+additionally builds, stages, and packages `wxc-wslc-daemon.exe` and the pinned
+`wslcsdk.dll`. Every selected backend's native files must stay together beside
+the loaded `mxc_ffi.dll`. `build.bat --with-wslc` stages the same complete unit
+into the Windows RID package directories. A multi-RID pack fails if the
+pre-staged second RID was built with a different optional-backend set.
+
 Creation telemetry is supplied through `Telemetry` on `RunOptions`,
 `SpawnOptions`, or `SpawnWithPtyOptions`, not on `ContainerRequest`. Omission
 leaves telemetry disabled; `new TelemetryConfig { Enabled = false }`
diff --git a/src/Cargo.toml b/src/Cargo.toml
index 72deda762..98d7ebf41 100644
--- a/src/Cargo.toml
+++ b/src/Cargo.toml
@@ -85,6 +85,7 @@ windows = { version = "0.62", features = [
     "Win32_System_Pipes",
     "Win32_System_ProcessStatus",
     "Win32_System_Registry",
+    "Win32_System_ApplicationInstallationAndServicing",
     "Win32_System_SystemInformation",
     "Win32_System_SystemServices",
     "Win32_System_Threading",
diff --git a/src/ffi/mxc_ffi/Cargo.toml b/src/ffi/mxc_ffi/Cargo.toml
index 1182f4564..d68c4d39f 100644
--- a/src/ffi/mxc_ffi/Cargo.toml
+++ b/src/ffi/mxc_ffi/Cargo.toml
@@ -53,3 +53,4 @@ csbindgen = { version = "1", optional = true }
 [target.'cfg(windows)'.build-dependencies]
 cc = "1"
 winresource.workspace = true
+zip = "2"
diff --git a/src/ffi/mxc_ffi/build.rs b/src/ffi/mxc_ffi/build.rs
index c528396f7..8b8d48ba1 100644
--- a/src/ffi/mxc_ffi/build.rs
+++ b/src/ffi/mxc_ffi/build.rs
@@ -26,10 +26,25 @@ fn main() {
     println!("cargo:rerun-if-changed=src/state_aware.rs");
     println!("cargo:rerun-if-changed=build.rs");
 
+    #[cfg(all(windows, feature = "isolation_session"))]
+    stage_isolation_session_runtime();
+
     #[cfg(feature = "dotnetsdk")]
     generate_csharp_bindings();
 }
 
+#[cfg(all(windows, feature = "isolation_session"))]
+fn stage_isolation_session_runtime() {
+    let manifest_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
+    let sdk_dir = manifest_dir
+        .join("..")
+        .join("..")
+        .join("mxc-sdk")
+        .join("build")
+        .join("isolation_session_bindings");
+    let _ = mxc_build_common::stage_isolation_session_runtime(&sdk_dir);
+}
+
 #[cfg(feature = "dotnetsdk")]
 fn generate_csharp_bindings() {
     use std::path::Path;
diff --git a/src/mxc-sdk/Cargo.toml b/src/mxc-sdk/Cargo.toml
index 733201b31..2cfd17d82 100644
--- a/src/mxc-sdk/Cargo.toml
+++ b/src/mxc-sdk/Cargo.toml
@@ -31,11 +31,19 @@ default = []
 wslc = ["link-wslcsdk", "dep:libloading", "dep:tar"]
 link-wslcsdk = ["dep:zip"]
 isolation_session = [
+    "lifted_msi",
     "dep:windows-bindgen",
     "dep:windows-collections",
     "dep:windows-future",
     "dep:zip",
 ]
+isolation_session_inbox = [
+    "dep:windows-bindgen",
+    "dep:windows-collections",
+    "dep:windows-future",
+    "dep:zip",
+]
+lifted_msi = []
 test-support = []
 microvm = []
 hyperlight = [
diff --git a/src/mxc-sdk/build.rs b/src/mxc-sdk/build.rs
index 5f52a78d6..2ab45cf2f 100644
--- a/src/mxc-sdk/build.rs
+++ b/src/mxc-sdk/build.rs
@@ -30,6 +30,8 @@ mod nanvix_common;
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     #[cfg(feature = "isolation_session")]
     build_isolation_session_bindings::run();
+    #[cfg(all(windows, feature = "isolation_session"))]
+    stage_isolation_session_runtime();
     build_mxc_telemetry::run();
     if let Some((bin_dir, use_prefetched_binaries)) = build_nanvix_binaries::run() {
         nanvix_build_common::stage_artifacts_next_to_exe(&bin_dir, !use_prefetched_binaries);
@@ -54,3 +56,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     )?;
     Ok(())
 }
+
+#[cfg(all(windows, feature = "isolation_session"))]
+fn stage_isolation_session_runtime() {
+    let manifest_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
+    let sdk_dir = manifest_dir
+        .join("build")
+        .join("isolation_session_bindings");
+    let _ = mxc_build_common::stage_isolation_session_runtime(&sdk_dir);
+}
diff --git a/src/mxc-sdk/build/build_mxc_build_common.rs b/src/mxc-sdk/build/build_mxc_build_common.rs
index 0cb0dbf5d..93b36603a 100644
--- a/src/mxc-sdk/build/build_mxc_build_common.rs
+++ b/src/mxc-sdk/build/build_mxc_build_common.rs
@@ -10,6 +10,9 @@ use std::io;
 use std::path::Path;
 use std::process::Command;
 
+#[cfg(windows)]
+use std::io::Read;
+
 /// Embed Windows VersionInfo resource metadata into the binary being compiled.
 ///
 /// On non-Windows hosts and when building non-Windows targets on a Windows host
@@ -83,6 +86,110 @@ pub fn embed_version_info_for_binary(
     Ok(())
 }
 
+/// Stages the lifted IsolationSession activation payload from the pinned SDK
+/// package beside the consuming Cargo artifact.
+#[cfg(all(windows, feature = "isolation_session"))]
+pub fn stage_isolation_session_runtime(sdk_dir: &Path) -> Option<String> {
+    const APP_DLL: &str = "IsoSessionApp.dll";
+    const RUNTIME_MANIFEST: &str = "IsoSession.manifest";
+    const VERSION_SIDECAR: &str = "IsoSessionApp.runtimeversion";
+
+    let nupkg = find_last_nupkg(sdk_dir)?;
+    println!("cargo:rerun-if-changed={}", nupkg.display());
+
+    let out_dir = std::env::var("OUT_DIR").expect("OUT_DIR");
+    let target_dir = Path::new(&out_dir)
+        .parent()
+        .and_then(|p| p.parent())
+        .and_then(|p| p.parent())
+        .expect("could not determine target dir from OUT_DIR");
+
+    let Some(app_dll) = extract_zip_entry(&nupkg, APP_DLL) else {
+        println!(
+            "cargo:warning=isosession: {} not found in {}; lifted activation will be unavailable",
+            APP_DLL,
+            nupkg.display()
+        );
+        return None;
+    };
+    std::fs::write(target_dir.join(APP_DLL), app_dll)
+        .unwrap_or_else(|e| panic!("stage {} to {}: {e}", APP_DLL, target_dir.display()));
+
+    let Some(version_bytes) = extract_zip_entry(&nupkg, VERSION_SIDECAR) else {
+        println!(
+            "cargo:warning=isosession: {} not found in {}; cannot stamp {}",
+            VERSION_SIDECAR,
+            nupkg.display(),
+            RUNTIME_MANIFEST
+        );
+        return None;
+    };
+    let instance = String::from_utf8(version_bytes)
+        .expect("IsoSessionApp.runtimeversion is valid UTF-8")
+        .trim()
+        .replace('_', ".");
+    let instance_bytes = instance.as_bytes();
+    assert!(
+        instance_bytes.len() == 7
+            && instance_bytes[4] == b'.'
+            && instance_bytes[..4]
+                .iter()
+                .all(|value| value.is_ascii_digit())
+            && instance_bytes[5..]
+                .iter()
+                .all(|value| value.is_ascii_digit()),
+        "IsoSessionApp.runtimeversion must identify a YYYY_MM instance"
+    );
+    let manifest = format!(
+        "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n\
+<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">\n\
+  <assemblyIdentity name=\"IsoSession.Runtime\" version=\"1.0.0.0\" type=\"win32\" />\n\
+  <file name=\"IsoSessionApp.dll\" />\n\
+  <iso:instance xmlns:iso=\"urn:schemas-microsoft-com:agentic-runtime.v1\" name=\"{instance}\" />\n\
+</assembly>\n"
+    );
+    std::fs::write(target_dir.join(RUNTIME_MANIFEST), manifest.as_bytes()).unwrap_or_else(|e| {
+        panic!(
+            "stage {} to {}: {e}",
+            RUNTIME_MANIFEST,
+            target_dir.display()
+        )
+    });
+    Some(manifest)
+}
+
+#[cfg(all(windows, feature = "isolation_session"))]
+fn find_last_nupkg(dir: &Path) -> Option<std::path::PathBuf> {
+    let mut packages: Vec<_> = std::fs::read_dir(dir)
+        .ok()?
+        .filter_map(|entry| entry.ok().map(|entry| entry.path()))
+        .filter(|path| {
+            path.extension()
+                .is_some_and(|extension| extension.eq_ignore_ascii_case("nupkg"))
+        })
+        .collect();
+    packages.sort();
+    packages.into_iter().next_back()
+}
+
+#[cfg(all(windows, feature = "isolation_session"))]
+fn extract_zip_entry(nupkg: &Path, file_name: &str) -> Option<Vec<u8>> {
+    let file =
+        std::fs::File::open(nupkg).unwrap_or_else(|e| panic!("open {}: {e}", nupkg.display()));
+    let mut archive =
+        zip::ZipArchive::new(file).unwrap_or_else(|e| panic!("read zip {}: {e}", nupkg.display()));
+    let wanted = file_name.to_ascii_lowercase();
+    let entry_name = (0..archive.len()).find_map(|index| {
+        let name = archive.by_index(index).ok()?.name().to_string();
+        let leaf = name.rsplit(['/', '\\']).next().unwrap_or(&name);
+        (leaf.to_ascii_lowercase() == wanted).then_some(name)
+    })?;
+    let mut entry = archive.by_name(&entry_name).ok()?;
+    let mut bytes = Vec::new();
+    entry.read_to_end(&mut bytes).ok()?;
+    Some(bytes)
+}
+
 #[cfg(windows)]
 fn embed_version_info_windows(
     file_description: &str,
diff --git a/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml b/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
index c611f9e36..e1f8e3fe3 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
+++ b/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
@@ -1,19 +1,17 @@
 # Provenance for the isolation_session_bindings crate.
 #
-# Bindings are regenerated at BUILD TIME by the crate's build.rs from the
-# Preview WinMD inside the pinned SDK nuget checked in beside this file --
-# there is no committed bindings.rs. This file is provenance documentation;
-# build.rs derives the actual output from the .nupkg.
+# Bindings are regenerated at build time from the Preview WinMD in the pinned
+# SDK package. Run Update-IsoSessionSdk.ps1 rather than editing this file.
 
 [tool]
-# Must match the `windows-bindgen` build-dependency pin in the crate's Cargo.toml
-# and stay in lockstep with the workspace `windows` crate major.minor.
 windows_bindgen_version = "0.62.1"
 target_windows_crate = "0.62"
-generated_date = "2026-08-19"
+generated_date = "2026-08-31"
 
 [source]
-nupkg = "Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg"
+nupkg = "Microsoft.Windows.AI.IsolationSession.SDK.0.202608.5.nupkg"
 winmd = "metadata/windows.ai.isolationsession.preview.winmd"
-winmd_sha256 = "4D7C49D34778028DA6DD08991765A7E37A0D57564F5B57CA4F7628CDC8917E5E"
+winmd_sha256 = "C6115B52525B06316BE77BEEB4FC4624C5CBB1CEC02E5493D86C46D90FABD6A9"
 namespace = "Windows.AI.IsolationSession.Preview"
+runtime_version = "2026_08"
+build_guid = "647f7f2e-caf7-eaa6-90d8-90f27fe8a346"
diff --git a/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.202608.5.nupkg b/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.202608.5.nupkg
new file mode 100644
index 0000000000000000000000000000000000000000..f2713b4561487b1ac0e222c8d14dfbd07bd2dd3c
GIT binary patch
literal 68375
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

literal 0
HcmV?d00001

diff --git a/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg b/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.2608.0.nupkg
deleted file mode 100644
index bfd7ecb1bf8a248b12f066d6875286c0f5b76918..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 93032
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

diff --git a/src/mxc-sdk/build/isolation_session_bindings/README.md b/src/mxc-sdk/build/isolation_session_bindings/README.md
index a445b3c4a..6df4e51e5 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/README.md
+++ b/src/mxc-sdk/build/isolation_session_bindings/README.md
@@ -40,8 +40,14 @@ re-runs when the `.nupkg` changes (`cargo:rerun-if-changed`).
 
 1. Produce a new package with the OS-side
    `nuget/Microsoft.Windows.AI.IsolationSession.SDK/pack.ps1`.
-2. Replace the `.nupkg` in this directory (and update `GENERATION_INFO.toml`'s
-   `winmd_sha256`).
+2. From the MXC repository root, run:
+   ```powershell
+   .\external\windows-sdk\isolation-session\Update-IsoSessionSdk.ps1 `
+       -PackagePath C:\path\to\Microsoft.Windows.AI.IsolationSession.SDK.<version>.nupkg
+   ```
+   The script validates the package payload and runtime identity, removes the
+   previously pinned package, copies the new package, and regenerates
+   `GENERATION_INFO.toml`.
 3. `cargo build` — the new bindings are generated automatically. Review the
    downstream diff (e.g. `cargo check -p wxc --features isolation_session`).
 
diff --git a/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1 b/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1
new file mode 100644
index 000000000..8e2962c53
--- /dev/null
+++ b/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1
@@ -0,0 +1,297 @@
+#Requires -Version 5.1
+
+<#
+.SYNOPSIS
+    Replaces MXC's pinned IsolationSession SDK package.
+
+.DESCRIPTION
+    Validates the package payload and release identity, replaces the single
+    checked-in package, and regenerates GENERATION_INFO.toml from the package.
+    The script fails before modifying the destination when the package is
+    incomplete or internally inconsistent.
+
+.PARAMETER PackagePath
+    Path to Microsoft.Windows.AI.IsolationSession.SDK.<version>.nupkg.
+
+.PARAMETER DestinationDirectory
+    MXC's external\windows-sdk\isolation-session directory. Defaults to the
+    directory containing this script.
+#>
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory = $true)]
+    [ValidateNotNullOrEmpty()]
+    [string] $PackagePath,
+
+    [string] $DestinationDirectory = $PSScriptRoot
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = 'Stop'
+
+$package = Get-Item -LiteralPath $PackagePath -ErrorAction Stop
+if ($package.Extension -ine '.nupkg') {
+    throw "PackagePath must identify a .nupkg file: '$PackagePath'."
+}
+
+if (-not (Test-Path -LiteralPath $DestinationDirectory -PathType Container)) {
+    throw "DestinationDirectory does not exist: '$DestinationDirectory'."
+}
+
+Add-Type -AssemblyName System.IO.Compression.FileSystem
+
+function Get-ZipEntryBytes {
+    param(
+        [Parameter(Mandatory = $true)]
+        [System.IO.Compression.ZipArchive] $Archive,
+
+        [Parameter(Mandatory = $true)]
+        [string] $EntryName
+    )
+
+    $entry = $Archive.Entries |
+        Where-Object { $_.FullName.Replace('\', '/') -ieq $EntryName } |
+        Select-Object -First 1
+    if (-not $entry) {
+        throw "Package is missing required entry '$EntryName'."
+    }
+
+    $stream = $entry.Open()
+    try {
+        $memory = [System.IO.MemoryStream]::new()
+        try {
+            $stream.CopyTo($memory)
+            return $memory.ToArray()
+        }
+        finally {
+            $memory.Dispose()
+        }
+    }
+    finally {
+        $stream.Dispose()
+    }
+}
+
+function Convert-BytesToText {
+    param([byte[]] $Bytes)
+
+    return [System.Text.UTF8Encoding]::new($true).GetString($Bytes).TrimStart([char]0xFEFF)
+}
+
+function Get-TomlString {
+    param(
+        [string] $Content,
+        [string[]] $Names,
+        [switch] $Optional
+    )
+
+    foreach ($name in $Names) {
+        $match = [regex]::Match(
+            $Content,
+            "(?m)^\s*$([regex]::Escape($name))\s*=\s*`"([^`"]*)`"\s*$")
+        if ($match.Success) {
+            return $match.Groups[1].Value
+        }
+    }
+
+    if ($Optional) {
+        return ''
+    }
+
+    throw "Package GENERATION_INFO.toml is missing '$($Names -join "' or '")'."
+}
+
+function Get-Sha256 {
+    param([byte[]] $Bytes)
+
+    $sha256 = [System.Security.Cryptography.SHA256]::Create()
+    try {
+        return ([BitConverter]::ToString($sha256.ComputeHash($Bytes))).Replace('-', '')
+    }
+    finally {
+        $sha256.Dispose()
+    }
+}
+
+$archive = [System.IO.Compression.ZipFile]::OpenRead($package.FullName)
+try {
+    $nuspecEntry = $archive.Entries |
+        Where-Object { $_.FullName -like '*.nuspec' } |
+        Select-Object -First 1
+    if (-not $nuspecEntry) {
+        throw 'Package is missing its .nuspec metadata.'
+    }
+
+    $nuspecBytes = Get-ZipEntryBytes -Archive $archive -EntryName $nuspecEntry.FullName
+    [xml] $nuspec = Convert-BytesToText -Bytes $nuspecBytes
+    $packageId = [string] $nuspec.package.metadata.id
+    $packageVersion = [string] $nuspec.package.metadata.version
+    if ($packageId -ne 'Microsoft.Windows.AI.IsolationSession.SDK') {
+        throw "Unexpected package id '$packageId'."
+    }
+    if ($packageVersion -notmatch '^0\.(\d{2}|20\d{2})(0[1-9]|1[0-2])\.(\d+)$') {
+        throw "Unexpected package version '$packageVersion'; expected 0.YYMM.patch or 0.YYYYMM.patch."
+    }
+
+    $year = $Matches[1]
+    $yearShort = $year.Substring($year.Length - 2)
+    $month = $Matches[2]
+    $runtimeVersionExpected = "20${yearShort}_$month"
+    $canonicalFileName = "$packageId.$packageVersion.nupkg"
+
+    $requiredEntries = @(
+        'metadata/windows.ai.isolationsession.winmd',
+        'metadata/windows.ai.isolationsession.preview.winmd',
+        'metadata/GENERATION_INFO.toml',
+        'runtime/IsoSessionApp.dll',
+        'runtime/IsoSessionApp.runtimeversion'
+    )
+    foreach ($entryName in $requiredEntries) {
+        [void] (Get-ZipEntryBytes -Archive $archive -EntryName $entryName)
+    }
+
+    $runtimeVersion = Convert-BytesToText (
+        Get-ZipEntryBytes -Archive $archive -EntryName 'runtime/IsoSessionApp.runtimeversion')
+    $runtimeVersion = $runtimeVersion.Trim()
+    if ($runtimeVersion -ne $runtimeVersionExpected) {
+        throw "Runtime sidecar '$runtimeVersion' does not match package version '$packageVersion' (expected '$runtimeVersionExpected')."
+    }
+
+    $packageGenerationInfo = Convert-BytesToText (
+        Get-ZipEntryBytes -Archive $archive -EntryName 'metadata/GENERATION_INFO.toml')
+    $targetWindowsCrate = Get-TomlString `
+        -Content $packageGenerationInfo `
+        -Names 'target_windows_crate'
+    $windowsBindgen = Get-TomlString `
+        -Content $packageGenerationInfo `
+        -Names @('windows_bindgen', 'windows_bindgen_version')
+    $instance = Get-TomlString -Content $packageGenerationInfo -Names 'instance'
+    $osBuild = Get-TomlString `
+        -Content $packageGenerationInfo `
+        -Names 'os_build' `
+        -Optional
+    $buildGuid = Get-TomlString `
+        -Content $packageGenerationInfo `
+        -Names 'build_guid' `
+        -Optional
+    $generatedTimestamp = Get-TomlString `
+        -Content $packageGenerationInfo `
+        -Names 'generated_utc' `
+        -Optional
+    $generatedDateValue = Get-TomlString `
+        -Content $packageGenerationInfo `
+        -Names 'generated_date' `
+        -Optional
+    $releaseGeneratedTimestamp = ''
+    $releaseInfoEntry = $archive.Entries |
+        Where-Object { $_.FullName.Replace('\', '/') -ieq 'metadata/RELEASE_INFO.json' } |
+        Select-Object -First 1
+    if ($releaseInfoEntry) {
+        $releaseInfoBytes = Get-ZipEntryBytes `
+            -Archive $archive `
+            -EntryName $releaseInfoEntry.FullName
+        $releaseInfoText = Convert-BytesToText -Bytes $releaseInfoBytes
+        $releaseTimestampMatch = [regex]::Match(
+            $releaseInfoText,
+            '"generatedUtc"\s*:\s*"([^"]+)"')
+        if ($releaseTimestampMatch.Success) {
+            $releaseGeneratedTimestamp = $releaseTimestampMatch.Groups[1].Value
+        }
+    }
+    $validInstances = @(
+        "$yearShort$month",
+        "20$yearShort.$month"
+    )
+    if ($instance -notin $validInstances) {
+        throw "Package instance '$instance' does not match package version '$packageVersion'."
+    }
+
+    $previewBytes = Get-ZipEntryBytes `
+        -Archive $archive `
+        -EntryName 'metadata/windows.ai.isolationsession.preview.winmd'
+    $previewHash = Get-Sha256 -Bytes $previewBytes
+}
+finally {
+    $archive.Dispose()
+}
+
+$destinationPackage = Join-Path $DestinationDirectory $canonicalFileName
+$sourceResolved = $package.FullName
+$destinationResolved = [System.IO.Path]::GetFullPath($destinationPackage)
+if ($sourceResolved -ine $destinationResolved) {
+    $temporaryPackage = "$destinationPackage.new"
+    try {
+        Copy-Item -LiteralPath $sourceResolved -Destination $temporaryPackage -Force
+        Get-ChildItem -LiteralPath $DestinationDirectory -Filter '*.nupkg' -File |
+            Where-Object { $_.FullName -ine $temporaryPackage } |
+            Remove-Item -Force
+        Move-Item -LiteralPath $temporaryPackage -Destination $destinationPackage -Force
+    }
+    finally {
+        if (Test-Path -LiteralPath $temporaryPackage) {
+            Remove-Item -LiteralPath $temporaryPackage -Force
+        }
+    }
+}
+else {
+    Get-ChildItem -LiteralPath $DestinationDirectory -Filter '*.nupkg' -File |
+        Where-Object { $_.FullName -ine $destinationResolved } |
+        Remove-Item -Force
+}
+
+# Cargo build scripts track this package by timestamp. Refresh it even when a
+# corrected package reuses the same version and canonical file name.
+(Get-Item -LiteralPath $destinationPackage).LastWriteTimeUtc = [DateTime]::UtcNow
+
+$parsedGeneratedDate = [DateTimeOffset]::MinValue
+if ($releaseGeneratedTimestamp -and
+    [DateTimeOffset]::TryParse($releaseGeneratedTimestamp, [ref] $parsedGeneratedDate)) {
+    $generatedDate = $parsedGeneratedDate.UtcDateTime.ToString('yyyy-MM-dd')
+}
+elseif ($generatedTimestamp -and
+    [DateTimeOffset]::TryParse($generatedTimestamp, [ref] $parsedGeneratedDate)) {
+    $generatedDate = $parsedGeneratedDate.UtcDateTime.ToString('yyyy-MM-dd')
+}
+elseif ($generatedDateValue -and
+    [DateTimeOffset]::TryParse($generatedDateValue, [ref] $parsedGeneratedDate)) {
+    $generatedDate = $parsedGeneratedDate.UtcDateTime.ToString('yyyy-MM-dd')
+}
+else {
+    throw 'Package GENERATION_INFO.toml has no valid generated_utc or generated_date value.'
+}
+$generationInfo = @"
+# Provenance for the isolation_session_bindings crate.
+#
+# Bindings are regenerated at build time from the Preview WinMD in the pinned
+# SDK package. Run Update-IsoSessionSdk.ps1 rather than editing this file.
+
+[tool]
+windows_bindgen_version = "$windowsBindgen"
+target_windows_crate = "$targetWindowsCrate"
+generated_date = "$generatedDate"
+
+[source]
+nupkg = "$canonicalFileName"
+winmd = "metadata/windows.ai.isolationsession.preview.winmd"
+winmd_sha256 = "$previewHash"
+namespace = "Windows.AI.IsolationSession.Preview"
+runtime_version = "$runtimeVersion"
+"@
+if ($osBuild) {
+    $generationInfo += "`nos_build = `"$osBuild`""
+}
+if ($buildGuid) {
+    $generationInfo += "`nbuild_guid = `"$buildGuid`""
+}
+
+$generationInfoPath = Join-Path $DestinationDirectory 'GENERATION_INFO.toml'
+Set-Content -LiteralPath $generationInfoPath -Value $generationInfo -Encoding UTF8
+
+[pscustomobject][ordered]@{
+    Package = $destinationPackage
+    PackageSha256 = (Get-FileHash -LiteralPath $destinationPackage -Algorithm SHA256).Hash
+    PreviewWinmdSha256 = $previewHash
+    OsBuild = $osBuild
+    BuildGuid = $buildGuid
+    RuntimeVersion = $runtimeVersion
+}
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/availability.rs b/src/mxc-sdk/src/backends/isolation_session/common/availability.rs
index 7c4fd1c95..d0b1eca7e 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/availability.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/availability.rs
@@ -10,6 +10,8 @@
 use std::sync::OnceLock;
 
 use crate::isolation_session_bindings::bindings::{IsoSessionFeature, IsoSessionOps};
+#[cfg(feature = "lifted_msi")]
+use windows::Win32::Foundation::REGDB_E_CLASSNOTREG;
 use windows_core::HRESULT;
 
 use super::owned_thread;
@@ -37,9 +39,28 @@ fn available_from(probe: Result<i32, HRESULT>) -> bool {
 }
 
 fn probe_feature_level() -> Result<i32, HRESULT> {
+    #[cfg(feature = "lifted_msi")]
+    let ops = match super::regfree::activate_from_adjacent_shim::<IsoSessionOps>() {
+        Some(result) => result.map_err(|error| {
+            eprintln!(
+                "[mxc isosession] lifted IsoSessionOps activation failed: {}",
+                error
+            );
+            error.code()
+        })?,
+        None => return Err(REGDB_E_CLASSNOTREG),
+    };
+    #[cfg(not(feature = "lifted_msi"))]
     let ops = IsoSessionOps::new().map_err(|e| e.code())?;
+
     ops.GetFeatureLevel(IsoSessionFeature::LocalAgentUser)
-        .map_err(|e| e.code())
+        .map_err(|error| {
+            eprintln!(
+                "[mxc isosession] GetFeatureLevel(LocalAgentUser) failed: {}",
+                error
+            );
+            error.code()
+        })
 }
 
 #[cfg(test)]
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/error.rs b/src/mxc-sdk/src/backends/isolation_session/common/error.rs
index bc9e1c61c..c8548e85a 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/error.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/error.rs
@@ -347,31 +347,30 @@ pub(super) fn identity_refusal(err: windows_core::Error) -> IsolationSessionErro
     })
 }
 
-/// The reg-free private-CLSID activator is not fused into this executable, so
-/// the version-pinned MSI-installed IsolationSession runtime cannot be bound.
+/// The adjacent lifted activation payload is missing, so the version-pinned
+/// MSI-installed IsolationSession runtime cannot be bound.
 ///
 /// Raised for the `None` arm of
-/// [`super::regfree::activate_via_private_clsid`] (`REGDB_E_CLASSNOTREG` from
-/// `CoCreateInstance` on the private activator CLSID). MXC deliberately does
+/// [`super::regfree::activate_from_adjacent_shim`]. MXC deliberately does
 /// **not** fall back to the inbox `System32` runtime here — silently binding a
 /// different, unversioned binary set is exactly the failure mode this design
-/// exists to prevent — so the missing fused manifest surfaces as a hard,
+/// exists to prevent — so the missing payload surfaces as a hard,
 /// actionable error instead.
-pub(super) fn regfree_not_fused(operation: &str) -> IsolationSessionError {
+#[cfg(feature = "lifted_msi")]
+pub(super) fn lifted_payload_missing(operation: &str) -> IsolationSessionError {
     IsolationSessionError::ServiceUnavailable(IsoApiFailure::new(
         operation,
         Some(REGDB_E_CLASSNOTREG_HRESULT),
         Some(
-            "IsolationSession reg-free activation was not taken: the private-CLSID activator \
-             (IsoSessionApp.comClass.manifest) is not fused into this executable, so the \
+            "IsolationSession lifted activation was not taken: IsoSessionApp.dll and \
+             IsoSession.manifest are not co-located with this executable, so the \
              version-pinned MSI-installed IsolationSession runtime could not be bound. MXC will \
              not silently fall back to the inbox System32 runtime."
                 .to_string(),
         ),
         Some(
-            "Rebuild wxc-exec against the Microsoft.Windows.AI.IsolationSession.SDK nuget so the \
-             activation manifest is fused into the executable and IsoSessionApp.dll is \
-             co-located next to wxc-exec.exe."
+            "Rebuild against the Microsoft.Windows.AI.IsolationSession.SDK NuGet so \
+             IsoSessionApp.dll and its stamped IsoSession.manifest are staged beside the host."
                 .to_string(),
         ),
     ))
@@ -863,19 +862,21 @@ mod tests {
         assert!(mapped.message.contains("same OS commit"));
     }
 
-    /// The hard error raised when the reg-free activator is not fused must
-    /// carry the REGDB_E_CLASSNOTREG code, an operation, a message that refuses
-    /// the inbox fallback, and an actionable remediation.
+    /// The hard error raised when the lifted payload is absent must carry the
+    /// class-not-registered code, an operation, a message that refuses the
+    /// inbox fallback, and an actionable remediation.
+    #[cfg(feature = "lifted_msi")]
     #[test]
-    fn regfree_not_fused_is_a_hard_actionable_error() {
-        let mapped = map_lifecycle_error(regfree_not_fused(op::ACTIVATE));
+    fn lifted_payload_missing_is_a_hard_actionable_error() {
+        let mapped = map_lifecycle_error(lifted_payload_missing(op::ACTIVATE));
         assert_eq!(mapped.code, MxcErrorCode::BackendUnavailable);
         assert_eq!(mapped.operation(), Some("IsoSessionOps.ActivateInstance"));
         assert_eq!(mapped.native_code(), Some("0x80040154"));
         assert!(mapped.message.contains("not silently fall back"));
         assert!(mapped
-            .remediation()
-            .is_some_and(|r| r.contains("IsolationSession.SDK nuget")));
+            .remediation
+            .as_deref()
+            .is_some_and(|r| r.contains("IsolationSession.SDK NuGet")));
     }
 
     #[test]
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
index 9ddaa34f9..ab62ffe9f 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
@@ -29,9 +29,11 @@ use windows_core::{HSTRING, PCWSTR};
 
 use super::console_mode::{get_local_console_size, ConsoleModeRestorer, CtrlHandlerGuard};
 use super::console_relay::{create_console_relay_thread, ConsoleRelayParams};
+#[cfg(feature = "lifted_msi")]
+use super::error::lifted_payload_missing;
 use super::error::{
-    activation_error, check_result, format_iso_error, lifecycle_err, op, regfree_not_fused,
-    transport_err, IsolationSessionError, StalePromotion,
+    activation_error, check_result, format_iso_error, lifecycle_err, op, transport_err,
+    IsolationSessionError, StalePromotion,
 };
 use super::owned_thread::{self, Impersonation};
 use super::pipe_relay::{
@@ -86,10 +88,11 @@ unsafe impl Sync for MtaReference {}
 /// binding the version-pinned MSI-installed runtime.
 ///
 /// There is **no inbox fallback**: if the private-CLSID activator is not fused
-/// into this executable, this returns a hard [`regfree_not_fused`] error rather
+/// beside this executable, this returns a hard [`lifted_payload_missing`] error rather
 /// than silently binding the inbox `System32` runtime.
+#[cfg(feature = "lifted_msi")]
 fn check_service_available_and_activate() -> Result<IsoSessionOps, IsolationSessionError> {
-    match super::regfree::activate_via_private_clsid::<IsoSessionOps>() {
+    match super::regfree::activate_from_adjacent_shim::<IsoSessionOps>() {
         Some(Ok(ops)) => Ok(ops),
         // The HRESULT→error mapping lives in `activation_error` so it stays
         // testable without depending on whether this host can activate the
@@ -97,10 +100,17 @@ fn check_service_available_and_activate() -> Result<IsoSessionOps, IsolationSess
         Some(Err(e)) => Err(activation_error(e.code().0 as u32, &e.message())),
         // The fused manifest is absent: refuse to silently bind the inbox
         // runtime, and surface an actionable hard error instead.
-        None => Err(regfree_not_fused(op::ACTIVATE)),
+        None => Err(lifted_payload_missing(op::ACTIVATE)),
     }
 }
 
+/// Activates the system-registered API for embedders such as the Rust and C#
+/// SDKs. They do not carry `wxc-exec`'s fused lifted-MSI activation manifest.
+#[cfg(not(feature = "lifted_msi"))]
+fn check_service_available_and_activate() -> Result<IsoSessionOps, IsolationSessionError> {
+    IsoSessionOps::new().map_err(|e| activation_error(e.code().0 as u32, &e.message()))
+}
+
 /// `GetFeatureLevel` fails on a host that does not recognize the feature
 /// value, so an error reads as not supported.
 fn feature_supported_from(level: windows_core::Result<i32>) -> bool {
@@ -1537,14 +1547,14 @@ mod tests {
                 // Service is NOT available. Verify the error is clean and
                 // descriptive (not a panic or cryptic COM error), and that
                 // it names the activation operation it failed on. On a host
-                // without the fused private-CLSID manifest (the usual dev
-                // box), activation resolves to the reg-free hard error; on a
+                // without the adjacent lifted payload (the usual dev box),
+                // activation resolves to the lifted hard error; on a
                 // host where the class is inbox-registered but unavailable it
                 // is the "not available" message.
                 assert!(
                     failure.message.contains("not available")
                         || failure.message.contains("activation failed")
-                        || failure.message.contains("reg-free activation was not taken"),
+                        || failure.message.contains("lifted activation was not taken"),
                     "Expected descriptive error message, got: {}",
                     failure.message
                 );
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/mod.rs b/src/mxc-sdk/src/backends/isolation_session/common/mod.rs
index d27e47ff0..730011e4a 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/mod.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/mod.rs
@@ -41,7 +41,7 @@ mod process_options;
 mod sandbox;
 #[cfg(target_os = "windows")]
 pub use sandbox::{spawn_one_shot, spawn_one_shot_pty, OneShotSpawnFailure};
-#[cfg(target_os = "windows")]
+#[cfg(all(target_os = "windows", feature = "lifted_msi"))]
 mod regfree;
 #[cfg(target_os = "windows")]
 mod sandbox_id;
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs b/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs
index c5ea5cfc9..e215459a2 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs
@@ -10,7 +10,9 @@ use crate::mxc_common::models::ExecutionRequest;
 use crate::isolation_session_bindings::bindings::IsoSessionProcessOptions;
 use windows_core::HSTRING;
 
-use super::error::{op, regfree_not_fused, transport_err, IsolationSessionError};
+#[cfg(feature = "lifted_msi")]
+use super::error::lifted_payload_missing;
+use super::error::{op, transport_err, IsolationSessionError};
 
 const REDIRECT_STDIN: u32 = 0x1;
 const REDIRECT_STDOUT: u32 = 0x2;
@@ -167,14 +169,7 @@ pub(super) fn with_service_timeout_grace(mut options: ProcessOptions) -> Process
 pub(super) fn build_iso_process_options(
     options: &ProcessOptions,
 ) -> Result<IsoSessionProcessOptions, IsolationSessionError> {
-    let proc_options =
-        match super::regfree::activate_via_private_clsid::<IsoSessionProcessOptions>() {
-            Some(result) => {
-                result.map_err(|e| transport_err(op::OPTIONS_NEW, "activation failed", &e))?
-            }
-            // No inbox fallback: the fused private-CLSID activator is absent.
-            None => return Err(regfree_not_fused(op::OPTIONS_NEW)),
-        };
+    let proc_options = new_iso_process_options()?;
 
     proc_options
         .SetTimeoutMilliseconds(options.timeout_ms)
@@ -221,6 +216,20 @@ pub(super) fn build_iso_process_options(
     Ok(proc_options)
 }
 
+#[cfg(feature = "lifted_msi")]
+fn new_iso_process_options() -> Result<IsoSessionProcessOptions, IsolationSessionError> {
+    match super::regfree::activate_from_adjacent_shim::<IsoSessionProcessOptions>() {
+        Some(result) => result.map_err(|e| transport_err(op::OPTIONS_NEW, "activation failed", &e)),
+        None => Err(lifted_payload_missing(op::OPTIONS_NEW)),
+    }
+}
+
+#[cfg(not(feature = "lifted_msi"))]
+fn new_iso_process_options() -> Result<IsoSessionProcessOptions, IsolationSessionError> {
+    IsoSessionProcessOptions::new()
+        .map_err(|e| transport_err(op::OPTIONS_NEW, "activation failed", &e))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
index 24327350a..acc261b97 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
@@ -1,193 +1,147 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-//! Reg-free classic-COM activation for the IsoSession client surface.
+//! Activation for the lifted IsolationSession runtime.
 //!
-//! By default MXC would activate `Windows.AI.IsolationSession.Preview.*`
-//! through the system-installed WinRT registration (the OS image populates the
-//! activation catalog, which resolves to the inbox `System32` binaries). To
-//! bind the **version-pinned MSI-installed** runtime instead, MXC ships
-//! `IsoSessionApp.dll` in its own nuget package (co-located with `wxc-exec.exe`)
-//! and activates it through a **private classic-COM CLSID** that `wxc-exec`'s
-//! fused manifest redirects (reg-free) to that DLL.
-//!
-//! Mechanism: [`activate_via_private_clsid`] calls
-//! `CoCreateInstance(<private CLSID>, CLSCTX_INPROC_SERVER, IID_IActivationFactory)`.
-//! The fused `<comClass>` redirection resolves the CLSID straight to the
-//! co-located `IsoSessionApp.dll` -- there is **no `LoadLibrary` in this caller
-//! and no runtime-path logic in Rust**. All knowledge of where the MSI runtime
-//! lives is owned by `IsoSessionApp.dll` (C++), which resolves the runtime
-//! directory and coresident-loads `IsoSessionClient.dll`, then binds the
-//! matching side-by-side service instance.
-//!
-//! Why classic-COM and not reg-free WinRT: a classic `<comClass>` redirection
-//! is honored **ahead of** HKCR and is never catalog-shadowed (a private CLSID
-//! is in no inbox catalog), so it is immune to the reserved-namespace shadowing
-//! that defeats a reg-free WinRT activation context on an image where the
-//! `Windows.AI.IsolationSession.*` classes are already registered inbox.
-//!
-//! No-fallback contract: when the private CLSID is not registered
-//! (`REGDB_E_CLASSNOTREG`) -- i.e. the manifest was not fused, such as an
-//! inbox-only build -- [`activate_via_private_clsid`] returns `None`. The
-//! callers (`manager::check_service_available_and_activate` and
-//! `process_options::build_iso_process_options`) turn that `None` into a hard,
-//! actionable error (`error::regfree_not_fused`): MXC deliberately does **not**
-//! fall back to the inbox `System32` runtime, because silently binding a
-//! different, unversioned binary set is exactly the failure this design exists
-//! to prevent. Any *other* activation error is surfaced as `Some(Err(..))`
-//! rather than silently redirected to a different binary set.
-//!
-//! GUID contract: the two private activator CLSIDs below are a hard contract
-//! duplicated in THREE places -- change all together:
-//!   * OS: `onecoreuap/windows/core/isoenvbroker/src/app/dll.cpp`
-//!   * nuget manifest fragment: `.../IsoSessionApp.comClass.manifest`
-//!   * this file (`backends/isolation_session/common/src/regfree.rs`)
-
-use isolation_session_bindings::bindings::{IsoSessionOps, IsoSessionProcessOptions};
-use windows::Win32::Foundation::REGDB_E_CLASSNOTREG;
-use windows::Win32::System::Com::{
-    CoCreateInstance, CoInitializeEx, CLSCTX_INPROC_SERVER, COINIT_MULTITHREADED,
+//! The lifted SDK places `IsoSessionApp.dll` and a stamped
+//! `IsoSession.manifest` beside the host. The shim exports
+//! `DllGetActivationFactory`; loading that export directly prevents the inbox
+//! WinRT catalog from shadowing the lifted implementation.
+
+#![allow(unsafe_code)]
+
+use std::os::windows::ffi::OsStrExt;
+use std::path::PathBuf;
+use std::sync::OnceLock;
+
+use windows::core::{s, HSTRING, PCWSTR};
+use windows::Win32::Foundation::{GetLastError, REGDB_E_CLASSNOTREG};
+use windows::Win32::System::Com::{CoInitializeEx, COINIT_MULTITHREADED};
+use windows::Win32::System::LibraryLoader::{
+    GetProcAddress, LoadLibraryExW, LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR, LOAD_LIBRARY_SEARCH_SYSTEM32,
 };
 use windows::Win32::System::WinRT::IActivationFactory;
-use windows_core::{Interface, RuntimeName, GUID};
+use windows_core::{Interface, RuntimeName, HRESULT};
+
+const SHIM_NAME: &str = "IsoSessionApp.dll";
+const MANIFEST_NAME: &str = "IsoSession.manifest";
+
+type DllGetActivationFactory =
+    unsafe extern "system" fn(*mut std::ffi::c_void, *mut *mut std::ffi::c_void) -> HRESULT;
+
+static GET_ACTIVATION_FACTORY: OnceLock<DllGetActivationFactory> = OnceLock::new();
 
-/// Maps a WinRT runtime class to the private classic-COM CLSID that
-/// `IsoSessionApp.dll` exposes (reg-free, via the fused manifest) as its in-proc
-/// activator. The CLSID is what MXC hands to `CoCreateInstance`; the shim's
-/// class factory then forwards to the matching WinRT class.
+/// Activates `T` through the lifted shim staged beside the current executable.
 ///
-/// See the module-level GUID contract note: these values must stay in sync with
-/// the OS `dll.cpp` and the nuget `.comClass.manifest`.
-pub(crate) trait ActivatorClsid {
-    /// The private activator CLSID for this runtime class.
-    const ACTIVATOR_CLSID: GUID;
-}
+/// Returns `None` only when the lifted activation payload is not present.
+/// Other failures are returned to the caller and must not fall back to inbox
+/// activation because that would silently mix the lifted WinMD with inbox code.
+pub(crate) fn activate_from_adjacent_shim<T>() -> Option<windows_core::Result<T>>
+where
+    T: Interface + RuntimeName,
+{
+    // Some callers enter through a native thread without initializing COM.
+    // RPC_E_CHANGED_MODE only means another apartment model is already active.
+    let _ = unsafe { CoInitializeEx(None, COINIT_MULTITHREADED) };
 
-impl ActivatorClsid for IsoSessionOps {
-    // {6EF3155B-D1A2-4A34-BCAA-089F8A6D9916}
-    const ACTIVATOR_CLSID: GUID = GUID::from_u128(0x6ef3155b_d1a2_4a34_bcaa_089f8a6d9916);
-}
+    let directory = adjacent_runtime_directory()?;
+    let factory = match load_activation_factory::<T>(&directory.join(SHIM_NAME)) {
+        Ok(factory) => factory,
+        Err(error) if error.code() == REGDB_E_CLASSNOTREG => return None,
+        Err(error) => return Some(Err(error)),
+    };
 
-impl ActivatorClsid for IsoSessionProcessOptions {
-    // {36B03FF1-21AA-4F3C-819D-2430EC830DD0}
-    const ACTIVATOR_CLSID: GUID = GUID::from_u128(0x36b03ff1_21aa_4f3c_819d_2430ec830dd0);
+    Some(activate_from_factory(factory))
 }
 
-/// Activates the WinRT runtime class `T` by resolving its private classic-COM
-/// activator CLSID (reg-free, via the fused manifest) to the co-located
-/// `IsoSessionApp.dll` and driving its activation factory.
-///
-/// Returns:
-/// - `None` when the private CLSID is not registered (`REGDB_E_CLASSNOTREG`) --
-///   the manifest was not fused / this is an inbox-only build. The caller turns
-///   this into a hard `error::regfree_not_fused` error (NO inbox fallback).
-/// - `Some(Err(..))` when activation was attempted but failed (the shim could
-///   not load the client, the factory failed, an unexpected HRESULT, ...). The
-///   caller must surface this rather than silently bind a different binary set.
-/// - `Some(Ok(instance))` on success.
-pub(crate) fn activate_via_private_clsid<T>() -> Option<windows_core::Result<T>>
+fn load_activation_factory<T>(
+    dll_path: &std::path::Path,
+) -> windows_core::Result<IActivationFactory>
 where
-    T: Interface + RuntimeName + ActivatorClsid,
+    T: Interface + RuntimeName,
 {
-    // `CoCreateInstance` requires an initialized COM apartment on this thread.
-    // `wxc-exec`'s `main` already initializes an MTA, so the expected result
-    // here is `S_FALSE` (already initialized); `RPC_E_CHANGED_MODE` (a
-    // different apartment already in force) is likewise fine -- the existing
-    // apartment is reused. We deliberately do NOT pair this with a
-    // `CoUninitialize`: the one extra init-count increment is leaked for the
-    // process lifetime (matching the prior implementation) and reclaimed at
-    // process teardown.
-    //
-    // SAFETY: `CoInitializeEx` is safe to call with a null reserved pointer.
-    unsafe {
-        let _ = CoInitializeEx(None, COINIT_MULTITHREADED);
+    let get_factory = resolve_get_activation_factory(dll_path)?;
+
+    let class_name = HSTRING::from(T::NAME);
+    // HSTRING is a transparent handle; pass the handle, not its UTF-16 buffer.
+    let class_name_handle = unsafe { std::mem::transmute_copy(&class_name) };
+    let mut factory = std::ptr::null_mut();
+    unsafe { get_factory(class_name_handle, &mut factory) }.ok()?;
+    if factory.is_null() {
+        return Err(windows_core::Error::from_hresult(HRESULT(
+            0x8000_4003u32 as i32,
+        )));
     }
 
-    // SAFETY: `T::ACTIVATOR_CLSID` is a valid CLSID; the fused manifest (or, on
-    // an inbox-only build, its absence) determines resolution. Requesting
-    // `IActivationFactory` matches what the shim's class factory returns.
-    let factory: IActivationFactory =
-        match unsafe { CoCreateInstance(&T::ACTIVATOR_CLSID, None, CLSCTX_INPROC_SERVER) } {
-            Ok(factory) => factory,
-            // Not registered: no fused manifest / inbox-only build. Let the
-            // caller fall back to inbox `T::new()`.
-            Err(e) if e.code() == REGDB_E_CLASSNOTREG => return None,
-            // Any other failure is a real activation error -- surface it.
-            Err(e) => {
-                eprintln!(
-                    "[mxc isosession] CoCreateInstance(<activator for '{}'>) failed: {}",
-                    <T as RuntimeName>::NAME,
-                    e
-                );
-                return Some(Err(e));
-            }
-        };
-
-    Some(activate_from_factory::<T>(factory))
+    // The module intentionally remains loaded so the returned vtable stays valid.
+    Ok(unsafe { IActivationFactory::from_raw(factory) })
+}
+
+fn resolve_get_activation_factory(
+    dll_path: &std::path::Path,
+) -> windows_core::Result<DllGetActivationFactory> {
+    if let Some(get_factory) = GET_ACTIVATION_FACTORY.get() {
+        return Ok(*get_factory);
+    }
+
+    let source: Vec<u16> = dll_path
+        .as_os_str()
+        .encode_wide()
+        .chain(std::iter::once(0))
+        .collect();
+
+    // The absolute path plus constrained dependency search prevents DLL planting.
+    let module = unsafe {
+        LoadLibraryExW(
+            PCWSTR(source.as_ptr()),
+            None,
+            LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32,
+        )
+    }?;
+    let export =
+        unsafe { GetProcAddress(module, s!("DllGetActivationFactory")) }.ok_or_else(|| {
+            windows_core::Error::from_hresult(HRESULT::from_win32(unsafe { GetLastError().0 }))
+        })?;
+    let get_factory: DllGetActivationFactory = unsafe { std::mem::transmute(export) };
+
+    // A racing activation may load the same module twice, but both handles remain
+    // valid for the process lifetime and every caller uses the cached export.
+    let _ = GET_ACTIVATION_FACTORY.set(get_factory);
+    Ok(*GET_ACTIVATION_FACTORY.get().unwrap_or(&get_factory))
+}
+
+fn adjacent_runtime_directory() -> Option<PathBuf> {
+    let executable = std::env::current_exe().ok()?;
+    let executable_directory = executable.parent()?;
+    let directory = [Some(executable_directory), executable_directory.parent()]
+        .into_iter()
+        .flatten()
+        .find(|directory| {
+            directory.join(SHIM_NAME).is_file() && directory.join(MANIFEST_NAME).is_file()
+        })
+        .map(PathBuf::from);
+    directory
 }
 
-/// Drives a resolved `IActivationFactory` to produce an instance of `T`.
 fn activate_from_factory<T>(factory: IActivationFactory) -> windows_core::Result<T>
 where
     T: Interface + RuntimeName,
 {
-    // SAFETY: `factory` came from the runtime class's own activator DLL.
-    let instance = match unsafe { factory.ActivateInstance() } {
-        Ok(instance) => instance,
-        Err(e) => {
-            eprintln!(
-                "[mxc isosession] ActivateInstance('{}') failed: {}",
-                <T as RuntimeName>::NAME,
-                e
-            );
-            return Err(e);
-        }
-    };
-
-    instance.cast::<T>().map_err(|e| {
-        // A cast failure here means the activated `IsoSessionApp.dll` produced
-        // an object that does not implement the interface IID the Preview WinMD
-        // was built against -- the winmd/MSI version-pin mismatch. The
-        // actionable mapping lives in `error::activation_error`
-        // (E_NOINTERFACE branch); this stays a diagnostic breadcrumb.
+    let instance = unsafe { factory.ActivateInstance() }.map_err(|error| {
         eprintln!(
-            "[mxc isosession] cast to '{}' failed (winmd/MSI version-pin mismatch? the \
-             activated IsoSessionApp.dll does not implement the expected interface IID): {}",
-            <T as RuntimeName>::NAME,
-            e
+            "[mxc isosession] ActivateInstance('{}') failed: {}",
+            T::NAME,
+            error
         );
-        e
-    })
-}
+        error
+    })?;
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /// The two private activator CLSIDs are the hard cross-repo contract. Guard
-    /// against an accidental edit that zeroes or aliases one of them.
-    #[test]
-    fn activator_clsids_match_contract() {
-        assert_eq!(
-            <IsoSessionOps as ActivatorClsid>::ACTIVATOR_CLSID,
-            GUID::from_u128(0x6ef3155b_d1a2_4a34_bcaa_089f8a6d9916),
-            "IsoSessionOps activator CLSID drifted from the OS dll.cpp / manifest contract"
-        );
-        assert_eq!(
-            <IsoSessionProcessOptions as ActivatorClsid>::ACTIVATOR_CLSID,
-            GUID::from_u128(0x36b03ff1_21aa_4f3c_819d_2430ec830dd0),
-            "IsoSessionProcessOptions activator CLSID drifted from the OS dll.cpp / manifest contract"
+    instance.cast::<T>().map_err(|error| {
+        eprintln!(
+            "[mxc isosession] cast to '{}' failed (WinMD/MSI version mismatch?): {}",
+            T::NAME,
+            error
         );
-    }
-
-    /// The two activators must be distinct and non-nil -- a typo collapsing them
-    /// would silently activate the wrong class.
-    #[test]
-    fn activator_clsids_are_distinct_and_nonzero() {
-        let ops = <IsoSessionOps as ActivatorClsid>::ACTIVATOR_CLSID;
-        let opts = <IsoSessionProcessOptions as ActivatorClsid>::ACTIVATOR_CLSID;
-        assert_ne!(ops, opts, "the two activator CLSIDs must differ");
-        assert_ne!(ops, GUID::from_u128(0), "IsoSessionOps activator CLSID must be non-nil");
-        assert_ne!(opts, GUID::from_u128(0), "IsoSessionProcessOptions activator CLSID must be non-nil");
-    }
+        error
+    })
 }
diff --git a/src/tools/wxc/build.rs b/src/tools/wxc/build.rs
index 0b8ac4c61..0bfb889ef 100644
--- a/src/tools/wxc/build.rs
+++ b/src/tools/wxc/build.rs
@@ -1,38 +1,15 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-//! Build script for wxc — embeds Windows VersionInfo.
+//! Build script for wxc - embeds Windows VersionInfo and stages runtime assets.
 
 #[path = "../../mxc-sdk/build/build_mxc_build_common.rs"]
 mod mxc_build_common;
 
 fn main() {
-    // Under the `isolation_session` feature the IsoSession reg-free COM
-    // manifest is fused into wxc-exec (mapping the two private activator CLSIDs
-    // to the co-located `IsoSessionApp.dll`) and `IsoSessionApp.dll` is staged
-    // next to the executable. Both are extracted from the pinned SDK nupkg.
-    // This MUST share a single resource compile with the version info, so the
-    // manifest is resolved first and handed to `embed_version_info_with_manifest`.
     #[cfg(all(windows, feature = "isolation_session"))]
-    {
-        match isosession::stage_and_resolve_manifest() {
-            Some(manifest_xml) => {
-                mxc_build_common::embed_version_info_with_manifest(
-                    "MXC sandbox executor",
-                    "wxc-exec.exe",
-                    Some(&manifest_xml),
-                );
-            }
-            None => {
-                // nupkg lacks the reg-free payload (e.g. an inbox-only /
-                // pre-repack package): build still succeeds; the Rust caller
-                // falls back to inbox activation at runtime.
-                mxc_build_common::embed_version_info("MXC sandbox executor", "wxc-exec.exe");
-            }
-        }
-    }
+    stage_isolation_session_runtime();
 
-    #[cfg(not(all(windows, feature = "isolation_session")))]
     mxc_build_common::embed_version_info("MXC sandbox executor", "wxc-exec.exe");
 
     #[cfg(windows)]
@@ -50,188 +27,36 @@ fn main() {
         }
     }
 
-    // Re-run prerequisite checks when PATH changes (e.g., after installing Python).
     #[cfg(windows)]
     println!("cargo:rerun-if-env-changed=PATH");
 }
 
-/// IsoSession reg-free COM wiring: extract `IsoSessionApp.dll` and the
-/// `.comClass.manifest` from the pinned SDK nupkg, stage the DLL next to
-/// `wxc-exec.exe`, and return the manifest XML for fusing into the exe.
-///
-/// The whole real-design activation path (see
-/// `backends/isolation_session/common/src/regfree.rs`) depends on wxc-exec's
-/// fused manifest redirecting the two private CLSIDs to this co-located DLL.
 #[cfg(all(windows, feature = "isolation_session"))]
-mod isosession {
-    use std::io::Read;
-    use std::path::{Path, PathBuf};
-
-    /// Name of the reg-free COM manifest fragment inside the nupkg `runtime`
-    /// folder (fused into wxc-exec so the private activator CLSIDs resolve to
-    /// the co-located `IsoSessionApp.dll`).
-    const COMCLASS_MANIFEST: &str = "IsoSessionApp.comClass.manifest";
-    /// The in-proc activation shim that owns knowledge of the MSI runtime dir.
-    const APP_DLL: &str = "IsoSessionApp.dll";
-
-    /// Name of the pipeline-stamped runtime-version sidecar inside the nupkg
-    /// `runtime` folder. `IsoSessionApp.dll` is version-agnostic at OS build
-    /// time and reads this co-located token (e.g. `2026_08`) at load time to
-    /// build its MSI reg key + fallback runtime dir. Staged next to the exe
-    /// alongside the DLL so the co-located read works in the fused scenario.
-    const VERSION_SIDECAR: &str = "IsoSessionApp.runtimeversion";
-
-    /// Locate the nupkg, extract the App.dll (stage next to the exe) and the
-    /// manifest fragment, and return the manifest XML. Returns `None` (with a
-    /// `cargo:warning`) when the nupkg does not carry the reg-free payload, so
-    /// the build degrades gracefully to inbox activation instead of failing.
-    pub fn stage_and_resolve_manifest() -> Option<String> {
-        let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR");
-
-        // This crate lives at <repo>/src/tools/wxc.
-        let sdk_dir = Path::new(&manifest_dir)
-            .join("..")
-            .join("..")
-            .join("mxc-sdk")
-            .join("build")
-            .join("isolation_session_bindings");
-
-        let nupkg = match find_nupkg(&sdk_dir) {
-            Some(p) => p,
-            None => {
-                println!(
-                    "cargo:warning=isosession: no .nupkg under {} — skipping reg-free manifest fuse",
-                    sdk_dir.display()
-                );
-                return None;
-            }
-        };
-        println!("cargo:rerun-if-changed={}", nupkg.display());
-
-        // Stage IsoSessionApp.dll next to the output exe (target/<profile>/).
-        // Cargo puts the binary at OUT_DIR/../../.. .
-        let out_dir = std::env::var("OUT_DIR").expect("OUT_DIR");
-        let target_dir = Path::new(&out_dir)
-            .parent()
-            .and_then(|p| p.parent())
-            .and_then(|p| p.parent())
-            .expect("could not determine target dir from OUT_DIR");
-
-        let app_dll = match extract_entry(&nupkg, APP_DLL) {
-            Some(bytes) => bytes,
-            None => {
-                println!(
-                    "cargo:warning=isosession: {} not found in {} — skipping reg-free manifest fuse (inbox fallback at runtime)",
-                    APP_DLL,
-                    nupkg.display()
-                );
-                return None;
-            }
-        };
-        let dll_dst = target_dir.join(APP_DLL);
-        std::fs::write(&dll_dst, &app_dll)
-            .unwrap_or_else(|e| panic!("stage {} to {}: {e}", APP_DLL, dll_dst.display()));
-
-        // Stage the pipeline-stamped runtime-version sidecar next to the DLL.
-        // Best-effort: if the nupkg predates the stamping pipeline, the shim
-        // falls back to its compile-time default version, so a missing sidecar
-        // is a warning, not a fatal error, and does NOT skip the manifest fuse.
-        match extract_entry(&nupkg, VERSION_SIDECAR) {
-            Some(bytes) => {
-                let sidecar_dst = target_dir.join(VERSION_SIDECAR);
-                std::fs::write(&sidecar_dst, &bytes).unwrap_or_else(|e| {
-                    panic!("stage {} to {}: {e}", VERSION_SIDECAR, sidecar_dst.display())
-                });
-            }
-            None => {
-                println!(
-                    "cargo:warning=isosession: {} not found in {} — IsoSessionApp.dll will use its compile-time default runtime version",
-                    VERSION_SIDECAR,
-                    nupkg.display()
-                );
-            }
-        }
-
-        let manifest_bytes = match extract_entry(&nupkg, COMCLASS_MANIFEST) {
-            Some(bytes) => bytes,
-            None => {
-                println!(
-                    "cargo:warning=isosession: {} not found in {} — skipping reg-free manifest fuse",
-                    COMCLASS_MANIFEST,
-                    nupkg.display()
-                );
-                return None;
-            }
-        };
-        let manifest_xml = String::from_utf8(manifest_bytes)
-            .expect("IsoSessionApp.comClass.manifest is valid UTF-8");
-
-        Some(manifest_xml)
-    }
-
-    /// Returns the lexicographically-last `*.nupkg` under `dir`.
-    fn find_nupkg(dir: &Path) -> Option<PathBuf> {
-        let mut hits: Vec<PathBuf> = std::fs::read_dir(dir)
-            .ok()?
-            .filter_map(|e| e.ok().map(|e| e.path()))
-            .filter(|p| {
-                p.extension()
-                    .map(|x| x.eq_ignore_ascii_case("nupkg"))
-                    .unwrap_or(false)
-            })
-            .collect();
-        hits.sort();
-        hits.into_iter().next_back()
-    }
-
-    /// Extract the nupkg (zip) entry whose file name matches `file_name`
-    /// (case-insensitive, path-separator tolerant). Returns `None` if absent.
-    fn extract_entry(nupkg: &Path, file_name: &str) -> Option<Vec<u8>> {
-        let file = std::fs::File::open(nupkg)
-            .unwrap_or_else(|e| panic!("open {}: {e}", nupkg.display()));
-        let mut archive = zip::ZipArchive::new(file)
-            .unwrap_or_else(|e| panic!("read zip {}: {e}", nupkg.display()));
-
-        let want = file_name.to_ascii_lowercase();
-        let entry_name = (0..archive.len()).find_map(|i| {
-            let name = archive.by_index(i).ok()?.name().to_string();
-            let leaf = name.rsplit(['/', '\\']).next().unwrap_or(&name);
-            if leaf.to_ascii_lowercase() == want {
-                Some(name)
-            } else {
-                None
-            }
-        })?;
-
-        let mut entry = archive
-            .by_name(&entry_name)
-            .unwrap_or_else(|e| panic!("open zip entry {entry_name}: {e}"));
-        let mut buf = Vec::new();
-        entry
-            .read_to_end(&mut buf)
-            .unwrap_or_else(|e| panic!("read zip entry {entry_name}: {e}"));
-        Some(buf)
-    }
+fn stage_isolation_session_runtime() {
+    let manifest_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
+    let sdk_dir = manifest_dir
+        .join("..")
+        .join("..")
+        .join("mxc-sdk")
+        .join("build")
+        .join("isolation_session_bindings");
+    let _ = mxc_build_common::stage_isolation_session_runtime(&sdk_dir);
 }
 
-/// Emit build warnings when E2E test prerequisites are missing or
-/// misconfigured. These are non-blocking — the build succeeds regardless.
 #[cfg(windows)]
 fn check_test_prerequisites() {
     use std::process::Command;
 
-    // Check Python
     let python_ok = Command::new("where.exe")
         .arg("python.exe")
         .output()
         .ok()
-        .and_then(|o| {
-            if !o.status.success() {
+        .and_then(|output| {
+            if !output.status.success() {
                 return None;
             }
-            let stdout = String::from_utf8_lossy(&o.stdout).to_string();
-            let first = stdout.lines().next().unwrap_or("").to_string();
-            Some(first)
+            let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+            Some(stdout.lines().next().unwrap_or("").to_string())
         });
 
     match python_ok {
@@ -252,7 +77,6 @@ fn check_test_prerequisites() {
         _ => {}
     }
 
-    // Check pwsh at the expected install path (test configs use a hardcoded path)
     const PWSH_PATH: &str = r"C:\Program Files\PowerShell\7\pwsh.exe";
     if !std::path::Path::new(PWSH_PATH).exists() {
         println!(

From c6688ed1c699c1958ab8067a058cc54b0a50bd77 Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Wed, 9 Sep 2026 15:54:12 -0700
Subject: [PATCH 13/26] Add inbox and lifted IsolationSession build modes

Keep isolation_session on the committed OS bindings and normal WinRT activation. Add isolation_session_lifted for hash-pinned NuGet restore, generated bindings, staged activation payloads, and fail-closed MSI activation.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 77a3362a-1fd0-4850-aaf9-ad0d8e0bc7d8
---
 src/ffi/mxc_ffi/Cargo.toml                    |    2 +
 src/ffi/mxc_ffi/build.rs                      |   36 +-
 src/mxc-sdk/Cargo.toml                        |    9 +-
 src/mxc-sdk/build.rs                          |   14 +-
 .../build/build_isolation_session_bindings.rs |  214 +-
 src/mxc-sdk/build/build_mxc_build_common.rs   |  337 ++-
 .../GENERATION_INFO.toml                      |   24 +-
 ...s.AI.IsolationSession.SDK.0.202608.5.nupkg |  Bin 68375 -> 0 bytes
 .../isolation_session_bindings/README.md      |   97 +-
 .../isolation_session/bindings/bindings.rs    | 2645 +++++++++++++++++
 .../isolation_session/bindings/mod.rs         |   12 +-
 src/tools/wxc/Cargo.toml                      |    2 +
 src/tools/wxc/build.rs                        |   44 +-
 13 files changed, 3119 insertions(+), 317 deletions(-)
 delete mode 100644 src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.202608.5.nupkg
 create mode 100644 src/mxc-sdk/src/backends/isolation_session/bindings/bindings.rs

diff --git a/src/ffi/mxc_ffi/Cargo.toml b/src/ffi/mxc_ffi/Cargo.toml
index d68c4d39f..713376888 100644
--- a/src/ffi/mxc_ffi/Cargo.toml
+++ b/src/ffi/mxc_ffi/Cargo.toml
@@ -28,6 +28,7 @@ wslc = ["mxc-sdk/wslc"]
 # IsolationSession backend (Windows only). Needed by the
 # `attached_console_ffi` example.
 isolation_session = ["mxc-sdk/isolation_session"]
+isolation_session_lifted = ["isolation_session", "mxc-sdk/isolation_session_lifted"]
 # Opt-in C# SDK P/Invoke code generation (csbindgen) in build.rs. Off by
 # default so normal builds don't compile csbindgen or write into the source
 # tree. Local C# builds, the Windows x64 pipeline build, and the drift gate
@@ -52,5 +53,6 @@ csbindgen = { version = "1", optional = true }
 
 [target.'cfg(windows)'.build-dependencies]
 cc = "1"
+sha2.workspace = true
 winresource.workspace = true
 zip = "2"
diff --git a/src/ffi/mxc_ffi/build.rs b/src/ffi/mxc_ffi/build.rs
index 8b8d48ba1..217e69a29 100644
--- a/src/ffi/mxc_ffi/build.rs
+++ b/src/ffi/mxc_ffi/build.rs
@@ -27,22 +27,38 @@ fn main() {
     println!("cargo:rerun-if-changed=build.rs");
 
     #[cfg(all(windows, feature = "isolation_session"))]
-    stage_isolation_session_runtime();
+    reconcile_isolation_session_runtime();
 
     #[cfg(feature = "dotnetsdk")]
     generate_csharp_bindings();
 }
 
 #[cfg(all(windows, feature = "isolation_session"))]
-fn stage_isolation_session_runtime() {
-    let manifest_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
-    let sdk_dir = manifest_dir
-        .join("..")
-        .join("..")
-        .join("mxc-sdk")
-        .join("build")
-        .join("isolation_session_bindings");
-    let _ = mxc_build_common::stage_isolation_session_runtime(&sdk_dir);
+fn reconcile_isolation_session_runtime() {
+    let out_dir = std::path::PathBuf::from(std::env::var("OUT_DIR").expect("OUT_DIR"));
+    let target_dir = out_dir
+        .parent()
+        .and_then(|path| path.parent())
+        .and_then(|path| path.parent())
+        .expect("could not determine target directory from OUT_DIR");
+
+    #[cfg(feature = "isolation_session_lifted")]
+    mxc_build_common::isolation_session_sdk::stage_runtime()
+        .unwrap_or_else(|error| panic!("IsolationSession SDK staging failed: {error}"));
+
+    #[cfg(not(feature = "isolation_session_lifted"))]
+    for file_name in [
+        "IsoSessionApp.dll",
+        "IsoSession.manifest",
+        "IsoSessionApp.runtimeversion",
+    ] {
+        let path = target_dir.join(file_name);
+        match std::fs::remove_file(&path) {
+            Ok(()) => {}
+            Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+            Err(error) => panic!("remove stale lifted payload {}: {error}", path.display()),
+        }
+    }
 }
 
 #[cfg(feature = "dotnetsdk")]
diff --git a/src/mxc-sdk/Cargo.toml b/src/mxc-sdk/Cargo.toml
index 2cfd17d82..334a8003c 100644
--- a/src/mxc-sdk/Cargo.toml
+++ b/src/mxc-sdk/Cargo.toml
@@ -31,16 +31,13 @@ default = []
 wslc = ["link-wslcsdk", "dep:libloading", "dep:tar"]
 link-wslcsdk = ["dep:zip"]
 isolation_session = [
-    "lifted_msi",
-    "dep:windows-bindgen",
     "dep:windows-collections",
     "dep:windows-future",
-    "dep:zip",
 ]
-isolation_session_inbox = [
+isolation_session_lifted = [
+    "isolation_session",
+    "lifted_msi",
     "dep:windows-bindgen",
-    "dep:windows-collections",
-    "dep:windows-future",
     "dep:zip",
 ]
 lifted_msi = []
diff --git a/src/mxc-sdk/build.rs b/src/mxc-sdk/build.rs
index 2ab45cf2f..f1e593b0b 100644
--- a/src/mxc-sdk/build.rs
+++ b/src/mxc-sdk/build.rs
@@ -30,8 +30,9 @@ mod nanvix_common;
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     #[cfg(feature = "isolation_session")]
     build_isolation_session_bindings::run();
-    #[cfg(all(windows, feature = "isolation_session"))]
-    stage_isolation_session_runtime();
+    #[cfg(all(windows, feature = "isolation_session_lifted"))]
+    build_mxc_build_common::isolation_session_sdk::stage_runtime()
+        .unwrap_or_else(|error| panic!("IsolationSession SDK staging failed: {error}"));
     build_mxc_telemetry::run();
     if let Some((bin_dir, use_prefetched_binaries)) = build_nanvix_binaries::run() {
         nanvix_build_common::stage_artifacts_next_to_exe(&bin_dir, !use_prefetched_binaries);
@@ -56,12 +57,3 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     )?;
     Ok(())
 }
-
-#[cfg(all(windows, feature = "isolation_session"))]
-fn stage_isolation_session_runtime() {
-    let manifest_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
-    let sdk_dir = manifest_dir
-        .join("build")
-        .join("isolation_session_bindings");
-    let _ = mxc_build_common::stage_isolation_session_runtime(&sdk_dir);
-}
diff --git a/src/mxc-sdk/build/build_isolation_session_bindings.rs b/src/mxc-sdk/build/build_isolation_session_bindings.rs
index 8a309dbeb..53cdf3149 100644
--- a/src/mxc-sdk/build/build_isolation_session_bindings.rs
+++ b/src/mxc-sdk/build/build_isolation_session_bindings.rs
@@ -1,109 +1,93 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-//! Build script that regenerates the IsolationSession Preview WinRT bindings
-//! from the checked-in SDK nuget at compile time, so the crate is always built
-//! directly against the pinned `Microsoft.Windows.AI.IsolationSession.SDK`
-//! package rather than a committed snapshot.
+//! Selects the IsolationSession projection source for the requested build mode.
 //!
-//! Pipeline: locate the single `*.nupkg` under
-//! `build/isolation_session_bindings/`, extract its Preview WinMD (a nupkg is a
-//! zip), then run `windows-bindgen` over it into `$OUT_DIR/bindings.rs`
-//! (included by the bindings module). The invocation mirrors the canonical
-//! OS-side generator (`RustBindingsGenerator`).
+//! Inbox builds use the committed OS-generated bindings and verify their
+//! `windows` crate compatibility. Lifted builds restore the pinned SDK package
+//! from NuGet.org and regenerate bindings from its Preview WinMD.
 
-use std::fs;
-use std::io::Read;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 
 pub(crate) fn run() {
-    let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR");
-    let out_dir = std::env::var("OUT_DIR").expect("OUT_DIR");
-    let sdk_dir = Path::new(&manifest_dir)
-        .join("build")
-        .join("isolation_session_bindings");
+    println!("cargo:rerun-if-changed=build/build_isolation_session_bindings.rs");
 
-    let nupkg = find_nupkg(&sdk_dir).unwrap_or_else(|| {
-        panic!(
-            "isolation_session_bindings: no .nupkg found in {}",
-            sdk_dir.display()
-        )
-    });
+    #[cfg(feature = "isolation_session_lifted")]
+    generate_lifted_bindings();
 
-    // Rebuild whenever the pinned package or this script changes.
-    println!("cargo:rerun-if-changed={}", nupkg.display());
-    println!("cargo:rerun-if-changed=build/build_isolation_session_bindings.rs");
+    #[cfg(not(feature = "isolation_session_lifted"))]
+    verify_inbox_bindings_version();
+}
 
-    // Extract the Preview WinMD from the nuget into OUT_DIR.
-    let winmd_bytes = extract_preview_winmd(&nupkg);
+#[cfg(feature = "isolation_session_lifted")]
+fn generate_lifted_bindings() {
+    let out_dir = std::env::var("OUT_DIR").expect("OUT_DIR");
+    let package = crate::build_mxc_build_common::isolation_session_sdk::resolve_package()
+        .unwrap_or_else(|e| panic!("IsolationSession SDK acquisition failed: {e}"));
+    let winmd_bytes = crate::build_mxc_build_common::isolation_session_sdk::read_entry(
+        &package,
+        "windows.ai.isolationsession.preview.winmd",
+    )
+    .unwrap_or_else(|e| panic!("IsolationSession SDK metadata extraction failed: {e}"));
     let winmd_path = Path::new(&out_dir).join("windows.ai.isolationsession.preview.winmd");
-    fs::write(&winmd_path, &winmd_bytes)
-        .unwrap_or_else(|e| panic!("write extracted winmd to {}: {e}", winmd_path.display()));
+    std::fs::write(&winmd_path, &winmd_bytes)
+        .unwrap_or_else(|e| panic!("write extracted WinMD to {}: {e}", winmd_path.display()));
 
     let bindings_path = Path::new(&out_dir).join("bindings.rs");
-
-    // Generate bindings for the IsolationSession Preview namespace only. The
-    // literal "default" input combines the SDK WinMD with windows-bindgen's
-    // bundled Windows metadata; "windows,skip-root,Windows.Foundation" maps the
-    // Windows.Foundation dependencies (DateTime, TypedEventHandler) onto the
-    // full `windows` crate (Foundation feature enabled in Cargo.toml). This
-    // mirrors RustBindingsGenerator exactly.
     let warnings = windows_bindgen::bindgen([
         "--in",
-        winmd_path.to_str().expect("winmd path is valid UTF-8"),
+        winmd_path.to_str().expect("WinMD path is valid UTF-8"),
         "--in",
         "default",
         "--out",
-        bindings_path.to_str().expect("out path is valid UTF-8"),
+        bindings_path
+            .to_str()
+            .expect("bindings path is valid UTF-8"),
         "--filter",
         "Windows.AI.IsolationSession.Preview",
         "--reference",
         "windows,skip-root,Windows.Foundation",
+        "--reference",
+        "windows,skip-root,Windows.UI",
         "--flat",
         "--implement",
     ]);
 
-    let warning_text = format!("{warnings}");
-    for line in warning_text.lines().filter(|l| !l.trim().is_empty()) {
+    for line in format!("{warnings}")
+        .lines()
+        .filter(|line| !line.trim().is_empty())
+    {
         println!("cargo:warning=isosession-bindgen: {line}");
     }
 
-    // windows-bindgen emits a leading `#![allow(...)]` inner attribute. That is
-    // invalid once the file is `include!`-ed inside `mod bindings { ... }`
-    // (an inner attribute cannot annotate the `include!` item macro). The
-    // module already carries an equivalent OUTER `#[allow(...)]` in lib.rs, so
-    // strip the generated leading inner-attribute block here.
-    let generated = fs::read_to_string(&bindings_path)
+    let generated = std::fs::read_to_string(&bindings_path)
         .unwrap_or_else(|e| panic!("read generated {}: {e}", bindings_path.display()));
-    let cleaned = strip_leading_inner_attrs(&generated);
-    fs::write(&bindings_path, cleaned)
+    std::fs::write(&bindings_path, strip_leading_inner_attrs(&generated))
         .unwrap_or_else(|e| panic!("rewrite cleaned {}: {e}", bindings_path.display()));
 }
 
-/// Drops leading `#![...]` inner-attribute blocks (single- or multi-line) from
-/// the generated file, preserving leading comments/blank lines and copying the
-/// rest of the body verbatim once the first real item is reached.
-fn strip_leading_inner_attrs(src: &str) -> String {
-    let mut result = String::with_capacity(src.len());
-    let mut in_inner = false;
+#[cfg(feature = "isolation_session_lifted")]
+fn strip_leading_inner_attrs(source: &str) -> String {
+    let mut result = String::with_capacity(source.len());
+    let mut in_inner_attribute = false;
     let mut started_body = false;
-    for line in src.lines() {
+
+    for line in source.lines() {
         if started_body {
             result.push_str(line);
             result.push('\n');
             continue;
         }
-        if in_inner {
+        if in_inner_attribute {
             if line.contains(']') {
-                in_inner = false;
+                in_inner_attribute = false;
             }
             continue;
         }
+
         let trimmed = line.trim_start();
         if trimmed.starts_with("#![") {
-            if !trimmed.contains(']') {
-                in_inner = true;
-            }
+            in_inner_attribute = !trimmed.contains(']');
             continue;
         }
         if trimmed.is_empty() || trimmed.starts_with("//") {
@@ -111,58 +95,80 @@ fn strip_leading_inner_attrs(src: &str) -> String {
             result.push('\n');
             continue;
         }
+
         started_body = true;
         result.push_str(line);
         result.push('\n');
     }
+
     result
 }
 
-/// Returns the single `*.nupkg` under `dir` (lexicographically last if several,
-/// so a version bump that leaves an old package behind still picks the newest).
-fn find_nupkg(dir: &Path) -> Option<PathBuf> {
-    let mut hits: Vec<PathBuf> = fs::read_dir(dir)
-        .ok()?
-        .filter_map(|e| e.ok().map(|e| e.path()))
-        .filter(|p| {
-            p.extension()
-                .map(|x| x.eq_ignore_ascii_case("nupkg"))
-                .unwrap_or(false)
-        })
-        .collect();
-    hits.sort();
-    hits.into_iter().next_back()
-}
+#[cfg(not(feature = "isolation_session_lifted"))]
+fn verify_inbox_bindings_version() {
+    let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR");
+    let info_path = Path::new(&manifest_dir)
+        .join("build")
+        .join("isolation_session_bindings")
+        .join("GENERATION_INFO.toml");
+    if !info_path.exists() {
+        return;
+    }
 
-/// Extracts the `*preview.winmd` entry from the nuget (a zip archive),
-/// tolerant of path-separator variations in the entry name.
-fn extract_preview_winmd(nupkg: &Path) -> Vec<u8> {
-    let file = fs::File::open(nupkg).unwrap_or_else(|e| panic!("open {}: {e}", nupkg.display()));
-    let mut archive =
-        zip::ZipArchive::new(file).unwrap_or_else(|e| panic!("read zip {}: {e}", nupkg.display()));
-
-    let entry_name = (0..archive.len())
-        .find_map(|i| {
-            let name = archive.by_index(i).ok()?.name().to_string();
-            if name.to_ascii_lowercase().ends_with("preview.winmd") {
-                Some(name)
-            } else {
-                None
-            }
+    let contents = std::fs::read_to_string(&info_path).unwrap_or_default();
+    let Some(expected) = contents.lines().find_map(|line| {
+        let line = line.trim();
+        if line.starts_with("target_windows_crate") {
+            line.split('=')
+                .nth(1)
+                .map(|value| value.trim().trim_matches('"').to_string())
+        } else {
+            None
+        }
+    }) else {
+        return;
+    };
+
+    let lock_path = Path::new(&manifest_dir)
+        .join("..")
+        .join("Cargo.lock");
+    let lock_contents = std::fs::read_to_string(lock_path).unwrap_or_default();
+    let actual = lock_contents
+        .split("[[package]]")
+        .find(|block| {
+            block
+                .lines()
+                .any(|line| line.trim() == "name = \"windows\"")
         })
-        .unwrap_or_else(|| {
-            panic!(
-                "isolation_session_bindings: no *preview.winmd entry in {}",
-                nupkg.display()
-            )
+        .and_then(|block| {
+            block.lines().find_map(|line| {
+                let line = line.trim();
+                if line.starts_with("version = ") {
+                    line.split('=')
+                        .nth(1)
+                        .map(|value| value.trim().trim_matches('"').to_string())
+                } else {
+                    None
+                }
+            })
         });
 
-    let mut entry = archive
-        .by_name(&entry_name)
-        .unwrap_or_else(|e| panic!("open zip entry {entry_name}: {e}"));
-    let mut buf = Vec::new();
-    entry
-        .read_to_end(&mut buf)
-        .unwrap_or_else(|e| panic!("read zip entry {entry_name}: {e}"));
-    buf
+    let parts = expected.split('.').take(2).collect::<Vec<_>>();
+    if parts.len() != 2 {
+        return;
+    }
+    let Ok(requirement) = semver::VersionReq::parse(&format!("^{}.{}", parts[0], parts[1])) else {
+        return;
+    };
+
+    if let Some(actual) = actual {
+        let Ok(actual_version) = semver::Version::parse(&actual) else {
+            return;
+        };
+        assert!(
+            requirement.matches(&actual_version),
+            "isolation_session_bindings: committed inbox bindings target windows crate \
+             {expected}, but the workspace has {actual}; regenerate the inbox bindings"
+        );
+    }
 }
diff --git a/src/mxc-sdk/build/build_mxc_build_common.rs b/src/mxc-sdk/build/build_mxc_build_common.rs
index 93b36603a..a3237460a 100644
--- a/src/mxc-sdk/build/build_mxc_build_common.rs
+++ b/src/mxc-sdk/build/build_mxc_build_common.rs
@@ -10,8 +10,237 @@ use std::io;
 use std::path::Path;
 use std::process::Command;
 
-#[cfg(windows)]
-use std::io::Read;
+#[cfg(all(windows, feature = "isolation_session_lifted"))]
+pub mod isolation_session_sdk {
+    use sha2::{Digest, Sha256};
+    use std::io::Read;
+    use std::path::{Path, PathBuf};
+    use std::process::Command;
+
+    pub const PACKAGE_ID: &str = "Microsoft.Windows.AI.IsolationSession.SDK";
+    pub const PACKAGE_VERSION: &str = "0.2608.0";
+    pub const PACKAGE_SHA256: &str =
+        "af609652e691e9f2ae47885bcfcfd29e8d8c05744482f50c104efd2f3ca1d8e5";
+    pub const PACKAGE_PATH_ENV: &str = "ISOLATION_SESSION_SDK_PACKAGE";
+
+    const APP_DLL: &str = "IsoSessionApp.dll";
+    const RUNTIME_MANIFEST: &str = "IsoSession.manifest";
+    const VERSION_SIDECAR: &str = "IsoSessionApp.runtimeversion";
+
+    pub fn resolve_package() -> Result<PathBuf, String> {
+        println!("cargo:rerun-if-env-changed={PACKAGE_PATH_ENV}");
+
+        if let Ok(value) = std::env::var(PACKAGE_PATH_ENV) {
+            let path = PathBuf::from(value);
+            verify_package(&path)?;
+            println!("cargo:rerun-if-changed={}", path.display());
+            return Ok(path);
+        }
+
+        let package_name = format!(
+            "{}.{}.nupkg",
+            PACKAGE_ID.to_ascii_lowercase(),
+            PACKAGE_VERSION
+        );
+        let package_dir = nuget_cache_root()?
+            .join(PACKAGE_ID.to_ascii_lowercase())
+            .join(PACKAGE_VERSION);
+        let package_path = package_dir.join(&package_name);
+
+        if package_path.exists() {
+            verify_package(&package_path)?;
+            println!("cargo:rerun-if-changed={}", package_path.display());
+            return Ok(package_path);
+        }
+
+        std::fs::create_dir_all(&package_dir).map_err(|e| {
+            format!(
+                "create IsolationSession NuGet cache directory {}: {e}",
+                package_dir.display()
+            )
+        })?;
+
+        let download_path =
+            package_dir.join(format!("{package_name}.download.{}", std::process::id()));
+        let url = format!(
+            "https://api.nuget.org/v3-flatcontainer/{}/{}/{}",
+            PACKAGE_ID.to_ascii_lowercase(),
+            PACKAGE_VERSION,
+            package_name
+        );
+        let status = Command::new("curl")
+            .args([
+                "--fail",
+                "--location",
+                "--retry",
+                "3",
+                "--silent",
+                "--show-error",
+            ])
+            .arg("--output")
+            .arg(&download_path)
+            .arg(&url)
+            .status()
+            .map_err(|e| format!("launch curl to download {PACKAGE_ID} {PACKAGE_VERSION}: {e}"))?;
+
+        if !status.success() {
+            let _ = std::fs::remove_file(&download_path);
+            return Err(format!(
+                "download {PACKAGE_ID} {PACKAGE_VERSION} from NuGet.org failed with {status}; \
+                 set {PACKAGE_PATH_ENV} to a pre-fetched package for an offline build"
+            ));
+        }
+
+        if let Err(e) = verify_package(&download_path) {
+            let _ = std::fs::remove_file(&download_path);
+            return Err(e);
+        }
+
+        match std::fs::rename(&download_path, &package_path) {
+            Ok(()) => {}
+            Err(e) if package_path.exists() => {
+                let _ = std::fs::remove_file(&download_path);
+                verify_package(&package_path).map_err(|verify_error| {
+                    format!(
+                        "another build populated {}, but it is invalid ({verify_error}); \
+                         original rename error: {e}",
+                        package_path.display()
+                    )
+                })?;
+            }
+            Err(e) => {
+                let _ = std::fs::remove_file(&download_path);
+                return Err(format!(
+                    "publish downloaded package to {}: {e}",
+                    package_path.display()
+                ));
+            }
+        }
+
+        println!("cargo:rerun-if-changed={}", package_path.display());
+        Ok(package_path)
+    }
+
+    pub fn stage_runtime() -> Result<(), String> {
+        let package = resolve_package()?;
+        let app_dll = read_entry(&package, APP_DLL)?;
+        let version_bytes = read_entry(&package, VERSION_SIDECAR)?;
+        let instance = String::from_utf8(version_bytes)
+            .map_err(|e| format!("{VERSION_SIDECAR} is not valid UTF-8: {e}"))?
+            .trim()
+            .replace('_', ".");
+        validate_instance(&instance)?;
+
+        let manifest = format!(
+            "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n\
+<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">\n\
+  <assemblyIdentity name=\"IsoSession.Runtime\" version=\"1.0.0.0\" type=\"win32\" />\n\
+  <file name=\"IsoSessionApp.dll\" />\n\
+  <iso:instance xmlns:iso=\"urn:schemas-microsoft-com:agentic-runtime.v1\" name=\"{instance}\" />\n\
+</assembly>\n"
+        );
+        let target_dir = target_profile_dir()?;
+        std::fs::write(target_dir.join(APP_DLL), app_dll)
+            .map_err(|e| format!("stage {APP_DLL} to {}: {e}", target_dir.display()))?;
+        std::fs::write(target_dir.join(RUNTIME_MANIFEST), manifest)
+            .map_err(|e| format!("stage {RUNTIME_MANIFEST} to {}: {e}", target_dir.display()))?;
+        Ok(())
+    }
+
+    pub fn read_entry(package: &Path, file_name: &str) -> Result<Vec<u8>, String> {
+        let file = std::fs::File::open(package)
+            .map_err(|e| format!("open NuGet package {}: {e}", package.display()))?;
+        let mut archive = zip::ZipArchive::new(file)
+            .map_err(|e| format!("read NuGet package {}: {e}", package.display()))?;
+        let wanted = file_name.to_ascii_lowercase();
+        let entry_name = (0..archive.len())
+            .find_map(|index| {
+                let name = archive.by_index(index).ok()?.name().to_string();
+                let leaf = name.rsplit(['/', '\\']).next().unwrap_or(&name);
+                (leaf.to_ascii_lowercase() == wanted).then_some(name)
+            })
+            .ok_or_else(|| {
+                format!(
+                    "{file_name} was not found in NuGet package {}",
+                    package.display()
+                )
+            })?;
+        let mut entry = archive
+            .by_name(&entry_name)
+            .map_err(|e| format!("open NuGet entry {entry_name}: {e}"))?;
+        let mut bytes = Vec::new();
+        entry
+            .read_to_end(&mut bytes)
+            .map_err(|e| format!("read NuGet entry {entry_name}: {e}"))?;
+        Ok(bytes)
+    }
+
+    fn target_profile_dir() -> Result<PathBuf, String> {
+        let out_dir = PathBuf::from(
+            std::env::var("OUT_DIR").map_err(|e| format!("OUT_DIR is not set: {e}"))?,
+        );
+        out_dir
+            .parent()
+            .and_then(|path| path.parent())
+            .and_then(|path| path.parent())
+            .map(PathBuf::from)
+            .ok_or_else(|| {
+                format!(
+                    "cannot resolve Cargo profile directory from {}",
+                    out_dir.display()
+                )
+            })
+    }
+
+    fn validate_instance(instance: &str) -> Result<(), String> {
+        let bytes = instance.as_bytes();
+        if bytes.len() == 7
+            && bytes[4] == b'.'
+            && bytes[..4].iter().all(u8::is_ascii_digit)
+            && bytes[5..].iter().all(u8::is_ascii_digit)
+        {
+            Ok(())
+        } else {
+            Err(format!(
+                "{VERSION_SIDECAR} must identify a YYYY_MM instance, got {instance:?}"
+            ))
+        }
+    }
+
+    fn nuget_cache_root() -> Result<PathBuf, String> {
+        if let Ok(path) = std::env::var("NUGET_PACKAGES") {
+            return Ok(PathBuf::from(path));
+        }
+        let home = std::env::var("USERPROFILE")
+            .or_else(|_| std::env::var("HOME"))
+            .map_err(|_| {
+                format!(
+                    "neither NUGET_PACKAGES, USERPROFILE, nor HOME is set; set \
+                     {PACKAGE_PATH_ENV} to a pre-fetched package"
+                )
+            })?;
+        Ok(PathBuf::from(home).join(".nuget").join("packages"))
+    }
+
+    fn verify_package(path: &Path) -> Result<(), String> {
+        let bytes = std::fs::read(path)
+            .map_err(|e| format!("read IsolationSession SDK package {}: {e}", path.display()))?;
+        let actual = Sha256::digest(bytes)
+            .iter()
+            .map(|byte| format!("{byte:02x}"))
+            .collect::<String>();
+        if actual.eq_ignore_ascii_case(PACKAGE_SHA256) {
+            Ok(())
+        } else {
+            Err(format!(
+                "IsolationSession SDK package hash mismatch for {}: expected {}, got {}",
+                path.display(),
+                PACKAGE_SHA256,
+                actual
+            ))
+        }
+    }
+}
 
 /// Embed Windows VersionInfo resource metadata into the binary being compiled.
 ///
@@ -86,110 +315,6 @@ pub fn embed_version_info_for_binary(
     Ok(())
 }
 
-/// Stages the lifted IsolationSession activation payload from the pinned SDK
-/// package beside the consuming Cargo artifact.
-#[cfg(all(windows, feature = "isolation_session"))]
-pub fn stage_isolation_session_runtime(sdk_dir: &Path) -> Option<String> {
-    const APP_DLL: &str = "IsoSessionApp.dll";
-    const RUNTIME_MANIFEST: &str = "IsoSession.manifest";
-    const VERSION_SIDECAR: &str = "IsoSessionApp.runtimeversion";
-
-    let nupkg = find_last_nupkg(sdk_dir)?;
-    println!("cargo:rerun-if-changed={}", nupkg.display());
-
-    let out_dir = std::env::var("OUT_DIR").expect("OUT_DIR");
-    let target_dir = Path::new(&out_dir)
-        .parent()
-        .and_then(|p| p.parent())
-        .and_then(|p| p.parent())
-        .expect("could not determine target dir from OUT_DIR");
-
-    let Some(app_dll) = extract_zip_entry(&nupkg, APP_DLL) else {
-        println!(
-            "cargo:warning=isosession: {} not found in {}; lifted activation will be unavailable",
-            APP_DLL,
-            nupkg.display()
-        );
-        return None;
-    };
-    std::fs::write(target_dir.join(APP_DLL), app_dll)
-        .unwrap_or_else(|e| panic!("stage {} to {}: {e}", APP_DLL, target_dir.display()));
-
-    let Some(version_bytes) = extract_zip_entry(&nupkg, VERSION_SIDECAR) else {
-        println!(
-            "cargo:warning=isosession: {} not found in {}; cannot stamp {}",
-            VERSION_SIDECAR,
-            nupkg.display(),
-            RUNTIME_MANIFEST
-        );
-        return None;
-    };
-    let instance = String::from_utf8(version_bytes)
-        .expect("IsoSessionApp.runtimeversion is valid UTF-8")
-        .trim()
-        .replace('_', ".");
-    let instance_bytes = instance.as_bytes();
-    assert!(
-        instance_bytes.len() == 7
-            && instance_bytes[4] == b'.'
-            && instance_bytes[..4]
-                .iter()
-                .all(|value| value.is_ascii_digit())
-            && instance_bytes[5..]
-                .iter()
-                .all(|value| value.is_ascii_digit()),
-        "IsoSessionApp.runtimeversion must identify a YYYY_MM instance"
-    );
-    let manifest = format!(
-        "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n\
-<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">\n\
-  <assemblyIdentity name=\"IsoSession.Runtime\" version=\"1.0.0.0\" type=\"win32\" />\n\
-  <file name=\"IsoSessionApp.dll\" />\n\
-  <iso:instance xmlns:iso=\"urn:schemas-microsoft-com:agentic-runtime.v1\" name=\"{instance}\" />\n\
-</assembly>\n"
-    );
-    std::fs::write(target_dir.join(RUNTIME_MANIFEST), manifest.as_bytes()).unwrap_or_else(|e| {
-        panic!(
-            "stage {} to {}: {e}",
-            RUNTIME_MANIFEST,
-            target_dir.display()
-        )
-    });
-    Some(manifest)
-}
-
-#[cfg(all(windows, feature = "isolation_session"))]
-fn find_last_nupkg(dir: &Path) -> Option<std::path::PathBuf> {
-    let mut packages: Vec<_> = std::fs::read_dir(dir)
-        .ok()?
-        .filter_map(|entry| entry.ok().map(|entry| entry.path()))
-        .filter(|path| {
-            path.extension()
-                .is_some_and(|extension| extension.eq_ignore_ascii_case("nupkg"))
-        })
-        .collect();
-    packages.sort();
-    packages.into_iter().next_back()
-}
-
-#[cfg(all(windows, feature = "isolation_session"))]
-fn extract_zip_entry(nupkg: &Path, file_name: &str) -> Option<Vec<u8>> {
-    let file =
-        std::fs::File::open(nupkg).unwrap_or_else(|e| panic!("open {}: {e}", nupkg.display()));
-    let mut archive =
-        zip::ZipArchive::new(file).unwrap_or_else(|e| panic!("read zip {}: {e}", nupkg.display()));
-    let wanted = file_name.to_ascii_lowercase();
-    let entry_name = (0..archive.len()).find_map(|index| {
-        let name = archive.by_index(index).ok()?.name().to_string();
-        let leaf = name.rsplit(['/', '\\']).next().unwrap_or(&name);
-        (leaf.to_ascii_lowercase() == wanted).then_some(name)
-    })?;
-    let mut entry = archive.by_name(&entry_name).ok()?;
-    let mut bytes = Vec::new();
-    entry.read_to_end(&mut bytes).ok()?;
-    Some(bytes)
-}
-
 #[cfg(windows)]
 fn embed_version_info_windows(
     file_description: &str,
diff --git a/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml b/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
index e1f8e3fe3..917f4294a 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
+++ b/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
@@ -1,17 +1,19 @@
-# Provenance for the isolation_session_bindings crate.
-#
-# Bindings are regenerated at build time from the Preview WinMD in the pinned
-# SDK package. Run Update-IsoSessionSdk.ps1 rather than editing this file.
+# Provenance for both IsolationSession binding sources.
 
 [tool]
+# Must match the `windows-bindgen` build-dependency pin in the crate's Cargo.toml
+# and stay in lockstep with the workspace `windows` crate major.minor.
 windows_bindgen_version = "0.62.1"
 target_windows_crate = "0.62"
-generated_date = "2026-08-31"
+generated_date = "2026-08-19"
 
-[source]
-nupkg = "Microsoft.Windows.AI.IsolationSession.SDK.0.202608.5.nupkg"
+[inbox]
+source = "OS-generated committed bindings.rs"
+
+[lifted]
+package_id = "Microsoft.Windows.AI.IsolationSession.SDK"
+package_version = "0.2608.0"
+package_sha256 = "AF609652E691E9F2AE47885BCFCFD29E8D8C05744482F50C104EFD2F3CA1D8E5"
 winmd = "metadata/windows.ai.isolationsession.preview.winmd"
-winmd_sha256 = "C6115B52525B06316BE77BEEB4FC4624C5CBB1CEC02E5493D86C46D90FABD6A9"
-namespace = "Windows.AI.IsolationSession.Preview"
-runtime_version = "2026_08"
-build_guid = "647f7f2e-caf7-eaa6-90d8-90f27fe8a346"
+winmd_sha256 = "4D7C49D34778028DA6DD08991765A7E37A0D57564F5B57CA4F7628CDC8917E5E"
+namespace = "Windows.AI.IsolationSession.Preview"
\ No newline at end of file
diff --git a/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.202608.5.nupkg b/src/mxc-sdk/build/isolation_session_bindings/Microsoft.Windows.AI.IsolationSession.SDK.0.202608.5.nupkg
deleted file mode 100644
index f2713b4561487b1ac0e222c8d14dfbd07bd2dd3c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 68375
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

diff --git a/src/mxc-sdk/build/isolation_session_bindings/README.md b/src/mxc-sdk/build/isolation_session_bindings/README.md
index 6df4e51e5..f3a2404f8 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/README.md
+++ b/src/mxc-sdk/build/isolation_session_bindings/README.md
@@ -1,57 +1,46 @@
-# Windows.AI.IsolationSession — SDK NuGet + Build-Time Bindings
-
-This directory pins the OS-produced SDK package that the Rust bindings in
-`src/mxc-sdk/src/backends/isolation_session/bindings/` are built from. The
-bindings are **generated at build time from this package** — there is no committed
-`bindings.rs` snapshot.
-
-## What is checked in here
-
-| File | Purpose |
-|------|---------|
-| `Microsoft.Windows.AI.IsolationSession.SDK.<ver>.nupkg` | The OS-produced SDK package. Contains the WinMD metadata (`metadata/*.winmd`) the bindings are generated from, plus `runtime/IsoSessionApp.dll` for reference. |
-| `GENERATION_INFO.toml` | Provenance: bindgen version, source WinMD hash, namespace. |
-| `README.md` | This file. |
-
-The `.nupkg` is committed (like `external/wslc-sdk/Microsoft.WSL.Containers.*.nupkg`)
-so a clean clone builds fully offline. The WinMD is produced by an internal
-Microsoft Windows OS build and is not publicly redistributable outside this
-pinned package.
-
-## How the bindings are built (every `cargo build`)
-
-The `mxc-sdk` build script regenerates the projection whenever the
-`isolation_session` feature is enabled:
-
-1. Locates the single `*.nupkg` in this directory.
-2. Extracts its **Preview** WinMD (`metadata/windows.ai.isolationsession.preview.winmd`)
-   — a `.nupkg` is a zip — into `OUT_DIR`.
-3. Runs `windows-bindgen` (pinned `=0.62.1` as a build-dependency) over it with
-   the canonical arguments (filter `Windows.AI.IsolationSession.Preview`,
-   `--reference windows,skip-root,Windows.Foundation --flat --implement`),
-   writing `OUT_DIR/bindings.rs`, which `lib.rs` `include!`s.
-
-This mirrors the OS-side canonical generator
-(`onecoreuap/windows/core/isoenvbroker/RustBindingsGenerator/`) exactly, so the
-crate is always built **directly against the pinned SDK package**. `build.rs`
-re-runs when the `.nupkg` changes (`cargo:rerun-if-changed`).
-
-## Refreshing to a newer OS build
-
-1. Produce a new package with the OS-side
-   `nuget/Microsoft.Windows.AI.IsolationSession.SDK/pack.ps1`.
-2. From the MXC repository root, run:
-   ```powershell
-   .\external\windows-sdk\isolation-session\Update-IsoSessionSdk.ps1 `
-       -PackagePath C:\path\to\Microsoft.Windows.AI.IsolationSession.SDK.<version>.nupkg
-   ```
-   The script validates the package payload and runtime identity, removes the
-   previously pinned package, copies the new package, and regenerates
-   `GENERATION_INFO.toml`.
-3. `cargo build` — the new bindings are generated automatically. Review the
-   downstream diff (e.g. `cargo check -p wxc --features isolation_session`).
-
-## Version coupling
+# Windows.AI.IsolationSession SDK selection
+
+MXC supports two explicit IsolationSession build modes:
+
+| Cargo feature | Metadata and runtime |
+|---|---|
+| `isolation_session` | Uses the committed OS-generated Rust bindings and normal inbox WinRT activation. |
+| `isolation_session_lifted` | Restores the pinned SDK package from NuGet.org, generates bindings from its Preview WinMD, and stages its lifted activation payload. This feature implies `isolation_session`. |
+
+The repository does not contain the SDK `.nupkg`. Lifted builds download the
+exact package version pinned in
+`src/mxc-sdk/build/build_mxc_build_common.rs` from the NuGet.org V3 flat-container
+endpoint, verify its SHA-256, and cache it in the standard global NuGet package
+directory.
+
+For offline builds or validation before a package is public, set
+`ISOLATION_SESSION_SDK_PACKAGE` to the exact `.nupkg` path. The same pinned hash
+is enforced for this override.
+
+## Build commands
+
+From `src`:
+
+```powershell
+# Existing inbox OS behavior
+cargo build --release -p wxc --features isolation_session
+
+# Lifted SDK NuGet and MSI behavior
+cargo build --release -p wxc --features isolation_session_lifted
+```
+
+Lifted mode fails the build if package download, integrity validation, metadata
+generation, or activation-payload staging fails. It never silently produces an
+inbox-mode binary.
+
+## Updating the lifted SDK
+
+1. Publish the new `Microsoft.Windows.AI.IsolationSession.SDK` package version
+   to NuGet.org.
+2. Update `PACKAGE_VERSION` and `PACKAGE_SHA256` in
+   `src/mxc-sdk/build/build_mxc_build_common.rs`.
+3. Update `GENERATION_INFO.toml` with the package and WinMD provenance.
+4. Build and test both feature configurations.
 
 `windows-bindgen` is pinned to `=0.62.1` in `src/mxc-sdk/Cargo.toml`
 and must stay in lockstep with the workspace `windows` crate's major.minor
diff --git a/src/mxc-sdk/src/backends/isolation_session/bindings/bindings.rs b/src/mxc-sdk/src/backends/isolation_session/bindings/bindings.rs
new file mode 100644
index 000000000..8e28748ae
--- /dev/null
+++ b/src/mxc-sdk/src/backends/isolation_session/bindings/bindings.rs
@@ -0,0 +1,2645 @@
+// Bindings generated by `windows-bindgen` 0.62.1
+
+#![allow(
+    non_snake_case,
+    non_upper_case_globals,
+    non_camel_case_types,
+    dead_code,
+    clippy::all
+)]
+
+windows_core::imp::define_interface!(
+    IIsoSessionError,
+    IIsoSessionError_Vtbl,
+    0x39e104da_6f4b_5fe8_a63f_f28fd8c3d606
+);
+impl windows_core::RuntimeType for IIsoSessionError {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_interface::<Self>();
+}
+impl windows_core::RuntimeName for IIsoSessionError {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionError";
+}
+pub trait IIsoSessionError_Impl: windows_core::IUnknownImpl {
+    fn Code(&self) -> windows_core::Result<windows_core::HRESULT>;
+    fn IsError(&self) -> windows_core::Result<bool>;
+    fn Message(&self) -> windows_core::Result<windows_core::HSTRING>;
+    fn Remediation(&self) -> windows_core::Result<windows_core::HSTRING>;
+}
+impl IIsoSessionError_Vtbl {
+    pub const fn new<Identity: IIsoSessionError_Impl, const OFFSET: isize>() -> Self {
+        unsafe extern "system" fn Code<Identity: IIsoSessionError_Impl, const OFFSET: isize>(
+            this: *mut core::ffi::c_void,
+            result__: *mut windows_core::HRESULT,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionError_Impl::Code(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn IsError<Identity: IIsoSessionError_Impl, const OFFSET: isize>(
+            this: *mut core::ffi::c_void,
+            result__: *mut bool,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionError_Impl::IsError(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn Message<Identity: IIsoSessionError_Impl, const OFFSET: isize>(
+            this: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionError_Impl::Message(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn Remediation<
+            Identity: IIsoSessionError_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionError_Impl::Remediation(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        Self {
+            base__: windows_core::IInspectable_Vtbl::new::<Identity, IIsoSessionError, OFFSET>(),
+            Code: Code::<Identity, OFFSET>,
+            IsError: IsError::<Identity, OFFSET>,
+            Message: Message::<Identity, OFFSET>,
+            Remediation: Remediation::<Identity, OFFSET>,
+        }
+    }
+    pub fn matches(iid: &windows_core::GUID) -> bool {
+        iid == &<IIsoSessionError as windows_core::Interface>::IID
+    }
+}
+#[repr(C)]
+#[doc(hidden)]
+pub struct IIsoSessionError_Vtbl {
+    pub base__: windows_core::IInspectable_Vtbl,
+    pub Code: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut windows_core::HRESULT,
+    ) -> windows_core::HRESULT,
+    pub IsError:
+        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
+    pub Message: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+    pub Remediation: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+}
+windows_core::imp::define_interface!(
+    IIsoSessionErrorPreview2,
+    IIsoSessionErrorPreview2_Vtbl,
+    0xd01fc5cc_fdfc_513a_9045_235932a03212
+);
+impl windows_core::RuntimeType for IIsoSessionErrorPreview2 {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_interface::<Self>();
+}
+impl windows_core::RuntimeName for IIsoSessionErrorPreview2 {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionErrorPreview2";
+}
+pub trait IIsoSessionErrorPreview2_Impl: windows_core::IUnknownImpl {
+    fn Diagnostics(&self) -> windows_core::Result<windows_core::HSTRING>;
+    fn FailingStage(&self) -> windows_core::Result<windows_core::HSTRING>;
+    fn UnderlyingError(&self) -> windows_core::Result<windows_core::HRESULT>;
+}
+impl IIsoSessionErrorPreview2_Vtbl {
+    pub const fn new<Identity: IIsoSessionErrorPreview2_Impl, const OFFSET: isize>() -> Self {
+        unsafe extern "system" fn Diagnostics<
+            Identity: IIsoSessionErrorPreview2_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionErrorPreview2_Impl::Diagnostics(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn FailingStage<
+            Identity: IIsoSessionErrorPreview2_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionErrorPreview2_Impl::FailingStage(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn UnderlyingError<
+            Identity: IIsoSessionErrorPreview2_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut windows_core::HRESULT,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionErrorPreview2_Impl::UnderlyingError(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        Self {
+            base__: windows_core::IInspectable_Vtbl::new::<
+                Identity,
+                IIsoSessionErrorPreview2,
+                OFFSET,
+            >(),
+            Diagnostics: Diagnostics::<Identity, OFFSET>,
+            FailingStage: FailingStage::<Identity, OFFSET>,
+            UnderlyingError: UnderlyingError::<Identity, OFFSET>,
+        }
+    }
+    pub fn matches(iid: &windows_core::GUID) -> bool {
+        iid == &<IIsoSessionErrorPreview2 as windows_core::Interface>::IID
+    }
+}
+#[repr(C)]
+#[doc(hidden)]
+pub struct IIsoSessionErrorPreview2_Vtbl {
+    pub base__: windows_core::IInspectable_Vtbl,
+    pub Diagnostics: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+    pub FailingStage: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+    pub UnderlyingError: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut windows_core::HRESULT,
+    ) -> windows_core::HRESULT,
+}
+windows_core::imp::define_interface!(
+    IIsoSessionErrorPreview3,
+    IIsoSessionErrorPreview3_Vtbl,
+    0xa81bc040_b534_5786_986e_9530bd12e588
+);
+impl windows_core::RuntimeType for IIsoSessionErrorPreview3 {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_interface::<Self>();
+}
+impl windows_core::RuntimeName for IIsoSessionErrorPreview3 {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionErrorPreview3";
+}
+pub trait IIsoSessionErrorPreview3_Impl: windows_core::IUnknownImpl {
+    fn Format(&self) -> windows_core::Result<windows_core::HSTRING>;
+}
+impl IIsoSessionErrorPreview3_Vtbl {
+    pub const fn new<Identity: IIsoSessionErrorPreview3_Impl, const OFFSET: isize>() -> Self {
+        unsafe extern "system" fn Format<
+            Identity: IIsoSessionErrorPreview3_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionErrorPreview3_Impl::Format(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        Self {
+            base__: windows_core::IInspectable_Vtbl::new::<
+                Identity,
+                IIsoSessionErrorPreview3,
+                OFFSET,
+            >(),
+            Format: Format::<Identity, OFFSET>,
+        }
+    }
+    pub fn matches(iid: &windows_core::GUID) -> bool {
+        iid == &<IIsoSessionErrorPreview3 as windows_core::Interface>::IID
+    }
+}
+#[repr(C)]
+#[doc(hidden)]
+pub struct IIsoSessionErrorPreview3_Vtbl {
+    pub base__: windows_core::IInspectable_Vtbl,
+    pub Format: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+}
+windows_core::imp::define_interface!(
+    IIsoSessionOps,
+    IIsoSessionOps_Vtbl,
+    0xabe3e450_1dd6_5c8f_88d1_f5522b785b96
+);
+impl windows_core::RuntimeType for IIsoSessionOps {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_interface::<Self>();
+}
+impl windows_core::RuntimeName for IIsoSessionOps {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionOps";
+}
+pub trait IIsoSessionOps_Impl: windows_core::IUnknownImpl {
+    fn BehaviorVersion(&self) -> windows_core::Result<i32>;
+    fn AddUserAsync(
+        &self,
+        optEnterpriseAccountName: &windows_core::HSTRING,
+        optWamToken: &windows_core::HSTRING,
+    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionUserResult>>;
+    fn GetFeatureLevel(&self, feature: IsoSessionFeature) -> windows_core::Result<i32>;
+    fn RemoveUserAsync(
+        &self,
+        agentUserName: &windows_core::HSTRING,
+    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionResult>>;
+    fn RunProcessWithOptionsAsync(
+        &self,
+        agentUserName: &windows_core::HSTRING,
+        processPath: &windows_core::HSTRING,
+        arguments: &windows_core::HSTRING,
+        options: windows_core::Ref<'_, IsoSessionProcessOptions>,
+    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionProcessResult>>;
+    fn StartSessionAsync(
+        &self,
+        agentUserName: &windows_core::HSTRING,
+        optWamToken: &windows_core::HSTRING,
+    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionResult>>;
+    fn StopSessionAsync(
+        &self,
+        agentUserName: &windows_core::HSTRING,
+    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionResult>>;
+}
+impl IIsoSessionOps_Vtbl {
+    pub const fn new<Identity: IIsoSessionOps_Impl, const OFFSET: isize>() -> Self {
+        unsafe extern "system" fn BehaviorVersion<
+            Identity: IIsoSessionOps_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut i32,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionOps_Impl::BehaviorVersion(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn AddUserAsync<
+            Identity: IIsoSessionOps_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            optenterpriseaccountname: *mut core::ffi::c_void,
+            optwamtoken: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionOps_Impl::AddUserAsync(
+                    this,
+                    core::mem::transmute(&optenterpriseaccountname),
+                    core::mem::transmute(&optwamtoken),
+                ) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn GetFeatureLevel<
+            Identity: IIsoSessionOps_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            feature: IsoSessionFeature,
+            result__: *mut i32,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionOps_Impl::GetFeatureLevel(this, feature) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn RemoveUserAsync<
+            Identity: IIsoSessionOps_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            agentusername: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionOps_Impl::RemoveUserAsync(
+                    this,
+                    core::mem::transmute(&agentusername),
+                ) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn RunProcessWithOptionsAsync<
+            Identity: IIsoSessionOps_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            agentusername: *mut core::ffi::c_void,
+            processpath: *mut core::ffi::c_void,
+            arguments: *mut core::ffi::c_void,
+            options: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionOps_Impl::RunProcessWithOptionsAsync(
+                    this,
+                    core::mem::transmute(&agentusername),
+                    core::mem::transmute(&processpath),
+                    core::mem::transmute(&arguments),
+                    core::mem::transmute_copy(&options),
+                ) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn StartSessionAsync<
+            Identity: IIsoSessionOps_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            agentusername: *mut core::ffi::c_void,
+            optwamtoken: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionOps_Impl::StartSessionAsync(
+                    this,
+                    core::mem::transmute(&agentusername),
+                    core::mem::transmute(&optwamtoken),
+                ) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn StopSessionAsync<
+            Identity: IIsoSessionOps_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            agentusername: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionOps_Impl::StopSessionAsync(
+                    this,
+                    core::mem::transmute(&agentusername),
+                ) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        Self {
+            base__: windows_core::IInspectable_Vtbl::new::<Identity, IIsoSessionOps, OFFSET>(),
+            BehaviorVersion: BehaviorVersion::<Identity, OFFSET>,
+            AddUserAsync: AddUserAsync::<Identity, OFFSET>,
+            GetFeatureLevel: GetFeatureLevel::<Identity, OFFSET>,
+            RemoveUserAsync: RemoveUserAsync::<Identity, OFFSET>,
+            RunProcessWithOptionsAsync: RunProcessWithOptionsAsync::<Identity, OFFSET>,
+            StartSessionAsync: StartSessionAsync::<Identity, OFFSET>,
+            StopSessionAsync: StopSessionAsync::<Identity, OFFSET>,
+        }
+    }
+    pub fn matches(iid: &windows_core::GUID) -> bool {
+        iid == &<IIsoSessionOps as windows_core::Interface>::IID
+    }
+}
+#[repr(C)]
+#[doc(hidden)]
+pub struct IIsoSessionOps_Vtbl {
+    pub base__: windows_core::IInspectable_Vtbl,
+    pub BehaviorVersion:
+        unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
+    pub AddUserAsync: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut core::ffi::c_void,
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+    pub GetFeatureLevel: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        IsoSessionFeature,
+        *mut i32,
+    ) -> windows_core::HRESULT,
+    pub RemoveUserAsync: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+    pub RunProcessWithOptionsAsync: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut core::ffi::c_void,
+        *mut core::ffi::c_void,
+        *mut core::ffi::c_void,
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+    pub StartSessionAsync: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut core::ffi::c_void,
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+    pub StopSessionAsync: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+}
+windows_core::imp::define_interface!(
+    IIsoSessionOpsPreview2,
+    IIsoSessionOpsPreview2_Vtbl,
+    0x2e26214d_02c1_5dc5_9ce7_f9a41cddd5b1
+);
+impl windows_core::RuntimeType for IIsoSessionOpsPreview2 {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_interface::<Self>();
+}
+impl windows_core::RuntimeName for IIsoSessionOpsPreview2 {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionOpsPreview2";
+}
+pub trait IIsoSessionOpsPreview2_Impl: windows_core::IUnknownImpl {
+    fn AddUserAsync2(
+        &self,
+        optAppId: &windows_core::HSTRING,
+        optEnterpriseAccountName: &windows_core::HSTRING,
+        optWamToken: &windows_core::HSTRING,
+    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionUserResult>>;
+}
+impl IIsoSessionOpsPreview2_Vtbl {
+    pub const fn new<Identity: IIsoSessionOpsPreview2_Impl, const OFFSET: isize>() -> Self {
+        unsafe extern "system" fn AddUserAsync2<
+            Identity: IIsoSessionOpsPreview2_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            optappid: *mut core::ffi::c_void,
+            optenterpriseaccountname: *mut core::ffi::c_void,
+            optwamtoken: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionOpsPreview2_Impl::AddUserAsync2(
+                    this,
+                    core::mem::transmute(&optappid),
+                    core::mem::transmute(&optenterpriseaccountname),
+                    core::mem::transmute(&optwamtoken),
+                ) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        Self {
+            base__: windows_core::IInspectable_Vtbl::new::<Identity, IIsoSessionOpsPreview2, OFFSET>(
+            ),
+            AddUserAsync2: AddUserAsync2::<Identity, OFFSET>,
+        }
+    }
+    pub fn matches(iid: &windows_core::GUID) -> bool {
+        iid == &<IIsoSessionOpsPreview2 as windows_core::Interface>::IID
+    }
+}
+#[repr(C)]
+#[doc(hidden)]
+pub struct IIsoSessionOpsPreview2_Vtbl {
+    pub base__: windows_core::IInspectable_Vtbl,
+    pub AddUserAsync2: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut core::ffi::c_void,
+        *mut core::ffi::c_void,
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+}
+windows_core::imp::define_interface!(
+    IIsoSessionOpsPreview3,
+    IIsoSessionOpsPreview3_Vtbl,
+    0x142b6655_e129_570d_902f_c20483662239
+);
+impl windows_core::RuntimeType for IIsoSessionOpsPreview3 {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_interface::<Self>();
+}
+impl windows_core::RuntimeName for IIsoSessionOpsPreview3 {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionOpsPreview3";
+}
+pub trait IIsoSessionOpsPreview3_Impl: windows_core::IUnknownImpl {
+    fn IsLocalAgentUserSupported(&self) -> windows_core::Result<bool>;
+    fn IsEnterpriseAgentUserSupported(&self) -> windows_core::Result<bool>;
+    fn IsAppScopedRegistrationSupported(&self) -> windows_core::Result<bool>;
+}
+impl IIsoSessionOpsPreview3_Vtbl {
+    pub const fn new<Identity: IIsoSessionOpsPreview3_Impl, const OFFSET: isize>() -> Self {
+        unsafe extern "system" fn IsLocalAgentUserSupported<
+            Identity: IIsoSessionOpsPreview3_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut bool,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionOpsPreview3_Impl::IsLocalAgentUserSupported(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn IsEnterpriseAgentUserSupported<
+            Identity: IIsoSessionOpsPreview3_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut bool,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionOpsPreview3_Impl::IsEnterpriseAgentUserSupported(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn IsAppScopedRegistrationSupported<
+            Identity: IIsoSessionOpsPreview3_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut bool,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionOpsPreview3_Impl::IsAppScopedRegistrationSupported(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        Self {
+            base__: windows_core::IInspectable_Vtbl::new::<Identity, IIsoSessionOpsPreview3, OFFSET>(
+            ),
+            IsLocalAgentUserSupported: IsLocalAgentUserSupported::<Identity, OFFSET>,
+            IsEnterpriseAgentUserSupported: IsEnterpriseAgentUserSupported::<Identity, OFFSET>,
+            IsAppScopedRegistrationSupported: IsAppScopedRegistrationSupported::<Identity, OFFSET>,
+        }
+    }
+    pub fn matches(iid: &windows_core::GUID) -> bool {
+        iid == &<IIsoSessionOpsPreview3 as windows_core::Interface>::IID
+    }
+}
+#[repr(C)]
+#[doc(hidden)]
+pub struct IIsoSessionOpsPreview3_Vtbl {
+    pub base__: windows_core::IInspectable_Vtbl,
+    pub IsLocalAgentUserSupported:
+        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
+    pub IsEnterpriseAgentUserSupported:
+        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
+    pub IsAppScopedRegistrationSupported:
+        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
+}
+windows_core::imp::define_interface!(
+    IIsoSessionOpsPreview4,
+    IIsoSessionOpsPreview4_Vtbl,
+    0x4d27018c_d1b8_5cdb_9e41_97635fbb59fd
+);
+impl windows_core::RuntimeType for IIsoSessionOpsPreview4 {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_interface::<Self>();
+}
+impl windows_core::RuntimeName for IIsoSessionOpsPreview4 {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionOpsPreview4";
+}
+pub trait IIsoSessionOpsPreview4_Impl: windows_core::IUnknownImpl {
+    fn IsDeducedEnterpriseAgentUserSupported(&self) -> windows_core::Result<bool>;
+    fn AddUserAsync3(
+        &self,
+        optAppId: &windows_core::HSTRING,
+        parentWindowId: &windows::UI::WindowId,
+    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionUserResult>>;
+    fn StartSessionAsync2(
+        &self,
+        agentUserName: &windows_core::HSTRING,
+        parentWindowId: &windows::UI::WindowId,
+    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionResult>>;
+}
+impl IIsoSessionOpsPreview4_Vtbl {
+    pub const fn new<Identity: IIsoSessionOpsPreview4_Impl, const OFFSET: isize>() -> Self {
+        unsafe extern "system" fn IsDeducedEnterpriseAgentUserSupported<
+            Identity: IIsoSessionOpsPreview4_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut bool,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionOpsPreview4_Impl::IsDeducedEnterpriseAgentUserSupported(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn AddUserAsync3<
+            Identity: IIsoSessionOpsPreview4_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            optappid: *mut core::ffi::c_void,
+            parentwindowid: windows::UI::WindowId,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionOpsPreview4_Impl::AddUserAsync3(
+                    this,
+                    core::mem::transmute(&optappid),
+                    core::mem::transmute(&parentwindowid),
+                ) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn StartSessionAsync2<
+            Identity: IIsoSessionOpsPreview4_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            agentusername: *mut core::ffi::c_void,
+            parentwindowid: windows::UI::WindowId,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionOpsPreview4_Impl::StartSessionAsync2(
+                    this,
+                    core::mem::transmute(&agentusername),
+                    core::mem::transmute(&parentwindowid),
+                ) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        Self {
+            base__: windows_core::IInspectable_Vtbl::new::<Identity, IIsoSessionOpsPreview4, OFFSET>(
+            ),
+            IsDeducedEnterpriseAgentUserSupported: IsDeducedEnterpriseAgentUserSupported::<
+                Identity,
+                OFFSET,
+            >,
+            AddUserAsync3: AddUserAsync3::<Identity, OFFSET>,
+            StartSessionAsync2: StartSessionAsync2::<Identity, OFFSET>,
+        }
+    }
+    pub fn matches(iid: &windows_core::GUID) -> bool {
+        iid == &<IIsoSessionOpsPreview4 as windows_core::Interface>::IID
+    }
+}
+#[repr(C)]
+#[doc(hidden)]
+pub struct IIsoSessionOpsPreview4_Vtbl {
+    pub base__: windows_core::IInspectable_Vtbl,
+    pub IsDeducedEnterpriseAgentUserSupported:
+        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
+    pub AddUserAsync3: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut core::ffi::c_void,
+        windows::UI::WindowId,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+    pub StartSessionAsync2: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut core::ffi::c_void,
+        windows::UI::WindowId,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+}
+windows_core::imp::define_interface!(
+    IIsoSessionProcess,
+    IIsoSessionProcess_Vtbl,
+    0x1cccc074_ce04_527c_8b2f_d367930af570
+);
+impl windows_core::RuntimeType for IIsoSessionProcess {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_interface::<Self>();
+}
+impl windows_core::RuntimeName for IIsoSessionProcess {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionProcess";
+}
+pub trait IIsoSessionProcess_Impl: windows_core::IUnknownImpl {
+    fn ErrorHandle(&self) -> windows_core::Result<u64>;
+    fn ExitCode(&self) -> windows_core::Result<i32>;
+    fn InputHandle(&self) -> windows_core::Result<u64>;
+    fn OutputHandle(&self) -> windows_core::Result<u64>;
+    fn CloseStandardInput(&self) -> windows_core::Result<()>;
+    fn ResizeConsole(&self, columns: u16, rows: u16) -> windows_core::Result<()>;
+    fn SendCtrlClose(&self) -> windows_core::Result<()>;
+    fn Terminate(&self) -> windows_core::Result<()>;
+    fn WaitForExit(&self, timeoutMs: u32) -> windows_core::Result<i32>;
+}
+impl IIsoSessionProcess_Vtbl {
+    pub const fn new<Identity: IIsoSessionProcess_Impl, const OFFSET: isize>() -> Self {
+        unsafe extern "system" fn ErrorHandle<
+            Identity: IIsoSessionProcess_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut u64,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionProcess_Impl::ErrorHandle(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn ExitCode<
+            Identity: IIsoSessionProcess_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut i32,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionProcess_Impl::ExitCode(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn InputHandle<
+            Identity: IIsoSessionProcess_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut u64,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionProcess_Impl::InputHandle(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn OutputHandle<
+            Identity: IIsoSessionProcess_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut u64,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionProcess_Impl::OutputHandle(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn CloseStandardInput<
+            Identity: IIsoSessionProcess_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                IIsoSessionProcess_Impl::CloseStandardInput(this).into()
+            }
+        }
+        unsafe extern "system" fn ResizeConsole<
+            Identity: IIsoSessionProcess_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            columns: u16,
+            rows: u16,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                IIsoSessionProcess_Impl::ResizeConsole(this, columns, rows).into()
+            }
+        }
+        unsafe extern "system" fn SendCtrlClose<
+            Identity: IIsoSessionProcess_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                IIsoSessionProcess_Impl::SendCtrlClose(this).into()
+            }
+        }
+        unsafe extern "system" fn Terminate<
+            Identity: IIsoSessionProcess_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                IIsoSessionProcess_Impl::Terminate(this).into()
+            }
+        }
+        unsafe extern "system" fn WaitForExit<
+            Identity: IIsoSessionProcess_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            timeoutms: u32,
+            result__: *mut i32,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionProcess_Impl::WaitForExit(this, timeoutms) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        Self {
+            base__: windows_core::IInspectable_Vtbl::new::<Identity, IIsoSessionProcess, OFFSET>(),
+            ErrorHandle: ErrorHandle::<Identity, OFFSET>,
+            ExitCode: ExitCode::<Identity, OFFSET>,
+            InputHandle: InputHandle::<Identity, OFFSET>,
+            OutputHandle: OutputHandle::<Identity, OFFSET>,
+            CloseStandardInput: CloseStandardInput::<Identity, OFFSET>,
+            ResizeConsole: ResizeConsole::<Identity, OFFSET>,
+            SendCtrlClose: SendCtrlClose::<Identity, OFFSET>,
+            Terminate: Terminate::<Identity, OFFSET>,
+            WaitForExit: WaitForExit::<Identity, OFFSET>,
+        }
+    }
+    pub fn matches(iid: &windows_core::GUID) -> bool {
+        iid == &<IIsoSessionProcess as windows_core::Interface>::IID
+    }
+}
+#[repr(C)]
+#[doc(hidden)]
+pub struct IIsoSessionProcess_Vtbl {
+    pub base__: windows_core::IInspectable_Vtbl,
+    pub ErrorHandle:
+        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+    pub ExitCode:
+        unsafe extern "system" fn(*mut core::ffi::c_void, *mut i32) -> windows_core::HRESULT,
+    pub InputHandle:
+        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+    pub OutputHandle:
+        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u64) -> windows_core::HRESULT,
+    pub CloseStandardInput:
+        unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
+    pub ResizeConsole:
+        unsafe extern "system" fn(*mut core::ffi::c_void, u16, u16) -> windows_core::HRESULT,
+    pub SendCtrlClose: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
+    pub Terminate: unsafe extern "system" fn(*mut core::ffi::c_void) -> windows_core::HRESULT,
+    pub WaitForExit:
+        unsafe extern "system" fn(*mut core::ffi::c_void, u32, *mut i32) -> windows_core::HRESULT,
+}
+windows_core::imp::define_interface!(
+    IIsoSessionProcessOptions,
+    IIsoSessionProcessOptions_Vtbl,
+    0x20e0f2f6_3b48_5f60_b97c_e856754ded74
+);
+impl windows_core::RuntimeType for IIsoSessionProcessOptions {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_interface::<Self>();
+}
+impl windows_core::RuntimeName for IIsoSessionProcessOptions {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionProcessOptions";
+}
+pub trait IIsoSessionProcessOptions_Impl: windows_core::IUnknownImpl {
+    fn Environment(
+        &self,
+    ) -> windows_core::Result<windows_collections::IMap<windows_core::HSTRING, windows_core::HSTRING>>;
+    fn InteractiveConsole(&self) -> windows_core::Result<bool>;
+    fn SetInteractiveConsole(&self, value: bool) -> windows_core::Result<()>;
+    fn RedirectStandardError(&self) -> windows_core::Result<bool>;
+    fn SetRedirectStandardError(&self, value: bool) -> windows_core::Result<()>;
+    fn RedirectStandardInput(&self) -> windows_core::Result<bool>;
+    fn SetRedirectStandardInput(&self, value: bool) -> windows_core::Result<()>;
+    fn RedirectStandardOutput(&self) -> windows_core::Result<bool>;
+    fn SetRedirectStandardOutput(&self, value: bool) -> windows_core::Result<()>;
+    fn TimeoutMilliseconds(&self) -> windows_core::Result<u32>;
+    fn SetTimeoutMilliseconds(&self, value: u32) -> windows_core::Result<()>;
+    fn WorkingDirectory(&self) -> windows_core::Result<windows_core::HSTRING>;
+    fn SetWorkingDirectory(&self, value: &windows_core::HSTRING) -> windows_core::Result<()>;
+}
+impl IIsoSessionProcessOptions_Vtbl {
+    pub const fn new<Identity: IIsoSessionProcessOptions_Impl, const OFFSET: isize>() -> Self {
+        unsafe extern "system" fn Environment<
+            Identity: IIsoSessionProcessOptions_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionProcessOptions_Impl::Environment(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn InteractiveConsole<
+            Identity: IIsoSessionProcessOptions_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut bool,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionProcessOptions_Impl::InteractiveConsole(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn SetInteractiveConsole<
+            Identity: IIsoSessionProcessOptions_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            value: bool,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                IIsoSessionProcessOptions_Impl::SetInteractiveConsole(this, value).into()
+            }
+        }
+        unsafe extern "system" fn RedirectStandardError<
+            Identity: IIsoSessionProcessOptions_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut bool,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionProcessOptions_Impl::RedirectStandardError(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn SetRedirectStandardError<
+            Identity: IIsoSessionProcessOptions_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            value: bool,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                IIsoSessionProcessOptions_Impl::SetRedirectStandardError(this, value).into()
+            }
+        }
+        unsafe extern "system" fn RedirectStandardInput<
+            Identity: IIsoSessionProcessOptions_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut bool,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionProcessOptions_Impl::RedirectStandardInput(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn SetRedirectStandardInput<
+            Identity: IIsoSessionProcessOptions_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            value: bool,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                IIsoSessionProcessOptions_Impl::SetRedirectStandardInput(this, value).into()
+            }
+        }
+        unsafe extern "system" fn RedirectStandardOutput<
+            Identity: IIsoSessionProcessOptions_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut bool,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionProcessOptions_Impl::RedirectStandardOutput(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn SetRedirectStandardOutput<
+            Identity: IIsoSessionProcessOptions_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            value: bool,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                IIsoSessionProcessOptions_Impl::SetRedirectStandardOutput(this, value).into()
+            }
+        }
+        unsafe extern "system" fn TimeoutMilliseconds<
+            Identity: IIsoSessionProcessOptions_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut u32,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionProcessOptions_Impl::TimeoutMilliseconds(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn SetTimeoutMilliseconds<
+            Identity: IIsoSessionProcessOptions_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            value: u32,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                IIsoSessionProcessOptions_Impl::SetTimeoutMilliseconds(this, value).into()
+            }
+        }
+        unsafe extern "system" fn WorkingDirectory<
+            Identity: IIsoSessionProcessOptions_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionProcessOptions_Impl::WorkingDirectory(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn SetWorkingDirectory<
+            Identity: IIsoSessionProcessOptions_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            value: *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                IIsoSessionProcessOptions_Impl::SetWorkingDirectory(
+                    this,
+                    core::mem::transmute(&value),
+                )
+                .into()
+            }
+        }
+        Self {
+            base__: windows_core::IInspectable_Vtbl::new::<
+                Identity,
+                IIsoSessionProcessOptions,
+                OFFSET,
+            >(),
+            Environment: Environment::<Identity, OFFSET>,
+            InteractiveConsole: InteractiveConsole::<Identity, OFFSET>,
+            SetInteractiveConsole: SetInteractiveConsole::<Identity, OFFSET>,
+            RedirectStandardError: RedirectStandardError::<Identity, OFFSET>,
+            SetRedirectStandardError: SetRedirectStandardError::<Identity, OFFSET>,
+            RedirectStandardInput: RedirectStandardInput::<Identity, OFFSET>,
+            SetRedirectStandardInput: SetRedirectStandardInput::<Identity, OFFSET>,
+            RedirectStandardOutput: RedirectStandardOutput::<Identity, OFFSET>,
+            SetRedirectStandardOutput: SetRedirectStandardOutput::<Identity, OFFSET>,
+            TimeoutMilliseconds: TimeoutMilliseconds::<Identity, OFFSET>,
+            SetTimeoutMilliseconds: SetTimeoutMilliseconds::<Identity, OFFSET>,
+            WorkingDirectory: WorkingDirectory::<Identity, OFFSET>,
+            SetWorkingDirectory: SetWorkingDirectory::<Identity, OFFSET>,
+        }
+    }
+    pub fn matches(iid: &windows_core::GUID) -> bool {
+        iid == &<IIsoSessionProcessOptions as windows_core::Interface>::IID
+    }
+}
+#[repr(C)]
+#[doc(hidden)]
+pub struct IIsoSessionProcessOptions_Vtbl {
+    pub base__: windows_core::IInspectable_Vtbl,
+    pub Environment: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+    pub InteractiveConsole:
+        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
+    pub SetInteractiveConsole:
+        unsafe extern "system" fn(*mut core::ffi::c_void, bool) -> windows_core::HRESULT,
+    pub RedirectStandardError:
+        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
+    pub SetRedirectStandardError:
+        unsafe extern "system" fn(*mut core::ffi::c_void, bool) -> windows_core::HRESULT,
+    pub RedirectStandardInput:
+        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
+    pub SetRedirectStandardInput:
+        unsafe extern "system" fn(*mut core::ffi::c_void, bool) -> windows_core::HRESULT,
+    pub RedirectStandardOutput:
+        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
+    pub SetRedirectStandardOutput:
+        unsafe extern "system" fn(*mut core::ffi::c_void, bool) -> windows_core::HRESULT,
+    pub TimeoutMilliseconds:
+        unsafe extern "system" fn(*mut core::ffi::c_void, *mut u32) -> windows_core::HRESULT,
+    pub SetTimeoutMilliseconds:
+        unsafe extern "system" fn(*mut core::ffi::c_void, u32) -> windows_core::HRESULT,
+    pub WorkingDirectory: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+    pub SetWorkingDirectory: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+}
+windows_core::imp::define_interface!(
+    IIsoSessionProcessPreview2,
+    IIsoSessionProcessPreview2_Vtbl,
+    0xeb6a3efa_736d_5301_a241_6d36eda0905a
+);
+impl windows_core::RuntimeType for IIsoSessionProcessPreview2 {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_interface::<Self>();
+}
+impl windows_core::RuntimeName for IIsoSessionProcessPreview2 {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionProcessPreview2";
+}
+pub trait IIsoSessionProcessPreview2_Impl: windows_core::IUnknownImpl {
+    fn IsRunning(&self) -> windows_core::Result<bool>;
+    fn Exited(
+        &self,
+        handler: windows_core::Ref<
+            '_,
+            windows::Foundation::TypedEventHandler<IsoSessionProcess, windows_core::IInspectable>,
+        >,
+    ) -> windows_core::Result<i64>;
+    fn RemoveExited(&self, token: i64) -> windows_core::Result<()>;
+}
+impl IIsoSessionProcessPreview2_Vtbl {
+    pub const fn new<Identity: IIsoSessionProcessPreview2_Impl, const OFFSET: isize>() -> Self {
+        unsafe extern "system" fn IsRunning<
+            Identity: IIsoSessionProcessPreview2_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut bool,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionProcessPreview2_Impl::IsRunning(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn Exited<
+            Identity: IIsoSessionProcessPreview2_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            handler: *mut core::ffi::c_void,
+            result__: *mut i64,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionProcessPreview2_Impl::Exited(
+                    this,
+                    core::mem::transmute_copy(&handler),
+                ) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn RemoveExited<
+            Identity: IIsoSessionProcessPreview2_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            token: i64,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                IIsoSessionProcessPreview2_Impl::RemoveExited(this, token).into()
+            }
+        }
+        Self {
+            base__: windows_core::IInspectable_Vtbl::new::<
+                Identity,
+                IIsoSessionProcessPreview2,
+                OFFSET,
+            >(),
+            IsRunning: IsRunning::<Identity, OFFSET>,
+            Exited: Exited::<Identity, OFFSET>,
+            RemoveExited: RemoveExited::<Identity, OFFSET>,
+        }
+    }
+    pub fn matches(iid: &windows_core::GUID) -> bool {
+        iid == &<IIsoSessionProcessPreview2 as windows_core::Interface>::IID
+    }
+}
+#[repr(C)]
+#[doc(hidden)]
+pub struct IIsoSessionProcessPreview2_Vtbl {
+    pub base__: windows_core::IInspectable_Vtbl,
+    pub IsRunning:
+        unsafe extern "system" fn(*mut core::ffi::c_void, *mut bool) -> windows_core::HRESULT,
+    pub Exited: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut core::ffi::c_void,
+        *mut i64,
+    ) -> windows_core::HRESULT,
+    pub RemoveExited:
+        unsafe extern "system" fn(*mut core::ffi::c_void, i64) -> windows_core::HRESULT,
+}
+windows_core::imp::define_interface!(
+    IIsoSessionProcessResult,
+    IIsoSessionProcessResult_Vtbl,
+    0x30c5f8a5_efb8_5872_b8f9_be625090b9ba
+);
+impl windows_core::RuntimeType for IIsoSessionProcessResult {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_interface::<Self>();
+}
+impl windows_core::RuntimeName for IIsoSessionProcessResult {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionProcessResult";
+}
+pub trait IIsoSessionProcessResult_Impl: windows_core::IUnknownImpl {
+    fn Error(&self) -> windows_core::Result<IsoSessionError>;
+    fn Process(&self) -> windows_core::Result<IsoSessionProcess>;
+}
+impl IIsoSessionProcessResult_Vtbl {
+    pub const fn new<Identity: IIsoSessionProcessResult_Impl, const OFFSET: isize>() -> Self {
+        unsafe extern "system" fn Error<
+            Identity: IIsoSessionProcessResult_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionProcessResult_Impl::Error(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn Process<
+            Identity: IIsoSessionProcessResult_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionProcessResult_Impl::Process(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        Self {
+            base__: windows_core::IInspectable_Vtbl::new::<
+                Identity,
+                IIsoSessionProcessResult,
+                OFFSET,
+            >(),
+            Error: Error::<Identity, OFFSET>,
+            Process: Process::<Identity, OFFSET>,
+        }
+    }
+    pub fn matches(iid: &windows_core::GUID) -> bool {
+        iid == &<IIsoSessionProcessResult as windows_core::Interface>::IID
+    }
+}
+#[repr(C)]
+#[doc(hidden)]
+pub struct IIsoSessionProcessResult_Vtbl {
+    pub base__: windows_core::IInspectable_Vtbl,
+    pub Error: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+    pub Process: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+}
+windows_core::imp::define_interface!(
+    IIsoSessionResult,
+    IIsoSessionResult_Vtbl,
+    0xc0f5de66_c487_571c_87a0_13a0854a7db0
+);
+impl windows_core::RuntimeType for IIsoSessionResult {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_interface::<Self>();
+}
+impl windows_core::RuntimeName for IIsoSessionResult {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionResult";
+}
+pub trait IIsoSessionResult_Impl: windows_core::IUnknownImpl {
+    fn Error(&self) -> windows_core::Result<IsoSessionError>;
+}
+impl IIsoSessionResult_Vtbl {
+    pub const fn new<Identity: IIsoSessionResult_Impl, const OFFSET: isize>() -> Self {
+        unsafe extern "system" fn Error<Identity: IIsoSessionResult_Impl, const OFFSET: isize>(
+            this: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionResult_Impl::Error(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        Self {
+            base__: windows_core::IInspectable_Vtbl::new::<Identity, IIsoSessionResult, OFFSET>(),
+            Error: Error::<Identity, OFFSET>,
+        }
+    }
+    pub fn matches(iid: &windows_core::GUID) -> bool {
+        iid == &<IIsoSessionResult as windows_core::Interface>::IID
+    }
+}
+#[repr(C)]
+#[doc(hidden)]
+pub struct IIsoSessionResult_Vtbl {
+    pub base__: windows_core::IInspectable_Vtbl,
+    pub Error: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+}
+windows_core::imp::define_interface!(
+    IIsoSessionUserResult,
+    IIsoSessionUserResult_Vtbl,
+    0x8733fb07_cce2_5483_95a7_0a68cbd7641a
+);
+impl windows_core::RuntimeType for IIsoSessionUserResult {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_interface::<Self>();
+}
+impl windows_core::RuntimeName for IIsoSessionUserResult {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IIsoSessionUserResult";
+}
+pub trait IIsoSessionUserResult_Impl: windows_core::IUnknownImpl {
+    fn AgentUserName(&self) -> windows_core::Result<windows_core::HSTRING>;
+    fn AgentUserSid(&self) -> windows_core::Result<windows_core::HSTRING>;
+    fn EphemeralWorkspacePath(&self) -> windows_core::Result<windows_core::HSTRING>;
+    fn Error(&self) -> windows_core::Result<IsoSessionError>;
+}
+impl IIsoSessionUserResult_Vtbl {
+    pub const fn new<Identity: IIsoSessionUserResult_Impl, const OFFSET: isize>() -> Self {
+        unsafe extern "system" fn AgentUserName<
+            Identity: IIsoSessionUserResult_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionUserResult_Impl::AgentUserName(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn AgentUserSid<
+            Identity: IIsoSessionUserResult_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionUserResult_Impl::AgentUserSid(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn EphemeralWorkspacePath<
+            Identity: IIsoSessionUserResult_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionUserResult_Impl::EphemeralWorkspacePath(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        unsafe extern "system" fn Error<
+            Identity: IIsoSessionUserResult_Impl,
+            const OFFSET: isize,
+        >(
+            this: *mut core::ffi::c_void,
+            result__: *mut *mut core::ffi::c_void,
+        ) -> windows_core::HRESULT {
+            unsafe {
+                let this: &Identity =
+                    &*((this as *const *const ()).offset(OFFSET) as *const Identity);
+                match IIsoSessionUserResult_Impl::Error(this) {
+                    Ok(ok__) => {
+                        result__.write(core::mem::transmute_copy(&ok__));
+                        core::mem::forget(ok__);
+                        windows_core::HRESULT(0)
+                    }
+                    Err(err) => err.into(),
+                }
+            }
+        }
+        Self {
+            base__: windows_core::IInspectable_Vtbl::new::<Identity, IIsoSessionUserResult, OFFSET>(
+            ),
+            AgentUserName: AgentUserName::<Identity, OFFSET>,
+            AgentUserSid: AgentUserSid::<Identity, OFFSET>,
+            EphemeralWorkspacePath: EphemeralWorkspacePath::<Identity, OFFSET>,
+            Error: Error::<Identity, OFFSET>,
+        }
+    }
+    pub fn matches(iid: &windows_core::GUID) -> bool {
+        iid == &<IIsoSessionUserResult as windows_core::Interface>::IID
+    }
+}
+#[repr(C)]
+#[doc(hidden)]
+pub struct IIsoSessionUserResult_Vtbl {
+    pub base__: windows_core::IInspectable_Vtbl,
+    pub AgentUserName: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+    pub AgentUserSid: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+    pub EphemeralWorkspacePath: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+    pub Error: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+}
+#[repr(transparent)]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct IsoSessionError(windows_core::IUnknown);
+windows_core::imp::interface_hierarchy!(
+    IsoSessionError,
+    windows_core::IUnknown,
+    windows_core::IInspectable
+);
+impl IsoSessionError {
+    pub fn new() -> windows_core::Result<Self> {
+        Self::IActivationFactory(|f| f.ActivateInstance::<Self>())
+    }
+    fn IActivationFactory<
+        R,
+        F: FnOnce(&windows_core::imp::IGenericFactory) -> windows_core::Result<R>,
+    >(
+        callback: F,
+    ) -> windows_core::Result<R> {
+        static SHARED: windows_core::imp::FactoryCache<
+            IsoSessionError,
+            windows_core::imp::IGenericFactory,
+        > = windows_core::imp::FactoryCache::new();
+        SHARED.call(callback)
+    }
+    pub fn Code(&self) -> windows_core::Result<windows_core::HRESULT> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).Code)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn IsError(&self) -> windows_core::Result<bool> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).IsError)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn Message(&self) -> windows_core::Result<windows_core::HSTRING> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).Message)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| core::mem::transmute(result__))
+        }
+    }
+    pub fn Remediation(&self) -> windows_core::Result<windows_core::HSTRING> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).Remediation)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| core::mem::transmute(result__))
+        }
+    }
+    pub fn Diagnostics(&self) -> windows_core::Result<windows_core::HSTRING> {
+        let this = &windows_core::Interface::cast::<IIsoSessionErrorPreview2>(self)?;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).Diagnostics)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| core::mem::transmute(result__))
+        }
+    }
+    pub fn FailingStage(&self) -> windows_core::Result<windows_core::HSTRING> {
+        let this = &windows_core::Interface::cast::<IIsoSessionErrorPreview2>(self)?;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).FailingStage)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| core::mem::transmute(result__))
+        }
+    }
+    pub fn UnderlyingError(&self) -> windows_core::Result<windows_core::HRESULT> {
+        let this = &windows_core::Interface::cast::<IIsoSessionErrorPreview2>(self)?;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).UnderlyingError)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn Format(&self) -> windows_core::Result<windows_core::HSTRING> {
+        let this = &windows_core::Interface::cast::<IIsoSessionErrorPreview3>(self)?;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).Format)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| core::mem::transmute(result__))
+        }
+    }
+}
+impl windows_core::RuntimeType for IsoSessionError {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_class::<Self, IIsoSessionError>();
+}
+unsafe impl windows_core::Interface for IsoSessionError {
+    type Vtable = <IIsoSessionError as windows_core::Interface>::Vtable;
+    const IID: windows_core::GUID = <IIsoSessionError as windows_core::Interface>::IID;
+}
+impl windows_core::RuntimeName for IsoSessionError {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IsoSessionError";
+}
+unsafe impl Send for IsoSessionError {}
+unsafe impl Sync for IsoSessionError {}
+#[repr(transparent)]
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub struct IsoSessionFeature(pub i32);
+impl IsoSessionFeature {
+    pub const Unknown: Self = Self(0i32);
+    pub const LocalAgentUser: Self = Self(1i32);
+    pub const EnterpriseAgentUser: Self = Self(2i32);
+    pub const AppScopedRegistration: Self = Self(3i32);
+    pub const DeducedEnterpriseAgentUser: Self = Self(4i32);
+}
+impl windows_core::TypeKind for IsoSessionFeature {
+    type TypeKind = windows_core::CopyType;
+}
+impl windows_core::RuntimeType for IsoSessionFeature {
+    const SIGNATURE: windows_core::imp::ConstBuffer = windows_core::imp::ConstBuffer::from_slice(
+        b"enum(Windows.AI.IsolationSession.Preview.IsoSessionFeature;i4)",
+    );
+}
+#[repr(transparent)]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct IsoSessionOps(windows_core::IUnknown);
+windows_core::imp::interface_hierarchy!(
+    IsoSessionOps,
+    windows_core::IUnknown,
+    windows_core::IInspectable
+);
+impl IsoSessionOps {
+    pub fn new() -> windows_core::Result<Self> {
+        Self::IActivationFactory(|f| f.ActivateInstance::<Self>())
+    }
+    fn IActivationFactory<
+        R,
+        F: FnOnce(&windows_core::imp::IGenericFactory) -> windows_core::Result<R>,
+    >(
+        callback: F,
+    ) -> windows_core::Result<R> {
+        static SHARED: windows_core::imp::FactoryCache<
+            IsoSessionOps,
+            windows_core::imp::IGenericFactory,
+        > = windows_core::imp::FactoryCache::new();
+        SHARED.call(callback)
+    }
+    pub fn BehaviorVersion(&self) -> windows_core::Result<i32> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).BehaviorVersion)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn AddUserAsync(
+        &self,
+        optenterpriseaccountname: &windows_core::HSTRING,
+        optwamtoken: &windows_core::HSTRING,
+    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionUserResult>> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).AddUserAsync)(
+                windows_core::Interface::as_raw(this),
+                core::mem::transmute_copy(optenterpriseaccountname),
+                core::mem::transmute_copy(optwamtoken),
+                &mut result__,
+            )
+            .and_then(|| windows_core::Type::from_abi(result__))
+        }
+    }
+    pub fn GetFeatureLevel(&self, feature: IsoSessionFeature) -> windows_core::Result<i32> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).GetFeatureLevel)(
+                windows_core::Interface::as_raw(this),
+                feature,
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn RemoveUserAsync(
+        &self,
+        agentusername: &windows_core::HSTRING,
+    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionResult>> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).RemoveUserAsync)(
+                windows_core::Interface::as_raw(this),
+                core::mem::transmute_copy(agentusername),
+                &mut result__,
+            )
+            .and_then(|| windows_core::Type::from_abi(result__))
+        }
+    }
+    pub fn RunProcessWithOptionsAsync<P3>(
+        &self,
+        agentusername: &windows_core::HSTRING,
+        processpath: &windows_core::HSTRING,
+        arguments: &windows_core::HSTRING,
+        options: P3,
+    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionProcessResult>>
+    where
+        P3: windows_core::Param<IsoSessionProcessOptions>,
+    {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).RunProcessWithOptionsAsync)(
+                windows_core::Interface::as_raw(this),
+                core::mem::transmute_copy(agentusername),
+                core::mem::transmute_copy(processpath),
+                core::mem::transmute_copy(arguments),
+                options.param().abi(),
+                &mut result__,
+            )
+            .and_then(|| windows_core::Type::from_abi(result__))
+        }
+    }
+    pub fn StartSessionAsync(
+        &self,
+        agentusername: &windows_core::HSTRING,
+        optwamtoken: &windows_core::HSTRING,
+    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionResult>> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).StartSessionAsync)(
+                windows_core::Interface::as_raw(this),
+                core::mem::transmute_copy(agentusername),
+                core::mem::transmute_copy(optwamtoken),
+                &mut result__,
+            )
+            .and_then(|| windows_core::Type::from_abi(result__))
+        }
+    }
+    pub fn StopSessionAsync(
+        &self,
+        agentusername: &windows_core::HSTRING,
+    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionResult>> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).StopSessionAsync)(
+                windows_core::Interface::as_raw(this),
+                core::mem::transmute_copy(agentusername),
+                &mut result__,
+            )
+            .and_then(|| windows_core::Type::from_abi(result__))
+        }
+    }
+    pub fn AddUserAsync2(
+        &self,
+        optappid: &windows_core::HSTRING,
+        optenterpriseaccountname: &windows_core::HSTRING,
+        optwamtoken: &windows_core::HSTRING,
+    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionUserResult>> {
+        let this = &windows_core::Interface::cast::<IIsoSessionOpsPreview2>(self)?;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).AddUserAsync2)(
+                windows_core::Interface::as_raw(this),
+                core::mem::transmute_copy(optappid),
+                core::mem::transmute_copy(optenterpriseaccountname),
+                core::mem::transmute_copy(optwamtoken),
+                &mut result__,
+            )
+            .and_then(|| windows_core::Type::from_abi(result__))
+        }
+    }
+    pub fn IsLocalAgentUserSupported(&self) -> windows_core::Result<bool> {
+        let this = &windows_core::Interface::cast::<IIsoSessionOpsPreview3>(self)?;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).IsLocalAgentUserSupported)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn IsEnterpriseAgentUserSupported(&self) -> windows_core::Result<bool> {
+        let this = &windows_core::Interface::cast::<IIsoSessionOpsPreview3>(self)?;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).IsEnterpriseAgentUserSupported)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn IsAppScopedRegistrationSupported(&self) -> windows_core::Result<bool> {
+        let this = &windows_core::Interface::cast::<IIsoSessionOpsPreview3>(self)?;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).IsAppScopedRegistrationSupported)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn IsDeducedEnterpriseAgentUserSupported(&self) -> windows_core::Result<bool> {
+        let this = &windows_core::Interface::cast::<IIsoSessionOpsPreview4>(self)?;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).IsDeducedEnterpriseAgentUserSupported)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn AddUserAsync3(
+        &self,
+        optappid: &windows_core::HSTRING,
+        parentwindowid: windows::UI::WindowId,
+    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionUserResult>> {
+        let this = &windows_core::Interface::cast::<IIsoSessionOpsPreview4>(self)?;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).AddUserAsync3)(
+                windows_core::Interface::as_raw(this),
+                core::mem::transmute_copy(optappid),
+                parentwindowid,
+                &mut result__,
+            )
+            .and_then(|| windows_core::Type::from_abi(result__))
+        }
+    }
+    pub fn StartSessionAsync2(
+        &self,
+        agentusername: &windows_core::HSTRING,
+        parentwindowid: windows::UI::WindowId,
+    ) -> windows_core::Result<windows_future::IAsyncOperation<IsoSessionResult>> {
+        let this = &windows_core::Interface::cast::<IIsoSessionOpsPreview4>(self)?;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).StartSessionAsync2)(
+                windows_core::Interface::as_raw(this),
+                core::mem::transmute_copy(agentusername),
+                parentwindowid,
+                &mut result__,
+            )
+            .and_then(|| windows_core::Type::from_abi(result__))
+        }
+    }
+}
+impl windows_core::RuntimeType for IsoSessionOps {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_class::<Self, IIsoSessionOps>();
+}
+unsafe impl windows_core::Interface for IsoSessionOps {
+    type Vtable = <IIsoSessionOps as windows_core::Interface>::Vtable;
+    const IID: windows_core::GUID = <IIsoSessionOps as windows_core::Interface>::IID;
+}
+impl windows_core::RuntimeName for IsoSessionOps {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IsoSessionOps";
+}
+unsafe impl Send for IsoSessionOps {}
+unsafe impl Sync for IsoSessionOps {}
+#[repr(transparent)]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct IsoSessionProcess(windows_core::IUnknown);
+windows_core::imp::interface_hierarchy!(
+    IsoSessionProcess,
+    windows_core::IUnknown,
+    windows_core::IInspectable
+);
+windows_core::imp::required_hierarchy!(IsoSessionProcess, windows::Foundation::IClosable);
+impl IsoSessionProcess {
+    pub fn Close(&self) -> windows_core::Result<()> {
+        let this = &windows_core::Interface::cast::<windows::Foundation::IClosable>(self)?;
+        unsafe {
+            (windows_core::Interface::vtable(this).Close)(windows_core::Interface::as_raw(this))
+                .ok()
+        }
+    }
+    pub fn ErrorHandle(&self) -> windows_core::Result<u64> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).ErrorHandle)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn ExitCode(&self) -> windows_core::Result<i32> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).ExitCode)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn InputHandle(&self) -> windows_core::Result<u64> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).InputHandle)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn OutputHandle(&self) -> windows_core::Result<u64> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).OutputHandle)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn CloseStandardInput(&self) -> windows_core::Result<()> {
+        let this = self;
+        unsafe {
+            (windows_core::Interface::vtable(this).CloseStandardInput)(
+                windows_core::Interface::as_raw(this),
+            )
+            .ok()
+        }
+    }
+    pub fn ResizeConsole(&self, columns: u16, rows: u16) -> windows_core::Result<()> {
+        let this = self;
+        unsafe {
+            (windows_core::Interface::vtable(this).ResizeConsole)(
+                windows_core::Interface::as_raw(this),
+                columns,
+                rows,
+            )
+            .ok()
+        }
+    }
+    pub fn SendCtrlClose(&self) -> windows_core::Result<()> {
+        let this = self;
+        unsafe {
+            (windows_core::Interface::vtable(this).SendCtrlClose)(windows_core::Interface::as_raw(
+                this,
+            ))
+            .ok()
+        }
+    }
+    pub fn Terminate(&self) -> windows_core::Result<()> {
+        let this = self;
+        unsafe {
+            (windows_core::Interface::vtable(this).Terminate)(windows_core::Interface::as_raw(this))
+                .ok()
+        }
+    }
+    pub fn WaitForExit(&self, timeoutms: u32) -> windows_core::Result<i32> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).WaitForExit)(
+                windows_core::Interface::as_raw(this),
+                timeoutms,
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn IsRunning(&self) -> windows_core::Result<bool> {
+        let this = &windows_core::Interface::cast::<IIsoSessionProcessPreview2>(self)?;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).IsRunning)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn Exited<P0>(&self, handler: P0) -> windows_core::Result<i64>
+    where
+        P0: windows_core::Param<
+            windows::Foundation::TypedEventHandler<IsoSessionProcess, windows_core::IInspectable>,
+        >,
+    {
+        let this = &windows_core::Interface::cast::<IIsoSessionProcessPreview2>(self)?;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).Exited)(
+                windows_core::Interface::as_raw(this),
+                handler.param().abi(),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn RemoveExited(&self, token: i64) -> windows_core::Result<()> {
+        let this = &windows_core::Interface::cast::<IIsoSessionProcessPreview2>(self)?;
+        unsafe {
+            (windows_core::Interface::vtable(this).RemoveExited)(
+                windows_core::Interface::as_raw(this),
+                token,
+            )
+            .ok()
+        }
+    }
+}
+impl windows_core::RuntimeType for IsoSessionProcess {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_class::<Self, IIsoSessionProcess>();
+}
+unsafe impl windows_core::Interface for IsoSessionProcess {
+    type Vtable = <IIsoSessionProcess as windows_core::Interface>::Vtable;
+    const IID: windows_core::GUID = <IIsoSessionProcess as windows_core::Interface>::IID;
+}
+impl windows_core::RuntimeName for IsoSessionProcess {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IsoSessionProcess";
+}
+unsafe impl Send for IsoSessionProcess {}
+unsafe impl Sync for IsoSessionProcess {}
+#[repr(transparent)]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct IsoSessionProcessOptions(windows_core::IUnknown);
+windows_core::imp::interface_hierarchy!(
+    IsoSessionProcessOptions,
+    windows_core::IUnknown,
+    windows_core::IInspectable
+);
+impl IsoSessionProcessOptions {
+    pub fn new() -> windows_core::Result<Self> {
+        Self::IActivationFactory(|f| f.ActivateInstance::<Self>())
+    }
+    fn IActivationFactory<
+        R,
+        F: FnOnce(&windows_core::imp::IGenericFactory) -> windows_core::Result<R>,
+    >(
+        callback: F,
+    ) -> windows_core::Result<R> {
+        static SHARED: windows_core::imp::FactoryCache<
+            IsoSessionProcessOptions,
+            windows_core::imp::IGenericFactory,
+        > = windows_core::imp::FactoryCache::new();
+        SHARED.call(callback)
+    }
+    pub fn Environment(
+        &self,
+    ) -> windows_core::Result<windows_collections::IMap<windows_core::HSTRING, windows_core::HSTRING>>
+    {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).Environment)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .and_then(|| windows_core::Type::from_abi(result__))
+        }
+    }
+    pub fn InteractiveConsole(&self) -> windows_core::Result<bool> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).InteractiveConsole)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn SetInteractiveConsole(&self, value: bool) -> windows_core::Result<()> {
+        let this = self;
+        unsafe {
+            (windows_core::Interface::vtable(this).SetInteractiveConsole)(
+                windows_core::Interface::as_raw(this),
+                value,
+            )
+            .ok()
+        }
+    }
+    pub fn RedirectStandardError(&self) -> windows_core::Result<bool> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).RedirectStandardError)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn SetRedirectStandardError(&self, value: bool) -> windows_core::Result<()> {
+        let this = self;
+        unsafe {
+            (windows_core::Interface::vtable(this).SetRedirectStandardError)(
+                windows_core::Interface::as_raw(this),
+                value,
+            )
+            .ok()
+        }
+    }
+    pub fn RedirectStandardInput(&self) -> windows_core::Result<bool> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).RedirectStandardInput)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn SetRedirectStandardInput(&self, value: bool) -> windows_core::Result<()> {
+        let this = self;
+        unsafe {
+            (windows_core::Interface::vtable(this).SetRedirectStandardInput)(
+                windows_core::Interface::as_raw(this),
+                value,
+            )
+            .ok()
+        }
+    }
+    pub fn RedirectStandardOutput(&self) -> windows_core::Result<bool> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).RedirectStandardOutput)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn SetRedirectStandardOutput(&self, value: bool) -> windows_core::Result<()> {
+        let this = self;
+        unsafe {
+            (windows_core::Interface::vtable(this).SetRedirectStandardOutput)(
+                windows_core::Interface::as_raw(this),
+                value,
+            )
+            .ok()
+        }
+    }
+    pub fn TimeoutMilliseconds(&self) -> windows_core::Result<u32> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).TimeoutMilliseconds)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| result__)
+        }
+    }
+    pub fn SetTimeoutMilliseconds(&self, value: u32) -> windows_core::Result<()> {
+        let this = self;
+        unsafe {
+            (windows_core::Interface::vtable(this).SetTimeoutMilliseconds)(
+                windows_core::Interface::as_raw(this),
+                value,
+            )
+            .ok()
+        }
+    }
+    pub fn WorkingDirectory(&self) -> windows_core::Result<windows_core::HSTRING> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).WorkingDirectory)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| core::mem::transmute(result__))
+        }
+    }
+    pub fn SetWorkingDirectory(&self, value: &windows_core::HSTRING) -> windows_core::Result<()> {
+        let this = self;
+        unsafe {
+            (windows_core::Interface::vtable(this).SetWorkingDirectory)(
+                windows_core::Interface::as_raw(this),
+                core::mem::transmute_copy(value),
+            )
+            .ok()
+        }
+    }
+}
+impl windows_core::RuntimeType for IsoSessionProcessOptions {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_class::<Self, IIsoSessionProcessOptions>();
+}
+unsafe impl windows_core::Interface for IsoSessionProcessOptions {
+    type Vtable = <IIsoSessionProcessOptions as windows_core::Interface>::Vtable;
+    const IID: windows_core::GUID = <IIsoSessionProcessOptions as windows_core::Interface>::IID;
+}
+impl windows_core::RuntimeName for IsoSessionProcessOptions {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IsoSessionProcessOptions";
+}
+unsafe impl Send for IsoSessionProcessOptions {}
+unsafe impl Sync for IsoSessionProcessOptions {}
+#[repr(transparent)]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct IsoSessionProcessResult(windows_core::IUnknown);
+windows_core::imp::interface_hierarchy!(
+    IsoSessionProcessResult,
+    windows_core::IUnknown,
+    windows_core::IInspectable
+);
+impl IsoSessionProcessResult {
+    pub fn Error(&self) -> windows_core::Result<IsoSessionError> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).Error)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .and_then(|| windows_core::Type::from_abi(result__))
+        }
+    }
+    pub fn Process(&self) -> windows_core::Result<IsoSessionProcess> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).Process)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .and_then(|| windows_core::Type::from_abi(result__))
+        }
+    }
+}
+impl windows_core::RuntimeType for IsoSessionProcessResult {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_class::<Self, IIsoSessionProcessResult>();
+}
+unsafe impl windows_core::Interface for IsoSessionProcessResult {
+    type Vtable = <IIsoSessionProcessResult as windows_core::Interface>::Vtable;
+    const IID: windows_core::GUID = <IIsoSessionProcessResult as windows_core::Interface>::IID;
+}
+impl windows_core::RuntimeName for IsoSessionProcessResult {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IsoSessionProcessResult";
+}
+unsafe impl Send for IsoSessionProcessResult {}
+unsafe impl Sync for IsoSessionProcessResult {}
+#[repr(transparent)]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct IsoSessionResult(windows_core::IUnknown);
+windows_core::imp::interface_hierarchy!(
+    IsoSessionResult,
+    windows_core::IUnknown,
+    windows_core::IInspectable
+);
+impl IsoSessionResult {
+    pub fn Error(&self) -> windows_core::Result<IsoSessionError> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).Error)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .and_then(|| windows_core::Type::from_abi(result__))
+        }
+    }
+}
+impl windows_core::RuntimeType for IsoSessionResult {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_class::<Self, IIsoSessionResult>();
+}
+unsafe impl windows_core::Interface for IsoSessionResult {
+    type Vtable = <IIsoSessionResult as windows_core::Interface>::Vtable;
+    const IID: windows_core::GUID = <IIsoSessionResult as windows_core::Interface>::IID;
+}
+impl windows_core::RuntimeName for IsoSessionResult {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IsoSessionResult";
+}
+unsafe impl Send for IsoSessionResult {}
+unsafe impl Sync for IsoSessionResult {}
+#[repr(transparent)]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct IsoSessionUserResult(windows_core::IUnknown);
+windows_core::imp::interface_hierarchy!(
+    IsoSessionUserResult,
+    windows_core::IUnknown,
+    windows_core::IInspectable
+);
+impl IsoSessionUserResult {
+    pub fn AgentUserName(&self) -> windows_core::Result<windows_core::HSTRING> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).AgentUserName)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| core::mem::transmute(result__))
+        }
+    }
+    pub fn AgentUserSid(&self) -> windows_core::Result<windows_core::HSTRING> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).AgentUserSid)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| core::mem::transmute(result__))
+        }
+    }
+    pub fn EphemeralWorkspacePath(&self) -> windows_core::Result<windows_core::HSTRING> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).EphemeralWorkspacePath)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .map(|| core::mem::transmute(result__))
+        }
+    }
+    pub fn Error(&self) -> windows_core::Result<IsoSessionError> {
+        let this = self;
+        unsafe {
+            let mut result__ = core::mem::zeroed();
+            (windows_core::Interface::vtable(this).Error)(
+                windows_core::Interface::as_raw(this),
+                &mut result__,
+            )
+            .and_then(|| windows_core::Type::from_abi(result__))
+        }
+    }
+}
+impl windows_core::RuntimeType for IsoSessionUserResult {
+    const SIGNATURE: windows_core::imp::ConstBuffer =
+        windows_core::imp::ConstBuffer::for_class::<Self, IIsoSessionUserResult>();
+}
+unsafe impl windows_core::Interface for IsoSessionUserResult {
+    type Vtable = <IIsoSessionUserResult as windows_core::Interface>::Vtable;
+    const IID: windows_core::GUID = <IIsoSessionUserResult as windows_core::Interface>::IID;
+}
+impl windows_core::RuntimeName for IsoSessionUserResult {
+    const NAME: &'static str = "Windows.AI.IsolationSession.Preview.IsoSessionUserResult";
+}
+unsafe impl Send for IsoSessionUserResult {}
+unsafe impl Sync for IsoSessionUserResult {}
diff --git a/src/mxc-sdk/src/backends/isolation_session/bindings/mod.rs b/src/mxc-sdk/src/backends/isolation_session/bindings/mod.rs
index e7a4f8815..121c9e448 100644
--- a/src/mxc-sdk/src/backends/isolation_session/bindings/mod.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/bindings/mod.rs
@@ -3,11 +3,9 @@
 
 //! Generated WinRT bindings for the IsolationSession Preview API.
 //!
-//! The bindings are generated **at build time** by `build.rs` from the WinMD
-//! inside the checked-in SDK nuget
-//! (`build/isolation_session_bindings/*.nupkg`) using `windows-bindgen`,
-//! so the crate is always built directly against the pinned SDK package rather
-//! than a committed snapshot.
+//! Inbox builds use the committed OS-generated projection. Builds with the
+//! `isolation_session_lifted` feature regenerate the projection from the pinned SDK package
+//! restored from NuGet.org.
 //!
 //! See `build/isolation_session_bindings/GENERATION_INFO.toml`
 //! for provenance details.
@@ -19,9 +17,13 @@
     dead_code,
     clippy::all
 )]
+#[cfg(feature = "isolation_session_lifted")]
 pub mod bindings {
     // Generated into OUT_DIR by build.rs from the SDK nuget's Preview WinMD.
     // The outer #[allow] above covers the generated items (the file's own
     // inner #![allow] does not propagate through include! into this module).
     include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
 }
+
+#[cfg(not(feature = "isolation_session_lifted"))]
+pub mod bindings;
diff --git a/src/tools/wxc/Cargo.toml b/src/tools/wxc/Cargo.toml
index 9006dacd5..e8b316614 100644
--- a/src/tools/wxc/Cargo.toml
+++ b/src/tools/wxc/Cargo.toml
@@ -21,6 +21,7 @@ tempfile.workspace = true
 
 [target.'cfg(windows)'.build-dependencies]
 cc = "1"
+sha2.workspace = true
 winresource.workspace = true
 zip = "2"
 
@@ -35,5 +36,6 @@ microvm = ["mxc-sdk/microvm"]
 wslc = ["mxc-sdk/wslc"]
 hyperlight = ["mxc-sdk/hyperlight"]
 isolation_session = ["mxc-sdk/isolation_session"]
+isolation_session_lifted = ["isolation_session", "mxc-sdk/isolation_session_lifted"]
 force-tier-testing = ["mxc-sdk/force-tier-testing"]
 tier2_bfs = ["mxc-sdk/tier2_bfs"]
diff --git a/src/tools/wxc/build.rs b/src/tools/wxc/build.rs
index 0bfb889ef..70f67b652 100644
--- a/src/tools/wxc/build.rs
+++ b/src/tools/wxc/build.rs
@@ -8,7 +8,7 @@ mod mxc_build_common;
 
 fn main() {
     #[cfg(all(windows, feature = "isolation_session"))]
-    stage_isolation_session_runtime();
+    reconcile_isolation_session_runtime();
 
     mxc_build_common::embed_version_info("MXC sandbox executor", "wxc-exec.exe");
 
@@ -32,15 +32,39 @@ fn main() {
 }
 
 #[cfg(all(windows, feature = "isolation_session"))]
-fn stage_isolation_session_runtime() {
-    let manifest_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"));
-    let sdk_dir = manifest_dir
-        .join("..")
-        .join("..")
-        .join("mxc-sdk")
-        .join("build")
-        .join("isolation_session_bindings");
-    let _ = mxc_build_common::stage_isolation_session_runtime(&sdk_dir);
+fn reconcile_isolation_session_runtime() {
+    let out_dir = std::path::PathBuf::from(std::env::var("OUT_DIR").expect("OUT_DIR"));
+    let target_dir = out_dir
+        .parent()
+        .and_then(|path| path.parent())
+        .and_then(|path| path.parent())
+        .expect("could not determine target directory from OUT_DIR");
+
+    // Feature configurations share the final profile directory but have
+    // separate build-script fingerprints. Force this script to reconcile the
+    // shared payload whenever Cargo is invoked.
+    println!(
+        "cargo:rerun-if-changed={}",
+        target_dir.join(".isosession-payload-state").display()
+    );
+
+    #[cfg(feature = "isolation_session_lifted")]
+    mxc_build_common::isolation_session_sdk::stage_runtime()
+        .unwrap_or_else(|e| panic!("IsolationSession SDK staging failed: {e}"));
+
+    #[cfg(not(feature = "isolation_session_lifted"))]
+    for file_name in [
+        "IsoSessionApp.dll",
+        "IsoSession.manifest",
+        "IsoSessionApp.runtimeversion",
+    ] {
+        let path = target_dir.join(file_name);
+        match std::fs::remove_file(&path) {
+            Ok(()) => {}
+            Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+            Err(error) => panic!("remove stale lifted payload {}: {error}", path.display()),
+        }
+    }
 }
 
 #[cfg(windows)]

From 6b7fdf320d0ff061ab06cbc43a2745c6b0c52cc7 Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Thu, 24 Sep 2026 12:05:13 -0700
Subject: [PATCH 14/26] Consume completed IsoSession runtime manifest

Update the pinned SDK package to the manifest-complete pipeline artifact. Stage IsoSession.manifest byte-for-byte from the package and remove MXC's dependency on the runtime-version sidecar.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: e37e4eb2-1e56-42ca-a48e-4b35e9100d16
---
 src/mxc-sdk/build/build_mxc_build_common.rs   | 101 +++++++++++++-----
 .../GENERATION_INFO.toml                      |  24 ++---
 .../Update-IsoSessionSdk.ps1                  |  21 ++--
 3 files changed, 98 insertions(+), 48 deletions(-)

diff --git a/src/mxc-sdk/build/build_mxc_build_common.rs b/src/mxc-sdk/build/build_mxc_build_common.rs
index a3237460a..750acd80a 100644
--- a/src/mxc-sdk/build/build_mxc_build_common.rs
+++ b/src/mxc-sdk/build/build_mxc_build_common.rs
@@ -18,14 +18,13 @@ pub mod isolation_session_sdk {
     use std::process::Command;
 
     pub const PACKAGE_ID: &str = "Microsoft.Windows.AI.IsolationSession.SDK";
-    pub const PACKAGE_VERSION: &str = "0.2608.0";
+    pub const PACKAGE_VERSION: &str = "0.202609.0";
     pub const PACKAGE_SHA256: &str =
-        "af609652e691e9f2ae47885bcfcfd29e8d8c05744482f50c104efd2f3ca1d8e5";
+        "5211a15b68f900fa92a47c96c4c59fe4112caaef6c6b1414623e8d4449528bff";
     pub const PACKAGE_PATH_ENV: &str = "ISOLATION_SESSION_SDK_PACKAGE";
 
     const APP_DLL: &str = "IsoSessionApp.dll";
     const RUNTIME_MANIFEST: &str = "IsoSession.manifest";
-    const VERSION_SIDECAR: &str = "IsoSessionApp.runtimeversion";
 
     pub fn resolve_package() -> Result<PathBuf, String> {
         println!("cargo:rerun-if-env-changed={PACKAGE_PATH_ENV}");
@@ -124,21 +123,10 @@ pub mod isolation_session_sdk {
     pub fn stage_runtime() -> Result<(), String> {
         let package = resolve_package()?;
         let app_dll = read_entry(&package, APP_DLL)?;
-        let version_bytes = read_entry(&package, VERSION_SIDECAR)?;
-        let instance = String::from_utf8(version_bytes)
-            .map_err(|e| format!("{VERSION_SIDECAR} is not valid UTF-8: {e}"))?
-            .trim()
-            .replace('_', ".");
-        validate_instance(&instance)?;
-
-        let manifest = format!(
-            "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n\
-<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">\n\
-  <assemblyIdentity name=\"IsoSession.Runtime\" version=\"1.0.0.0\" type=\"win32\" />\n\
-  <file name=\"IsoSessionApp.dll\" />\n\
-  <iso:instance xmlns:iso=\"urn:schemas-microsoft-com:agentic-runtime.v1\" name=\"{instance}\" />\n\
-</assembly>\n"
-        );
+        let manifest = read_entry(&package, RUNTIME_MANIFEST)?;
+        let instance = package_runtime_instance()?;
+        validate_runtime_manifest(&manifest, &instance)?;
+
         let target_dir = target_profile_dir()?;
         std::fs::write(target_dir.join(APP_DLL), app_dll)
             .map_err(|e| format!("stage {APP_DLL} to {}: {e}", target_dir.display()))?;
@@ -192,19 +180,46 @@ pub mod isolation_session_sdk {
             })
     }
 
-    fn validate_instance(instance: &str) -> Result<(), String> {
-        let bytes = instance.as_bytes();
-        if bytes.len() == 7
-            && bytes[4] == b'.'
-            && bytes[..4].iter().all(u8::is_ascii_digit)
-            && bytes[5..].iter().all(u8::is_ascii_digit)
+    fn package_runtime_instance() -> Result<String, String> {
+        let mut parts = PACKAGE_VERSION.split('.');
+        let prefix = parts.next();
+        let release = parts.next();
+        let patch = parts.next();
+        if prefix != Some("0")
+            || parts.next().is_some()
+            || !patch.is_some_and(|value| value.bytes().all(|byte| byte.is_ascii_digit()))
+            || !release.is_some_and(|value| {
+                value.len() == 6 && value.bytes().all(|byte| byte.is_ascii_digit())
+            })
         {
-            Ok(())
-        } else {
-            Err(format!(
-                "{VERSION_SIDECAR} must identify a YYYY_MM instance, got {instance:?}"
-            ))
+            return Err(format!(
+                "IsolationSession SDK package version must use 0.YYYYMM.patch, got {PACKAGE_VERSION:?}"
+            ));
+        }
+
+        let release = release.unwrap();
+        Ok(format!("{}.{}", &release[..4], &release[4..]))
+    }
+
+    fn validate_runtime_manifest(manifest: &[u8], instance: &str) -> Result<(), String> {
+        let content = std::str::from_utf8(manifest)
+            .map_err(|e| format!("{RUNTIME_MANIFEST} is not valid UTF-8: {e}"))?;
+        for required in [
+            "<assemblyIdentity name=\"IsoSession.Runtime\"",
+            "<file name=\"IsoSessionApp.dll\"",
+        ] {
+            if !content.contains(required) {
+                return Err(format!("{RUNTIME_MANIFEST} is missing {required:?}"));
+            }
         }
+
+        let expected_instance = format!("name=\"{instance}\"");
+        if !content.contains(&expected_instance) {
+            return Err(format!(
+                "{RUNTIME_MANIFEST} does not identify runtime instance {instance:?}"
+            ));
+        }
+        Ok(())
     }
 
     fn nuget_cache_root() -> Result<PathBuf, String> {
@@ -240,6 +255,34 @@ pub mod isolation_session_sdk {
             ))
         }
     }
+
+    #[cfg(test)]
+    mod tests {
+        use super::{package_runtime_instance, validate_runtime_manifest};
+
+        const MANIFEST: &str = "\
+<assembly>
+  <assemblyIdentity name=\"IsoSession.Runtime\" />
+  <file name=\"IsoSessionApp.dll\" />
+  <iso:instance name=\"2026.09\" />
+</assembly>";
+
+        #[test]
+        fn package_version_maps_to_runtime_instance() {
+            assert_eq!(package_runtime_instance().unwrap(), "2026.09");
+        }
+
+        #[test]
+        fn completed_runtime_manifest_is_accepted() {
+            validate_runtime_manifest(MANIFEST.as_bytes(), "2026.09").unwrap();
+        }
+
+        #[test]
+        fn mismatched_runtime_manifest_is_rejected() {
+            let error = validate_runtime_manifest(MANIFEST.as_bytes(), "2026.10").unwrap_err();
+            assert!(error.contains("does not identify runtime instance"));
+        }
+    }
 }
 
 /// Embed Windows VersionInfo resource metadata into the binary being compiled.
diff --git a/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml b/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
index 917f4294a..4182fcc29 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
+++ b/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
@@ -1,19 +1,17 @@
-# Provenance for both IsolationSession binding sources.
+# Provenance for the isolation_session_bindings crate.
+#
+# Bindings are regenerated at build time from the Preview WinMD in the pinned
+# SDK package. Run Update-IsoSessionSdk.ps1 rather than editing this file.
 
 [tool]
-# Must match the `windows-bindgen` build-dependency pin in the crate's Cargo.toml
-# and stay in lockstep with the workspace `windows` crate major.minor.
 windows_bindgen_version = "0.62.1"
 target_windows_crate = "0.62"
-generated_date = "2026-08-19"
+generated_date = "2026-09-24"
 
-[inbox]
-source = "OS-generated committed bindings.rs"
-
-[lifted]
-package_id = "Microsoft.Windows.AI.IsolationSession.SDK"
-package_version = "0.2608.0"
-package_sha256 = "AF609652E691E9F2AE47885BCFCFD29E8D8C05744482F50C104EFD2F3CA1D8E5"
+[source]
+nupkg = "Microsoft.Windows.AI.IsolationSession.SDK.0.202609.0.nupkg"
 winmd = "metadata/windows.ai.isolationsession.preview.winmd"
-winmd_sha256 = "4D7C49D34778028DA6DD08991765A7E37A0D57564F5B57CA4F7628CDC8917E5E"
-namespace = "Windows.AI.IsolationSession.Preview"
\ No newline at end of file
+winmd_sha256 = "C6115B52525B06316BE77BEEB4FC4624C5CBB1CEC02E5493D86C46D90FABD6A9"
+namespace = "Windows.AI.IsolationSession.Preview"
+runtime_version = "2026_09"
+build_guid = "4b65b23a-aecf-b892-ff92-ba6b0c005688"
diff --git a/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1 b/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1
index 8e2962c53..06d379083 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1
+++ b/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1
@@ -144,17 +144,26 @@ try {
         'metadata/windows.ai.isolationsession.preview.winmd',
         'metadata/GENERATION_INFO.toml',
         'runtime/IsoSessionApp.dll',
-        'runtime/IsoSessionApp.runtimeversion'
+        'runtime/IsoSession.manifest'
     )
     foreach ($entryName in $requiredEntries) {
         [void] (Get-ZipEntryBytes -Archive $archive -EntryName $entryName)
     }
 
-    $runtimeVersion = Convert-BytesToText (
-        Get-ZipEntryBytes -Archive $archive -EntryName 'runtime/IsoSessionApp.runtimeversion')
-    $runtimeVersion = $runtimeVersion.Trim()
-    if ($runtimeVersion -ne $runtimeVersionExpected) {
-        throw "Runtime sidecar '$runtimeVersion' does not match package version '$packageVersion' (expected '$runtimeVersionExpected')."
+    $runtimeVersion = $runtimeVersionExpected
+    $runtimeInstance = $runtimeVersion.Replace('_', '.')
+    $runtimeManifest = Convert-BytesToText (
+        Get-ZipEntryBytes -Archive $archive -EntryName 'runtime/IsoSession.manifest')
+    if ($runtimeManifest -match '\$\(MonthId\)' -or
+        $runtimeManifest -notmatch [regex]::Escape("name=`"$runtimeInstance`"")) {
+        throw "Runtime manifest does not match package version '$packageVersion' (expected instance '$runtimeInstance')."
+    }
+    foreach ($requiredFragment in @(
+            '<assemblyIdentity name="IsoSession.Runtime"',
+            '<file name="IsoSessionApp.dll"')) {
+        if ($runtimeManifest -notmatch [regex]::Escape($requiredFragment)) {
+            throw "Runtime manifest is missing '$requiredFragment'."
+        }
     }
 
     $packageGenerationInfo = Convert-BytesToText (

From 5ea82d6d1ff761e72cb7a500490ef92a64570b22 Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Thu, 24 Sep 2026 13:37:40 -0700
Subject: [PATCH 15/26] Repin lean IsolationSession SDK package

Remove the obsolete runtime sidecars from the pinned package and update the verified package hash.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: e37e4eb2-1e56-42ca-a48e-4b35e9100d16
---
 src/mxc-sdk/build/build_mxc_build_common.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/mxc-sdk/build/build_mxc_build_common.rs b/src/mxc-sdk/build/build_mxc_build_common.rs
index 750acd80a..eeb947046 100644
--- a/src/mxc-sdk/build/build_mxc_build_common.rs
+++ b/src/mxc-sdk/build/build_mxc_build_common.rs
@@ -20,7 +20,7 @@ pub mod isolation_session_sdk {
     pub const PACKAGE_ID: &str = "Microsoft.Windows.AI.IsolationSession.SDK";
     pub const PACKAGE_VERSION: &str = "0.202609.0";
     pub const PACKAGE_SHA256: &str =
-        "5211a15b68f900fa92a47c96c4c59fe4112caaef6c6b1414623e8d4449528bff";
+        "2ce0c920f55b879eec3f3841e286d4be8f53b1a5ee42d5f16f997c6e24a09397";
     pub const PACKAGE_PATH_ENV: &str = "ISOLATION_SESSION_SDK_PACKAGE";
 
     const APP_DLL: &str = "IsoSessionApp.dll";

From dc5f0466cd8df016db8f7182076030847ce2066d Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Thu, 1 Oct 2026 14:18:48 -0700
Subject: [PATCH 16/26] Make IsolationSession inbox/lifted modes consistent
 across SDKs

Align mxc-sdk and mxc_ffi with wxc: `isolation_session` is the inbox OS
API and `isolation_session_lifted` adds the lifted SDK + MSI runtime.
Their build scripts called a removed helper; they now stage the payload
through mxc_build_common::isolation_session_sdk::stage_runtime only in
lifted mode. This keeps main's CI (`--features isolation_session`,
`-p:MxcWithIsolationSession=true`) on the inbox path.

- build.bat: add --with-isolation-session-lifted; copy the payload into
  the Node/.NET runtimes only in lifted mode; stamp the lifted bit.
- .NET: add MxcIsolationSessionLifted (implies MxcWithIsolationSession);
  gate payload requirements on it, include the payload in the prebuilt
  native unit, and stamp the lifted bit.
- regfree: resolve the payload beside the module hosting mxc_ffi first,
  so in-process hosts (node.exe, dotnet) find it beside mxc_ffi.dll.
- mxc_build_common: resolve the checked-in, hash-pinned SDK package
  before the NuGet cache / NuGet.org; test that it matches the pin.
- Lifted error remediation names `winget install
  Microsoft.AI.IsolationSession`.
- Docs: replace stale fused private-CLSID prerequisites, describe both
  modes, the checked-in package, and the winget MSI.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: e37e4eb2-1e56-42ca-a48e-4b35e9100d16
---
 build.bat                                     | 23 +++++---
 .../backends/isolation-session/oneshot.md     | 28 ++++++----
 .../Microsoft.Mxc.Sdk.Tests.csproj            |  4 +-
 .../Microsoft.Mxc.Sdk.csproj                  | 31 +++++++----
 sdk/dotnet/README.md                          | 16 +++---
 src/ffi/mxc_ffi/Cargo.toml                    |  1 +
 src/mxc-sdk/build/build_mxc_build_common.rs   | 24 ++++++++-
 .../isolation_session_bindings/README.md      | 36 ++++++++++---
 .../isolation_session/common/error.rs         | 11 ++--
 .../isolation_session/common/manager.rs       | 18 +++----
 .../isolation_session/common/regfree.rs       | 52 ++++++++++++++++---
 11 files changed, 181 insertions(+), 63 deletions(-)

diff --git a/build.bat b/build.bat
index 9904cc331..dd61d772a 100644
--- a/build.bat
+++ b/build.bat
@@ -8,6 +8,7 @@ set "BUILD_ALL=0"
 set "WITH_NANVIX=0"
 set "WITH_WSLC=0"
 set "WITH_ISOLATION_SESSION=0"
+set "WITH_ISOLATION_SESSION_LIFTED=0"
 set "WITH_HYPERLIGHT=0"
 
 :: Parse arguments
@@ -21,6 +22,7 @@ if /i "%~1"=="--all"     ( set "BUILD_ALL=1"           & shift & goto :parse_arg
 if /i "%~1"=="--with-microvm" ( set "WITH_NANVIX=1"    & shift & goto :parse_args )
 if /i "%~1"=="--with-wslc"    ( set "WITH_WSLC=1"      & shift & goto :parse_args )
 if /i "%~1"=="--with-isolation-session" ( set "WITH_ISOLATION_SESSION=1" & shift & goto :parse_args )
+if /i "%~1"=="--with-isolation-session-lifted" ( set "WITH_ISOLATION_SESSION=1" & set "WITH_ISOLATION_SESSION_LIFTED=1" & shift & goto :parse_args )
 if /i "%~1"=="--with-hyperlight" ( set "WITH_HYPERLIGHT=1" & shift & goto :parse_args )
 if /i "%~1"=="--help"    ( goto :usage )
 if /i "%~1"=="-h"        ( goto :usage )
@@ -46,12 +48,17 @@ set "PLM_FLAGS=--target"
 if "%BUILD_CONFIG%"=="release" set "PLM_FLAGS=--release --target"
 if "%WITH_NANVIX%"=="1" set "CARGO_FLAGS=--features microvm %CARGO_FLAGS%"
 if "%WITH_WSLC%"=="1" set "CARGO_FLAGS=--features wslc %CARGO_FLAGS%"
-if "%WITH_ISOLATION_SESSION%"=="1" set "CARGO_FLAGS=--features isolation_session %CARGO_FLAGS%"
+if "%WITH_ISOLATION_SESSION_LIFTED%"=="1" (
+    set "CARGO_FLAGS=--features isolation_session_lifted %CARGO_FLAGS%"
+) else if "%WITH_ISOLATION_SESSION%"=="1" (
+    set "CARGO_FLAGS=--features isolation_session %CARGO_FLAGS%"
+)
 if "%WITH_HYPERLIGHT%"=="1" set "CARGO_FLAGS=--features hyperlight %CARGO_FLAGS%"
 set "DOTNET_CONFIG=Release"
 if "%BUILD_CONFIG%"=="debug" set "DOTNET_CONFIG=Debug"
 set "DOTNET_BUILD_PROPERTIES="
 if "%WITH_ISOLATION_SESSION%"=="1" set "DOTNET_BUILD_PROPERTIES=!DOTNET_BUILD_PROPERTIES! -p:MxcWithIsolationSession=true"
+if "%WITH_ISOLATION_SESSION_LIFTED%"=="1" set "DOTNET_BUILD_PROPERTIES=!DOTNET_BUILD_PROPERTIES! -p:MxcIsolationSessionLifted=true"
 if "%WITH_WSLC%"=="1" set "DOTNET_BUILD_PROPERTIES=!DOTNET_BUILD_PROPERTIES! -p:MxcWithWslc=true"
 
 :: Build Rust
@@ -167,10 +174,10 @@ for %%T in (x86_64-pc-windows-msvc aarch64-pc-windows-msvc) do (
             )
         )
         if "!COPY_WSLC_RUNTIME!"=="1" (
-            if "%WITH_ISOLATION_SESSION%"=="1" (
+            if "%WITH_ISOLATION_SESSION_LIFTED%"=="1" (
                 for %%B in (IsoSessionApp.dll IsoSession.manifest) do (
                     if not exist "!BIN_DIR!\%%B" (
-                        echo ERROR: IsolationSession-enabled Node runtime is missing !BIN_DIR!\%%B
+                        echo ERROR: Lifted IsolationSession Node runtime is missing !BIN_DIR!\%%B
                         exit /b 1
                     )
                     copy /Y "!BIN_DIR!\%%B" "sdk\node\bin\!SDK_ARCH!\" >nul
@@ -191,7 +198,7 @@ for %%T in (x86_64-pc-windows-msvc aarch64-pc-windows-msvc) do (
         if exist "sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\native\wxc-wslc-daemon.exe" del /Q "sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\native\wxc-wslc-daemon.exe"
         if exist "sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\native\wslcsdk.dll" del /Q "sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\native\wslcsdk.dll"
     )
-    if "!COPY_WSLC_RUNTIME!"=="1" if not "%WITH_ISOLATION_SESSION%"=="1" (
+    if "!COPY_WSLC_RUNTIME!"=="1" if not "%WITH_ISOLATION_SESSION_LIFTED%"=="1" (
         for %%B in (IsoSessionApp.dll IsoSession.manifest) do (
             if exist "sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\native\%%B" del /Q "sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\native\%%B"
         )
@@ -214,10 +221,10 @@ for %%T in (x86_64-pc-windows-msvc aarch64-pc-windows-msvc) do (
                 echo   Copied !RID!\native\%%B
             )
         )
-        if "%WITH_ISOLATION_SESSION%"=="1" if "!COPY_WSLC_RUNTIME!"=="1" (
+        if "%WITH_ISOLATION_SESSION_LIFTED%"=="1" if "!COPY_WSLC_RUNTIME!"=="1" (
             for %%B in (IsoSessionApp.dll IsoSession.manifest) do (
                 if not exist "!BIN_DIR!\%%B" (
-                    echo ERROR: IsolationSession-enabled C# runtime unit is missing !BIN_DIR!\%%B
+                    echo ERROR: Lifted IsolationSession C# runtime unit is missing !BIN_DIR!\%%B
                     exit /b 1
                 )
                 copy /Y "!BIN_DIR!\%%B" "sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\native\" >nul
@@ -226,6 +233,7 @@ for %%T in (x86_64-pc-windows-msvc aarch64-pc-windows-msvc) do (
         )
         if "!COPY_WSLC_RUNTIME!"=="1" (
             >"sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\mxc-build-features.txt" echo isolation_session=%WITH_ISOLATION_SESSION%
+            >>"sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\mxc-build-features.txt" echo isolation_session_lifted=%WITH_ISOLATION_SESSION_LIFTED%
             >>"sdk\dotnet\Microsoft.Mxc.Sdk\runtimes\!RID!\mxc-build-features.txt" echo wslc=%WITH_WSLC%
         )
     )
@@ -342,7 +350,8 @@ echo   --arm64     Build for ARM64 only
 echo   --all             Build both Windows architectures and create the .NET NuGet package
 echo   --with-microvm    Download and include NanVix micro-VM binaries
 echo   --with-wslc       Build with WSL Container (WSLC SDK) support
-echo   --with-isolation-session   Build with IsolationSession backend (IsoEnvBroker)
+echo   --with-isolation-session   Build with IsolationSession backend (inbox OS API)
+echo   --with-isolation-session-lifted   Build with lifted IsolationSession (NuGet SDK + MSI runtime)
 echo   --with-hyperlight         Build with Hyperlight (micro-VM) backend (x86_64 only)
 echo   -h, --help        Show this help
 echo.
diff --git a/docs/development/architecture/backends/isolation-session/oneshot.md b/docs/development/architecture/backends/isolation-session/oneshot.md
index 05548bd79..a5911b5d7 100644
--- a/docs/development/architecture/backends/isolation-session/oneshot.md
+++ b/docs/development/architecture/backends/isolation-session/oneshot.md
@@ -204,7 +204,8 @@ per-machine fact owned by the MSI:
 
 ### Apartment initialization
 
-The private-CLSID path obtains the factory via `CoCreateInstance` and calls
+The lifted path obtains the factory from the shim's `DllGetActivationFactory`
+export and calls
 `IActivationFactory::ActivateInstance` directly — which, unlike the
 inbox `RoActivateInstance` path, does **not** implicitly initialize the
 WinRT/COM apartment. `src/core/wxc/src/main.rs` calls
@@ -405,7 +406,7 @@ The following were observed during VM testing and are accepted for v0.1.
 | Risk | Mitigation |
 |---|---|
 | Bindings tied to a specific OS API version | `GENERATION_INFO.toml` records the `windows-bindgen` version and target `windows` crate version; `build.rs` panics if the workspace `windows` crate drifts from the recorded `target_windows_crate`. Regeneration is a manual step performed by a Microsoft engineer with WinMD access |
-| OS API not present on older Windows builds | the IsolationSession feature is OS-side; the runner reports a hard, actionable error when the private-CLSID activation is not fused or the runtime fails to bind — it never silently falls back to the inbox binaries. Feature-unavailable test exercises this on CI |
+| OS API not present on older Windows builds | the IsolationSession feature is OS-side; the runner reports a hard, actionable error when the lifted activation payload or MSI runtime is missing or fails to bind — it never silently falls back to the inbox binaries. Feature-unavailable test exercises this on CI |
 | New Cargo feature increases coupling | The `isolation_session` feature is off by default in the workspace; default builds and existing CI are unaffected |
 | Manual VM testing required | The OS-side service has the same constraint for any consumer (it rejects network-logon tokens). Automated suite covers what it can without the OS-side service |
 | One-shot lifecycle is heavy (full provision → start per call) | Inherent to the one-shot path; the experimental flag indicates rough edges. The state-aware lifecycle is the mitigation — it provisions once and reuses the session across `exec` calls |
@@ -416,20 +417,25 @@ The following were observed during VM testing and are accepted for v0.1.
 **For end users:**
 
 - A Windows build with the IsolationSession feature enabled.
-- The paired isolation-session **MSI** installed, providing the runtime
-  binaries at the MSI install directory recorded in HKLM `InstallDir`. MXC
-  binds this coresident runtime by reg-free private-CLSID activation (the
-  fused `<comClass>` manifest in `wxc-exec` redirects to the co-located
-  `IsoSessionApp.dll`). Without the fused manifest MXC reports a hard,
-  actionable error — it does **not** silently fall back to the inbox
-  `System32` runtime.
+- Inbox mode (`isolation_session`): nothing else; MXC activates the OS
+  runtime through normal WinRT activation.
+- Lifted mode (`isolation_session_lifted`): the version-matched runtime MSI
+  (`winget install Microsoft.AI.IsolationSession`). The build stages the SDK's
+  `IsoSessionApp.dll` shim and stamped `IsoSession.manifest` beside
+  `wxc-exec` / `mxc_ffi.dll`; MXC loads the shim's `DllGetActivationFactory`
+  by absolute path, and the shim binds the MSI runtime recorded in HKLM
+  `InstallDir`. A missing payload or runtime is a hard, actionable error — MXC
+  does **not** silently fall back to the inbox `System32` runtime.
 - WinRT/COM initialized as MTA (handled by `wxc-exec` and `regfree.rs`).
 
 **For developers:**
 
 - Standard Rust toolchain.
-- `cargo build --features isolation_session` to build the feature into
-  `wxc-exec`. Default builds skip it — no impact on existing workflows.
+- `cargo build --features isolation_session` (inbox) or
+  `--features isolation_session_lifted` (lifted SDK + MSI) to build the
+  feature into `wxc-exec`. Default builds skip it — no impact on existing
+  workflows. Lifted builds use the pinned SDK package checked in under
+  `external/windows-sdk/isolation-session`.
 - A private WinMD only when **regenerating** bindings. As long as the OS
   API hasn't changed, no regen is needed.
 
diff --git a/sdk/dotnet/Microsoft.Mxc.Sdk.Tests/Microsoft.Mxc.Sdk.Tests.csproj b/sdk/dotnet/Microsoft.Mxc.Sdk.Tests/Microsoft.Mxc.Sdk.Tests.csproj
index 6bcf850b1..98b636a7f 100644
--- a/sdk/dotnet/Microsoft.Mxc.Sdk.Tests/Microsoft.Mxc.Sdk.Tests.csproj
+++ b/sdk/dotnet/Microsoft.Mxc.Sdk.Tests/Microsoft.Mxc.Sdk.Tests.csproj
@@ -11,6 +11,7 @@
     <!-- The native detail struct is marshalled with raw pointers. -->
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <DefineConstants Condition="'$(MxcWithWslc)' == 'true'">$(DefineConstants);MXC_WITH_WSLC</DefineConstants>
+    <MxcWithIsolationSession Condition="'$(MxcIsolationSessionLifted)' == 'true'">true</MxcWithIsolationSession>
     <DefineConstants Condition="'$(MxcWithIsolationSession)' == 'true'">$(DefineConstants);MXC_WITH_ISOLATION_SESSION</DefineConstants>
     <MxcSrcDir>$(MSBuildProjectDirectory)/../../../src</MxcSrcDir>
     <MxcTestCargoTargetDir>$(MxcSrcDir)/target/dotnet-test-support</MxcTestCargoTargetDir>
@@ -18,7 +19,8 @@
          including when the managed tests themselves run in Release. -->
     <MxcTestCargoProfileDir>debug</MxcTestCargoProfileDir>
     <MxcTestCargoFeatures>dotnetsdk test-support</MxcTestCargoFeatures>
-    <MxcTestCargoFeatures Condition="'$(MxcWithIsolationSession)' == 'true' and $([MSBuild]::IsOSPlatform('Windows'))">$(MxcTestCargoFeatures) isolation_session</MxcTestCargoFeatures>
+    <MxcTestCargoFeatures Condition="'$(MxcWithIsolationSession)' == 'true' and '$(MxcIsolationSessionLifted)' != 'true' and $([MSBuild]::IsOSPlatform('Windows'))">$(MxcTestCargoFeatures) isolation_session</MxcTestCargoFeatures>
+    <MxcTestCargoFeatures Condition="'$(MxcIsolationSessionLifted)' == 'true' and $([MSBuild]::IsOSPlatform('Windows'))">$(MxcTestCargoFeatures) isolation_session_lifted</MxcTestCargoFeatures>
     <MxcTestCargoFeatures Condition="'$(MxcWithWslc)' == 'true' and $([MSBuild]::IsOSPlatform('Windows'))">$(MxcTestCargoFeatures) wslc</MxcTestCargoFeatures>
     <MxcTestNativeFileName Condition="$([MSBuild]::IsOSPlatform('Windows'))">mxc_ffi.dll</MxcTestNativeFileName>
     <MxcTestNativeFileName Condition="$([MSBuild]::IsOSPlatform('OSX'))">libmxc_ffi.dylib</MxcTestNativeFileName>
diff --git a/sdk/dotnet/Microsoft.Mxc.Sdk/Microsoft.Mxc.Sdk.csproj b/sdk/dotnet/Microsoft.Mxc.Sdk/Microsoft.Mxc.Sdk.csproj
index f141351f5..20a14dd9e 100644
--- a/sdk/dotnet/Microsoft.Mxc.Sdk/Microsoft.Mxc.Sdk.csproj
+++ b/sdk/dotnet/Microsoft.Mxc.Sdk/Microsoft.Mxc.Sdk.csproj
@@ -45,11 +45,16 @@
 
     <!-- Mirrors build.bat's optional-backend switches, including their
          defaults. The two build paths choose this set independently. -->
+    <!-- MxcIsolationSessionLifted selects the lifted SDK + MSI runtime and implies
+         MxcWithIsolationSession; without it the backend uses the inbox OS API. -->
+    <MxcIsolationSessionLifted Condition="'$(MxcIsolationSessionLifted)' == ''">false</MxcIsolationSessionLifted>
+    <MxcWithIsolationSession Condition="'$(MxcIsolationSessionLifted)' == 'true'">true</MxcWithIsolationSession>
     <MxcWithIsolationSession Condition="'$(MxcWithIsolationSession)' == ''">false</MxcWithIsolationSession>
     <MxcWithWslc Condition="'$(MxcWithWslc)' == ''">false</MxcWithWslc>
 
     <MxcCargoFeatures>dotnetsdk</MxcCargoFeatures>
-    <MxcCargoFeatures Condition="'$(MxcWithIsolationSession)' == 'true' and $([MSBuild]::IsOSPlatform('Windows'))">$(MxcCargoFeatures) isolation_session</MxcCargoFeatures>
+    <MxcCargoFeatures Condition="'$(MxcWithIsolationSession)' == 'true' and '$(MxcIsolationSessionLifted)' != 'true' and $([MSBuild]::IsOSPlatform('Windows'))">$(MxcCargoFeatures) isolation_session</MxcCargoFeatures>
+    <MxcCargoFeatures Condition="'$(MxcIsolationSessionLifted)' == 'true' and $([MSBuild]::IsOSPlatform('Windows'))">$(MxcCargoFeatures) isolation_session_lifted</MxcCargoFeatures>
     <MxcCargoFeatures Condition="'$(MxcWithWslc)' == 'true' and $([MSBuild]::IsOSPlatform('Windows'))">$(MxcCargoFeatures) wslc</MxcCargoFeatures>
 
     <MxcUnsupportedOptionalBackends Condition="!$([MSBuild]::IsOSPlatform('Windows')) and ('$(MxcWithIsolationSession)' == 'true' or '$(MxcWithWslc)' == 'true')">true</MxcUnsupportedOptionalBackends>
@@ -67,16 +72,18 @@
     <MxcNativeUnitFileNames>$(MxcNativeFileName)</MxcNativeUnitFileNames>
     <MxcNativeUnitFileNames Condition="'$(MxcSidecarFileName)' != ''">$(MxcNativeFileName) and $(MxcSidecarFileName)</MxcNativeUnitFileNames>
     <MxcNativeUnitFileNames Condition="'$(MxcWithWslc)' == 'true' and $([MSBuild]::IsOSPlatform('Windows'))">$(MxcNativeUnitFileNames), wxc-wslc-daemon.exe, and wslcsdk.dll</MxcNativeUnitFileNames>
-    <MxcNativeUnitFileNames Condition="'$(MxcWithIsolationSession)' == 'true' and $([MSBuild]::IsOSPlatform('Windows'))">$(MxcNativeUnitFileNames), IsoSessionApp.dll, and IsoSession.manifest</MxcNativeUnitFileNames>
+    <MxcNativeUnitFileNames Condition="'$(MxcIsolationSessionLifted)' == 'true' and $([MSBuild]::IsOSPlatform('Windows'))">$(MxcNativeUnitFileNames), IsoSessionApp.dll, and IsoSession.manifest</MxcNativeUnitFileNames>
     <MxcNativeUnitExpectedCount>1</MxcNativeUnitExpectedCount>
     <MxcNativeUnitExpectedCount Condition="'$(MxcSidecarFileName)' != ''">2</MxcNativeUnitExpectedCount>
     <MxcNativeUnitExpectedCount Condition="'$(MxcWithWslc)' == 'true' and $([MSBuild]::IsOSPlatform('Windows'))">4</MxcNativeUnitExpectedCount>
-    <MxcNativeUnitExpectedCount Condition="'$(MxcWithIsolationSession)' == 'true' and $([MSBuild]::IsOSPlatform('Windows'))">$([MSBuild]::Add($(MxcNativeUnitExpectedCount), 2))</MxcNativeUnitExpectedCount>
+    <MxcNativeUnitExpectedCount Condition="'$(MxcIsolationSessionLifted)' == 'true' and $([MSBuild]::IsOSPlatform('Windows'))">$([MSBuild]::Add($(MxcNativeUnitExpectedCount), 2))</MxcNativeUnitExpectedCount>
     <MxcIsolationSessionFeatureBit>0</MxcIsolationSessionFeatureBit>
     <MxcIsolationSessionFeatureBit Condition="'$(MxcWithIsolationSession)' == 'true'">1</MxcIsolationSessionFeatureBit>
+    <MxcIsolationSessionLiftedFeatureBit>0</MxcIsolationSessionLiftedFeatureBit>
+    <MxcIsolationSessionLiftedFeatureBit Condition="'$(MxcIsolationSessionLifted)' == 'true'">1</MxcIsolationSessionLiftedFeatureBit>
     <MxcWslcFeatureBit>0</MxcWslcFeatureBit>
     <MxcWslcFeatureBit Condition="'$(MxcWithWslc)' == 'true'">1</MxcWslcFeatureBit>
-    <MxcExpectedOptionalBackendStamp>isolation_session=$(MxcIsolationSessionFeatureBit);wslc=$(MxcWslcFeatureBit)</MxcExpectedOptionalBackendStamp>
+    <MxcExpectedOptionalBackendStamp>isolation_session=$(MxcIsolationSessionFeatureBit);isolation_session_lifted=$(MxcIsolationSessionLiftedFeatureBit);wslc=$(MxcWslcFeatureBit)</MxcExpectedOptionalBackendStamp>
 
     <MxcHostRid>$(NETCoreSdkPortableRuntimeIdentifier)</MxcHostRid>
     <MxcHostArch>$(MxcHostRid.Substring($([MSBuild]::Add($(MxcHostRid.LastIndexOf('-')), 1))))</MxcHostArch>
@@ -215,14 +222,14 @@
                      Condition="'$(MxcWithWslc)' == 'true'" />
       <MxcIsolationSessionRuntime Include="@(MxcFfiArtifact->'%(RootDir)%(Directory)IsoSessionApp.dll');
                                            @(MxcFfiArtifact->'%(RootDir)%(Directory)IsoSession.manifest')"
-                                  Condition="'$(MxcWithIsolationSession)' == 'true'" />
+                                  Condition="'$(MxcIsolationSessionLifted)' == 'true'" />
       <MxcNativeUnit Include="@(MxcIsolationSessionRuntime)"
-                     Condition="'$(MxcWithIsolationSession)' == 'true'" />
+                     Condition="'$(MxcIsolationSessionLifted)' == 'true'" />
     </ItemGroup>
     <Error Condition="'$(MxcWithWslc)' == 'true' and !Exists('@(MxcWslcSdkDll)')"
            Text="mxc: the WSLC-enabled cargo build did not stage wslcsdk.dll beside mxc_ffi." />
-    <Error Condition="'$(MxcWithIsolationSession)' == 'true' and @(MxcIsolationSessionRuntime->Count()) != 2"
-           Text="mxc: the IsolationSession-enabled cargo build did not stage the complete lifted activation payload beside mxc_ffi." />
+    <Error Condition="'$(MxcIsolationSessionLifted)' == 'true' and @(MxcIsolationSessionRuntime->Count()) != 2"
+           Text="mxc: the lifted IsolationSession cargo build did not stage the complete lifted activation payload beside mxc_ffi." />
     <Error Condition="!Exists('$(MxcGeneratedBindings)')"
            Text="Binding generation did not produce $(MxcGeneratedBindings). Ensure the Rust toolchain (cargo) is installed and on PATH." />
   </Target>
@@ -240,12 +247,16 @@
            Text="mxc: prebuilt native directory '$(MxcPrebuiltNativeDir)' is missing wxc-wslc-daemon.exe." />
     <Error Condition="'$(MxcWithWslc)' == 'true' and $([MSBuild]::IsOSPlatform('Windows')) and !Exists('$(MxcPrebuiltNativeDir)/wslcsdk.dll')"
            Text="mxc: prebuilt native directory '$(MxcPrebuiltNativeDir)' is missing wslcsdk.dll." />
+    <Error Condition="'$(MxcIsolationSessionLifted)' == 'true' and $([MSBuild]::IsOSPlatform('Windows')) and (!Exists('$(MxcPrebuiltNativeDir)/IsoSessionApp.dll') or !Exists('$(MxcPrebuiltNativeDir)/IsoSession.manifest'))"
+           Text="mxc: prebuilt native directory '$(MxcPrebuiltNativeDir)' is missing the lifted IsolationSession activation payload (IsoSessionApp.dll and IsoSession.manifest)." />
     <ItemGroup>
       <MxcNativeUnit Include="$(MxcPrebuiltNativeDir)/$(MxcNativeFileName)" />
       <MxcNativeUnit Include="$(MxcPrebuiltNativeDir)/$(MxcSidecarFileName)"
                      Condition="'$(MxcSidecarFileName)' != ''" />
       <MxcNativeUnit Include="$(MxcPrebuiltNativeDir)/wxc-wslc-daemon.exe;$(MxcPrebuiltNativeDir)/wslcsdk.dll"
                      Condition="'$(MxcWithWslc)' == 'true' and $([MSBuild]::IsOSPlatform('Windows'))" />
+      <MxcNativeUnit Include="$(MxcPrebuiltNativeDir)/IsoSessionApp.dll;$(MxcPrebuiltNativeDir)/IsoSession.manifest"
+                     Condition="'$(MxcIsolationSessionLifted)' == 'true' and $([MSBuild]::IsOSPlatform('Windows'))" />
     </ItemGroup>
     <Error Condition="@(MxcNativeUnit->Count()) != $(MxcNativeUnitExpectedCount)"
            Text="mxc: prebuilt native directory '$(MxcPrebuiltNativeDir)' does not contain the complete native unit ($(MxcNativeUnitFileNames))." />
@@ -333,8 +344,8 @@
          Text="mxc: pre-staged $(MxcOtherWindowsRid) is missing mxc_ffi.dll or plm.exe. Rebuild that RID before creating a multi-RID package." />
   <Error Condition="@(MxcOtherRidNative->Count()) != 0 and '$(MxcWithWslc)' == 'true' and (!Exists('runtimes/$(MxcOtherWindowsRid)/native/wxc-wslc-daemon.exe') or !Exists('runtimes/$(MxcOtherWindowsRid)/native/wslcsdk.dll'))"
          Text="mxc: pre-staged $(MxcOtherWindowsRid) does not contain the complete WSLC runtime unit. Rebuild it with WSLC enabled." />
-  <Error Condition="@(MxcOtherRidNative->Count()) != 0 and '$(MxcWithIsolationSession)' == 'true' and (!Exists('runtimes/$(MxcOtherWindowsRid)/native/IsoSessionApp.dll') or !Exists('runtimes/$(MxcOtherWindowsRid)/native/IsoSession.manifest'))"
-         Text="mxc: pre-staged $(MxcOtherWindowsRid) does not contain the complete lifted IsolationSession activation payload. Rebuild it with IsolationSession enabled." />
+  <Error Condition="@(MxcOtherRidNative->Count()) != 0 and '$(MxcIsolationSessionLifted)' == 'true' and (!Exists('runtimes/$(MxcOtherWindowsRid)/native/IsoSessionApp.dll') or !Exists('runtimes/$(MxcOtherWindowsRid)/native/IsoSession.manifest'))"
+         Text="mxc: pre-staged $(MxcOtherWindowsRid) does not contain the complete lifted IsolationSession activation payload. Rebuild it with lifted IsolationSession enabled." />
   <Error Condition="@(MxcOtherRidNative->Count()) != 0 and !Exists('runtimes/$(MxcOtherWindowsRid)/mxc-build-features.txt')"
          Text="mxc: pre-staged $(MxcOtherWindowsRid) has no optional-backend feature stamp. Rebuild that RID before creating a multi-RID package." />
   <Error Condition="@(MxcOtherRidNative->Count()) != 0 and '$(MxcOtherRidFeatureStamp)' != '$(MxcExpectedOptionalBackendStamp)'"
diff --git a/sdk/dotnet/README.md b/sdk/dotnet/README.md
index c1ca418f8..a514f6d6d 100644
--- a/sdk/dotnet/README.md
+++ b/sdk/dotnet/README.md
@@ -238,12 +238,16 @@ host backend capabilities; availability is advisory and launch-time
 validation still applies.
 
 The switches compose, so either backend can be enabled independently. Passing
-one on Linux or macOS fails the build instead of silently ignoring it. An
-IsolationSession build additionally stages and packages the lifted activation
-unit from the pinned IsolationSession SDK NuGet: `IsoSessionApp.dll` and a
-stamped `IsoSession.manifest`. These files let in-process Rust and C# callers
-load the shim and request its WinRT activation factory directly without
-binding the inbox WinRT catalog. A WSLC build
+one on Linux or macOS fails the build instead of silently ignoring it.
+`MxcWithIsolationSession` uses the inbox OS API. Add
+`-p:MxcIsolationSessionLifted=true` (which implies `MxcWithIsolationSession`)
+to build the lifted mode instead, which additionally stages and packages the
+lifted activation unit from the pinned IsolationSession SDK NuGet:
+`IsoSessionApp.dll` and a stamped `IsoSession.manifest`. These files let
+in-process Rust and C# callers load the shim beside `mxc_ffi.dll` and request
+its WinRT activation factory directly without binding the inbox WinRT catalog.
+Lifted mode needs the matching runtime MSI on the host
+(`winget install Microsoft.AI.IsolationSession`). A WSLC build
 additionally builds, stages, and packages `wxc-wslc-daemon.exe` and the pinned
 `wslcsdk.dll`. Every selected backend's native files must stay together beside
 the loaded `mxc_ffi.dll`. `build.bat --with-wslc` stages the same complete unit
diff --git a/src/ffi/mxc_ffi/Cargo.toml b/src/ffi/mxc_ffi/Cargo.toml
index 713376888..21b326c6a 100644
--- a/src/ffi/mxc_ffi/Cargo.toml
+++ b/src/ffi/mxc_ffi/Cargo.toml
@@ -28,6 +28,7 @@ wslc = ["mxc-sdk/wslc"]
 # IsolationSession backend (Windows only). Needed by the
 # `attached_console_ffi` example.
 isolation_session = ["mxc-sdk/isolation_session"]
+# Lifted SDK + MSI runtime: generated bindings and the staged activation payload.
 isolation_session_lifted = ["isolation_session", "mxc-sdk/isolation_session_lifted"]
 # Opt-in C# SDK P/Invoke code generation (csbindgen) in build.rs. Off by
 # default so normal builds don't compile csbindgen or write into the source
diff --git a/src/mxc-sdk/build/build_mxc_build_common.rs b/src/mxc-sdk/build/build_mxc_build_common.rs
index eeb947046..47eb0c91a 100644
--- a/src/mxc-sdk/build/build_mxc_build_common.rs
+++ b/src/mxc-sdk/build/build_mxc_build_common.rs
@@ -36,6 +36,13 @@ pub mod isolation_session_sdk {
             return Ok(path);
         }
 
+        let vendored = vendored_package_path();
+        if vendored.is_file() {
+            verify_package(&vendored)?;
+            println!("cargo:rerun-if-changed={}", vendored.display());
+            return Ok(vendored);
+        }
+
         let package_name = format!(
             "{}.{}.nupkg",
             PACKAGE_ID.to_ascii_lowercase(),
@@ -120,6 +127,13 @@ pub mod isolation_session_sdk {
         Ok(package_path)
     }
 
+    /// The pinned package checked in under `external/windows-sdk/isolation-session`.
+    pub fn vendored_package_path() -> PathBuf {
+        Path::new(env!("CARGO_MANIFEST_DIR"))
+            .join("../../../external/windows-sdk/isolation-session")
+            .join(format!("{PACKAGE_ID}.{PACKAGE_VERSION}.nupkg"))
+    }
+
     pub fn stage_runtime() -> Result<(), String> {
         let package = resolve_package()?;
         let app_dll = read_entry(&package, APP_DLL)?;
@@ -258,7 +272,15 @@ pub mod isolation_session_sdk {
 
     #[cfg(test)]
     mod tests {
-        use super::{package_runtime_instance, validate_runtime_manifest};
+        use super::{
+            package_runtime_instance, validate_runtime_manifest, vendored_package_path,
+            verify_package,
+        };
+
+        #[test]
+        fn vendored_package_matches_pin() {
+            verify_package(&vendored_package_path()).unwrap();
+        }
 
         const MANIFEST: &str = "\
 <assembly>
diff --git a/src/mxc-sdk/build/isolation_session_bindings/README.md b/src/mxc-sdk/build/isolation_session_bindings/README.md
index f3a2404f8..957f6a34b 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/README.md
+++ b/src/mxc-sdk/build/isolation_session_bindings/README.md
@@ -13,9 +13,24 @@ exact package version pinned in
 endpoint, verify its SHA-256, and cache it in the standard global NuGet package
 directory.
 
-For offline builds or validation before a package is public, set
-`ISOLATION_SESSION_SDK_PACKAGE` to the exact `.nupkg` path. The same pinned hash
-is enforced for this override.
+1. `ISOLATION_SESSION_SDK_PACKAGE`, if set, for validating a different local
+   copy of the same package.
+2. The standard global NuGet package cache, then the NuGet.org V3
+   flat-container endpoint (cached after download).
+
+## Runtime prerequisite
+
+Lifted binaries bind the version-pinned runtime installed by the
+IsolationSession MSI. Install the matching release with:
+
+```powershell
+winget install Microsoft.AI.IsolationSession
+```
+
+The build stages `IsoSessionApp.dll` and `IsoSession.manifest` beside
+`wxc-exec.exe` and `mxc_ffi.dll`. MXC never falls back to the inbox runtime
+when the payload or MSI is missing; it reports `BackendUnavailable` with this
+remediation.
 
 ## Build commands
 
@@ -29,18 +44,23 @@ cargo build --release -p wxc --features isolation_session
 cargo build --release -p wxc --features isolation_session_lifted
 ```
 
+The same features exist on `mxc-sdk` and `mxc_ffi`. From the repository root,
+`build.bat --with-isolation-session` builds inbox mode and
+`build.bat --with-isolation-session-lifted` builds lifted mode and copies the
+payload into the Node and .NET SDK runtimes. The .NET SDK uses
+`-p:MxcWithIsolationSession=true` (inbox) or `-p:MxcIsolationSessionLifted=true`
+(lifted).
+
 Lifted mode fails the build if package download, integrity validation, metadata
 generation, or activation-payload staging fails. It never silently produces an
 inbox-mode binary.
 
 ## Updating the lifted SDK
 
-1. Publish the new `Microsoft.Windows.AI.IsolationSession.SDK` package version
-   to NuGet.org.
-2. Update `PACKAGE_VERSION` and `PACKAGE_SHA256` in
+1. Update `PACKAGE_VERSION` and `PACKAGE_SHA256` in
    `src/mxc-sdk/build/build_mxc_build_common.rs`.
-3. Update `GENERATION_INFO.toml` with the package and WinMD provenance.
-4. Build and test both feature configurations.
+2. Update `GENERATION_INFO.toml` with the package and WinMD provenance.
+3. Build and test both feature configurations.
 
 `windows-bindgen` is pinned to `=0.62.1` in `src/mxc-sdk/Cargo.toml`
 and must stay in lockstep with the workspace `windows` crate's major.minor
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/error.rs b/src/mxc-sdk/src/backends/isolation_session/common/error.rs
index c8548e85a..d2d581a50 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/error.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/error.rs
@@ -363,14 +363,16 @@ pub(super) fn lifted_payload_missing(operation: &str) -> IsolationSessionError {
         Some(REGDB_E_CLASSNOTREG_HRESULT),
         Some(
             "IsolationSession lifted activation was not taken: IsoSessionApp.dll and \
-             IsoSession.manifest are not co-located with this executable, so the \
-             version-pinned MSI-installed IsolationSession runtime could not be bound. MXC will \
+             IsoSession.manifest are not co-located with this module or executable, or the \
+             shim reported the runtime class as not registered, so the version-pinned \
+             MSI-installed IsolationSession runtime could not be bound. MXC will \
              not silently fall back to the inbox System32 runtime."
                 .to_string(),
         ),
         Some(
             "Rebuild against the Microsoft.Windows.AI.IsolationSession.SDK NuGet so \
-             IsoSessionApp.dll and its stamped IsoSession.manifest are staged beside the host."
+             IsoSessionApp.dll and its stamped IsoSession.manifest are staged beside the host, \
+             and install the matching runtime MSI (`winget install Microsoft.AI.IsolationSession`)."
                 .to_string(),
         ),
     ))
@@ -876,7 +878,8 @@ mod tests {
         assert!(mapped
             .remediation
             .as_deref()
-            .is_some_and(|r| r.contains("IsolationSession.SDK NuGet")));
+            .is_some_and(|r| r.contains("IsolationSession.SDK NuGet")
+                && r.contains("winget install Microsoft.AI.IsolationSession")));
     }
 
     #[test]
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
index ab62ffe9f..7e9973bea 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
@@ -83,13 +83,13 @@ unsafe impl Send for MtaReference {}
 unsafe impl Sync for MtaReference {}
 
 /// Activates the in-proc IsolationSession runtime factory and returns the
-/// instance. Activation is redirected reg-free through the fused private-CLSID
-/// activator (see [`super::regfree`]) to the co-located `IsoSessionApp.dll`,
-/// binding the version-pinned MSI-installed runtime.
+/// instance. Activation goes through the `DllGetActivationFactory` export of
+/// the co-located `IsoSessionApp.dll` shim (see [`super::regfree`]), binding
+/// the version-pinned MSI-installed runtime.
 ///
-/// There is **no inbox fallback**: if the private-CLSID activator is not fused
-/// beside this executable, this returns a hard [`lifted_payload_missing`] error rather
-/// than silently binding the inbox `System32` runtime.
+/// There is **no inbox fallback**: if the lifted payload is not staged beside
+/// this module or executable, this returns a hard [`lifted_payload_missing`]
+/// error rather than silently binding the inbox `System32` runtime.
 #[cfg(feature = "lifted_msi")]
 fn check_service_available_and_activate() -> Result<IsoSessionOps, IsolationSessionError> {
     match super::regfree::activate_from_adjacent_shim::<IsoSessionOps>() {
@@ -98,14 +98,14 @@ fn check_service_available_and_activate() -> Result<IsoSessionOps, IsolationSess
         // testable without depending on whether this host can activate the
         // API at all.
         Some(Err(e)) => Err(activation_error(e.code().0 as u32, &e.message())),
-        // The fused manifest is absent: refuse to silently bind the inbox
+        // The lifted payload is absent: refuse to silently bind the inbox
         // runtime, and surface an actionable hard error instead.
         None => Err(lifted_payload_missing(op::ACTIVATE)),
     }
 }
 
-/// Activates the system-registered API for embedders such as the Rust and C#
-/// SDKs. They do not carry `wxc-exec`'s fused lifted-MSI activation manifest.
+/// Inbox mode: activates the system-registered OS API through normal WinRT
+/// activation.
 #[cfg(not(feature = "lifted_msi"))]
 fn check_service_available_and_activate() -> Result<IsoSessionOps, IsolationSessionError> {
     IsoSessionOps::new().map_err(|e| activation_error(e.code().0 as u32, &e.message()))
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
index acc261b97..7f30e3b3b 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
@@ -4,7 +4,7 @@
 //! Activation for the lifted IsolationSession runtime.
 //!
 //! The lifted SDK places `IsoSessionApp.dll` and a stamped
-//! `IsoSession.manifest` beside the host. The shim exports
+//! `IsoSession.manifest` beside the host module (or executable). The shim exports
 //! `DllGetActivationFactory`; loading that export directly prevents the inbox
 //! WinRT catalog from shadowing the lifted implementation.
 
@@ -110,17 +110,57 @@ fn resolve_get_activation_factory(
     Ok(*GET_ACTIVATION_FACTORY.get().unwrap_or(&get_factory))
 }
 
+/// Finds the staged payload beside the module hosting this code first, so
+/// in-process hosts (node.exe, dotnet) resolve it beside `mxc_ffi.dll`, then
+/// beside the executable or its parent (`target\<profile>\deps` tests).
 fn adjacent_runtime_directory() -> Option<PathBuf> {
-    let executable = std::env::current_exe().ok()?;
-    let executable_directory = executable.parent()?;
-    let directory = [Some(executable_directory), executable_directory.parent()]
+    let module_directory = current_module_path().and_then(|path| path.parent().map(PathBuf::from));
+    let executable_directory = std::env::current_exe()
+        .ok()
+        .and_then(|path| path.parent().map(PathBuf::from));
+    let executable_parent = executable_directory
+        .as_deref()
+        .and_then(|directory| directory.parent().map(PathBuf::from));
+
+    [module_directory, executable_directory, executable_parent]
         .into_iter()
         .flatten()
         .find(|directory| {
             directory.join(SHIM_NAME).is_file() && directory.join(MANIFEST_NAME).is_file()
         })
-        .map(PathBuf::from);
-    directory
+}
+
+fn current_module_path() -> Option<PathBuf> {
+    use std::os::windows::ffi::OsStringExt;
+    use windows::Win32::Foundation::HMODULE;
+    use windows::Win32::System::LibraryLoader::{
+        GetModuleFileNameW, GetModuleHandleExW, GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
+        GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
+    };
+
+    let mut module = HMODULE::default();
+    let address = current_module_path as *const () as *const u16;
+    unsafe {
+        GetModuleHandleExW(
+            GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
+            PCWSTR(address),
+            &mut module,
+        )
+    }
+    .ok()?;
+
+    let mut buffer = vec![0u16; 1024];
+    loop {
+        let length = unsafe { GetModuleFileNameW(Some(module), &mut buffer) } as usize;
+        if length == 0 {
+            return None;
+        }
+        if length < buffer.len() {
+            buffer.truncate(length);
+            return Some(PathBuf::from(std::ffi::OsString::from_wide(&buffer)));
+        }
+        buffer.resize(buffer.len() * 2, 0);
+    }
 }
 
 fn activate_from_factory<T>(factory: IActivationFactory) -> windows_core::Result<T>

From 101bfe0f8a31967f49255b4dbffe7de1ddd02439 Mon Sep 17 00:00:00 2001
From: Dom Giandinoto <domgiandinoto@gmail.com>
Date: Mon, 5 Oct 2026 11:15:43 -0700
Subject: [PATCH 17/26] IsoSession Runtime version checks (#1376)

Co-authored-by: Dom Giandinoto <dgiandinoto@microsoft.com>
---
 .../backends/isolation-session/oneshot.md     |   7 +
 .../isolation-session/state-aware-rust.md     |  11 +-
 .../isolation_session/common/availability.rs  |   7 +
 .../isolation_session/common/error.rs         |  24 +++
 .../isolation_session/common/manager.rs       |   5 +-
 .../isolation_session/common/regfree.rs       | 197 +++++++++++++++++-
 6 files changed, 246 insertions(+), 5 deletions(-)

diff --git a/docs/development/architecture/backends/isolation-session/oneshot.md b/docs/development/architecture/backends/isolation-session/oneshot.md
index a5911b5d7..6618c85aa 100644
--- a/docs/development/architecture/backends/isolation-session/oneshot.md
+++ b/docs/development/architecture/backends/isolation-session/oneshot.md
@@ -189,6 +189,13 @@ machine-wide registration or private classic-COM classes.
   the MSI and the SDK nuget from the same OS commit).
 - **`Some(Ok(factory))`** — the coresident factory is used.
 
+### Framework verification
+
+Before any session work, MXC asks the co-located `IsoSessionApp.dll` whether the
+matching IsolationSession runtime is actually installed and loadable on this
+machine. MXC refuses to continue on any failure result, and raises
+`error::framework_unavailable`.
+
 ### Runtime folder resolution
 
 Runtime-folder resolution is owned entirely by `IsoSessionApp.dll` (C++,
diff --git a/docs/development/architecture/backends/isolation-session/state-aware-rust.md b/docs/development/architecture/backends/isolation-session/state-aware-rust.md
index f7ac7d06c..138967aaa 100644
--- a/docs/development/architecture/backends/isolation-session/state-aware-rust.md
+++ b/docs/development/architecture/backends/isolation-session/state-aware-rust.md
@@ -436,7 +436,7 @@ wire-format `MxcError` codes via `map_lifecycle_error`:
 | `IsolationSessionError` variant | Wire `error.code` | Trigger |
 |---|---|---|
 | `Policy(...)` | `policy_validation` | A structurally representable request violates a backend semantic invariant — see the honor matrix above. Rejected by `validate_<phase>` hooks (state-aware) or `validate_runner` (one-shot); fields excluded by an exact request root fail earlier as `malformed_request`. |
-| `ServiceUnavailable(...)` | `backend_unavailable` | Activation failure of the in-proc IsolationSession runtime API: it is unavailable on this OS build (not registered, or the OS feature gate is off). HRESULTs `CLASS_E_CLASSNOTAVAILABLE` (`0x80040111`) or `REGDB_E_CLASSNOTREG` (`0x80040154`). |
+| `ServiceUnavailable(...)` | `backend_unavailable` | Activation failure of the in-proc IsolationSession runtime API: it is unavailable on this OS build (not registered, or the OS feature gate is off). HRESULTs `CLASS_E_CLASSNOTAVAILABLE` (`0x80040111`) or `REGDB_E_CLASSNOTREG` (`0x80040154`). Also raised when the pre-activation framework check refuses — see [Framework verification](#framework-verification) below. |
 | `Stale(...)` | `stale_id` | The OS service reports `HRESULT_FROM_WIN32(ERROR_NOT_FOUND)` (`0x80070490`) — the agent user is unknown to it. After `deprovision`, every non-provision op against the dead `sandboxId` triggers this. |
 | `Lifecycle(...)` | `backend_error` | Any other failure of a lifecycle op, whether the API reported it semantically or the call itself could not be completed. |
 
@@ -495,6 +495,15 @@ semantic error channel, and **only** for non-provision operations.
 - *Non-provision only:* provision mints the agent user. There is no `sandboxId` yet, so
   reporting a stale one would be incoherent.
 
+### Framework verification
+
+Before activating the runtime, the state-aware path runs the same pre-activation
+framework check the one-shot path uses (`regfree::verify_framework`, gated behind
+the lifted build). It asks the co-located `IsoSessionApp.dll` — via its exported
+`VerifyIsoSessionFramework` — whether the matching IsolationSession runtime is
+installed and loadable. Only `S_OK` proceeds; **any** other outcome (including an
+older shim replying that it cannot verify) is fail-closed and refuses.
+
 ## Cancellation
 
 State-aware exec (and other phases) use OS-level cancellation in v1:
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/availability.rs b/src/mxc-sdk/src/backends/isolation_session/common/availability.rs
index d0b1eca7e..b3ca37e0c 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/availability.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/availability.rs
@@ -39,6 +39,13 @@ fn available_from(probe: Result<i32, HRESULT>) -> bool {
 }
 
 fn probe_feature_level() -> Result<i32, HRESULT> {
+    // Report unavailable if the framework runtime is not verified, so callers
+    // never attempt a session they cannot complete.
+    #[cfg(feature = "lifted_msi")]
+    if super::regfree::verify_framework().is_err() {
+        return Err(REGDB_E_CLASSNOTREG);
+    }
+
     #[cfg(feature = "lifted_msi")]
     let ops = match super::regfree::activate_from_adjacent_shim::<IsoSessionOps>() {
         Some(result) => result.map_err(|error| {
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/error.rs b/src/mxc-sdk/src/backends/isolation_session/common/error.rs
index d2d581a50..d39528c70 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/error.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/error.rs
@@ -45,6 +45,11 @@ pub(super) mod op {
     pub(crate) const OPTIONS_REDIRECT_STDERR: &str =
         "IsoSessionProcessOptions.SetRedirectStandardError";
     pub(crate) const OPTIONS_ENVIRONMENT: &str = "IsoSessionProcessOptions.Environment";
+
+    /// The staged shim's runtime-verification export, called before any session
+    /// work to confirm the IsolationSession framework is installed.
+    #[cfg(feature = "lifted_msi")]
+    pub(crate) const VERIFY_FRAMEWORK: &str = "IsoSessionApp.VerifyIsoSessionFramework";
 }
 
 /// `HRESULT_FROM_WIN32(ERROR_NOT_FOUND)`. Every non-provision lifecycle op
@@ -378,6 +383,25 @@ pub(super) fn lifted_payload_missing(operation: &str) -> IsolationSessionError {
     ))
 }
 
+/// The staged shim reports that the IsolationSession framework runtime is not
+/// installed (or could not confirm it is), so no session work may proceed.
+///
+/// The refusal's concise problem statement becomes the failure `message` (so it
+/// surfaces in the one-shot `ScriptResponse` string and as the state-aware
+/// `MxcError` message), and the shim's ready-to-display fix text, when present,
+/// becomes the `remediation`.
+#[cfg(feature = "lifted_msi")]
+pub(super) fn framework_unavailable(
+    refusal: super::regfree::FrameworkRefusal,
+) -> IsolationSessionError {
+    IsolationSessionError::ServiceUnavailable(IsoApiFailure::new(
+        op::VERIFY_FRAMEWORK,
+        None,
+        Some(refusal.message),
+        refusal.remediation,
+    ))
+}
+
 /// Whether an `ERROR_NOT_FOUND` from this operation means "the sandbox is
 /// gone".
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
index 7e9973bea..619931988 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
@@ -30,7 +30,7 @@ use windows_core::{HSTRING, PCWSTR};
 use super::console_mode::{get_local_console_size, ConsoleModeRestorer, CtrlHandlerGuard};
 use super::console_relay::{create_console_relay_thread, ConsoleRelayParams};
 #[cfg(feature = "lifted_msi")]
-use super::error::lifted_payload_missing;
+use super::error::{framework_unavailable, lifted_payload_missing};
 use super::error::{
     activation_error, check_result, format_iso_error, lifecycle_err, op, transport_err,
     IsolationSessionError, StalePromotion,
@@ -92,6 +92,9 @@ unsafe impl Sync for MtaReference {}
 /// error rather than silently binding the inbox `System32` runtime.
 #[cfg(feature = "lifted_msi")]
 fn check_service_available_and_activate() -> Result<IsoSessionOps, IsolationSessionError> {
+    // Refuse before touching the runtime if the framework is not verified.
+    super::regfree::verify_framework().map_err(framework_unavailable)?;
+
     match super::regfree::activate_from_adjacent_shim::<IsoSessionOps>() {
         Some(Ok(ops)) => Ok(ops),
         // The HRESULT→error mapping lives in `activation_error` so it stays
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
index 7f30e3b3b..4339d4366 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
@@ -14,9 +14,9 @@ use std::os::windows::ffi::OsStrExt;
 use std::path::PathBuf;
 use std::sync::OnceLock;
 
-use windows::core::{s, HSTRING, PCWSTR};
-use windows::Win32::Foundation::{GetLastError, REGDB_E_CLASSNOTREG};
-use windows::Win32::System::Com::{CoInitializeEx, COINIT_MULTITHREADED};
+use windows::core::{s, HSTRING, PCSTR, PCWSTR, PWSTR};
+use windows::Win32::Foundation::{GetLastError, ERROR_NOT_SUPPORTED, REGDB_E_CLASSNOTREG, S_OK};
+use windows::Win32::System::Com::{CoInitializeEx, CoTaskMemFree, COINIT_MULTITHREADED};
 use windows::Win32::System::LibraryLoader::{
     GetProcAddress, LoadLibraryExW, LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR, LOAD_LIBRARY_SEARCH_SYSTEM32,
 };
@@ -31,6 +31,48 @@ type DllGetActivationFactory =
 
 static GET_ACTIVATION_FACTORY: OnceLock<DllGetActivationFactory> = OnceLock::new();
 
+/// Flat-C export on the staged shim that answers whether the matching
+/// IsolationSession runtime is installed and loadable on this machine. The
+/// out-param receives an owned, ready-to-display remediation string (which the
+/// caller frees) when it is not; it is left null on success.
+type VerifyIsoSessionFramework = unsafe extern "system" fn(*mut *mut u16) -> HRESULT;
+
+/// Resolved by name, so the name is the contract.
+const VERIFY_FRAMEWORK_EXPORT: PCSTR = s!("VerifyIsoSessionFramework");
+
+/// Verified once per process: the install state cannot change under us.
+static FRAMEWORK_STATUS: OnceLock<Result<(), FrameworkRefusal>> = OnceLock::new();
+
+/// Why framework verification refused, split to match the wire error fields.
+///
+/// `message` is a concise problem statement (what is wrong); `remediation` is
+/// the shim's own ready-to-display fix text, present only when the shim
+/// supplied one. A synthetic refusal (verification unsupported, or a bare
+/// failure status) carries no remediation.
+#[derive(Debug, Clone)]
+pub(crate) struct FrameworkRefusal {
+    pub(crate) message: String,
+    pub(crate) remediation: Option<String>,
+}
+
+impl FrameworkRefusal {
+    /// A problem statement with no accompanying fix text.
+    fn new(message: impl Into<String>) -> Self {
+        Self {
+            message: message.into(),
+            remediation: None,
+        }
+    }
+
+    /// A problem statement paired with the shim's ready-to-display fix text.
+    fn with_remediation(message: impl Into<String>, remediation: String) -> Self {
+        Self {
+            message: message.into(),
+            remediation: Some(remediation),
+        }
+    }
+}
+
 /// Activates `T` through the lifted shim staged beside the current executable.
 ///
 /// Returns `None` only when the lifted activation payload is not present.
@@ -54,6 +96,107 @@ where
     Some(activate_from_factory(factory))
 }
 
+/// Confirms the IsolationSession runtime is installed before any session work.
+///
+/// `Ok(())` means proceed; `Err(refusal)` means block, carrying the text to
+/// show the user. The result is cached for the process.
+///
+/// Only `S_OK` from the shim proceeds; every other outcome is fail-closed. If
+/// the shim itself is not staged beside the host, there is nothing to check
+/// here and activation raises its own "payload missing" error, so this returns
+/// `Ok(())`.
+pub(crate) fn verify_framework() -> Result<(), FrameworkRefusal> {
+    FRAMEWORK_STATUS.get_or_init(run_framework_check).clone()
+}
+
+fn run_framework_check() -> Result<(), FrameworkRefusal> {
+    let Some(directory) = adjacent_runtime_directory() else {
+        return Ok(());
+    };
+
+    // The shim is staged beside us, so it must expose the verification entry
+    // point. If it cannot be loaded, the payload is broken — block.
+    let shim_verify_fn = resolve_verify_framework(&directory.join(SHIM_NAME)).map_err(|error| {
+        FrameworkRefusal::new(format!(
+            "the IsolationSession framework verification entry point could not be loaded: {error}"
+        ))
+    })?;
+
+    let mut remediation: *mut u16 = std::ptr::null_mut();
+    // SAFETY: the out-param is a valid pointer; per the export's contract we
+    // own any returned string and must free it with `CoTaskMemFree`.
+    let hresult = unsafe { shim_verify_fn(&mut remediation) };
+    classify_framework_status(hresult, take_cotaskmem_string(remediation))
+}
+
+/// Pure decision split from the FFI call so it is unit-testable without the
+/// shim. When the shim supplies its own fix text, that becomes the refusal's
+/// remediation and the message is a concise problem statement; otherwise the
+/// message stands alone.
+fn classify_framework_status(
+    hresult: HRESULT,
+    remediation: Option<String>,
+) -> Result<(), FrameworkRefusal> {
+    if hresult == S_OK {
+        return Ok(());
+    }
+    if let Some(remediation) = remediation {
+        return Err(FrameworkRefusal::with_remediation(
+            "the IsolationSession framework runtime is not installed",
+            remediation,
+        ));
+    }
+    if hresult == HRESULT::from_win32(ERROR_NOT_SUPPORTED.0) {
+        return Err(FrameworkRefusal::new(
+            "the installed IsolationSession framework does not support runtime verification, \
+             so MXC cannot confirm the required runtime is present",
+        ));
+    }
+    Err(FrameworkRefusal::new(format!(
+        "IsolationSession framework verification failed (0x{:08X})",
+        hresult.0 as u32
+    )))
+}
+
+fn resolve_verify_framework(
+    dll_path: &std::path::Path,
+) -> windows_core::Result<VerifyIsoSessionFramework> {
+    let source: Vec<u16> = dll_path
+        .as_os_str()
+        .encode_wide()
+        .chain(std::iter::once(0))
+        .collect();
+
+    // Same absolute-path, constrained-search load used for activation.
+    let module = unsafe {
+        LoadLibraryExW(
+            PCWSTR(source.as_ptr()),
+            None,
+            LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32,
+        )
+    }?;
+    let export = unsafe { GetProcAddress(module, VERIFY_FRAMEWORK_EXPORT) }.ok_or_else(|| {
+        windows_core::Error::from_hresult(HRESULT::from_win32(unsafe { GetLastError().0 }))
+    })?;
+
+    // The module intentionally stays loaded; the process only verifies once.
+    let shim_verify_fn: VerifyIsoSessionFramework = unsafe { std::mem::transmute(export) };
+    Ok(shim_verify_fn)
+}
+
+/// Reads a shim-allocated wide string into an owned `String`, then frees it
+/// with `CoTaskMemFree` as the contract requires. A null pointer yields `None`.
+fn take_cotaskmem_string(pointer: *mut u16) -> Option<String> {
+    if pointer.is_null() {
+        return None;
+    }
+    // SAFETY: the contract hands back a NUL-terminated wide string; we read it
+    // and then release it with the matching allocator.
+    let text = unsafe { PWSTR(pointer).to_string() }.ok();
+    unsafe { CoTaskMemFree(Some(pointer as *const std::ffi::c_void)) };
+    text
+}
+
 fn load_activation_factory<T>(
     dll_path: &std::path::Path,
 ) -> windows_core::Result<IActivationFactory>
@@ -185,3 +328,51 @@ where
         error
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use windows::Win32::Foundation::ERROR_MOD_NOT_FOUND;
+
+    #[test]
+    fn ok_status_proceeds() {
+        assert!(classify_framework_status(S_OK, None).is_ok());
+    }
+
+    #[test]
+    fn remediation_text_is_surfaced_verbatim() {
+        // The shim returns this fix text when the runtime is missing; it lands
+        // in the refusal's remediation, with a concise problem statement.
+        let fix = "IsoSession isn't found; download from aka.ms/foo".to_string();
+        let refusal = classify_framework_status(
+            HRESULT::from_win32(ERROR_MOD_NOT_FOUND.0),
+            Some(fix.clone()),
+        )
+        .unwrap_err();
+        assert_eq!(refusal.remediation.as_deref(), Some(fix.as_str()));
+        assert!(refusal.message.contains("not installed"));
+    }
+
+    #[test]
+    fn not_supported_is_fail_closed() {
+        // No fix text accompanies this status; MXC still blocks, message-only.
+        let refusal = classify_framework_status(HRESULT::from_win32(ERROR_NOT_SUPPORTED.0), None)
+            .unwrap_err();
+        assert!(
+            refusal.message.contains("does not support"),
+            "expected the verification-unsupported wording"
+        );
+        assert_eq!(refusal.remediation, None);
+    }
+
+    #[test]
+    fn bare_failure_without_remediation_still_blocks() {
+        // Any other failure with no shim text falls back to a synthetic message.
+        let refusal = classify_framework_status(HRESULT(0x8000_4005u32 as i32), None).unwrap_err();
+        assert!(
+            refusal.message.contains("verification failed"),
+            "expected the synthetic failure wording"
+        );
+        assert_eq!(refusal.remediation, None);
+    }
+}

From 88ecf6298bc5cc0b140e0923d2d4093206a6966d Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Tue, 6 Oct 2026 14:12:03 -0700
Subject: [PATCH 18/26] Prepare lifted IsolationSession SDK integration and CI

Remove the checked-in SDK package, harden package and activation validation,
and add opt-in x64 Cargo coverage for the lifted feature path.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: f67f236f-a9cb-4ff1-b180-25b798dd4967
---
 .github/workflows/Build.Windows.Job.yml       |  64 ++++
 .github/workflows/Build.yml                   |   5 +
 .../backends/isolation-session/oneshot.md     |  64 ++--
 .../V1/MxcContainerTests.cs                   |  10 +-
 src/Cargo.lock                                | 299 +-----------------
 src/ffi/mxc_ffi/Cargo.toml                    |   2 +-
 .../build/build_isolation_session_bindings.rs | 108 ++++---
 src/mxc-sdk/build/build_mxc_build_common.rs   | 114 +++++--
 .../isolation_session_bindings/README.md      |  15 +-
 .../Update-IsoSessionSdk.ps1                  |  73 +++--
 .../isolation_session/common/manager.rs       |  40 ++-
 .../isolation_session/common/regfree.rs       |  14 +-
 src/tools/wxc/Cargo.toml                      |   2 +-
 src/tools/wxc/build.rs                        |   6 +-
 14 files changed, 352 insertions(+), 464 deletions(-)

diff --git a/.github/workflows/Build.Windows.Job.yml b/.github/workflows/Build.Windows.Job.yml
index e205cdcb2..64a3039a2 100644
--- a/.github/workflows/Build.Windows.Job.yml
+++ b/.github/workflows/Build.Windows.Job.yml
@@ -2,6 +2,12 @@ name: Windows Build
 
 on:
   workflow_call:
+    inputs:
+      run_isolation_session_lifted:
+        description: Run x64 Cargo validation against the published lifted IsolationSession SDK package.
+        required: false
+        default: false
+        type: boolean
 
 jobs:
   build:
@@ -120,3 +126,61 @@ jobs:
             src/target/${{ matrix.target }}/release/wxc-test-driver.exe
           if-no-files-found: error
           retention-days: 1
+
+  isolation-session-lifted:
+    name: x64 isolation_session_lifted
+    if: inputs.run_isolation_session_lifted
+    runs-on: windows-2025
+    defaults:
+      run:
+        working-directory: src
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+
+      - name: Surface toolchain file at repo root
+        shell: bash
+        working-directory: ${{ github.workspace }}
+        run: cp src/rust-toolchain.toml rust-toolchain.toml
+
+      - uses: actions-rust-lang/setup-rust-toolchain@ecabd13d1c56bd1345c230e542e9144811ad706f # v2.0.0
+        with:
+          target: x86_64-pc-windows-msvc
+          override: false
+          rustflags: ''
+
+      - name: Point cargo at the MxcDependencies feed
+        uses: ./.github/actions/setup-cargo-feed
+
+      - uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2
+        with:
+          workspaces: src -> target
+          key: x86_64-pc-windows-msvc-isolation-session-lifted-v1
+          cache-on-failure: false
+
+      - name: Test lifted SDK and compile FFI tests
+        run: |
+          cargo test --locked --release --target x86_64-pc-windows-msvc `
+            -p mxc-sdk --features isolation_session_lifted
+          cargo test --locked --release --target x86_64-pc-windows-msvc `
+            -p mxc_ffi --features isolation_session_lifted --no-run
+
+      - name: Build lifted CLI
+        run: cargo build --locked --release --target x86_64-pc-windows-msvc
+             -p wxc --no-default-features --features isolation_session_lifted
+
+      - name: Verify adjacent activation payload
+        shell: pwsh
+        run: |
+          $releaseDir = 'target\x86_64-pc-windows-msvc\release'
+          $requiredFiles = @(
+            'wxc-exec.exe',
+            'IsoSessionApp.dll',
+            'IsoSession.manifest'
+          )
+
+          foreach ($file in $requiredFiles) {
+            $path = Join-Path $releaseDir $file
+            if (-not (Test-Path -LiteralPath $path -PathType Leaf)) {
+              throw "Lifted build did not stage required file: $path"
+            }
+          }
diff --git a/.github/workflows/Build.yml b/.github/workflows/Build.yml
index 0841fd502..5444117be 100644
--- a/.github/workflows/Build.yml
+++ b/.github/workflows/Build.yml
@@ -41,6 +41,11 @@ jobs:
   windows:
     needs: dependency-feed-check
     uses: ./.github/workflows/Build.Windows.Job.yml
+    with:
+      # Enable after the pinned SDK package is published at the endpoint used
+      # by mxc_build_common. Until then, package-independent helper tests still
+      # run in the normal x64 Windows job.
+      run_isolation_session_lifted: ${{ vars.MXC_ISOLATION_SESSION_LIFTED_CI == 'true' }}
 
   linux:
     needs: dependency-feed-check
diff --git a/docs/development/architecture/backends/isolation-session/oneshot.md b/docs/development/architecture/backends/isolation-session/oneshot.md
index 6618c85aa..52f75ff0e 100644
--- a/docs/development/architecture/backends/isolation-session/oneshot.md
+++ b/docs/development/architecture/backends/isolation-session/oneshot.md
@@ -217,10 +217,11 @@ export and calls
 inbox `RoActivateInstance` path, does **not** implicitly initialize the
 WinRT/COM apartment. `src/core/wxc/src/main.rs` calls
 `CoInitializeEx(COINIT_MULTITHREADED)` at startup, and `regfree.rs`
-additionally calls `CoInitializeEx` (best-effort; `S_FALSE` /
-`RPC_E_CHANGED_MODE` ignored) before activation so the factory's internal COM
-activation (coresident client → service) has an initialized apartment even on
-the `--probe` path, which returns before `main`'s initialization.
+additionally calls `CoInitializeEx` before activation so the factory's internal
+COM activation (coresident client → service) has an initialized apartment even
+on the `--probe` path, which returns before `main`'s initialization.
+`RPC_E_CHANGED_MODE` is benign because the thread already has an apartment;
+other initialization failures are propagated.
 
 The API surface includes the lifecycle methods plus
 `IsoSessionProcess` (the running-process handle). The runner uses the
@@ -231,42 +232,32 @@ flag when `wxc-exec`'s stdout is a TTY.
 
 ## Bindings Workflow
 
-**Why a private WinMD.** The OS-side API ships its WinMD as part of an
-internal Windows OS build (the exact file name and provenance are recorded
-in `GENERATION_INFO.toml`). There is no public NuGet or release distribution
-today. MXC stores generated Rust bindings in the workspace and tracks their
-provenance.
+MXC supports two explicit metadata paths:
 
-**Future direction.** The OS API is expected to land in the public Windows
-SDK eventually, at which point the `windows` crate (auto-generated from
-the public Windows SDK metadata) will pick it up automatically. When that
-happens, MXC can drop this private bindings crate and consume the API
-through the standard `windows` crate dependency. That milestone is
-currently far off — the private bindings remain the working approach for
-the foreseeable future.
+- **Inbox mode (`isolation_session`)** uses the committed OS-generated
+  `bindings.rs` and normal inbox WinRT activation. The private source WinMD is
+  not committed; its provenance is recorded in `GENERATION_INFO.toml`.
+- **Lifted mode (`isolation_session_lifted`)** resolves the pinned
+  `Microsoft.Windows.AI.IsolationSession.SDK` package, generates Rust bindings
+  from its Preview WinMD at build time, and stages the package's activation
+  shim and manifest. The package itself is not committed.
 
 **Generated bindings are committed.**
 `src/mxc-sdk/src/backends/isolation_session/bindings/bindings.rs` is a checked-in artifact.
 The WinMD itself is **not** committed (binary, frequently updated). All
 provenance lives in `GENERATION_INFO.toml`.
-
-**Regeneration.** When the OS-side API changes (or the consumed OS build
-moves), the bindings must be regenerated by a Microsoft engineer with
-access to the private WinMD. `windows-bindgen` X.Y generates code that
-targets the `windows` X.Y crate, so a regenerator must use a
-`windows-bindgen` release whose major.minor matches the workspace
-`windows` crate. The generated bindings and the Rust code in this repo use
-the `Windows.AI.IsolationSession.Preview` namespace (for example,
-`IsoSessionOps`) — that is the naming to use when diagnosing regeneration or
-version-coupling issues. The build-time check below catches the most common
-slip — bumping the workspace `windows` crate without regenerating — by
-comparing the workspace version against the recorded `target_windows_crate`.
-
-**`build.rs` version check.** `isolation_session_bindings/build.rs` reads
-the expected `windows` crate version from `GENERATION_INFO.toml`
-(`target_windows_crate`) and compares against the actual workspace
-`Cargo.lock`. A mismatch panics the build with a message naming both
-versions and stating that the bindings must be regenerated.
+`windows-bindgen` must remain compatible with the workspace `windows` crate.
+The generated APIs use the stable
+`Windows.AI.IsolationSession.Preview` namespace, including `IsoSessionOps`.
+
+To update lifted mode, run
+`src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1` with the new
+package. The script validates the package, updates the version and SHA-256 pin,
+and regenerates `GENERATION_INFO.toml`; use
+`ISOLATION_SESSION_SDK_PACKAGE` until the exact package is published. Then
+build and test both inbox and lifted configurations. The lifted build validates
+the package hash, runtime-instance manifest, and native shim architecture and
+fails rather than falling back to inbox behavior.
 
 ## v0.1 Scope
 
@@ -441,8 +432,9 @@ The following were observed during VM testing and are accepted for v0.1.
 - `cargo build --features isolation_session` (inbox) or
   `--features isolation_session_lifted` (lifted SDK + MSI) to build the
   feature into `wxc-exec`. Default builds skip it — no impact on existing
-  workflows. Lifted builds use the pinned SDK package checked in under
-  `external/windows-sdk/isolation-session`.
+  workflows. Lifted builds restore the version- and hash-pinned SDK package
+  from NuGet.org, the standard NuGet cache, or
+  `ISOLATION_SESSION_SDK_PACKAGE`.
 - A private WinMD only when **regenerating** bindings. As long as the OS
   API hasn't changed, no regen is needed.
 
diff --git a/sdk/dotnet/Microsoft.Mxc.Sdk.Tests/V1/MxcContainerTests.cs b/sdk/dotnet/Microsoft.Mxc.Sdk.Tests/V1/MxcContainerTests.cs
index b3b9ea7e8..f05650b72 100644
--- a/sdk/dotnet/Microsoft.Mxc.Sdk.Tests/V1/MxcContainerTests.cs
+++ b/sdk/dotnet/Microsoft.Mxc.Sdk.Tests/V1/MxcContainerTests.cs
@@ -436,15 +436,15 @@ public void GetAvailableBackends_ReturnsTypedNativeProbe()
         Assert.NotNull(backends);
         if (OperatingSystem.IsWindows())
         {
+            var support = MxcPlatform.GetPlatformSupport();
             var processContainer = Assert.Single(
                 backends,
                 backend => backend.Backend == ContainmentBackend.ProcessContainer);
             Assert.NotNull(processContainer.Tier);
-#if MXC_WITH_ISOLATION_SESSION
-            Assert.Contains(
-                backends,
-                backend => backend.Backend == ContainmentBackend.IsolationSession);
-#endif
+            Assert.Equal(
+                support.AvailableMethods.Contains(ContainmentBackend.IsolationSession),
+                backends.Any(
+                    backend => backend.Backend == ContainmentBackend.IsolationSession));
         }
     }
 
diff --git a/src/Cargo.lock b/src/Cargo.lock
index 7573d4f0c..c8f41b907 100644
--- a/src/Cargo.lock
+++ b/src/Cargo.lock
@@ -8,17 +8,6 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
-[[package]]
-name = "aes"
-version = "0.8.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
-dependencies = [
- "cfg-if",
- "cipher",
- "cpufeatures 0.2.17",
-]
-
 [[package]]
 name = "aho-corasick"
 version = "1.1.4"
@@ -186,17 +175,8 @@ dependencies = [
  "arrayvec",
  "cc",
  "cfg-if",
- "constant_time_eq 0.4.2",
- "cpufeatures 0.3.0",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
-dependencies = [
- "generic-array",
+ "constant_time_eq",
+ "cpufeatures",
 ]
 
 [[package]]
@@ -254,37 +234,12 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "byteorder"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
-
 [[package]]
 name = "bytes"
 version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 
-[[package]]
-name = "bzip2"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49ecfb22d906f800d4fe833b6282cf4dc1c298f5057ca0b5445e5c209735ca47"
-dependencies = [
- "bzip2-sys",
-]
-
-[[package]]
-name = "bzip2-sys"
-version = "0.1.13+1.0.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225bff33b2141874fe80d71e07d6eec4f85c5c216453dd96388240f96e1acc14"
-dependencies = [
- "cc",
- "pkg-config",
-]
-
 [[package]]
 name = "cap-primitives"
 version = "4.0.3"
@@ -355,7 +310,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06"
 dependencies = [
  "cfg-if",
- "cpufeatures 0.3.0",
+ "cpufeatures",
  "rand_core",
 ]
 
@@ -376,16 +331,6 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "579504560394e388085d0c080ea587dfa5c15f7e251b4d5247d1e1a61d1d6928"
 
-[[package]]
-name = "cipher"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
-dependencies = [
- "crypto-common 0.1.7",
- "inout",
-]
-
 [[package]]
 name = "clang-sys"
 version = "1.9.1"
@@ -470,12 +415,6 @@ dependencies = [
  "unicode-xid",
 ]
 
-[[package]]
-name = "constant_time_eq"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
-
 [[package]]
 name = "constant_time_eq"
 version = "0.4.2"
@@ -488,15 +427,6 @@ version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
-[[package]]
-name = "cpufeatures"
-version = "0.2.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "cpufeatures"
 version = "0.3.0"
@@ -506,21 +436,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "crc"
-version = "3.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d"
-dependencies = [
- "crc-catalog",
-]
-
-[[package]]
-name = "crc-catalog"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "217698eaf96b4a3f0bc4f3662aaa55bdf913cd54d7204591faa790070c6d0853"
-
 [[package]]
 name = "crc32fast"
 version = "1.5.0"
@@ -545,16 +460,6 @@ version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
-[[package]]
-name = "crypto-common"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
-dependencies = [
- "generic-array",
- "typenum",
-]
-
 [[package]]
 name = "crypto-common"
 version = "0.2.2"
@@ -609,18 +514,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "deflate64"
-version = "0.1.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac6b926516df9c60bfa16e107b21086399f8285a44ca9711344b9e553c5146e2"
-
-[[package]]
-name = "deranged"
-version = "0.5.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
-
 [[package]]
 name = "derive_arbitrary"
 version = "1.4.2"
@@ -663,26 +556,15 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "digest"
-version = "0.10.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
-dependencies = [
- "block-buffer 0.10.4",
- "crypto-common 0.1.7",
- "subtle",
-]
-
 [[package]]
 name = "digest"
 version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
 dependencies = [
- "block-buffer 0.12.1",
+ "block-buffer",
  "const-oid",
- "crypto-common 0.2.2",
+ "crypto-common",
 ]
 
 [[package]]
@@ -864,16 +746,6 @@ dependencies = [
  "slab",
 ]
 
-[[package]]
-name = "generic-array"
-version = "0.14.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
-dependencies = [
- "typenum",
- "version_check",
-]
-
 [[package]]
 name = "getrandom"
 version = "0.2.17"
@@ -892,11 +764,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
 dependencies = [
  "cfg-if",
- "js-sys",
  "libc",
  "r-efi 5.3.0",
  "wasip2",
- "wasm-bindgen",
 ]
 
 [[package]]
@@ -993,15 +863,6 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
-[[package]]
-name = "hmac"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
-dependencies = [
- "digest 0.10.7",
-]
-
 [[package]]
 name = "http"
 version = "1.4.2"
@@ -1329,15 +1190,6 @@ dependencies = [
  "serde_core",
 ]
 
-[[package]]
-name = "inout"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
-dependencies = [
- "generic-array",
-]
-
 [[package]]
 name = "io-extras"
 version = "0.19.0"
@@ -1545,27 +1397,6 @@ dependencies = [
  "winresource",
 ]
 
-[[package]]
-name = "lzma-rs"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "297e814c836ae64db86b36cf2a557ba54368d03f6afcd7d947c266692f71115e"
-dependencies = [
- "byteorder",
- "crc",
-]
-
-[[package]]
-name = "lzma-sys"
-version = "0.1.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fda04ab3764e6cde78b9974eec4f779acaba7c4e84b36eca3cf77c581b85d27"
-dependencies = [
- "cc",
- "libc",
- "pkg-config",
-]
-
 [[package]]
 name = "maybe-owned"
 version = "0.3.4"
@@ -1764,12 +1595,6 @@ dependencies = [
  "minimal-lexical",
 ]
 
-[[package]]
-name = "num-conv"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441"
-
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -1868,16 +1693,6 @@ dependencies = [
  "windows-link 0.2.1",
 ]
 
-[[package]]
-name = "pbkdf2"
-version = "0.12.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"
-dependencies = [
- "digest 0.10.7",
- "hmac",
-]
-
 [[package]]
 name = "percent-encoding"
 version = "2.3.2"
@@ -1935,12 +1750,6 @@ dependencies = [
  "zerovec",
 ]
 
-[[package]]
-name = "powerfmt"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
-
 [[package]]
 name = "prettyplease"
 version = "0.2.37"
@@ -2334,17 +2143,6 @@ dependencies = [
  "serde_core",
 ]
 
-[[package]]
-name = "sha1"
-version = "0.10.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8"
-dependencies = [
- "cfg-if",
- "cpufeatures 0.2.17",
- "digest 0.10.7",
-]
-
 [[package]]
 name = "sha2"
 version = "0.11.0"
@@ -2352,8 +2150,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
 dependencies = [
  "cfg-if",
- "cpufeatures 0.3.0",
- "digest 0.11.3",
+ "cpufeatures",
+ "digest",
 ]
 
 [[package]]
@@ -2535,25 +2333,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "time"
-version = "0.3.55"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdb87b95ec50ddfa440816d227a17b2ccbdda963a316a727fda0fc4334f7d134"
-dependencies = [
- "deranged",
- "num-conv",
- "powerfmt",
- "serde_core",
- "time-core",
-]
-
-[[package]]
-name = "time-core"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e1c906769ad99c88eaa54e728060edef082f8e358ff32030cb7c7d315e81109"
-
 [[package]]
 name = "tinystr"
 version = "0.8.3"
@@ -3404,15 +3183,6 @@ dependencies = [
  "rustix",
 ]
 
-[[package]]
-name = "xz2"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "388c44dc09d76f1536602ead6d325eb532f5c122f17782bd57fb47baeeb767e2"
-dependencies = [
- "lzma-sys",
-]
-
 [[package]]
 name = "yoke"
 version = "0.8.3"
@@ -3482,20 +3252,6 @@ name = "zeroize"
 version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e13c156562582aa81c60cb29407084cdb54c4164760106ab78e6c5b0858cf64e"
-dependencies = [
- "zeroize_derive",
-]
-
-[[package]]
-name = "zeroize_derive"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c50655cbb0fe3fc43170059e702f1ce5e19b84cec58dc87b037a09935c2f328"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
 
 [[package]]
 name = "zerotrie"
@@ -3536,28 +3292,15 @@ version = "2.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fabe6324e908f85a1c52063ce7aa26b68dcb7eb6dbc83a2d148403c9bc3eba50"
 dependencies = [
- "aes",
  "arbitrary",
- "bzip2",
- "constant_time_eq 0.3.1",
  "crc32fast",
  "crossbeam-utils",
- "deflate64",
  "displaydoc",
  "flate2",
- "getrandom 0.3.4",
- "hmac",
  "indexmap",
- "lzma-rs",
  "memchr",
- "pbkdf2",
- "sha1",
  "thiserror",
- "time",
- "xz2",
- "zeroize",
  "zopfli",
- "zstd",
 ]
 
 [[package]]
@@ -3577,31 +3320,3 @@ dependencies = [
  "log",
  "simd-adler32",
 ]
-
-[[package]]
-name = "zstd"
-version = "0.13.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
-dependencies = [
- "zstd-safe",
-]
-
-[[package]]
-name = "zstd-safe"
-version = "7.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64d80649ab6db9d9f6f9c80a40becd948eda4714a0a5ac8c4d157a32231c7882"
-dependencies = [
- "zstd-sys",
-]
-
-[[package]]
-name = "zstd-sys"
-version = "2.1.0+zstd.1.5.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ef0a8027ec3ee71300ab3bcbcd0393f434aa72b91ca6d635a39941deae8eea0"
-dependencies = [
- "cc",
- "pkg-config",
-]
diff --git a/src/ffi/mxc_ffi/Cargo.toml b/src/ffi/mxc_ffi/Cargo.toml
index 21b326c6a..d2e4ce225 100644
--- a/src/ffi/mxc_ffi/Cargo.toml
+++ b/src/ffi/mxc_ffi/Cargo.toml
@@ -56,4 +56,4 @@ csbindgen = { version = "1", optional = true }
 cc = "1"
 sha2.workspace = true
 winresource.workspace = true
-zip = "2"
+zip = { version = "2", default-features = false, features = ["deflate"] }
diff --git a/src/mxc-sdk/build/build_isolation_session_bindings.rs b/src/mxc-sdk/build/build_isolation_session_bindings.rs
index 53cdf3149..de0d4f395 100644
--- a/src/mxc-sdk/build/build_isolation_session_bindings.rs
+++ b/src/mxc-sdk/build/build_isolation_session_bindings.rs
@@ -111,64 +111,80 @@ fn verify_inbox_bindings_version() {
         .join("build")
         .join("isolation_session_bindings")
         .join("GENERATION_INFO.toml");
-    if !info_path.exists() {
-        return;
-    }
-
-    let contents = std::fs::read_to_string(&info_path).unwrap_or_default();
-    let Some(expected) = contents.lines().find_map(|line| {
-        let line = line.trim();
-        if line.starts_with("target_windows_crate") {
-            line.split('=')
-                .nth(1)
-                .map(|value| value.trim().trim_matches('"').to_string())
-        } else {
-            None
-        }
-    }) else {
-        return;
-    };
+    let contents = std::fs::read_to_string(&info_path).unwrap_or_else(|error| {
+        panic!(
+            "isolation_session_bindings: read provenance {}: {error}",
+            info_path.display()
+        )
+    });
+    let expected = contents
+        .lines()
+        .find_map(|line| {
+            let line = line.trim();
+            if line.starts_with("target_windows_crate") {
+                line.split('=')
+                    .nth(1)
+                    .map(|value| value.trim().trim_matches('"').to_string())
+            } else {
+                None
+            }
+        })
+        .unwrap_or_else(|| {
+            panic!(
+                "isolation_session_bindings: {} has no target_windows_crate",
+                info_path.display()
+            )
+        });
 
     let lock_path = Path::new(&manifest_dir)
         .join("..")
         .join("Cargo.lock");
-    let lock_contents = std::fs::read_to_string(lock_path).unwrap_or_default();
-    let actual = lock_contents
+    let lock_contents = std::fs::read_to_string(&lock_path).unwrap_or_else(|error| {
+        panic!(
+            "isolation_session_bindings: read workspace lockfile {}: {error}",
+            lock_path.display()
+        )
+    });
+    let actual_versions = lock_contents
         .split("[[package]]")
-        .find(|block| {
+        .filter(|block| {
             block
                 .lines()
                 .any(|line| line.trim() == "name = \"windows\"")
         })
-        .and_then(|block| {
+        .filter_map(|block| {
             block.lines().find_map(|line| {
                 let line = line.trim();
-                if line.starts_with("version = ") {
-                    line.split('=')
-                        .nth(1)
-                        .map(|value| value.trim().trim_matches('"').to_string())
-                } else {
-                    None
-                }
+                line.strip_prefix("version = ")
+                    .map(|value| value.trim().trim_matches('"').to_string())
             })
-        });
+        })
+        .collect::<Vec<_>>();
+    assert_eq!(
+        actual_versions.len(),
+        1,
+        "isolation_session_bindings: expected exactly one windows package in {}, found {:?}",
+        lock_path.display(),
+        actual_versions
+    );
+    let actual = &actual_versions[0];
 
     let parts = expected.split('.').take(2).collect::<Vec<_>>();
-    if parts.len() != 2 {
-        return;
-    }
-    let Ok(requirement) = semver::VersionReq::parse(&format!("^{}.{}", parts[0], parts[1])) else {
-        return;
-    };
-
-    if let Some(actual) = actual {
-        let Ok(actual_version) = semver::Version::parse(&actual) else {
-            return;
-        };
-        assert!(
-            requirement.matches(&actual_version),
-            "isolation_session_bindings: committed inbox bindings target windows crate \
-             {expected}, but the workspace has {actual}; regenerate the inbox bindings"
-        );
-    }
+    assert_eq!(
+        parts.len(),
+        2,
+        "isolation_session_bindings: invalid target_windows_crate {expected:?}"
+    );
+    let requirement = semver::VersionReq::parse(&format!("^{}.{}", parts[0], parts[1]))
+        .unwrap_or_else(|error| {
+            panic!("isolation_session_bindings: invalid target_windows_crate {expected:?}: {error}")
+        });
+    let actual_version = semver::Version::parse(actual).unwrap_or_else(|error| {
+        panic!("isolation_session_bindings: invalid windows version {actual:?}: {error}")
+    });
+    assert!(
+        requirement.matches(&actual_version),
+        "isolation_session_bindings: committed inbox bindings target windows crate \
+         {expected}, but the workspace has {actual}; regenerate the inbox bindings"
+    );
 }
diff --git a/src/mxc-sdk/build/build_mxc_build_common.rs b/src/mxc-sdk/build/build_mxc_build_common.rs
index 47eb0c91a..1f6b5e7a1 100644
--- a/src/mxc-sdk/build/build_mxc_build_common.rs
+++ b/src/mxc-sdk/build/build_mxc_build_common.rs
@@ -25,6 +25,8 @@ pub mod isolation_session_sdk {
 
     const APP_DLL: &str = "IsoSessionApp.dll";
     const RUNTIME_MANIFEST: &str = "IsoSession.manifest";
+    const IMAGE_FILE_MACHINE_AMD64: u16 = 0x8664;
+    const IMAGE_FILE_MACHINE_ARM64: u16 = 0xAA64;
 
     pub fn resolve_package() -> Result<PathBuf, String> {
         println!("cargo:rerun-if-env-changed={PACKAGE_PATH_ENV}");
@@ -36,13 +38,6 @@ pub mod isolation_session_sdk {
             return Ok(path);
         }
 
-        let vendored = vendored_package_path();
-        if vendored.is_file() {
-            verify_package(&vendored)?;
-            println!("cargo:rerun-if-changed={}", vendored.display());
-            return Ok(vendored);
-        }
-
         let package_name = format!(
             "{}.{}.nupkg",
             PACKAGE_ID.to_ascii_lowercase(),
@@ -127,17 +122,13 @@ pub mod isolation_session_sdk {
         Ok(package_path)
     }
 
-    /// The pinned package checked in under `external/windows-sdk/isolation-session`.
-    pub fn vendored_package_path() -> PathBuf {
-        Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("../../../external/windows-sdk/isolation-session")
-            .join(format!("{PACKAGE_ID}.{PACKAGE_VERSION}.nupkg"))
-    }
-
     pub fn stage_runtime() -> Result<(), String> {
         let package = resolve_package()?;
         let app_dll = read_entry(&package, APP_DLL)?;
         let manifest = read_entry(&package, RUNTIME_MANIFEST)?;
+        let target_arch = std::env::var("CARGO_CFG_TARGET_ARCH")
+            .map_err(|e| format!("CARGO_CFG_TARGET_ARCH is not set: {e}"))?;
+        validate_runtime_architecture(&app_dll, &target_arch)?;
         let instance = package_runtime_instance()?;
         validate_runtime_manifest(&manifest, &instance)?;
 
@@ -149,6 +140,47 @@ pub mod isolation_session_sdk {
         Ok(())
     }
 
+    fn validate_runtime_architecture(binary: &[u8], target_arch: &str) -> Result<(), String> {
+        let expected_machine = match target_arch {
+            "x86_64" => IMAGE_FILE_MACHINE_AMD64,
+            "aarch64" => IMAGE_FILE_MACHINE_ARM64,
+            other => {
+                return Err(format!(
+                    "IsolationSession lifted runtime does not support target architecture {other:?}"
+                ));
+            }
+        };
+
+        if binary.len() < 0x40 || &binary[..2] != b"MZ" {
+            return Err(format!("{APP_DLL} is not a valid PE image"));
+        }
+        let pe_offset = u32::from_le_bytes(
+            binary[0x3c..0x40]
+                .try_into()
+                .expect("slice length is checked"),
+        ) as usize;
+        let machine_end = pe_offset
+            .checked_add(6)
+            .ok_or_else(|| format!("{APP_DLL} has an invalid PE header offset"))?;
+        if machine_end > binary.len() || &binary[pe_offset..pe_offset + 4] != b"PE\0\0" {
+            return Err(format!("{APP_DLL} has an invalid PE header"));
+        }
+
+        let actual_machine = u16::from_le_bytes(
+            binary[pe_offset + 4..machine_end]
+                .try_into()
+                .expect("slice length is checked"),
+        );
+        if actual_machine != expected_machine {
+            return Err(format!(
+                "{APP_DLL} machine type 0x{actual_machine:04X} does not match Cargo target \
+                 architecture {target_arch:?} (expected 0x{expected_machine:04X}); publish a \
+                 matching runtime payload before building this target"
+            ));
+        }
+        Ok(())
+    }
+
     pub fn read_entry(package: &Path, file_name: &str) -> Result<Vec<u8>, String> {
         let file = std::fs::File::open(package)
             .map_err(|e| format!("open NuGet package {}: {e}", package.display()))?;
@@ -273,15 +305,10 @@ pub mod isolation_session_sdk {
     #[cfg(test)]
     mod tests {
         use super::{
-            package_runtime_instance, validate_runtime_manifest, vendored_package_path,
-            verify_package,
+            package_runtime_instance, validate_runtime_architecture, validate_runtime_manifest,
+            IMAGE_FILE_MACHINE_AMD64, IMAGE_FILE_MACHINE_ARM64,
         };
 
-        #[test]
-        fn vendored_package_matches_pin() {
-            verify_package(&vendored_package_path()).unwrap();
-        }
-
         const MANIFEST: &str = "\
 <assembly>
   <assemblyIdentity name=\"IsoSession.Runtime\" />
@@ -304,6 +331,51 @@ pub mod isolation_session_sdk {
             let error = validate_runtime_manifest(MANIFEST.as_bytes(), "2026.10").unwrap_err();
             assert!(error.contains("does not identify runtime instance"));
         }
+
+        fn pe_image(machine: u16) -> Vec<u8> {
+            let mut image = vec![0; 0x80];
+            image[..2].copy_from_slice(b"MZ");
+            image[0x3c..0x40].copy_from_slice(&0x40u32.to_le_bytes());
+            image[0x40..0x44].copy_from_slice(b"PE\0\0");
+            image[0x44..0x46].copy_from_slice(&machine.to_le_bytes());
+            image
+        }
+
+        #[test]
+        fn runtime_architecture_accepts_matching_targets() {
+            validate_runtime_architecture(&pe_image(IMAGE_FILE_MACHINE_AMD64), "x86_64").unwrap();
+            validate_runtime_architecture(&pe_image(IMAGE_FILE_MACHINE_ARM64), "aarch64").unwrap();
+        }
+
+        #[test]
+        fn runtime_architecture_rejects_mismatched_target() {
+            let error =
+                validate_runtime_architecture(&pe_image(IMAGE_FILE_MACHINE_AMD64), "aarch64")
+                    .unwrap_err();
+            assert!(error.contains("does not match Cargo target architecture"));
+        }
+
+        #[test]
+        fn runtime_architecture_rejects_invalid_pe() {
+            let error = validate_runtime_architecture(b"not a PE", "x86_64").unwrap_err();
+            assert!(error.contains("not a valid PE image"));
+        }
+
+        #[test]
+        fn runtime_architecture_rejects_truncated_pe_header() {
+            let mut image = pe_image(IMAGE_FILE_MACHINE_AMD64);
+            image.truncate(0x44);
+
+            let error = validate_runtime_architecture(&image, "x86_64").unwrap_err();
+            assert!(error.contains("invalid PE header"));
+        }
+
+        #[test]
+        fn runtime_architecture_rejects_unsupported_target() {
+            let error = validate_runtime_architecture(&pe_image(IMAGE_FILE_MACHINE_AMD64), "x86")
+                .unwrap_err();
+            assert!(error.contains("does not support target architecture"));
+        }
     }
 }
 
diff --git a/src/mxc-sdk/build/isolation_session_bindings/README.md b/src/mxc-sdk/build/isolation_session_bindings/README.md
index 957f6a34b..5278497dd 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/README.md
+++ b/src/mxc-sdk/build/isolation_session_bindings/README.md
@@ -52,15 +52,18 @@ payload into the Node and .NET SDK runtimes. The .NET SDK uses
 (lifted).
 
 Lifted mode fails the build if package download, integrity validation, metadata
-generation, or activation-payload staging fails. It never silently produces an
-inbox-mode binary.
+generation, activation-payload staging, or native payload architecture
+validation fails. It never silently produces an inbox-mode binary or package a
+shim for the wrong target architecture.
 
 ## Updating the lifted SDK
 
-1. Update `PACKAGE_VERSION` and `PACKAGE_SHA256` in
-   `src/mxc-sdk/build/build_mxc_build_common.rs`.
-2. Update `GENERATION_INFO.toml` with the package and WinMD provenance.
-3. Build and test both feature configurations.
+1. Run `Update-IsoSessionSdk.ps1 -PackagePath <path-to-package>`. The script
+   validates the package, updates `PACKAGE_VERSION` and `PACKAGE_SHA256`, and
+   regenerates `GENERATION_INFO.toml` without copying the package into Git.
+2. Build and test both feature configurations. Set
+   `ISOLATION_SESSION_SDK_PACKAGE` to the validated local package until that
+   exact version is available from NuGet.org.
 
 `windows-bindgen` is pinned to `=0.62.1` in `src/mxc-sdk/Cargo.toml`
 and must stay in lockstep with the workspace `windows` crate's major.minor
diff --git a/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1 b/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1
index 06d379083..036e7547d 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1
+++ b/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1
@@ -2,13 +2,13 @@
 
 <#
 .SYNOPSIS
-    Replaces MXC's pinned IsolationSession SDK package.
+    Updates MXC's pinned IsolationSession SDK package metadata.
 
 .DESCRIPTION
-    Validates the package payload and release identity, replaces the single
-    checked-in package, and regenerates GENERATION_INFO.toml from the package.
-    The script fails before modifying the destination when the package is
-    incomplete or internally inconsistent.
+    Validates the package payload and release identity, updates MXC's package
+    version and SHA-256 pin, and regenerates GENERATION_INFO.toml. The package
+    itself is not copied into the repository. The script fails before modifying
+    tracked files when the package is incomplete or internally inconsistent.
 
 .PARAMETER PackagePath
     Path to Microsoft.Windows.AI.IsolationSession.SDK.<version>.nupkg.
@@ -129,8 +129,8 @@ try {
     if ($packageId -ne 'Microsoft.Windows.AI.IsolationSession.SDK') {
         throw "Unexpected package id '$packageId'."
     }
-    if ($packageVersion -notmatch '^0\.(\d{2}|20\d{2})(0[1-9]|1[0-2])\.(\d+)$') {
-        throw "Unexpected package version '$packageVersion'; expected 0.YYMM.patch or 0.YYYYMM.patch."
+    if ($packageVersion -notmatch '^0\.(20\d{2})(0[1-9]|1[0-2])\.(\d+)$') {
+        throw "Unexpected package version '$packageVersion'; expected 0.YYYYMM.patch."
     }
 
     $year = $Matches[1]
@@ -224,33 +224,32 @@ finally {
     $archive.Dispose()
 }
 
-$destinationPackage = Join-Path $DestinationDirectory $canonicalFileName
-$sourceResolved = $package.FullName
-$destinationResolved = [System.IO.Path]::GetFullPath($destinationPackage)
-if ($sourceResolved -ine $destinationResolved) {
-    $temporaryPackage = "$destinationPackage.new"
-    try {
-        Copy-Item -LiteralPath $sourceResolved -Destination $temporaryPackage -Force
-        Get-ChildItem -LiteralPath $DestinationDirectory -Filter '*.nupkg' -File |
-            Where-Object { $_.FullName -ine $temporaryPackage } |
-            Remove-Item -Force
-        Move-Item -LiteralPath $temporaryPackage -Destination $destinationPackage -Force
-    }
-    finally {
-        if (Test-Path -LiteralPath $temporaryPackage) {
-            Remove-Item -LiteralPath $temporaryPackage -Force
-        }
-    }
+$packageHash = (Get-FileHash -LiteralPath $package.FullName -Algorithm SHA256).Hash.ToLowerInvariant()
+$repositoryRoot = [System.IO.Path]::GetFullPath(
+    (Join-Path $DestinationDirectory '..\..\..'))
+$pinPath = Join-Path $repositoryRoot 'src\core\mxc_build_common\src\lib.rs'
+if (-not (Test-Path -LiteralPath $pinPath -PathType Leaf)) {
+    throw "IsolationSession SDK pin file does not exist: '$pinPath'."
 }
-else {
-    Get-ChildItem -LiteralPath $DestinationDirectory -Filter '*.nupkg' -File |
-        Where-Object { $_.FullName -ine $destinationResolved } |
-        Remove-Item -Force
+
+$pinContent = [System.IO.File]::ReadAllText($pinPath)
+$versionPattern = 'pub const PACKAGE_VERSION: &str = "[^"]+";'
+$hashPattern = 'pub const PACKAGE_SHA256: &str =\s*"[^"]+";'
+if ([regex]::Matches($pinContent, $versionPattern).Count -ne 1) {
+    throw "Expected exactly one PACKAGE_VERSION pin in '$pinPath'."
+}
+if ([regex]::Matches($pinContent, $hashPattern).Count -ne 1) {
+    throw "Expected exactly one PACKAGE_SHA256 pin in '$pinPath'."
 }
 
-# Cargo build scripts track this package by timestamp. Refresh it even when a
-# corrected package reuses the same version and canonical file name.
-(Get-Item -LiteralPath $destinationPackage).LastWriteTimeUtc = [DateTime]::UtcNow
+$pinContent = [regex]::Replace(
+    $pinContent,
+    $versionPattern,
+    "pub const PACKAGE_VERSION: &str = `"$packageVersion`";")
+$pinContent = [regex]::Replace(
+    $pinContent,
+    $hashPattern,
+    "pub const PACKAGE_SHA256: &str =`n        `"$packageHash`";")
 
 $parsedGeneratedDate = [DateTimeOffset]::MinValue
 if ($releaseGeneratedTimestamp -and
@@ -294,11 +293,17 @@ if ($buildGuid) {
 }
 
 $generationInfoPath = Join-Path $DestinationDirectory 'GENERATION_INFO.toml'
-Set-Content -LiteralPath $generationInfoPath -Value $generationInfo -Encoding UTF8
+$utf8WithoutBom = [System.Text.UTF8Encoding]::new($false)
+[System.IO.File]::WriteAllText($pinPath, $pinContent, $utf8WithoutBom)
+[System.IO.File]::WriteAllText(
+    $generationInfoPath,
+    "$generationInfo`n",
+    $utf8WithoutBom)
 
 [pscustomobject][ordered]@{
-    Package = $destinationPackage
-    PackageSha256 = (Get-FileHash -LiteralPath $destinationPackage -Algorithm SHA256).Hash
+    Package = $package.FullName
+    PackageSha256 = $packageHash
+    PackageVersion = $packageVersion
     PreviewWinmdSha256 = $previewHash
     OsBuild = $osBuild
     BuildGuid = $buildGuid
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
index 619931988..95fb672f0 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
@@ -29,12 +29,12 @@ use windows_core::{HSTRING, PCWSTR};
 
 use super::console_mode::{get_local_console_size, ConsoleModeRestorer, CtrlHandlerGuard};
 use super::console_relay::{create_console_relay_thread, ConsoleRelayParams};
-#[cfg(feature = "lifted_msi")]
-use super::error::{framework_unavailable, lifted_payload_missing};
 use super::error::{
     activation_error, check_result, format_iso_error, lifecycle_err, op, transport_err,
     IsolationSessionError, StalePromotion,
 };
+#[cfg(feature = "lifted_msi")]
+use super::error::{framework_unavailable, lifted_payload_missing};
 use super::owned_thread::{self, Impersonation};
 use super::pipe_relay::{
     create_relay_thread, create_relay_thread_with_stop, duplicate_handle, PipeRelayWithStopParams,
@@ -1549,23 +1549,37 @@ mod tests {
             Err(IsolationSessionError::ServiceUnavailable(failure)) => {
                 // Service is NOT available. Verify the error is clean and
                 // descriptive (not a panic or cryptic COM error), and that
-                // it names the activation operation it failed on. On a host
-                // without the adjacent lifted payload (the usual dev box),
-                // activation resolves to the lifted hard error; on a
-                // host where the class is inbox-registered but unavailable it
-                // is the "not available" message.
+                // it names the operation it failed on. Lifted builds verify
+                // the adjacent framework before activation; inbox builds go
+                // directly to activation.
                 assert!(
                     failure.message.contains("not available")
                         || failure.message.contains("activation failed")
-                        || failure.message.contains("lifted activation was not taken"),
+                        || failure.message.contains("lifted activation was not taken")
+                        || failure
+                            .message
+                            .contains("framework verification entry point could not be loaded"),
                     "Expected descriptive error message, got: {}",
                     failure.message
                 );
-                assert_eq!(failure.operation, op::ACTIVATE);
-                assert!(
-                    failure.code.is_some(),
-                    "activation failure carries no HRESULT"
-                );
+
+                #[cfg(feature = "lifted_msi")]
+                {
+                    assert_eq!(failure.operation, op::VERIFY_FRAMEWORK);
+                    assert!(
+                        failure.code.is_none(),
+                        "framework refusal unexpectedly carried an HRESULT"
+                    );
+                }
+
+                #[cfg(not(feature = "lifted_msi"))]
+                {
+                    assert_eq!(failure.operation, op::ACTIVATE);
+                    assert!(
+                        failure.code.is_some(),
+                        "activation failure carries no HRESULT"
+                    );
+                }
             }
             Err(other) => {
                 panic!("expected ServiceUnavailable variant, got: {:?}", other);
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
index 4339d4366..f999f8871 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
@@ -15,7 +15,9 @@ use std::path::PathBuf;
 use std::sync::OnceLock;
 
 use windows::core::{s, HSTRING, PCSTR, PCWSTR, PWSTR};
-use windows::Win32::Foundation::{GetLastError, ERROR_NOT_SUPPORTED, REGDB_E_CLASSNOTREG, S_OK};
+use windows::Win32::Foundation::{
+    ERROR_NOT_SUPPORTED, ERROR_PROC_NOT_FOUND, REGDB_E_CLASSNOTREG, S_OK,
+};
 use windows::Win32::System::Com::{CoInitializeEx, CoTaskMemFree, COINIT_MULTITHREADED};
 use windows::Win32::System::LibraryLoader::{
     GetProcAddress, LoadLibraryExW, LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR, LOAD_LIBRARY_SEARCH_SYSTEM32,
@@ -25,6 +27,7 @@ use windows_core::{Interface, RuntimeName, HRESULT};
 
 const SHIM_NAME: &str = "IsoSessionApp.dll";
 const MANIFEST_NAME: &str = "IsoSession.manifest";
+const RPC_E_CHANGED_MODE: u32 = 0x8001_0106;
 
 type DllGetActivationFactory =
     unsafe extern "system" fn(*mut std::ffi::c_void, *mut *mut std::ffi::c_void) -> HRESULT;
@@ -84,7 +87,10 @@ where
 {
     // Some callers enter through a native thread without initializing COM.
     // RPC_E_CHANGED_MODE only means another apartment model is already active.
-    let _ = unsafe { CoInitializeEx(None, COINIT_MULTITHREADED) };
+    let initialize_result = unsafe { CoInitializeEx(None, COINIT_MULTITHREADED) };
+    if initialize_result.is_err() && initialize_result.0 as u32 != RPC_E_CHANGED_MODE {
+        return Some(Err(windows_core::Error::from_hresult(initialize_result)));
+    }
 
     let directory = adjacent_runtime_directory()?;
     let factory = match load_activation_factory::<T>(&directory.join(SHIM_NAME)) {
@@ -176,7 +182,7 @@ fn resolve_verify_framework(
         )
     }?;
     let export = unsafe { GetProcAddress(module, VERIFY_FRAMEWORK_EXPORT) }.ok_or_else(|| {
-        windows_core::Error::from_hresult(HRESULT::from_win32(unsafe { GetLastError().0 }))
+        windows_core::Error::from_hresult(HRESULT::from_win32(ERROR_PROC_NOT_FOUND.0))
     })?;
 
     // The module intentionally stays loaded; the process only verifies once.
@@ -243,7 +249,7 @@ fn resolve_get_activation_factory(
     }?;
     let export =
         unsafe { GetProcAddress(module, s!("DllGetActivationFactory")) }.ok_or_else(|| {
-            windows_core::Error::from_hresult(HRESULT::from_win32(unsafe { GetLastError().0 }))
+            windows_core::Error::from_hresult(HRESULT::from_win32(ERROR_PROC_NOT_FOUND.0))
         })?;
     let get_factory: DllGetActivationFactory = unsafe { std::mem::transmute(export) };
 
diff --git a/src/tools/wxc/Cargo.toml b/src/tools/wxc/Cargo.toml
index e8b316614..b526a7740 100644
--- a/src/tools/wxc/Cargo.toml
+++ b/src/tools/wxc/Cargo.toml
@@ -23,7 +23,7 @@ tempfile.workspace = true
 cc = "1"
 sha2.workspace = true
 winresource.workspace = true
-zip = "2"
+zip = { version = "2", default-features = false, features = ["deflate"] }
 
 [build-dependencies]
 serde.workspace = true
diff --git a/src/tools/wxc/build.rs b/src/tools/wxc/build.rs
index 70f67b652..56d59ba7b 100644
--- a/src/tools/wxc/build.rs
+++ b/src/tools/wxc/build.rs
@@ -53,11 +53,7 @@ fn reconcile_isolation_session_runtime() {
         .unwrap_or_else(|e| panic!("IsolationSession SDK staging failed: {e}"));
 
     #[cfg(not(feature = "isolation_session_lifted"))]
-    for file_name in [
-        "IsoSessionApp.dll",
-        "IsoSession.manifest",
-        "IsoSessionApp.runtimeversion",
-    ] {
+    for file_name in ["IsoSessionApp.dll", "IsoSession.manifest"] {
         let path = target_dir.join(file_name);
         match std::fs::remove_file(&path) {
             Ok(()) => {}

From bd2a0f6f79babb6f71f93e510b306b4e1f735fa2 Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Tue, 6 Oct 2026 14:39:37 -0700
Subject: [PATCH 19/26] Consume published IsolationSession SDK package

Pin Microsoft.AI.IsolationSession.SDK 0.202610.5 from NuGet.org and refresh the generated provenance and package diagnostics.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 1d43372e-f942-4bb7-a358-48f9218c2332
---
 .../backends/isolation-session/oneshot.md          |  2 +-
 src/mxc-sdk/build/build_mxc_build_common.rs        | 14 +++++++-------
 .../GENERATION_INFO.toml                           |  8 ++++----
 .../Update-IsoSessionSdk.ps1                       |  4 ++--
 .../src/backends/isolation_session/common/error.rs |  4 ++--
 5 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/docs/development/architecture/backends/isolation-session/oneshot.md b/docs/development/architecture/backends/isolation-session/oneshot.md
index 52f75ff0e..4a080bdc6 100644
--- a/docs/development/architecture/backends/isolation-session/oneshot.md
+++ b/docs/development/architecture/backends/isolation-session/oneshot.md
@@ -238,7 +238,7 @@ MXC supports two explicit metadata paths:
   `bindings.rs` and normal inbox WinRT activation. The private source WinMD is
   not committed; its provenance is recorded in `GENERATION_INFO.toml`.
 - **Lifted mode (`isolation_session_lifted`)** resolves the pinned
-  `Microsoft.Windows.AI.IsolationSession.SDK` package, generates Rust bindings
+  `Microsoft.AI.IsolationSession.SDK` package, generates Rust bindings
   from its Preview WinMD at build time, and stages the package's activation
   shim and manifest. The package itself is not committed.
 
diff --git a/src/mxc-sdk/build/build_mxc_build_common.rs b/src/mxc-sdk/build/build_mxc_build_common.rs
index 1f6b5e7a1..a523d2e37 100644
--- a/src/mxc-sdk/build/build_mxc_build_common.rs
+++ b/src/mxc-sdk/build/build_mxc_build_common.rs
@@ -17,10 +17,10 @@ pub mod isolation_session_sdk {
     use std::path::{Path, PathBuf};
     use std::process::Command;
 
-    pub const PACKAGE_ID: &str = "Microsoft.Windows.AI.IsolationSession.SDK";
-    pub const PACKAGE_VERSION: &str = "0.202609.0";
+    pub const PACKAGE_ID: &str = "Microsoft.AI.IsolationSession.SDK";
+    pub const PACKAGE_VERSION: &str = "0.202610.5";
     pub const PACKAGE_SHA256: &str =
-        "2ce0c920f55b879eec3f3841e286d4be8f53b1a5ee42d5f16f997c6e24a09397";
+        "b387c9d11808bf8864d3d7e4d6924f79bdcd6e7c4c54c4e2e49ab0e3525b3d2e";
     pub const PACKAGE_PATH_ENV: &str = "ISOLATION_SESSION_SDK_PACKAGE";
 
     const APP_DLL: &str = "IsoSessionApp.dll";
@@ -313,22 +313,22 @@ pub mod isolation_session_sdk {
 <assembly>
   <assemblyIdentity name=\"IsoSession.Runtime\" />
   <file name=\"IsoSessionApp.dll\" />
-  <iso:instance name=\"2026.09\" />
+  <iso:instance name=\"2026.10\" />
 </assembly>";
 
         #[test]
         fn package_version_maps_to_runtime_instance() {
-            assert_eq!(package_runtime_instance().unwrap(), "2026.09");
+            assert_eq!(package_runtime_instance().unwrap(), "2026.10");
         }
 
         #[test]
         fn completed_runtime_manifest_is_accepted() {
-            validate_runtime_manifest(MANIFEST.as_bytes(), "2026.09").unwrap();
+            validate_runtime_manifest(MANIFEST.as_bytes(), "2026.10").unwrap();
         }
 
         #[test]
         fn mismatched_runtime_manifest_is_rejected() {
-            let error = validate_runtime_manifest(MANIFEST.as_bytes(), "2026.10").unwrap_err();
+            let error = validate_runtime_manifest(MANIFEST.as_bytes(), "2026.11").unwrap_err();
             assert!(error.contains("does not identify runtime instance"));
         }
 
diff --git a/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml b/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
index 4182fcc29..eec63fbb1 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
+++ b/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
@@ -6,12 +6,12 @@
 [tool]
 windows_bindgen_version = "0.62.1"
 target_windows_crate = "0.62"
-generated_date = "2026-09-24"
+generated_date = "2026-10-06"
 
 [source]
-nupkg = "Microsoft.Windows.AI.IsolationSession.SDK.0.202609.0.nupkg"
+nupkg = "Microsoft.AI.IsolationSession.SDK.0.202610.5.nupkg"
 winmd = "metadata/windows.ai.isolationsession.preview.winmd"
 winmd_sha256 = "C6115B52525B06316BE77BEEB4FC4624C5CBB1CEC02E5493D86C46D90FABD6A9"
 namespace = "Windows.AI.IsolationSession.Preview"
-runtime_version = "2026_09"
-build_guid = "4b65b23a-aecf-b892-ff92-ba6b0c005688"
+runtime_version = "2026_10"
+build_guid = "e5ad0558-b9a6-a19a-f50e-cc2ebcaccf65"
diff --git a/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1 b/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1
index 036e7547d..619aba242 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1
+++ b/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1
@@ -11,7 +11,7 @@
     tracked files when the package is incomplete or internally inconsistent.
 
 .PARAMETER PackagePath
-    Path to Microsoft.Windows.AI.IsolationSession.SDK.<version>.nupkg.
+    Path to Microsoft.AI.IsolationSession.SDK.<version>.nupkg.
 
 .PARAMETER DestinationDirectory
     MXC's external\windows-sdk\isolation-session directory. Defaults to the
@@ -126,7 +126,7 @@ try {
     [xml] $nuspec = Convert-BytesToText -Bytes $nuspecBytes
     $packageId = [string] $nuspec.package.metadata.id
     $packageVersion = [string] $nuspec.package.metadata.version
-    if ($packageId -ne 'Microsoft.Windows.AI.IsolationSession.SDK') {
+    if ($packageId -ne 'Microsoft.AI.IsolationSession.SDK') {
         throw "Unexpected package id '$packageId'."
     }
     if ($packageVersion -notmatch '^0\.(20\d{2})(0[1-9]|1[0-2])\.(\d+)$') {
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/error.rs b/src/mxc-sdk/src/backends/isolation_session/common/error.rs
index d39528c70..7ae0354d9 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/error.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/error.rs
@@ -325,7 +325,7 @@ pub(super) fn activation_error(code: u32, detail: &str) -> IsolationSessionError
          version-pin mismatch: the Preview WinMD wxc-exec was built against and the \
          MSI-installed IsolationSession runtime were produced from different OS versions, so \
          their interface IIDs differ. Rebuild the MSI and the \
-         Microsoft.Windows.AI.IsolationSession.SDK nuget from the same OS commit."
+         Microsoft.AI.IsolationSession.SDK NuGet from the same OS commit."
                 .to_string()
         } else {
             format!("IsolationSession runtime API activation failed: {detail}")
@@ -375,7 +375,7 @@ pub(super) fn lifted_payload_missing(operation: &str) -> IsolationSessionError {
                 .to_string(),
         ),
         Some(
-            "Rebuild against the Microsoft.Windows.AI.IsolationSession.SDK NuGet so \
+            "Rebuild against the Microsoft.AI.IsolationSession.SDK NuGet so \
              IsoSessionApp.dll and its stamped IsoSession.manifest are staged beside the host, \
              and install the matching runtime MSI (`winget install Microsoft.AI.IsolationSession`)."
                 .to_string(),

From 9aca872722c1716479690d4a72b57c2c7b69a8d8 Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Tue, 6 Oct 2026 15:56:58 -0700
Subject: [PATCH 20/26] Finalize IsolationSession SDK package integration

Correct the relocated updater paths, refresh the Cargo lockfile, and fix lifted-mode validation discovered after rebasing.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 1d43372e-f942-4bb7-a358-48f9218c2332
---
 .github/workflows/Build.yml                   |  5 ++-
 .../backends/isolation-session/oneshot.md     |  2 +-
 src/Cargo.lock                                |  3 ++
 src/ffi/mxc_ffi/build.rs                      | 36 ++++++++++---------
 .../build/build_isolation_session_bindings.rs |  4 +--
 src/mxc-sdk/build/build_mxc_build_common.rs   |  4 +++
 .../Update-IsoSessionSdk.ps1                  |  8 ++---
 .../isolation_session/common/manager.rs       |  3 ++
 8 files changed, 37 insertions(+), 28 deletions(-)

diff --git a/.github/workflows/Build.yml b/.github/workflows/Build.yml
index 5444117be..28fde51d9 100644
--- a/.github/workflows/Build.yml
+++ b/.github/workflows/Build.yml
@@ -42,9 +42,8 @@ jobs:
     needs: dependency-feed-check
     uses: ./.github/workflows/Build.Windows.Job.yml
     with:
-      # Enable after the pinned SDK package is published at the endpoint used
-      # by mxc_build_common. Until then, package-independent helper tests still
-      # run in the normal x64 Windows job.
+      # Opt in to the additional build that restores the pinned public SDK,
+      # generates its bindings, and validates the adjacent activation payload.
       run_isolation_session_lifted: ${{ vars.MXC_ISOLATION_SESSION_LIFTED_CI == 'true' }}
 
   linux:
diff --git a/docs/development/architecture/backends/isolation-session/oneshot.md b/docs/development/architecture/backends/isolation-session/oneshot.md
index 4a080bdc6..2645552eb 100644
--- a/docs/development/architecture/backends/isolation-session/oneshot.md
+++ b/docs/development/architecture/backends/isolation-session/oneshot.md
@@ -215,7 +215,7 @@ The lifted path obtains the factory from the shim's `DllGetActivationFactory`
 export and calls
 `IActivationFactory::ActivateInstance` directly — which, unlike the
 inbox `RoActivateInstance` path, does **not** implicitly initialize the
-WinRT/COM apartment. `src/core/wxc/src/main.rs` calls
+WinRT/COM apartment. `src/tools/wxc/src/main.rs` calls
 `CoInitializeEx(COINIT_MULTITHREADED)` at startup, and `regfree.rs`
 additionally calls `CoInitializeEx` before activation so the factory's internal
 COM activation (coresident client → service) has an initialized apartment even
diff --git a/src/Cargo.lock b/src/Cargo.lock
index c8f41b907..5db5fa82b 100644
--- a/src/Cargo.lock
+++ b/src/Cargo.lock
@@ -1558,8 +1558,10 @@ dependencies = [
  "serde",
  "serde_ignored",
  "serde_json",
+ "sha2",
  "tempfile",
  "winresource",
+ "zip",
 ]
 
 [[package]]
@@ -3109,6 +3111,7 @@ dependencies = [
  "mxc-sdk",
  "serde",
  "serde_json",
+ "sha2",
  "tempfile",
  "windows",
  "winresource",
diff --git a/src/ffi/mxc_ffi/build.rs b/src/ffi/mxc_ffi/build.rs
index 217e69a29..f86c73ecb 100644
--- a/src/ffi/mxc_ffi/build.rs
+++ b/src/ffi/mxc_ffi/build.rs
@@ -35,28 +35,30 @@ fn main() {
 
 #[cfg(all(windows, feature = "isolation_session"))]
 fn reconcile_isolation_session_runtime() {
-    let out_dir = std::path::PathBuf::from(std::env::var("OUT_DIR").expect("OUT_DIR"));
-    let target_dir = out_dir
-        .parent()
-        .and_then(|path| path.parent())
-        .and_then(|path| path.parent())
-        .expect("could not determine target directory from OUT_DIR");
-
     #[cfg(feature = "isolation_session_lifted")]
     mxc_build_common::isolation_session_sdk::stage_runtime()
         .unwrap_or_else(|error| panic!("IsolationSession SDK staging failed: {error}"));
 
     #[cfg(not(feature = "isolation_session_lifted"))]
-    for file_name in [
-        "IsoSessionApp.dll",
-        "IsoSession.manifest",
-        "IsoSessionApp.runtimeversion",
-    ] {
-        let path = target_dir.join(file_name);
-        match std::fs::remove_file(&path) {
-            Ok(()) => {}
-            Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
-            Err(error) => panic!("remove stale lifted payload {}: {error}", path.display()),
+    {
+        let out_dir = std::path::PathBuf::from(std::env::var("OUT_DIR").expect("OUT_DIR"));
+        let target_dir = out_dir
+            .parent()
+            .and_then(|path| path.parent())
+            .and_then(|path| path.parent())
+            .expect("could not determine target directory from OUT_DIR");
+
+        for file_name in [
+            "IsoSessionApp.dll",
+            "IsoSession.manifest",
+            "IsoSessionApp.runtimeversion",
+        ] {
+            let path = target_dir.join(file_name);
+            match std::fs::remove_file(&path) {
+                Ok(()) => {}
+                Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
+                Err(error) => panic!("remove stale lifted payload {}: {error}", path.display()),
+            }
         }
     }
 }
diff --git a/src/mxc-sdk/build/build_isolation_session_bindings.rs b/src/mxc-sdk/build/build_isolation_session_bindings.rs
index de0d4f395..e35f12e73 100644
--- a/src/mxc-sdk/build/build_isolation_session_bindings.rs
+++ b/src/mxc-sdk/build/build_isolation_session_bindings.rs
@@ -136,9 +136,7 @@ fn verify_inbox_bindings_version() {
             )
         });
 
-    let lock_path = Path::new(&manifest_dir)
-        .join("..")
-        .join("Cargo.lock");
+    let lock_path = Path::new(&manifest_dir).join("..").join("Cargo.lock");
     let lock_contents = std::fs::read_to_string(&lock_path).unwrap_or_else(|error| {
         panic!(
             "isolation_session_bindings: read workspace lockfile {}: {error}",
diff --git a/src/mxc-sdk/build/build_mxc_build_common.rs b/src/mxc-sdk/build/build_mxc_build_common.rs
index a523d2e37..920f61e72 100644
--- a/src/mxc-sdk/build/build_mxc_build_common.rs
+++ b/src/mxc-sdk/build/build_mxc_build_common.rs
@@ -6,6 +6,10 @@
 //! Stamps `ProductName`, `FileDescription`, `OriginalFilename`, and
 //! `ProductVersion` (with the git commit hash) into MXC PE executables and libraries.
 
+// This source-included helper is also compiled by binaries that do not expose
+// the lifted feature, so their Cargo manifests cannot declare this cfg value.
+#![allow(unexpected_cfgs)]
+
 use std::io;
 use std::path::Path;
 use std::process::Command;
diff --git a/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1 b/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1
index 619aba242..28b1f1cf0 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1
+++ b/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1
@@ -14,8 +14,8 @@
     Path to Microsoft.AI.IsolationSession.SDK.<version>.nupkg.
 
 .PARAMETER DestinationDirectory
-    MXC's external\windows-sdk\isolation-session directory. Defaults to the
-    directory containing this script.
+    MXC's src\mxc-sdk\build\isolation_session_bindings directory. Defaults to
+    the directory containing this script.
 #>
 [CmdletBinding()]
 param(
@@ -226,8 +226,8 @@ finally {
 
 $packageHash = (Get-FileHash -LiteralPath $package.FullName -Algorithm SHA256).Hash.ToLowerInvariant()
 $repositoryRoot = [System.IO.Path]::GetFullPath(
-    (Join-Path $DestinationDirectory '..\..\..'))
-$pinPath = Join-Path $repositoryRoot 'src\core\mxc_build_common\src\lib.rs'
+    (Join-Path $DestinationDirectory '..\..\..\..'))
+$pinPath = Join-Path $repositoryRoot 'src\mxc-sdk\build\build_mxc_build_common.rs'
 if (-not (Test-Path -LiteralPath $pinPath -PathType Leaf)) {
     throw "IsolationSession SDK pin file does not exist: '$pinPath'."
 }
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
index 95fb672f0..b9721ac17 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
@@ -1556,6 +1556,9 @@ mod tests {
                     failure.message.contains("not available")
                         || failure.message.contains("activation failed")
                         || failure.message.contains("lifted activation was not taken")
+                        || failure
+                            .message
+                            .contains("does not support runtime verification")
                         || failure
                             .message
                             .contains("framework verification entry point could not be loaded"),

From bd09aceb49ceef95bd5dd6516591fba9d50fc28f Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Wed, 7 Oct 2026 11:12:39 -0700
Subject: [PATCH 21/26] Fix packaged IsolationSession lockfile lookup

Support Cargo.lock at either the packaged crate root or workspace root, and track the selected provenance inputs for build-script reruns.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 1d43372e-f942-4bb7-a358-48f9218c2332
---
 .../build/build_isolation_session_bindings.rs | 20 +++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/src/mxc-sdk/build/build_isolation_session_bindings.rs b/src/mxc-sdk/build/build_isolation_session_bindings.rs
index e35f12e73..4207b370e 100644
--- a/src/mxc-sdk/build/build_isolation_session_bindings.rs
+++ b/src/mxc-sdk/build/build_isolation_session_bindings.rs
@@ -111,6 +111,7 @@ fn verify_inbox_bindings_version() {
         .join("build")
         .join("isolation_session_bindings")
         .join("GENERATION_INFO.toml");
+    println!("cargo:rerun-if-changed={}", info_path.display());
     let contents = std::fs::read_to_string(&info_path).unwrap_or_else(|error| {
         panic!(
             "isolation_session_bindings: read provenance {}: {error}",
@@ -136,10 +137,25 @@ fn verify_inbox_bindings_version() {
             )
         });
 
-    let lock_path = Path::new(&manifest_dir).join("..").join("Cargo.lock");
+    let lock_candidates = [
+        Path::new(&manifest_dir).join("Cargo.lock"),
+        Path::new(&manifest_dir).join("..").join("Cargo.lock"),
+    ];
+    let lock_path = lock_candidates
+        .iter()
+        .find(|path| path.is_file())
+        .unwrap_or_else(|| {
+            panic!(
+                "isolation_session_bindings: no Cargo.lock found at the package root ({}) \
+                 or workspace root ({})",
+                lock_candidates[0].display(),
+                lock_candidates[1].display()
+            )
+        });
+    println!("cargo:rerun-if-changed={}", lock_path.display());
     let lock_contents = std::fs::read_to_string(&lock_path).unwrap_or_else(|error| {
         panic!(
-            "isolation_session_bindings: read workspace lockfile {}: {error}",
+            "isolation_session_bindings: read lockfile {}: {error}",
             lock_path.display()
         )
     });

From 1040b76bc49cb804e2d3e9eaad3b382ea773b0d6 Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Wed, 7 Oct 2026 13:32:24 -0700
Subject: [PATCH 22/26] Use configured NuGet restore for lifted
 IsolationSession

Resolve the blocking acquisition and validation findings by restoring through MxcDependencies into an MXC-owned cache, seeding the pinned package, and requiring lifted CI coverage. Also reconcile staged payloads, improve activation diagnostics, balance COM initialization, and update the backend documentation.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 1d43372e-f942-4bb7-a358-48f9218c2332
---
 .azure-pipelines/Update.Feed.Dependencies.yml |  25 +-
 .azure-pipelines/scripts/seed_feed.py         |  88 +++++-
 .github/workflows/Build.Windows.Job.yml       |  86 ++++++
 .github/workflows/Build.yml                   |   4 +-
 .../backends/isolation-session/oneshot.md     | 278 ++++++++----------
 src/ffi/mxc_ffi/build.rs                      |  22 +-
 src/mxc-sdk/build/build_mxc_build_common.rs   | 166 ++++++-----
 .../IsolationSessionSdk.Restore.csproj        |  12 +
 .../isolation_session_bindings/NuGet.Config   |   8 +
 .../isolation_session/common/error.rs         |  44 ++-
 .../isolation_session/common/manager.rs       |  19 +-
 .../isolation_session/common/regfree.rs       |  40 ++-
 12 files changed, 497 insertions(+), 295 deletions(-)
 create mode 100644 src/mxc-sdk/build/isolation_session_bindings/IsolationSessionSdk.Restore.csproj
 create mode 100644 src/mxc-sdk/build/isolation_session_bindings/NuGet.Config

diff --git a/.azure-pipelines/Update.Feed.Dependencies.yml b/.azure-pipelines/Update.Feed.Dependencies.yml
index d798c0ef1..7fb851515 100644
--- a/.azure-pipelines/Update.Feed.Dependencies.yml
+++ b/.azure-pipelines/Update.Feed.Dependencies.yml
@@ -1,5 +1,5 @@
-# Seeds the public shine-oss MxcDependencies feed with every crates.io crate in
-# src/Cargo.lock.
+# Seeds the public shine-oss MxcDependencies feeds with the dependencies pinned
+# by src/Cargo.lock and the IsolationSession SDK package constants.
 #
 # This pipeline cannot be run with `/azp run`; run it manually from shine-oss
 # (Run pipeline at https://dev.azure.com/shine-oss/mxc/_build?definitionId=33).
@@ -21,17 +21,26 @@ jobs:
       - checkout: self
         persistCredentials: true
 
-      # Overlay only the lockfile from the PR head onto the trusted checkout. cargo is never
-      # run and only Cargo.lock (data) is read, so no PR code executes. Review the PR's
-      # Cargo.lock first.
+      # Overlay only dependency-pin data from the PR head onto the trusted
+      # checkout. Neither Cargo nor the Rust source is executed: the script
+      # parses Cargo.lock and three string constants from the build helper.
+      # Review both files before running this manually triggered pipeline.
       - script: |
           set -euo pipefail
           git fetch origin "pull/${{ parameters.prNumber }}/head"
-          git checkout FETCH_HEAD -- src/Cargo.lock
-          echo "Overlaid Cargo.lock from PR #${{ parameters.prNumber }}"
-        displayName: Overlay Cargo.lock from PR
+          git checkout FETCH_HEAD -- \
+            src/Cargo.lock \
+            src/mxc-sdk/build/build_mxc_build_common.rs
+          echo "Overlaid dependency pins from PR #${{ parameters.prNumber }}"
+        displayName: Overlay dependency pins from PR
 
       - script: python3 .azure-pipelines/scripts/seed_feed.py
         displayName: Seed the MxcDependencies feed from Cargo.lock
         env:
           SYSTEM_ACCESSTOKEN: $(System.AccessToken)
+
+      - task: NuGetAuthenticate@1
+        displayName: Authenticate to MxcDependencies
+
+      - script: python3 .azure-pipelines/scripts/seed_feed.py --nuget-only
+        displayName: Seed the IsolationSession SDK package into MxcDependencies
diff --git a/.azure-pipelines/scripts/seed_feed.py b/.azure-pipelines/scripts/seed_feed.py
index 117f48ec1..0b4658f65 100644
--- a/.azure-pipelines/scripts/seed_feed.py
+++ b/.azure-pipelines/scripts/seed_feed.py
@@ -1,24 +1,35 @@
 #!/usr/bin/env python3
-"""Seed the public MxcDependencies cargo feed from src/Cargo.lock.
+"""Seed the public MxcDependencies feeds from pinned repository dependencies.
 
-The feed can be read without credentials, so cargo does not send a token when it reads.
-As a result, cargo cannot make Azure Artifacts pull a missing crate from its crates.io
-upstream. This script instead sends an authenticated request for each locked crate, which
-makes the feed fetch and cache it. Later credential-free reads then resolve every dependency.
+The Cargo feed can be read without credentials, so cargo does not send a token when it
+reads. As a result, cargo cannot make Azure Artifacts pull a missing crate from its
+crates.io upstream. This script instead sends an authenticated request for each locked
+crate, which makes the feed fetch and cache it. Later credential-free reads then resolve
+every dependency.
 
-The script only reads Cargo.lock and never runs cargo or build scripts, so it is safe to run
-against a fork's lockfile.
+The NuGet mode reads the pinned IsolationSession package identity and hash, downloads that
+public package, verifies it, and publishes it through the authenticated NuGet client.
 """
+import hashlib
 import json
 import os
+import re
+import subprocess
 import sys
+import tempfile
 import tomllib
 import urllib.request
+from pathlib import Path
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from typing import NamedTuple
 
 FEED_INDEX_URL = "https://pkgs.dev.azure.com/shine-oss/mxc/_packaging/MxcDependencies/Cargo/index"
 CARGO_LOCK = "src/Cargo.lock"
+ISOLATION_SESSION_PIN = "src/mxc-sdk/build/build_mxc_build_common.rs"
+NUGET_FEED_URL = (
+    "https://pkgs.dev.azure.com/shine-oss/mxc/"
+    "_packaging/MxcDependencies/nuget/v3/index.json"
+)
 MAX_WORKERS = 16
 REQUEST_TIMEOUT = 30  # seconds; fail a stuck request instead of hanging the job
 
@@ -82,7 +93,70 @@ def _read_locked_crates() -> list[Crate]:
     ]
 
 
+def _read_isolation_session_pin() -> tuple[str, str, str]:
+    content = Path(ISOLATION_SESSION_PIN).read_text(encoding="utf-8")
+
+    def constant(name: str) -> str:
+        match = re.search(
+            rf'pub const {name}: &str =\s*"([^"]+)";',
+            content,
+        )
+        if not match:
+            raise RuntimeError(f"Could not read {name} from {ISOLATION_SESSION_PIN}")
+        return match.group(1)
+
+    return (
+        constant("PACKAGE_ID"),
+        constant("PACKAGE_VERSION"),
+        constant("PACKAGE_SHA256"),
+    )
+
+
+def _seed_nuget_package() -> None:
+    package_id, version, expected_hash = _read_isolation_session_pin()
+    lower_id = package_id.lower()
+    file_name = f"{lower_id}.{version}.nupkg"
+    source_url = f"https://api.nuget.org/v3-flatcontainer/{lower_id}/{version}/{file_name}"
+
+    with tempfile.TemporaryDirectory() as directory:
+        package_path = Path(directory) / file_name
+        print(f"Downloading {package_id} {version} from NuGet.org for feed seeding")
+        with urllib.request.urlopen(source_url, timeout=REQUEST_TIMEOUT) as response:
+            package_path.write_bytes(response.read())
+
+        actual_hash = hashlib.sha256(package_path.read_bytes()).hexdigest()
+        if actual_hash.lower() != expected_hash.lower():
+            raise RuntimeError(
+                f"{package_id} {version} hash mismatch: "
+                f"expected {expected_hash}, got {actual_hash}"
+            )
+
+        subprocess.run(
+            [
+                "dotnet",
+                "nuget",
+                "push",
+                str(package_path),
+                "--source",
+                NUGET_FEED_URL,
+                "--api-key",
+                "AzureDevOps",
+                "--skip-duplicate",
+            ],
+            check=True,
+        )
+        print(f"Seeded {package_id} {version} into MxcDependencies")
+
+
 def main() -> int:
+    if sys.argv[1:] == ["--nuget-only"]:
+        try:
+            _seed_nuget_package()
+        except (OSError, RuntimeError, subprocess.CalledProcessError) as error:
+            print(f"Failed to seed IsolationSession SDK package: {error}")
+            return 1
+        return 0
+
     token = os.environ.get("SYSTEM_ACCESSTOKEN")
     if not token:
         print("SYSTEM_ACCESSTOKEN is not set; cannot authenticate to the feed")
diff --git a/.github/workflows/Build.Windows.Job.yml b/.github/workflows/Build.Windows.Job.yml
index 64a3039a2..3f2e04fe2 100644
--- a/.github/workflows/Build.Windows.Job.yml
+++ b/.github/workflows/Build.Windows.Job.yml
@@ -148,6 +148,12 @@ jobs:
           override: false
           rustflags: ''
 
+      - uses: actions/setup-dotnet@a98b56852c35b8e3190ac28c8c2271da59106c68 # v6.0.0
+        with:
+          dotnet-version: |
+            8.0.x
+            10.0.x
+
       - name: Point cargo at the MxcDependencies feed
         uses: ./.github/actions/setup-cargo-feed
 
@@ -168,6 +174,86 @@ jobs:
         run: cargo build --locked --release --target x86_64-pc-windows-msvc
              -p wxc --no-default-features --features isolation_session_lifted
 
+      - name: Build and test lifted .NET SDK
+        working-directory: sdk/dotnet
+        shell: pwsh
+        run: |
+          dotnet build Microsoft.Mxc.Sdk.slnx -p:MxcIsolationSessionLifted=true
+          if ($LASTEXITCODE -ne 0) { throw "dotnet build exited $LASTEXITCODE" }
+
+          $testExe = 'Microsoft.Mxc.Sdk.Tests\bin\Debug\net8.0\Microsoft.Mxc.Sdk.Tests.exe'
+          if (-not (Test-Path -LiteralPath $testExe -PathType Leaf)) {
+            throw "The xUnit v3 test executable was not built: $testExe"
+          }
+
+          $log = Join-Path $env:RUNNER_TEMP 'dotnet-test-isolation-session-lifted.log'
+          & $testExe -automated sync -noColor 2>&1 |
+            Tee-Object -FilePath $log
+          $code = $LASTEXITCODE
+          if ($code -ne 0) { throw "The lifted managed tests exited $code" }
+          $summary = Get-Content -LiteralPath $log |
+            Where-Object { $_ -match '"\$type":"test-assembly-finished"' } |
+            Select-Object -Last 1 |
+            ConvertFrom-Json
+          if ($null -eq $summary -or $summary.TestsTotal -eq 0) {
+            throw 'The lifted run passed no tests, so it did not establish managed coverage.'
+          }
+          if ($summary.TestsFailed -ne 0 -or $summary.TestsNotRun -ne 0) {
+            throw "The lifted managed run was incomplete: $($summary | ConvertTo-Json -Compress)"
+          }
+
+          $pinLog = Join-Path $env:RUNNER_TEMP 'dotnet-test-isolation-session-lifted-pin.log'
+          & $testExe -automated sync -noColor `
+            -method '*IsolationSessionBuildSwitch*' 2>&1 |
+            Tee-Object -FilePath $pinLog
+          $code = $LASTEXITCODE
+          if ($code -ne 0) { throw "The lifted build-switch pin exited $code" }
+          $pinSummary = Get-Content -LiteralPath $pinLog |
+            Where-Object { $_ -match '"\$type":"test-assembly-finished"' } |
+            Select-Object -Last 1 |
+            ConvertFrom-Json
+          if (
+            $null -eq $pinSummary -or
+            $pinSummary.TestsTotal -ne 1 -or
+            $pinSummary.TestsFailed -ne 0 -or
+            $pinSummary.TestsSkipped -ne 0 -or
+            $pinSummary.TestsNotRun -ne 0
+          ) {
+            throw 'The IsolationSession build-switch test did not run and pass in lifted mode.'
+          }
+
+      - name: Pack lifted .NET SDK
+        working-directory: sdk/dotnet
+        shell: pwsh
+        run: |
+          dotnet pack Microsoft.Mxc.Sdk/Microsoft.Mxc.Sdk.csproj `
+            --configuration Release `
+            -p:MxcIsolationSessionLifted=true `
+            -p:MxcPackSingleRid=true `
+            -p:MxcPackageRid=win-x64
+          if ($LASTEXITCODE -ne 0) { throw "dotnet pack exited $LASTEXITCODE" }
+
+          $packages = @(Get-ChildItem Microsoft.Mxc.Sdk\bin\Release\*.nupkg)
+          if ($packages.Count -ne 1) {
+            throw "Expected exactly one packed SDK, found $($packages.Count)."
+          }
+          Add-Type -AssemblyName System.IO.Compression.FileSystem
+          $archive = [System.IO.Compression.ZipFile]::OpenRead($packages[0].FullName)
+          try {
+            $entries = @($archive.Entries | ForEach-Object FullName)
+            foreach ($entry in @(
+              'runtimes/win-x64/native/IsoSessionApp.dll',
+              'runtimes/win-x64/native/IsoSession.manifest'
+            )) {
+              if ($entry -notin $entries) {
+                throw "Packed SDK is missing lifted runtime entry: $entry"
+              }
+            }
+          }
+          finally {
+            $archive.Dispose()
+          }
+
       - name: Verify adjacent activation payload
         shell: pwsh
         run: |
diff --git a/.github/workflows/Build.yml b/.github/workflows/Build.yml
index 28fde51d9..96b46a294 100644
--- a/.github/workflows/Build.yml
+++ b/.github/workflows/Build.yml
@@ -42,9 +42,7 @@ jobs:
     needs: dependency-feed-check
     uses: ./.github/workflows/Build.Windows.Job.yml
     with:
-      # Opt in to the additional build that restores the pinned public SDK,
-      # generates its bindings, and validates the adjacent activation payload.
-      run_isolation_session_lifted: ${{ vars.MXC_ISOLATION_SESSION_LIFTED_CI == 'true' }}
+      run_isolation_session_lifted: true
 
   linux:
     needs: dependency-feed-check
diff --git a/docs/development/architecture/backends/isolation-session/oneshot.md b/docs/development/architecture/backends/isolation-session/oneshot.md
index 2645552eb..88666182f 100644
--- a/docs/development/architecture/backends/isolation-session/oneshot.md
+++ b/docs/development/architecture/backends/isolation-session/oneshot.md
@@ -18,9 +18,9 @@ session. Use cases that need this — per the broader claw-on-MXC scenario — c
 
 ## Proposed Solution
 
-Add an **IsolationSession runner** to `wxc-exec.exe`, behind `--experimental`.
+Add an **IsolationSession runner** to `wxc-exec.exe`.
 When the JSON config specifies `"containment": "isolation_session"` and the
-experimental flag is set, the binary routes to a new `IsolationSessionRunner`
+the backend is selected, the binary routes to a new `IsolationSessionRunner`
 (implementing the existing `ScriptRunner` trait). The runner orchestrates the
 full lifecycle against the OS-side Isolation Session API: provision an
 agent user, start a session, run the script (capturing stdout / stderr /
@@ -38,13 +38,13 @@ reuse the manager's methods individually.
 ## How It Works
 
 ```
-User: wxc-exec.exe --experimental config.json
+User: wxc-exec.exe config.json
        (config.json sets containment = "isolation_session")
    │
    ▼
 wxc-exec.exe (Rust — single binary, multiple backends)
    ├── Parses JSON config → sees containment = "isolation_session"
-   ├── Checks --experimental flag → instantiates IsolationSessionRunner
+   ├── Instantiates IsolationSessionRunner
    ├── Calls IsolationSessionManager methods 1:1 with the OS-side service:
    │     add_user(...)               → Step 1 — creates agent user
    │     start_session(...)          → Step 2 — boots session
@@ -69,14 +69,9 @@ Dispatch in `wxc/src/main.rs`:
 ```rust
 let mut runner: Box<dyn ScriptRunner> = match request.containment {
     ContainmentBackend::AppContainer => Box::new(AppContainerScriptRunner::new()),
-    // ... existing stable + experimental backends ...
-    ContainmentBackend::IsolationSession => {
-        if !request.experimental_enabled {
-            eprintln!("Error: IsolationSession is experimental. Use --experimental.");
-            process::exit(1);
-        }
-        Box::new(IsolationSessionRunner::new(/* ... */))
-    }
+    // ... other containment backends ...
+    ContainmentBackend::IsolationSession =>
+        Box::new(IsolationSessionRunner::new(/* ... */)),
 };
 ```
 
@@ -122,34 +117,34 @@ invocations, without changing the manager's interface. See
 
 ```json
 {
-    "version": "0.6.0-alpha",
+    "version": "0.9.0-alpha",
     "containerId": "MyIsolationSessionRun",
     "containment": "isolation_session",
     "process": {
         "commandLine": "echo hello & whoami",
         "cwd": "C:\\Windows",
         "env": ["MYVAR=hello"],
+        "inheritDefaultEnv": true,
         "timeout": 30000
     },
     "network": {
-        "defaultPolicy": "allow",
-        "allowLocalNetwork": true
-    },
-    "experimental": {
-        "isolation_session": {}
+        "egress": { "default": "allow" },
+        "ingress": { "default": "allow", "hostLoopback": "allow" }
     }
 }
 ```
 
-The one-shot surface takes **no backend configuration at all** — there is no
-`experimental.isolation_session` field the one-shot path reads. The Entra
-`user` bundle is state-aware-only, so supplying it here is just an
-unrecognised key in the deliberately permissive `experimental` block and is
-ignored (the run proceeds as a local, non-Entra agent). Process options
-(`cwd`, `env`, `timeout`) read from the existing top-level `process` section,
-matching the contract every other backend honors.
+The directional shape explicitly describes the backend's actual unrestricted
+posture across egress, ingress, and host loopback. All three values are
+required; rules, proxies, mixed postures, and omission are rejected.
+
+Legacy network fields are rejected.
 
-Run with: `wxc-exec.exe --experimental config.json`.
+`appId` and the nested `provision` section are state-aware-only and are
+rejected on one-shot requests. Process options (`cwd`, `env`, `timeout`) remain
+in the top-level `process` section.
+
+Run with: `wxc-exec.exe config.json`.
 
 ## OS API Dependency
 
@@ -158,70 +153,19 @@ The runner calls into the WinRT API namespaced
 Session service (running as SYSTEM via `svchost.exe`). The API is gated
 on an internal Windows feature flag.
 
-### Activation path and the no-fallback rule
-
-The runtime class `IsoSessionOps` (and `IsoSessionProcessOptions`) is activated
-through a single mechanism in
-`src/backends/isolation_session/common/src/regfree.rs`:
-
-**Direct shim activation.** `regfree::activate_from_adjacent_shim` loads the
-co-located `IsoSessionApp.dll` by absolute path, resolves its
-`DllGetActivationFactory` export, and requests the projected runtime class
-factory directly. The co-located stamped `IsoSession.manifest` selects the
-matching version under `%ProgramFiles%\Microsoft\Agentic Runtime`. The shim
-then loads that version's `IsoSessionClient.dll` and binds the matching
-side-by-side service instance. This bypasses the inbox WinRT catalog without
-machine-wide registration or private classic-COM classes.
-
-**No-fallback rule.** `activate_from_adjacent_shim` returns
-`Option<Result<T>>`, and the callers
-(`manager::check_service_available_and_activate`,
-`process_options::build_iso_process_options`) treat it as:
-
-- **`None`** — the adjacent shim/manifest activation unit is absent (an
-  inbox-only build). This is turned into a
-  **hard, actionable error** (`error::lifted_payload_missing`). MXC deliberately
-  does **not** fall back to the inbox `System32` runtime — silently binding a
-  different, unversioned binary set is exactly the failure this design prevents.
-- **`Some(Err(e))`** — any other activation failure (including a fused-but-
-  broken MSI) is **surfaced** unchanged, never redirected to the inbox binaries.
-  An `E_NOINTERFACE` here is mapped to a version-pin-mismatch message (rebuild
-  the MSI and the SDK nuget from the same OS commit).
-- **`Some(Ok(factory))`** — the coresident factory is used.
-
-### Framework verification
-
-Before any session work, MXC asks the co-located `IsoSessionApp.dll` whether the
-matching IsolationSession runtime is actually installed and loadable on this
-machine. MXC refuses to continue on any failure result, and raises
-`error::framework_unavailable`.
-
-### Runtime folder resolution
-
-Runtime-folder resolution is owned entirely by `IsoSessionApp.dll` (C++,
-`onecoreuap/windows/core/isoenvbroker/src/app/dll.cpp`), **not** by MXC. There
-is no MXC-side environment override — the earlier `MXC_ISOSESSION_RUNTIME_DIR`
-knob has been removed so the runtime location is a single authoritative
-per-machine fact owned by the MSI:
-
-| Source | Effect |
-|---|---|
-| HKLM `InstallDir` (`REG_EXPAND_SZ`) under the runtime install key | Authoritative per-machine install directory recorded by the MSI. Read via `wil::reg::try_get_value_expanded_string`. |
-| Hardcoded fallback in the App DLL | Used only when the HKLM value is absent, so a correctly-installed MSI always wins. |
-
-### Apartment initialization
-
-The lifted path obtains the factory from the shim's `DllGetActivationFactory`
-export and calls
-`IActivationFactory::ActivateInstance` directly — which, unlike the
-inbox `RoActivateInstance` path, does **not** implicitly initialize the
-WinRT/COM apartment. `src/tools/wxc/src/main.rs` calls
-`CoInitializeEx(COINIT_MULTITHREADED)` at startup, and `regfree.rs`
-additionally calls `CoInitializeEx` before activation so the factory's internal
-COM activation (coresident client → service) has an initialized apartment even
-on the `--probe` path, which returns before `main`'s initialization.
-`RPC_E_CHANGED_MODE` is benign because the thread already has an apartment;
-other initialization failures are propagated.
+Activation goes through the WinRT activation factory for the
+`Windows.AI.IsolationSession.Preview` `IsoSessionOps` runtime class.
+
+MXC supports two explicit IsolationSession build modes:
+
+- `isolation_session` uses the checked-in bindings and activates the inbox
+  Windows runtime.
+- `isolation_session_lifted` generates bindings from the pinned
+  `Microsoft.AI.IsolationSession.SDK` package and stages the package's
+  registration-free activation payload beside the executable.
+
+The lifted mode verifies the packaged framework before activation and does not
+fall back to the inbox runtime. Default builds enable neither mode.
 
 The API surface includes the lifecycle methods plus
 `IsoSessionProcess` (the running-process handle). The runner uses the
@@ -232,43 +176,60 @@ flag when `wxc-exec`'s stdout is a TTY.
 
 ## Bindings Workflow
 
-MXC supports two explicit metadata paths:
-
-- **Inbox mode (`isolation_session`)** uses the committed OS-generated
-  `bindings.rs` and normal inbox WinRT activation. The private source WinMD is
-  not committed; its provenance is recorded in `GENERATION_INFO.toml`.
-- **Lifted mode (`isolation_session_lifted`)** resolves the pinned
-  `Microsoft.AI.IsolationSession.SDK` package, generates Rust bindings
-  from its Preview WinMD at build time, and stages the package's activation
-  shim and manifest. The package itself is not committed.
-
-**Generated bindings are committed.**
+**Inbox bindings.** The inbox mode uses a WinMD from an internal Windows OS
+build (the exact file name and provenance are recorded in
+`GENERATION_INFO.toml`). MXC stores the generated Rust bindings in the
+workspace and tracks their provenance.
+
+**Lifted bindings and runtime.** The lifted mode pins
+`Microsoft.AI.IsolationSession.SDK` version `0.202610.5`. The build restores it
+through NuGet using the repository's configured `MxcDependencies` source into
+an MXC-owned cache under the Cargo target directory, verifies the package hash,
+generates bindings from the packaged WinMD, and stages `IsoSessionApp.dll` and
+its activation manifest beside the consuming binary. For offline builds,
+`ISOLATION_SESSION_SDK_PACKAGE` can point to a pre-fetched package with the
+same expected hash.
+
+**Future direction.** The OS API is expected to land in the public Windows
+SDK eventually, at which point the `windows` crate (auto-generated from
+the public Windows SDK metadata) will pick it up automatically. When that
+happens, MXC can drop this private bindings crate and consume the API
+through the standard `windows` crate dependency. That milestone is
+currently far off — the private bindings remain the working approach for
+the foreseeable future.
+
+**Inbox generated bindings are committed.**
 `src/mxc-sdk/src/backends/isolation_session/bindings/bindings.rs` is a checked-in artifact.
-The WinMD itself is **not** committed (binary, frequently updated). All
-provenance lives in `GENERATION_INFO.toml`.
-`windows-bindgen` must remain compatible with the workspace `windows` crate.
-The generated APIs use the stable
-`Windows.AI.IsolationSession.Preview` namespace, including `IsoSessionOps`.
-
-To update lifted mode, run
-`src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1` with the new
-package. The script validates the package, updates the version and SHA-256 pin,
-and regenerates `GENERATION_INFO.toml`; use
-`ISOLATION_SESSION_SDK_PACKAGE` until the exact package is published. Then
-build and test both inbox and lifted configurations. The lifted build validates
-the package hash, runtime-instance manifest, and native shim architecture and
-fails rather than falling back to inbox behavior.
+The private WinMD itself is **not** committed (binary, frequently updated).
+All provenance lives in `GENERATION_INFO.toml`. Lifted bindings are generated
+from the restored package during the build and are not committed.
+
+**Regeneration.** When the inbox OS-side API changes (or the consumed OS build
+moves), the committed bindings must be regenerated by a Microsoft engineer
+with access to the private WinMD. `windows-bindgen` X.Y generates code that
+targets the `windows` X.Y crate, so both inbox regeneration and lifted
+build-time generation must use a `windows-bindgen` release whose major.minor
+matches the workspace `windows` crate. The generated bindings and the Rust
+code in this repo use the `Windows.AI.IsolationSession.Preview` namespace (for
+example, `IsoSessionOps`).
+
+**`build.rs` version check.** `isolation_session_bindings/build.rs` reads
+the expected `windows` crate version from `GENERATION_INFO.toml`
+(`target_windows_crate`) and compares against the actual workspace
+`Cargo.lock`. A mismatch panics the build with a message naming both
+versions and stating that the bindings must be regenerated.
 
 ## v0.1 Scope
 
 **Implemented:**
 
 - Single-shot `provision → start → run → stop → deprovision` lifecycle,
-  gated by `--experimental`.
+  selected directly by the exact v0.9 contract.
 - `process.commandLine` (the script command, wrapped via `cmd.exe /c "..."`
   — the same pattern the LXC runner uses with `/bin/sh -c`).
 - `process.cwd` (working directory inside the session).
-- `process.env` (environment variables forwarded via the OS-side
+- `process.env` with `process.inheritDefaultEnv: true` (the entries are layered
+  over the agent user's default environment through the OS-side
   `IsoSessionProcessOptions`).
 - `process.timeout` (forwarded to the OS-side per-process timeout
   enforcement).
@@ -279,12 +240,15 @@ fails rather than falling back to inbox behavior.
 - `lifecycle.destroyOnExit: false` and `lifecycle.preservePolicy: true`. The
   in-proc API exposes no session-lifetime knob, so the backend cannot vary
   teardown: the one-shot path always stops the session and removes the agent
-  user before returning. `destroyOnExit: true` (the default) is therefore
+  user. `destroyOnExit: true` (the default) is therefore
   accepted because it matches actual behavior; `false` is refused. There is no
   filesystem or network policy to preserve (both are rejected outright), so
   `preservePolicy: true` is refused as meaningless here.
 - `ui` (any value). The backend has no UI-restriction primitive — see the
   cross-cutting policy honor matrix below.
+- `process.env` without `process.inheritDefaultEnv: true`, including `[]`.
+  Every process starts from the agent user's default environment, which the
+  backend cannot replace or empty.
 
 ## Cross-cutting policy honor matrix (one-shot)
 
@@ -295,23 +259,24 @@ the rationale for each disposition, and the error mapping live in
 | Field | one-shot disposition |
 |---|---|
 | `process.commandLine` | **honored** (required) |
-| `process.cwd` / `process.env` / `process.timeout` | **honored** |
+| `process.cwd` / `process.timeout` | **honored** |
+| `process.env` | **honored** with `process.inheritDefaultEnv: true`; rejected without it, including `[]` |
 | `filesystem.{readwritePaths,readonlyPaths,deniedPaths}` | rejected — no host-folder-sharing primitive |
-| `network` — canonical unrestricted acknowledgment (`defaultPolicy=allow` + `allowLocalNetwork=true`, no host rules, no proxy, default enforcement) | **required** |
-| `network` — anything else, including absent (defaults to the unenforceable `block`) | rejected |
+| `network` — directional all-allow (`egress.default`, `ingress.default`, and `ingress.hostLoopback` all `allow`, no rules) | **required** |
+| `network` — legacy fields, absent, empty, restrictive, mixed, rule-bearing, or proxy-bearing | rejected |
 | `ui` | rejected if supplied — no `ui` posture is truthful here (see below); an omitted `ui` is accepted and applies no restriction |
 | `lifecycle.destroyOnExit` | `true` accepted (matches behavior); `false` rejected |
 | `lifecycle.preservePolicy` | `false` accepted; `true` rejected |
 | `fallback.allowDaclMutation` | n/a — AppContainer-only; this backend never mutates DACLs, so either value is vacuously satisfied |
 | `containerId` | accepted, no effect (a label; the backend addresses sandboxes by the OS-assigned agent user name) |
-| `experimental.isolation_session.user` | accepted, ignored — Entra is state-aware-only, and one-shot reads no backend config |
-| `experimental.isolation_session.{provision,start}` | accepted, ignored — per-phase config is state-aware-only |
+| `isolationSession` / one-shot `appId` | rejected as `malformed_request` — IsolationSession one-shot configuration uses only the stable top-level policy |
 | `processContainer` / `lxc` / `seatbelt` / another backend's section | rejected — only the section matching `containment` is accepted |
 
 Refusals surface as a non-zero exit with the reason on stderr. One-shot has no
 typed policy error code: the envelope carries `error.code = "backend_error"` with
-the reason in the message, unlike the state-aware surface which emits
-`policy_validation`.
+the reason in the message. On the state-aware surface, structurally
+representable backend policy failures emit `policy_validation`; fields excluded
+by an exact phase root fail earlier as `malformed_request`.
 
 **Why every supplied `ui` is refused.** The `ui` section states intent about the
 contained code's relationship to the *user's* environment, and was modelled on a
@@ -331,12 +296,11 @@ The full field-by-field table is in
 
 **Deferred to follow-up work:**
 
-- **TypeScript SDK exposure.** Adding a one-shot isolation-session config
-  surface to `SandboxSpawnOptions` so the SDK can spawn isolation-session
-  workloads programmatically **on the one-shot path**. Today the one-shot
-  backend is reachable only via JSON config (`spawnSandboxFromConfig` or
-  `wxc-exec` directly), and it takes no backend configuration; the
-  state-aware lifecycle *is* SDK-exposed.
+- **C# one-shot SDK support.** The Rust SDK already supports one-shot `run` and
+  `spawn_sandbox` behind the `isolation_session` feature. The Node JSON/config
+  path (`spawnSandboxFromConfig`) and
+  `wxc-exec` support the required network posture. The C# SDK still reaches
+  IsolationSession only through the state-aware lifecycle APIs.
 
 ## Test Plan
 
@@ -344,8 +308,8 @@ The full field-by-field table is in
 
 | Category | Location | What it verifies |
 |---|---|---|
-| Config parsing | `config_parser.rs` | The `"isolation_session"` containment value; a stray `experimental.isolation_session` payload is accepted and ignored |
-| Policy validation | `policy.rs` | Filesystem fields (`readwritePaths` / `readonlyPaths` / `deniedPaths`) are rejected at every phase; the network policy must be the canonical unrestricted-network acknowledgment (`defaultPolicy=allow` + `allowLocalNetwork=true`, no host rules or proxy) at provision, and any supplied network policy is rejected post-provision |
+| Config parsing | `config_parser.rs` | Directional network shape, closure, legacy-field removal, and phase-specific field rejection |
+| Policy validation | `policy.rs` | Filesystem/UI rejection; directional unrestricted form; empty/restrictive/mixed policy rejection; unchanged post-provision rules; `process.env` without `inheritDefaultEnv` rejection |
 | Option building | `process_options.rs` | `ExecutionRequest` → `ProcessOptions` mapping (timeout, cwd, env vars, redirect flags) |
 | Feature unavailable | `manager.rs` | Runner returns a clean error on machines without the IsolationSession feature enabled, so the test passes everywhere |
 
@@ -366,7 +330,7 @@ Two end-to-end configs live under `tests/configs/`:
   exit code 42 propagates to `ScriptResponse.exit_code`.
 
 A test runner at `tests/scripts/run_isolation_session_tests.ps1` invokes
-both configs via `wxc-exec.exe --experimental`, validates exit codes and
+both configs via `wxc-exec.exe`, validates exit codes and
 expected output substrings, and reports a pass/fail summary. Pattern
 follows the existing per-backend integration scripts (e.g.
 `run_microvm_tests.ps1`, `run_wslc_all_tests.ps1`).
@@ -404,37 +368,34 @@ The following were observed during VM testing and are accepted for v0.1.
 | Risk | Mitigation |
 |---|---|
 | Bindings tied to a specific OS API version | `GENERATION_INFO.toml` records the `windows-bindgen` version and target `windows` crate version; `build.rs` panics if the workspace `windows` crate drifts from the recorded `target_windows_crate`. Regeneration is a manual step performed by a Microsoft engineer with WinMD access |
-| OS API not present on older Windows builds | the IsolationSession feature is OS-side; the runner reports a hard, actionable error when the lifted activation payload or MSI runtime is missing or fails to bind — it never silently falls back to the inbox binaries. Feature-unavailable test exercises this on CI |
+| OS API not present on older Windows builds | the IsolationSession feature is OS-side; runner reports a clean error when the activation factory fails. Feature-unavailable test exercises this on CI |
 | New Cargo feature increases coupling | The `isolation_session` feature is off by default in the workspace; default builds and existing CI are unaffected |
 | Manual VM testing required | The OS-side service has the same constraint for any consumer (it rejects network-logon tokens). Automated suite covers what it can without the OS-side service |
-| One-shot lifecycle is heavy (full provision → start per call) | Inherent to the one-shot path; the experimental flag indicates rough edges. The state-aware lifecycle is the mitigation — it provisions once and reuses the session across `exec` calls |
-| Session lifetime is not caller-controllable | The in-proc API exposes no lifetime knob, so `lifecycle.destroyOnExit: false` cannot be honored. The one-shot path always stops the session and removes the agent user before returning |
+| One-shot lifecycle is heavy (full provision → start per call) | Inherent to the one-shot path. The state-aware lifecycle is the mitigation — it provisions once and reuses the session across `exec` calls |
+| Session lifetime is not caller-controllable | The in-proc API exposes no lifetime knob, so `lifecycle.destroyOnExit: false` cannot be honored. The one-shot path always stops the session and removes the agent user |
 
 ## Prerequisites
 
 **For end users:**
 
 - A Windows build with the IsolationSession feature enabled.
-- Inbox mode (`isolation_session`): nothing else; MXC activates the OS
-  runtime through normal WinRT activation.
-- Lifted mode (`isolation_session_lifted`): the version-matched runtime MSI
-  (`winget install Microsoft.AI.IsolationSession`). The build stages the SDK's
-  `IsoSessionApp.dll` shim and stamped `IsoSession.manifest` beside
-  `wxc-exec` / `mxc_ffi.dll`; MXC loads the shim's `DllGetActivationFactory`
-  by absolute path, and the shim binds the MSI runtime recorded in HKLM
-  `InstallDir`. A missing payload or runtime is a hard, actionable error — MXC
-  does **not** silently fall back to the inbox `System32` runtime.
-- WinRT/COM initialized as MTA (handled by `wxc-exec` and `regfree.rs`).
+- For inbox builds, the OS-side isolation-session host binary present in
+  `%SystemRoot%\System32\` (ships with Windows as part of the OS-side
+  service).
+- For lifted builds, the generated activation manifest and
+  `IsoSessionApp.dll` distributed beside the executable.
+- WinRT initialized as MTA (handled by `wxc-exec`).
 
 **For developers:**
 
 - Standard Rust toolchain.
-- `cargo build --features isolation_session` (inbox) or
-  `--features isolation_session_lifted` (lifted SDK + MSI) to build the
-  feature into `wxc-exec`. Default builds skip it — no impact on existing
-  workflows. Lifted builds restore the version- and hash-pinned SDK package
-  from NuGet.org, the standard NuGet cache, or
-  `ISOLATION_SESSION_SDK_PACKAGE`.
+- `cargo build --features isolation_session` to build against the inbox
+  runtime, or `cargo build --features isolation_session_lifted` to restore the
+  pinned package and stage the lifted runtime. Default builds enable neither
+  mode.
+- .NET SDK 10 for the lifted package restore. The normal restore uses the
+  configured `MxcDependencies` feed and an MXC-owned cache; use
+  `ISOLATION_SESSION_SDK_PACKAGE` only for an explicitly pre-fetched package.
 - A private WinMD only when **regenerating** bindings. As long as the OS
   API hasn't changed, no regen is needed.
 
@@ -442,14 +403,14 @@ The following were observed during VM testing and are accepted for v0.1.
 
 ```powershell
 # Minimal config: print the agent identity inside the session
-wxc-exec.exe --experimental hello.json
+wxc-exec.exe hello.json
 ```
 
 `hello.json`:
 
 ```json
 {
-  "version": "0.6.0-alpha",
+  "version": "0.9.0-alpha",
   "containerId": "Hello",
   "containment": "isolation_session",
   "process": {
@@ -457,11 +418,8 @@ wxc-exec.exe --experimental hello.json
     "timeout": 30000
   },
   "network": {
-    "defaultPolicy": "allow",
-    "allowLocalNetwork": true
-  },
-  "experimental": {
-    "isolation_session": {}
+    "egress": { "default": "allow" },
+    "ingress": { "default": "allow", "hostLoopback": "allow" }
   }
 }
 ```
diff --git a/src/ffi/mxc_ffi/build.rs b/src/ffi/mxc_ffi/build.rs
index f86c73ecb..afaff374c 100644
--- a/src/ffi/mxc_ffi/build.rs
+++ b/src/ffi/mxc_ffi/build.rs
@@ -35,19 +35,27 @@ fn main() {
 
 #[cfg(all(windows, feature = "isolation_session"))]
 fn reconcile_isolation_session_runtime() {
+    let out_dir = std::path::PathBuf::from(std::env::var("OUT_DIR").expect("OUT_DIR"));
+    let target_dir = out_dir
+        .parent()
+        .and_then(|path| path.parent())
+        .and_then(|path| path.parent())
+        .expect("could not determine target directory from OUT_DIR");
+
+    // Feature configurations share the final profile directory but have
+    // separate build-script fingerprints. A missing tracked path keeps this
+    // reconciliation active whenever Cargo switches fingerprints.
+    println!(
+        "cargo:rerun-if-changed={}",
+        target_dir.join(".isosession-payload-state").display()
+    );
+
     #[cfg(feature = "isolation_session_lifted")]
     mxc_build_common::isolation_session_sdk::stage_runtime()
         .unwrap_or_else(|error| panic!("IsolationSession SDK staging failed: {error}"));
 
     #[cfg(not(feature = "isolation_session_lifted"))]
     {
-        let out_dir = std::path::PathBuf::from(std::env::var("OUT_DIR").expect("OUT_DIR"));
-        let target_dir = out_dir
-            .parent()
-            .and_then(|path| path.parent())
-            .and_then(|path| path.parent())
-            .expect("could not determine target directory from OUT_DIR");
-
         for file_name in [
             "IsoSessionApp.dll",
             "IsoSession.manifest",
diff --git a/src/mxc-sdk/build/build_mxc_build_common.rs b/src/mxc-sdk/build/build_mxc_build_common.rs
index 920f61e72..efed71854 100644
--- a/src/mxc-sdk/build/build_mxc_build_common.rs
+++ b/src/mxc-sdk/build/build_mxc_build_common.rs
@@ -27,6 +27,9 @@ pub mod isolation_session_sdk {
         "b387c9d11808bf8864d3d7e4d6924f79bdcd6e7c4c54c4e2e49ab0e3525b3d2e";
     pub const PACKAGE_PATH_ENV: &str = "ISOLATION_SESSION_SDK_PACKAGE";
 
+    const RESTORE_PROJECT: &str =
+        "build/isolation_session_bindings/IsolationSessionSdk.Restore.csproj";
+    const NUGET_CONFIG: &str = "build/isolation_session_bindings/NuGet.Config";
     const APP_DLL: &str = "IsoSessionApp.dll";
     const RUNTIME_MANIFEST: &str = "IsoSession.manifest";
     const IMAGE_FILE_MACHINE_AMD64: u16 = 0x8664;
@@ -42,12 +45,8 @@ pub mod isolation_session_sdk {
             return Ok(path);
         }
 
-        let package_name = format!(
-            "{}.{}.nupkg",
-            PACKAGE_ID.to_ascii_lowercase(),
-            PACKAGE_VERSION
-        );
-        let package_dir = nuget_cache_root()?
+        let package_name = package_file_name();
+        let package_dir = mxc_nuget_cache_root()?
             .join(PACKAGE_ID.to_ascii_lowercase())
             .join(PACKAGE_VERSION);
         let package_path = package_dir.join(&package_name);
@@ -58,69 +57,8 @@ pub mod isolation_session_sdk {
             return Ok(package_path);
         }
 
-        std::fs::create_dir_all(&package_dir).map_err(|e| {
-            format!(
-                "create IsolationSession NuGet cache directory {}: {e}",
-                package_dir.display()
-            )
-        })?;
-
-        let download_path =
-            package_dir.join(format!("{package_name}.download.{}", std::process::id()));
-        let url = format!(
-            "https://api.nuget.org/v3-flatcontainer/{}/{}/{}",
-            PACKAGE_ID.to_ascii_lowercase(),
-            PACKAGE_VERSION,
-            package_name
-        );
-        let status = Command::new("curl")
-            .args([
-                "--fail",
-                "--location",
-                "--retry",
-                "3",
-                "--silent",
-                "--show-error",
-            ])
-            .arg("--output")
-            .arg(&download_path)
-            .arg(&url)
-            .status()
-            .map_err(|e| format!("launch curl to download {PACKAGE_ID} {PACKAGE_VERSION}: {e}"))?;
-
-        if !status.success() {
-            let _ = std::fs::remove_file(&download_path);
-            return Err(format!(
-                "download {PACKAGE_ID} {PACKAGE_VERSION} from NuGet.org failed with {status}; \
-                 set {PACKAGE_PATH_ENV} to a pre-fetched package for an offline build"
-            ));
-        }
-
-        if let Err(e) = verify_package(&download_path) {
-            let _ = std::fs::remove_file(&download_path);
-            return Err(e);
-        }
-
-        match std::fs::rename(&download_path, &package_path) {
-            Ok(()) => {}
-            Err(e) if package_path.exists() => {
-                let _ = std::fs::remove_file(&download_path);
-                verify_package(&package_path).map_err(|verify_error| {
-                    format!(
-                        "another build populated {}, but it is invalid ({verify_error}); \
-                         original rename error: {e}",
-                        package_path.display()
-                    )
-                })?;
-            }
-            Err(e) => {
-                let _ = std::fs::remove_file(&download_path);
-                return Err(format!(
-                    "publish downloaded package to {}: {e}",
-                    package_path.display()
-                ));
-            }
-        }
+        restore_package()?;
+        verify_package(&package_path)?;
 
         println!("cargo:rerun-if-changed={}", package_path.display());
         Ok(package_path)
@@ -272,19 +210,77 @@ pub mod isolation_session_sdk {
         Ok(())
     }
 
-    fn nuget_cache_root() -> Result<PathBuf, String> {
-        if let Ok(path) = std::env::var("NUGET_PACKAGES") {
-            return Ok(PathBuf::from(path));
-        }
-        let home = std::env::var("USERPROFILE")
-            .or_else(|_| std::env::var("HOME"))
-            .map_err(|_| {
+    fn package_file_name() -> String {
+        format!(
+            "{}.{}.nupkg",
+            PACKAGE_ID.to_ascii_lowercase(),
+            PACKAGE_VERSION
+        )
+    }
+
+    fn mxc_nuget_cache_root() -> Result<PathBuf, String> {
+        Ok(target_profile_dir()?.join(".mxc-nuget").join("packages"))
+    }
+
+    fn restore_package() -> Result<(), String> {
+        let manifest_dir = PathBuf::from(
+            std::env::var("CARGO_MANIFEST_DIR")
+                .map_err(|e| format!("CARGO_MANIFEST_DIR is not set: {e}"))?,
+        );
+        let restore_project = manifest_dir.join(RESTORE_PROJECT);
+        let nuget_config = manifest_dir.join(NUGET_CONFIG);
+        let cache_root = target_profile_dir()?.join(".mxc-nuget");
+        let packages_root = cache_root.join("packages");
+        let restore_output = PathBuf::from(
+            std::env::var("OUT_DIR").map_err(|e| format!("OUT_DIR is not set: {e}"))?,
+        )
+        .join("isolation-session-nuget-obj");
+
+        println!("cargo:rerun-if-changed={}", restore_project.display());
+        println!("cargo:rerun-if-changed={}", nuget_config.display());
+
+        std::fs::create_dir_all(&cache_root).map_err(|e| {
+            format!(
+                "create IsolationSession NuGet restore directory {}: {e}",
+                cache_root.display()
+            )
+        })?;
+
+        let output = Command::new("dotnet")
+            .arg("restore")
+            .arg(&restore_project)
+            .arg("--configfile")
+            .arg(&nuget_config)
+            .arg("--packages")
+            .arg(&packages_root)
+            .arg(format!(
+                "--property:RestoreOutputPath={}",
+                restore_output.display()
+            ))
+            .arg(format!(
+                "--property:IsolationSessionSdkVersion={PACKAGE_VERSION}"
+            ))
+            .args(["--nologo", "--verbosity", "minimal"])
+            .output()
+            .map_err(|e| {
                 format!(
-                    "neither NUGET_PACKAGES, USERPROFILE, nor HOME is set; set \
-                     {PACKAGE_PATH_ENV} to a pre-fetched package"
+                    "launch dotnet restore for {PACKAGE_ID} {PACKAGE_VERSION}: {e}; \
+                     set {PACKAGE_PATH_ENV} to a pre-fetched package if dotnet is unavailable"
                 )
             })?;
-        Ok(PathBuf::from(home).join(".nuget").join("packages"))
+
+        if output.status.success() {
+            return Ok(());
+        }
+
+        Err(format!(
+            "restore {PACKAGE_ID} {PACKAGE_VERSION} through {} failed with {}:\n{}\n{}\
+             \nSet {PACKAGE_PATH_ENV} to a pre-fetched package for an offline build.",
+            nuget_config.display(),
+            output.status,
+            String::from_utf8_lossy(&output.stdout).trim(),
+            String::from_utf8_lossy(&output.stderr).trim()
+        ))
     }
 
     fn verify_package(path: &Path) -> Result<(), String> {
@@ -309,8 +305,8 @@ pub mod isolation_session_sdk {
     #[cfg(test)]
     mod tests {
         use super::{
-            package_runtime_instance, validate_runtime_architecture, validate_runtime_manifest,
-            IMAGE_FILE_MACHINE_AMD64, IMAGE_FILE_MACHINE_ARM64,
+            package_file_name, package_runtime_instance, validate_runtime_architecture,
+            validate_runtime_manifest, IMAGE_FILE_MACHINE_AMD64, IMAGE_FILE_MACHINE_ARM64,
         };
 
         const MANIFEST: &str = "\
@@ -325,6 +321,14 @@ pub mod isolation_session_sdk {
             assert_eq!(package_runtime_instance().unwrap(), "2026.10");
         }
 
+        #[test]
+        fn package_file_name_uses_nuget_global_packages_layout() {
+            assert_eq!(
+                package_file_name(),
+                "microsoft.ai.isolationsession.sdk.0.202610.5.nupkg"
+            );
+        }
+
         #[test]
         fn completed_runtime_manifest_is_accepted() {
             validate_runtime_manifest(MANIFEST.as_bytes(), "2026.10").unwrap();
diff --git a/src/mxc-sdk/build/isolation_session_bindings/IsolationSessionSdk.Restore.csproj b/src/mxc-sdk/build/isolation_session_bindings/IsolationSessionSdk.Restore.csproj
new file mode 100644
index 000000000..3303ac9a2
--- /dev/null
+++ b/src/mxc-sdk/build/isolation_session_bindings/IsolationSessionSdk.Restore.csproj
@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <DisableImplicitNuGetFallbackFolder>true</DisableImplicitNuGetFallbackFolder>
+    <RestoreIgnoreFailedSources>false</RestoreIgnoreFailedSources>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AI.IsolationSession.SDK"
+                      Version="$(IsolationSessionSdkVersion)" />
+  </ItemGroup>
+</Project>
diff --git a/src/mxc-sdk/build/isolation_session_bindings/NuGet.Config b/src/mxc-sdk/build/isolation_session_bindings/NuGet.Config
new file mode 100644
index 000000000..7563711b4
--- /dev/null
+++ b/src/mxc-sdk/build/isolation_session_bindings/NuGet.Config
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+  <packageSources>
+    <clear />
+    <add key="MxcDependencies"
+         value="https://pkgs.dev.azure.com/shine-oss/mxc/_packaging/MxcDependencies/nuget/v3/index.json" />
+  </packageSources>
+</configuration>
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/error.rs b/src/mxc-sdk/src/backends/isolation_session/common/error.rs
index 7ae0354d9..f7e00bb1b 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/error.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/error.rs
@@ -67,10 +67,9 @@ const CLASS_E_CLASSNOTAVAILABLE_HRESULT: u32 = 0x80040111;
 const REGDB_E_CLASSNOTREG_HRESULT: u32 = 0x80040154;
 
 /// `E_NOINTERFACE` — the activator produced an object that does not implement
-/// the requested interface. In this backend that is the signature of a
-/// winmd/MSI version-pin mismatch: `IsoSessionApp.dll` activated, but the
-/// interface IID the Preview WinMD was built against does not match the IID
-/// the MSI-installed runtime exposes. See [`activation_error`].
+/// the requested interface. In lifted mode this is the signature of a
+/// WinMD/runtime version-pin mismatch. Inbox activation does not have enough
+/// information to make that diagnosis. See [`activation_error`].
 const E_NOINTERFACE_HRESULT: u32 = 0x80004002;
 
 /// Renders an HRESULT for the wire `nativeCode` field.
@@ -320,13 +319,20 @@ pub(super) fn activation_error(code: u32, detail: &str) -> IsolationSessionError
          the OS feature gate is enabled and the platform supports isolation sessions."
                 .to_string()
         } else if code == E_NOINTERFACE_HRESULT {
-            "the co-located IsoSessionApp.dll activated but returned an object that does not \
-         implement the expected IsolationSession interface. This is the classic winmd/MSI \
-         version-pin mismatch: the Preview WinMD wxc-exec was built against and the \
-         MSI-installed IsolationSession runtime were produced from different OS versions, so \
-         their interface IIDs differ. Rebuild the MSI and the \
-         Microsoft.AI.IsolationSession.SDK NuGet from the same OS commit."
-                .to_string()
+            #[cfg(feature = "lifted_msi")]
+            {
+                "the co-located IsoSessionApp.dll activated but returned an object that does not \
+                 implement the expected IsolationSession interface. This is the classic WinMD/MSI \
+                 version-pin mismatch: the Preview WinMD wxc-exec was built against and the \
+                 MSI-installed IsolationSession runtime were produced from different OS versions, \
+                 so their interface IIDs differ. Rebuild the MSI and the \
+                 Microsoft.AI.IsolationSession.SDK NuGet from the same OS commit."
+                    .to_string()
+            }
+            #[cfg(not(feature = "lifted_msi"))]
+            {
+                format!("IsolationSession runtime API activation failed: {detail}")
+            }
         } else {
             format!("IsolationSession runtime API activation failed: {detail}")
         };
@@ -876,9 +882,10 @@ mod tests {
         assert!(mapped.message.contains("catastrophic failure"));
     }
 
-    /// `E_NOINTERFACE` from activation is the winmd/MSI version-pin mismatch
+    /// `E_NOINTERFACE` from lifted activation is the WinMD/MSI version-pin mismatch
     /// signature: the mapping must name that cause rather than echo the bare
     /// COM detail, so the message points at rebuilding both from one commit.
+    #[cfg(feature = "lifted_msi")]
     #[test]
     fn e_nointerface_activation_names_version_pin_mismatch() {
         let mapped = map_lifecycle_error(activation_error(E_NOINTERFACE_HRESULT, "ignored"));
@@ -888,6 +895,19 @@ mod tests {
         assert!(mapped.message.contains("same OS commit"));
     }
 
+    #[cfg(not(feature = "lifted_msi"))]
+    #[test]
+    fn inbox_e_nointerface_activation_preserves_platform_detail() {
+        let mapped = map_lifecycle_error(activation_error(
+            E_NOINTERFACE_HRESULT,
+            "platform activation detail",
+        ));
+        assert_eq!(mapped.code, MxcErrorCode::BackendUnavailable);
+        assert_eq!(mapped.native_code(), Some("0x80004002"));
+        assert!(mapped.message.contains("platform activation detail"));
+        assert!(!mapped.message.contains("version-pin mismatch"));
+    }
+
     /// The hard error raised when the lifted payload is absent must carry the
     /// class-not-registered code, an operation, a message that refuses the
     /// inbox fallback, and an actionable remediation.
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
index b9721ac17..c6d65d086 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
@@ -1566,22 +1566,17 @@ mod tests {
                     failure.message
                 );
 
-                #[cfg(feature = "lifted_msi")]
-                {
-                    assert_eq!(failure.operation, op::VERIFY_FRAMEWORK);
-                    assert!(
+                match failure.operation.as_str() {
+                    #[cfg(feature = "lifted_msi")]
+                    op::VERIFY_FRAMEWORK => assert!(
                         failure.code.is_none(),
                         "framework refusal unexpectedly carried an HRESULT"
-                    );
-                }
-
-                #[cfg(not(feature = "lifted_msi"))]
-                {
-                    assert_eq!(failure.operation, op::ACTIVATE);
-                    assert!(
+                    ),
+                    op::ACTIVATE => assert!(
                         failure.code.is_some(),
                         "activation failure carries no HRESULT"
-                    );
+                    ),
+                    operation => panic!("unexpected availability operation: {operation}"),
                 }
             }
             Err(other) => {
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
index f999f8871..7c70440c4 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/regfree.rs
@@ -18,7 +18,9 @@ use windows::core::{s, HSTRING, PCSTR, PCWSTR, PWSTR};
 use windows::Win32::Foundation::{
     ERROR_NOT_SUPPORTED, ERROR_PROC_NOT_FOUND, REGDB_E_CLASSNOTREG, S_OK,
 };
-use windows::Win32::System::Com::{CoInitializeEx, CoTaskMemFree, COINIT_MULTITHREADED};
+use windows::Win32::System::Com::{
+    CoInitializeEx, CoTaskMemFree, CoUninitialize, COINIT_MULTITHREADED,
+};
 use windows::Win32::System::LibraryLoader::{
     GetProcAddress, LoadLibraryExW, LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR, LOAD_LIBRARY_SEARCH_SYSTEM32,
 };
@@ -34,6 +36,27 @@ type DllGetActivationFactory =
 
 static GET_ACTIVATION_FACTORY: OnceLock<DllGetActivationFactory> = OnceLock::new();
 
+struct ComApartment;
+
+impl Drop for ComApartment {
+    fn drop(&mut self) {
+        unsafe { CoUninitialize() };
+    }
+}
+
+thread_local! {
+    static COM_APARTMENT: Result<Option<ComApartment>, HRESULT> = {
+        let result = unsafe { CoInitializeEx(None, COINIT_MULTITHREADED) };
+        if result.is_ok() {
+            Ok(Some(ComApartment))
+        } else if result.0 as u32 == RPC_E_CHANGED_MODE {
+            Ok(None)
+        } else {
+            Err(result)
+        }
+    };
+}
+
 /// Flat-C export on the staged shim that answers whether the matching
 /// IsolationSession runtime is installed and loadable on this machine. The
 /// out-param receives an owned, ready-to-display remediation string (which the
@@ -86,10 +109,10 @@ where
     T: Interface + RuntimeName,
 {
     // Some callers enter through a native thread without initializing COM.
-    // RPC_E_CHANGED_MODE only means another apartment model is already active.
-    let initialize_result = unsafe { CoInitializeEx(None, COINIT_MULTITHREADED) };
-    if initialize_result.is_err() && initialize_result.0 as u32 != RPC_E_CHANGED_MODE {
-        return Some(Err(windows_core::Error::from_hresult(initialize_result)));
+    // Keep any initialization owned here alive until that same thread exits,
+    // then balance it with CoUninitialize.
+    if let Err(error) = ensure_com_apartment() {
+        return Some(Err(error));
     }
 
     let directory = adjacent_runtime_directory()?;
@@ -102,6 +125,13 @@ where
     Some(activate_from_factory(factory))
 }
 
+fn ensure_com_apartment() -> windows_core::Result<()> {
+    COM_APARTMENT.with(|apartment| match apartment {
+        Ok(_) => Ok(()),
+        Err(result) => Err(windows_core::Error::from_hresult(*result)),
+    })
+}
+
 /// Confirms the IsolationSession runtime is installed before any session work.
 ///
 /// `Ok(())` means proceed; `Err(refusal)` means block, carrying the text to

From b5d77b28617c9d35f80cb095b8efcc1e5d5bdbca Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Wed, 7 Oct 2026 14:13:55 -0700
Subject: [PATCH 23/26] Harden lifted IsolationSession package integration

Restrict the AMD64-only lifted payload to x64 builds, remove the invalid standalone activation feature, execute package validation tests through Cargo, and separate inbox binding provenance from lifted SDK provenance.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 1d43372e-f942-4bb7-a358-48f9218c2332
---
 build.bat                                     |  13 +-
 .../Microsoft.Mxc.Sdk.csproj                  |  12 +-
 src/mxc-sdk/Cargo.toml                        |   2 -
 .../build/build_isolation_session_bindings.rs |   3 +-
 src/mxc-sdk/build/build_mxc_build_common.rs   | 190 +-----------------
 .../GENERATION_INFO.toml                      |  16 +-
 .../LIFTED_SDK_INFO.toml                      |  18 ++
 .../isolation_session_bindings/README.md      |  46 +++--
 .../Update-IsoSessionSdk.ps1                  |  17 +-
 .../package_validation.rs                     | 182 +++++++++++++++++
 .../isolation_session/bindings/mod.rs         |   5 +-
 .../isolation_session/common/availability.rs  |   8 +-
 .../isolation_session/common/error.rs         |  19 +-
 .../isolation_session/common/manager.rs       |   8 +-
 .../backends/isolation_session/common/mod.rs  |   2 +-
 .../common/process_options.rs                 |   6 +-
 .../isolation_session_package_validation.rs   |   6 +
 17 files changed, 309 insertions(+), 244 deletions(-)
 create mode 100644 src/mxc-sdk/build/isolation_session_bindings/LIFTED_SDK_INFO.toml
 create mode 100644 src/mxc-sdk/build/isolation_session_bindings/package_validation.rs
 create mode 100644 src/mxc-sdk/tests/isolation_session_package_validation.rs

diff --git a/build.bat b/build.bat
index dd61d772a..34ec121a3 100644
--- a/build.bat
+++ b/build.bat
@@ -39,6 +39,17 @@ if "%BUILD_ALL%"=="0" if "%BUILD_ARCH%"=="" (
     )
 )
 
+if "%WITH_ISOLATION_SESSION_LIFTED%"=="1" (
+    if "%BUILD_ALL%"=="1" (
+        echo ERROR: Lifted IsolationSession currently supports x64 only because the pinned SDK package contains one AMD64 IsoSessionApp.dll. Use --x64 instead of --all.
+        exit /b 1
+    )
+    if /i "%BUILD_ARCH%"=="aarch64-pc-windows-msvc" (
+        echo ERROR: Lifted IsolationSession currently supports x64 only because the pinned SDK package contains one AMD64 IsoSessionApp.dll.
+        exit /b 1
+    )
+)
+
 :: Build flags
 set "CARGO_FLAGS=--target"
 if "%BUILD_CONFIG%"=="release" set "CARGO_FLAGS=--release --target"
@@ -351,7 +362,7 @@ echo   --all             Build both Windows architectures and create the .NET Nu
 echo   --with-microvm    Download and include NanVix micro-VM binaries
 echo   --with-wslc       Build with WSL Container (WSLC SDK) support
 echo   --with-isolation-session   Build with IsolationSession backend (inbox OS API)
-echo   --with-isolation-session-lifted   Build with lifted IsolationSession (NuGet SDK + MSI runtime)
+echo   --with-isolation-session-lifted   Build with lifted IsolationSession (x64-only NuGet SDK + MSI runtime)
 echo   --with-hyperlight         Build with Hyperlight (micro-VM) backend (x86_64 only)
 echo   -h, --help        Show this help
 echo.
diff --git a/sdk/dotnet/Microsoft.Mxc.Sdk/Microsoft.Mxc.Sdk.csproj b/sdk/dotnet/Microsoft.Mxc.Sdk/Microsoft.Mxc.Sdk.csproj
index 20a14dd9e..d8387b546 100644
--- a/sdk/dotnet/Microsoft.Mxc.Sdk/Microsoft.Mxc.Sdk.csproj
+++ b/sdk/dotnet/Microsoft.Mxc.Sdk/Microsoft.Mxc.Sdk.csproj
@@ -171,6 +171,8 @@
            Text="mxc: PlatformTarget '$(PlatformTarget)' is not this host's '$(MxcHostArch)', and cargo builds the native unit for the host. Drop the PlatformTarget, or set it to '$(MxcHostArch)'." />
     <Error Condition="'$(MxcUnsupportedOptionalBackends)' == 'true'"
            Text="mxc: MxcWithIsolationSession and MxcWithWslc are Windows-only build switches." />
+    <Error Condition="'$(MxcIsolationSessionLifted)' == 'true' and '$(MxcHostRid)' != 'win-x64'"
+           Text="mxc: lifted IsolationSession currently supports only win-x64 because the pinned SDK package contains one AMD64 IsoSessionApp.dll." />
     <!-- Pinning keeps cargo on the host the guards above validated; a
          CARGO_BUILD_TARGET or a `[build] target` would otherwise choose it. -->
     <Exec Command="rustc -vV"
@@ -237,6 +239,8 @@
   <Target Name="MxcLoadPrebuiltNativeUnit"
           BeforeTargets="CoreCompile"
           Condition="'$(MxcUsePrebuiltNativeUnit)' == 'true'">
+    <Error Condition="'$(MxcIsolationSessionLifted)' == 'true' and '$(MxcHostRid)' != 'win-x64'"
+           Text="mxc: lifted IsolationSession currently supports only win-x64 because the pinned SDK package contains one AMD64 IsoSessionApp.dll." />
     <Error Condition="!Exists('$(MxcGeneratedBindings)')"
            Text="mxc: prebuilt native mode requires generated bindings at $(MxcGeneratedBindings)." />
     <Error Condition="!Exists('$(MxcPrebuiltNativeDir)/$(MxcNativeFileName)')"
@@ -322,8 +326,14 @@
   <PropertyGroup>
     <TargetsForTfmSpecificContentInPackage>$(TargetsForTfmSpecificContentInPackage);MxcAddNativeUnitToPackage</TargetsForTfmSpecificContentInPackage>
   </PropertyGroup>
+  <Target Name="MxcValidateLiftedPackage">
+    <Error Condition="'$(MxcIsolationSessionLifted)' == 'true' and '$(MxcPackageRid)' != 'win-x64'"
+           Text="mxc: lifted IsolationSession can only be packaged for win-x64 because the pinned SDK package contains one AMD64 IsoSessionApp.dll." />
+    <Error Condition="'$(MxcIsolationSessionLifted)' == 'true' and '$(MxcPackSingleRid)' != 'true'"
+           Text="mxc: lifted IsolationSession requires a single-RID win-x64 package until architecture-specific runtime payloads are published." />
+  </Target>
   <Target Name="MxcAddNativeUnitToPackage"
-          DependsOnTargets="GenerateNativeBindings;MxcLoadPrebuiltNativeUnit">
+          DependsOnTargets="MxcValidateLiftedPackage;GenerateNativeBindings;MxcLoadPrebuiltNativeUnit">
     <ItemGroup>
     <MxcOtherRidNative Include="runtimes/$(MxcOtherWindowsRid)/native/*"
                        Condition="'$(MxcPackSingleRid)' != 'true' and '$(MxcOtherWindowsRid)' != ''" />
diff --git a/src/mxc-sdk/Cargo.toml b/src/mxc-sdk/Cargo.toml
index 334a8003c..80651df5d 100644
--- a/src/mxc-sdk/Cargo.toml
+++ b/src/mxc-sdk/Cargo.toml
@@ -36,11 +36,9 @@ isolation_session = [
 ]
 isolation_session_lifted = [
     "isolation_session",
-    "lifted_msi",
     "dep:windows-bindgen",
     "dep:zip",
 ]
-lifted_msi = []
 test-support = []
 microvm = []
 hyperlight = [
diff --git a/src/mxc-sdk/build/build_isolation_session_bindings.rs b/src/mxc-sdk/build/build_isolation_session_bindings.rs
index 4207b370e..b6736fd62 100644
--- a/src/mxc-sdk/build/build_isolation_session_bindings.rs
+++ b/src/mxc-sdk/build/build_isolation_session_bindings.rs
@@ -5,7 +5,8 @@
 //!
 //! Inbox builds use the committed OS-generated bindings and verify their
 //! `windows` crate compatibility. Lifted builds restore the pinned SDK package
-//! from NuGet.org and regenerate bindings from its Preview WinMD.
+//! through the configured MxcDependencies feed and regenerate bindings from
+//! its Preview WinMD.
 
 use std::path::Path;
 
diff --git a/src/mxc-sdk/build/build_mxc_build_common.rs b/src/mxc-sdk/build/build_mxc_build_common.rs
index efed71854..b4233b084 100644
--- a/src/mxc-sdk/build/build_mxc_build_common.rs
+++ b/src/mxc-sdk/build/build_mxc_build_common.rs
@@ -21,6 +21,15 @@ pub mod isolation_session_sdk {
     use std::path::{Path, PathBuf};
     use std::process::Command;
 
+    mod package_validation {
+        include!("isolation_session_bindings/package_validation.rs");
+    }
+
+    use package_validation::{
+        package_file_name, package_runtime_instance, validate_runtime_architecture,
+        validate_runtime_manifest,
+    };
+
     pub const PACKAGE_ID: &str = "Microsoft.AI.IsolationSession.SDK";
     pub const PACKAGE_VERSION: &str = "0.202610.5";
     pub const PACKAGE_SHA256: &str =
@@ -32,8 +41,6 @@ pub mod isolation_session_sdk {
     const NUGET_CONFIG: &str = "build/isolation_session_bindings/NuGet.Config";
     const APP_DLL: &str = "IsoSessionApp.dll";
     const RUNTIME_MANIFEST: &str = "IsoSession.manifest";
-    const IMAGE_FILE_MACHINE_AMD64: u16 = 0x8664;
-    const IMAGE_FILE_MACHINE_ARM64: u16 = 0xAA64;
 
     pub fn resolve_package() -> Result<PathBuf, String> {
         println!("cargo:rerun-if-env-changed={PACKAGE_PATH_ENV}");
@@ -45,7 +52,7 @@ pub mod isolation_session_sdk {
             return Ok(path);
         }
 
-        let package_name = package_file_name();
+        let package_name = package_file_name(PACKAGE_ID, PACKAGE_VERSION);
         let package_dir = mxc_nuget_cache_root()?
             .join(PACKAGE_ID.to_ascii_lowercase())
             .join(PACKAGE_VERSION);
@@ -71,7 +78,7 @@ pub mod isolation_session_sdk {
         let target_arch = std::env::var("CARGO_CFG_TARGET_ARCH")
             .map_err(|e| format!("CARGO_CFG_TARGET_ARCH is not set: {e}"))?;
         validate_runtime_architecture(&app_dll, &target_arch)?;
-        let instance = package_runtime_instance()?;
+        let instance = package_runtime_instance(PACKAGE_VERSION)?;
         validate_runtime_manifest(&manifest, &instance)?;
 
         let target_dir = target_profile_dir()?;
@@ -82,47 +89,6 @@ pub mod isolation_session_sdk {
         Ok(())
     }
 
-    fn validate_runtime_architecture(binary: &[u8], target_arch: &str) -> Result<(), String> {
-        let expected_machine = match target_arch {
-            "x86_64" => IMAGE_FILE_MACHINE_AMD64,
-            "aarch64" => IMAGE_FILE_MACHINE_ARM64,
-            other => {
-                return Err(format!(
-                    "IsolationSession lifted runtime does not support target architecture {other:?}"
-                ));
-            }
-        };
-
-        if binary.len() < 0x40 || &binary[..2] != b"MZ" {
-            return Err(format!("{APP_DLL} is not a valid PE image"));
-        }
-        let pe_offset = u32::from_le_bytes(
-            binary[0x3c..0x40]
-                .try_into()
-                .expect("slice length is checked"),
-        ) as usize;
-        let machine_end = pe_offset
-            .checked_add(6)
-            .ok_or_else(|| format!("{APP_DLL} has an invalid PE header offset"))?;
-        if machine_end > binary.len() || &binary[pe_offset..pe_offset + 4] != b"PE\0\0" {
-            return Err(format!("{APP_DLL} has an invalid PE header"));
-        }
-
-        let actual_machine = u16::from_le_bytes(
-            binary[pe_offset + 4..machine_end]
-                .try_into()
-                .expect("slice length is checked"),
-        );
-        if actual_machine != expected_machine {
-            return Err(format!(
-                "{APP_DLL} machine type 0x{actual_machine:04X} does not match Cargo target \
-                 architecture {target_arch:?} (expected 0x{expected_machine:04X}); publish a \
-                 matching runtime payload before building this target"
-            ));
-        }
-        Ok(())
-    }
-
     pub fn read_entry(package: &Path, file_name: &str) -> Result<Vec<u8>, String> {
         let file = std::fs::File::open(package)
             .map_err(|e| format!("open NuGet package {}: {e}", package.display()))?;
@@ -168,56 +134,6 @@ pub mod isolation_session_sdk {
             })
     }
 
-    fn package_runtime_instance() -> Result<String, String> {
-        let mut parts = PACKAGE_VERSION.split('.');
-        let prefix = parts.next();
-        let release = parts.next();
-        let patch = parts.next();
-        if prefix != Some("0")
-            || parts.next().is_some()
-            || !patch.is_some_and(|value| value.bytes().all(|byte| byte.is_ascii_digit()))
-            || !release.is_some_and(|value| {
-                value.len() == 6 && value.bytes().all(|byte| byte.is_ascii_digit())
-            })
-        {
-            return Err(format!(
-                "IsolationSession SDK package version must use 0.YYYYMM.patch, got {PACKAGE_VERSION:?}"
-            ));
-        }
-
-        let release = release.unwrap();
-        Ok(format!("{}.{}", &release[..4], &release[4..]))
-    }
-
-    fn validate_runtime_manifest(manifest: &[u8], instance: &str) -> Result<(), String> {
-        let content = std::str::from_utf8(manifest)
-            .map_err(|e| format!("{RUNTIME_MANIFEST} is not valid UTF-8: {e}"))?;
-        for required in [
-            "<assemblyIdentity name=\"IsoSession.Runtime\"",
-            "<file name=\"IsoSessionApp.dll\"",
-        ] {
-            if !content.contains(required) {
-                return Err(format!("{RUNTIME_MANIFEST} is missing {required:?}"));
-            }
-        }
-
-        let expected_instance = format!("name=\"{instance}\"");
-        if !content.contains(&expected_instance) {
-            return Err(format!(
-                "{RUNTIME_MANIFEST} does not identify runtime instance {instance:?}"
-            ));
-        }
-        Ok(())
-    }
-
-    fn package_file_name() -> String {
-        format!(
-            "{}.{}.nupkg",
-            PACKAGE_ID.to_ascii_lowercase(),
-            PACKAGE_VERSION
-        )
-    }
-
     fn mxc_nuget_cache_root() -> Result<PathBuf, String> {
         Ok(target_profile_dir()?.join(".mxc-nuget").join("packages"))
     }
@@ -301,90 +217,6 @@ pub mod isolation_session_sdk {
             ))
         }
     }
-
-    #[cfg(test)]
-    mod tests {
-        use super::{
-            package_file_name, package_runtime_instance, validate_runtime_architecture,
-            validate_runtime_manifest, IMAGE_FILE_MACHINE_AMD64, IMAGE_FILE_MACHINE_ARM64,
-        };
-
-        const MANIFEST: &str = "\
-<assembly>
-  <assemblyIdentity name=\"IsoSession.Runtime\" />
-  <file name=\"IsoSessionApp.dll\" />
-  <iso:instance name=\"2026.10\" />
-</assembly>";
-
-        #[test]
-        fn package_version_maps_to_runtime_instance() {
-            assert_eq!(package_runtime_instance().unwrap(), "2026.10");
-        }
-
-        #[test]
-        fn package_file_name_uses_nuget_global_packages_layout() {
-            assert_eq!(
-                package_file_name(),
-                "microsoft.ai.isolationsession.sdk.0.202610.5.nupkg"
-            );
-        }
-
-        #[test]
-        fn completed_runtime_manifest_is_accepted() {
-            validate_runtime_manifest(MANIFEST.as_bytes(), "2026.10").unwrap();
-        }
-
-        #[test]
-        fn mismatched_runtime_manifest_is_rejected() {
-            let error = validate_runtime_manifest(MANIFEST.as_bytes(), "2026.11").unwrap_err();
-            assert!(error.contains("does not identify runtime instance"));
-        }
-
-        fn pe_image(machine: u16) -> Vec<u8> {
-            let mut image = vec![0; 0x80];
-            image[..2].copy_from_slice(b"MZ");
-            image[0x3c..0x40].copy_from_slice(&0x40u32.to_le_bytes());
-            image[0x40..0x44].copy_from_slice(b"PE\0\0");
-            image[0x44..0x46].copy_from_slice(&machine.to_le_bytes());
-            image
-        }
-
-        #[test]
-        fn runtime_architecture_accepts_matching_targets() {
-            validate_runtime_architecture(&pe_image(IMAGE_FILE_MACHINE_AMD64), "x86_64").unwrap();
-            validate_runtime_architecture(&pe_image(IMAGE_FILE_MACHINE_ARM64), "aarch64").unwrap();
-        }
-
-        #[test]
-        fn runtime_architecture_rejects_mismatched_target() {
-            let error =
-                validate_runtime_architecture(&pe_image(IMAGE_FILE_MACHINE_AMD64), "aarch64")
-                    .unwrap_err();
-            assert!(error.contains("does not match Cargo target architecture"));
-        }
-
-        #[test]
-        fn runtime_architecture_rejects_invalid_pe() {
-            let error = validate_runtime_architecture(b"not a PE", "x86_64").unwrap_err();
-            assert!(error.contains("not a valid PE image"));
-        }
-
-        #[test]
-        fn runtime_architecture_rejects_truncated_pe_header() {
-            let mut image = pe_image(IMAGE_FILE_MACHINE_AMD64);
-            image.truncate(0x44);
-
-            let error = validate_runtime_architecture(&image, "x86_64").unwrap_err();
-            assert!(error.contains("invalid PE header"));
-        }
-
-        #[test]
-        fn runtime_architecture_rejects_unsupported_target() {
-            let error = validate_runtime_architecture(&pe_image(IMAGE_FILE_MACHINE_AMD64), "x86")
-                .unwrap_err();
-            assert!(error.contains("does not support target architecture"));
-        }
-    }
 }
 
 /// Embed Windows VersionInfo resource metadata into the binary being compiled.
diff --git a/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml b/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
index eec63fbb1..665ae6364 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
+++ b/src/mxc-sdk/build/isolation_session_bindings/GENERATION_INFO.toml
@@ -1,17 +1,7 @@
-# Provenance for the isolation_session_bindings crate.
-#
-# Bindings are regenerated at build time from the Preview WinMD in the pinned
-# SDK package. Run Update-IsoSessionSdk.ps1 rather than editing this file.
+# Provenance information for the generated isolation_session_bindings crate.
+# Updated manually after regenerating the bindings; verified by the bindings crate's build.rs.
 
 [tool]
 windows_bindgen_version = "0.62.1"
 target_windows_crate = "0.62"
-generated_date = "2026-10-06"
-
-[source]
-nupkg = "Microsoft.AI.IsolationSession.SDK.0.202610.5.nupkg"
-winmd = "metadata/windows.ai.isolationsession.preview.winmd"
-winmd_sha256 = "C6115B52525B06316BE77BEEB4FC4624C5CBB1CEC02E5493D86C46D90FABD6A9"
-namespace = "Windows.AI.IsolationSession.Preview"
-runtime_version = "2026_10"
-build_guid = "e5ad0558-b9a6-a19a-f50e-cc2ebcaccf65"
+generated_date = "2026-09-16"
diff --git a/src/mxc-sdk/build/isolation_session_bindings/LIFTED_SDK_INFO.toml b/src/mxc-sdk/build/isolation_session_bindings/LIFTED_SDK_INFO.toml
new file mode 100644
index 000000000..4119bc498
--- /dev/null
+++ b/src/mxc-sdk/build/isolation_session_bindings/LIFTED_SDK_INFO.toml
@@ -0,0 +1,18 @@
+# Provenance for the lifted IsolationSession SDK package.
+#
+# Bindings are regenerated at build time from the Preview WinMD in the pinned
+# SDK package. Run Update-IsoSessionSdk.ps1 rather than editing this file.
+
+[tool]
+windows_bindgen_version = "0.62.1"
+target_windows_crate = "0.62"
+generated_date = "2026-10-06"
+
+[source]
+nupkg = "Microsoft.AI.IsolationSession.SDK.0.202610.5.nupkg"
+nupkg_sha256 = "b387c9d11808bf8864d3d7e4d6924f79bdcd6e7c4c54c4e2e49ab0e3525b3d2e"
+winmd = "metadata/windows.ai.isolationsession.preview.winmd"
+winmd_sha256 = "C6115B52525B06316BE77BEEB4FC4624C5CBB1CEC02E5493D86C46D90FABD6A9"
+namespace = "Windows.AI.IsolationSession.Preview"
+runtime_version = "2026_10"
+build_guid = "e5ad0558-b9a6-a19a-f50e-cc2ebcaccf65"
diff --git a/src/mxc-sdk/build/isolation_session_bindings/README.md b/src/mxc-sdk/build/isolation_session_bindings/README.md
index 5278497dd..0153b8867 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/README.md
+++ b/src/mxc-sdk/build/isolation_session_bindings/README.md
@@ -5,18 +5,23 @@ MXC supports two explicit IsolationSession build modes:
 | Cargo feature | Metadata and runtime |
 |---|---|
 | `isolation_session` | Uses the committed OS-generated Rust bindings and normal inbox WinRT activation. |
-| `isolation_session_lifted` | Restores the pinned SDK package from NuGet.org, generates bindings from its Preview WinMD, and stages its lifted activation payload. This feature implies `isolation_session`. |
+| `isolation_session_lifted` | Restores the pinned SDK package through the configured `MxcDependencies` feed, generates bindings from its Preview WinMD, and stages its lifted activation payload. This feature implies `isolation_session`. |
 
-The repository does not contain the SDK `.nupkg`. Lifted builds download the
-exact package version pinned in
-`src/mxc-sdk/build/build_mxc_build_common.rs` from the NuGet.org V3 flat-container
-endpoint, verify its SHA-256, and cache it in the standard global NuGet package
-directory.
+The repository does not contain the SDK `.nupkg`. Lifted builds run normal
+`dotnet restore` using the checked-in `NuGet.Config`, which clears implicit
+sources and selects the `MxcDependencies` feed. NuGet restores the exact package
+version pinned in `src/mxc-sdk/build/build_mxc_build_common.rs` into the
+Cargo target profile's `.mxc-nuget/packages` directory. MXC then independently
+verifies the restored `.nupkg` SHA-256 before reading it.
 
-1. `ISOLATION_SESSION_SDK_PACKAGE`, if set, for validating a different local
-   copy of the same package.
-2. The standard global NuGet package cache, then the NuGet.org V3
-   flat-container endpoint (cached after download).
+Set `ISOLATION_SESSION_SDK_PACKAGE` to use a local package without restoring.
+The local package must still match the pinned version, contents, and SHA-256.
+Normal builds never contact NuGet.org directly.
+
+Before updating the pin, seed both the package and locked Cargo dependencies
+into the configured feeds by running the `MXC-Update-Feed-Dependencies`
+pipeline with this PR number. Builds without the local override fail until the
+new package version is available from `MxcDependencies`.
 
 ## Runtime prerequisite
 
@@ -28,10 +33,15 @@ winget install Microsoft.AI.IsolationSession
 ```
 
 The build stages `IsoSessionApp.dll` and `IsoSession.manifest` beside
-`wxc-exec.exe` and `mxc_ffi.dll`. MXC never falls back to the inbox runtime
+the current MXC native module. MXC never falls back to the inbox runtime
 when the payload or MSI is missing; it reports `BackendUnavailable` with this
 remediation.
 
+The published package contains one AMD64 `IsoSessionApp.dll`, so lifted mode
+currently supports only x64 (`x86_64-pc-windows-msvc` / `win-x64`). Inbox mode
+continues to support both Windows architectures. Lifted ARM64 and multi-RID
+builds are rejected before compilation or packaging.
+
 ## Build commands
 
 From `src`:
@@ -60,12 +70,16 @@ shim for the wrong target architecture.
 
 1. Run `Update-IsoSessionSdk.ps1 -PackagePath <path-to-package>`. The script
    validates the package, updates `PACKAGE_VERSION` and `PACKAGE_SHA256`, and
-   regenerates `GENERATION_INFO.toml` without copying the package into Git.
-2. Build and test both feature configurations. Set
-   `ISOLATION_SESSION_SDK_PACKAGE` to the validated local package until that
-   exact version is available from NuGet.org.
+   regenerates `LIFTED_SDK_INFO.toml` without copying the package into Git.
+2. Run the dependency-feed update pipeline, then build and test both feature
+   configurations. Set `ISOLATION_SESSION_SDK_PACKAGE` to the validated local
+   package while feed seeding is pending.
 
 `windows-bindgen` is pinned to `=0.62.1` in `src/mxc-sdk/Cargo.toml`
 and must stay in lockstep with the workspace `windows` crate's major.minor
-(`target_windows_crate` in `GENERATION_INFO.toml`). If you bump the `windows`
+(`target_windows_crate` in both provenance files). If you bump the `windows`
 crate, bump `windows-bindgen` to the matching version in the same change.
+
+`GENERATION_INFO.toml` describes the committed inbox projection and changes
+only when those bindings are regenerated. `LIFTED_SDK_INFO.toml` describes the
+pinned lifted package and is updated by `Update-IsoSessionSdk.ps1`.
diff --git a/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1 b/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1
index 28b1f1cf0..e6a7d744e 100644
--- a/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1
+++ b/src/mxc-sdk/build/isolation_session_bindings/Update-IsoSessionSdk.ps1
@@ -6,7 +6,7 @@
 
 .DESCRIPTION
     Validates the package payload and release identity, updates MXC's package
-    version and SHA-256 pin, and regenerates GENERATION_INFO.toml. The package
+    version and SHA-256 pin, and regenerates LIFTED_SDK_INFO.toml. The package
     itself is not copied into the repository. The script fails before modifying
     tracked files when the package is incomplete or internally inconsistent.
 
@@ -267,8 +267,8 @@ elseif ($generatedDateValue -and
 else {
     throw 'Package GENERATION_INFO.toml has no valid generated_utc or generated_date value.'
 }
-$generationInfo = @"
-# Provenance for the isolation_session_bindings crate.
+$liftedSdkInfo = @"
+# Provenance for the lifted IsolationSession SDK package.
 #
 # Bindings are regenerated at build time from the Preview WinMD in the pinned
 # SDK package. Run Update-IsoSessionSdk.ps1 rather than editing this file.
@@ -280,24 +280,25 @@ generated_date = "$generatedDate"
 
 [source]
 nupkg = "$canonicalFileName"
+nupkg_sha256 = "$packageHash"
 winmd = "metadata/windows.ai.isolationsession.preview.winmd"
 winmd_sha256 = "$previewHash"
 namespace = "Windows.AI.IsolationSession.Preview"
 runtime_version = "$runtimeVersion"
 "@
 if ($osBuild) {
-    $generationInfo += "`nos_build = `"$osBuild`""
+    $liftedSdkInfo += "`nos_build = `"$osBuild`""
 }
 if ($buildGuid) {
-    $generationInfo += "`nbuild_guid = `"$buildGuid`""
+    $liftedSdkInfo += "`nbuild_guid = `"$buildGuid`""
 }
 
-$generationInfoPath = Join-Path $DestinationDirectory 'GENERATION_INFO.toml'
+$liftedSdkInfoPath = Join-Path $DestinationDirectory 'LIFTED_SDK_INFO.toml'
 $utf8WithoutBom = [System.Text.UTF8Encoding]::new($false)
 [System.IO.File]::WriteAllText($pinPath, $pinContent, $utf8WithoutBom)
 [System.IO.File]::WriteAllText(
-    $generationInfoPath,
-    "$generationInfo`n",
+    $liftedSdkInfoPath,
+    "$liftedSdkInfo`n",
     $utf8WithoutBom)
 
 [pscustomobject][ordered]@{
diff --git a/src/mxc-sdk/build/isolation_session_bindings/package_validation.rs b/src/mxc-sdk/build/isolation_session_bindings/package_validation.rs
new file mode 100644
index 000000000..d184a9493
--- /dev/null
+++ b/src/mxc-sdk/build/isolation_session_bindings/package_validation.rs
@@ -0,0 +1,182 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+const APP_DLL: &str = "IsoSessionApp.dll";
+const RUNTIME_MANIFEST: &str = "IsoSession.manifest";
+const IMAGE_FILE_MACHINE_AMD64: u16 = 0x8664;
+
+pub(super) fn package_file_name(package_id: &str, package_version: &str) -> String {
+    format!(
+        "{}.{}.nupkg",
+        package_id.to_ascii_lowercase(),
+        package_version
+    )
+}
+
+pub(super) fn package_runtime_instance(package_version: &str) -> Result<String, String> {
+    let mut parts = package_version.split('.');
+    let prefix = parts.next();
+    let release = parts.next();
+    let patch = parts.next();
+    if prefix != Some("0")
+        || parts.next().is_some()
+        || !patch.is_some_and(|value| value.bytes().all(|byte| byte.is_ascii_digit()))
+        || !release.is_some_and(|value| {
+            value.len() == 6 && value.bytes().all(|byte| byte.is_ascii_digit())
+        })
+    {
+        return Err(format!(
+            "IsolationSession SDK package version must use 0.YYYYMM.patch, got {package_version:?}"
+        ));
+    }
+
+    let release = release.unwrap();
+    Ok(format!("{}.{}", &release[..4], &release[4..]))
+}
+
+pub(super) fn validate_runtime_manifest(manifest: &[u8], instance: &str) -> Result<(), String> {
+    let content = std::str::from_utf8(manifest)
+        .map_err(|e| format!("{RUNTIME_MANIFEST} is not valid UTF-8: {e}"))?;
+    for required in [
+        "<assemblyIdentity name=\"IsoSession.Runtime\"",
+        "<file name=\"IsoSessionApp.dll\"",
+    ] {
+        if !content.contains(required) {
+            return Err(format!("{RUNTIME_MANIFEST} is missing {required:?}"));
+        }
+    }
+
+    let expected_instance = format!("name=\"{instance}\"");
+    if !content.contains(&expected_instance) {
+        return Err(format!(
+            "{RUNTIME_MANIFEST} does not identify runtime instance {instance:?}"
+        ));
+    }
+    Ok(())
+}
+
+pub(super) fn validate_runtime_architecture(
+    binary: &[u8],
+    target_arch: &str,
+) -> Result<(), String> {
+    if target_arch != "x86_64" {
+        return Err(format!(
+            "IsolationSession lifted runtime supports only target architecture \"x86_64\"; \
+             the pinned SDK package contains one AMD64 {APP_DLL}, so {target_arch:?} cannot be \
+             built until an architecture-specific payload is published"
+        ));
+    }
+
+    if binary.len() < 0x40 || &binary[..2] != b"MZ" {
+        return Err(format!("{APP_DLL} is not a valid PE image"));
+    }
+    let pe_offset = u32::from_le_bytes(
+        binary[0x3c..0x40]
+            .try_into()
+            .expect("slice length is checked"),
+    ) as usize;
+    let machine_end = pe_offset
+        .checked_add(6)
+        .ok_or_else(|| format!("{APP_DLL} has an invalid PE header offset"))?;
+    if machine_end > binary.len() || &binary[pe_offset..pe_offset + 4] != b"PE\0\0" {
+        return Err(format!("{APP_DLL} has an invalid PE header"));
+    }
+
+    let actual_machine = u16::from_le_bytes(
+        binary[pe_offset + 4..machine_end]
+            .try_into()
+            .expect("slice length is checked"),
+    );
+    if actual_machine != IMAGE_FILE_MACHINE_AMD64 {
+        return Err(format!(
+            "{APP_DLL} machine type 0x{actual_machine:04X} does not match Cargo target \
+             architecture \"x86_64\" (expected 0x{IMAGE_FILE_MACHINE_AMD64:04X})"
+        ));
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        package_file_name, package_runtime_instance, validate_runtime_architecture,
+        validate_runtime_manifest, IMAGE_FILE_MACHINE_AMD64,
+    };
+
+    const MANIFEST: &str = "\
+<assembly>
+  <assemblyIdentity name=\"IsoSession.Runtime\" />
+  <file name=\"IsoSessionApp.dll\" />
+  <iso:instance name=\"2026.10\" />
+</assembly>";
+
+    #[test]
+    fn package_version_maps_to_runtime_instance() {
+        assert_eq!(
+            package_runtime_instance("0.202610.5").unwrap(),
+            "2026.10"
+        );
+    }
+
+    #[test]
+    fn package_file_name_uses_nuget_packages_layout() {
+        assert_eq!(
+            package_file_name("Microsoft.AI.IsolationSession.SDK", "0.202610.5"),
+            "microsoft.ai.isolationsession.sdk.0.202610.5.nupkg"
+        );
+    }
+
+    #[test]
+    fn completed_runtime_manifest_is_accepted() {
+        validate_runtime_manifest(MANIFEST.as_bytes(), "2026.10").unwrap();
+    }
+
+    #[test]
+    fn mismatched_runtime_manifest_is_rejected() {
+        let error = validate_runtime_manifest(MANIFEST.as_bytes(), "2026.11").unwrap_err();
+        assert!(error.contains("does not identify runtime instance"));
+    }
+
+    fn pe_image(machine: u16) -> Vec<u8> {
+        let mut image = vec![0; 0x80];
+        image[..2].copy_from_slice(b"MZ");
+        image[0x3c..0x40].copy_from_slice(&0x40u32.to_le_bytes());
+        image[0x40..0x44].copy_from_slice(b"PE\0\0");
+        image[0x44..0x46].copy_from_slice(&machine.to_le_bytes());
+        image
+    }
+
+    #[test]
+    fn runtime_architecture_accepts_amd64_for_x86_64() {
+        validate_runtime_architecture(&pe_image(IMAGE_FILE_MACHINE_AMD64), "x86_64").unwrap();
+    }
+
+    #[test]
+    fn runtime_architecture_rejects_non_amd64_payload() {
+        let error = validate_runtime_architecture(&pe_image(0xAA64), "x86_64").unwrap_err();
+        assert!(error.contains("does not match Cargo target architecture"));
+    }
+
+    #[test]
+    fn runtime_architecture_rejects_unsupported_target() {
+        let error =
+            validate_runtime_architecture(&pe_image(IMAGE_FILE_MACHINE_AMD64), "aarch64")
+                .unwrap_err();
+        assert!(error.contains("supports only target architecture"));
+    }
+
+    #[test]
+    fn runtime_architecture_rejects_invalid_pe() {
+        let error = validate_runtime_architecture(b"not a PE", "x86_64").unwrap_err();
+        assert!(error.contains("not a valid PE image"));
+    }
+
+    #[test]
+    fn runtime_architecture_rejects_truncated_pe_header() {
+        let mut image = pe_image(IMAGE_FILE_MACHINE_AMD64);
+        image.truncate(0x44);
+
+        let error = validate_runtime_architecture(&image, "x86_64").unwrap_err();
+        assert!(error.contains("invalid PE header"));
+    }
+}
diff --git a/src/mxc-sdk/src/backends/isolation_session/bindings/mod.rs b/src/mxc-sdk/src/backends/isolation_session/bindings/mod.rs
index 121c9e448..a99fff2e7 100644
--- a/src/mxc-sdk/src/backends/isolation_session/bindings/mod.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/bindings/mod.rs
@@ -5,10 +5,11 @@
 //!
 //! Inbox builds use the committed OS-generated projection. Builds with the
 //! `isolation_session_lifted` feature regenerate the projection from the pinned SDK package
-//! restored from NuGet.org.
+//! restored through the configured MxcDependencies feed into an MXC-owned cache.
 //!
 //! See `build/isolation_session_bindings/GENERATION_INFO.toml`
-//! for provenance details.
+//! for inbox-binding provenance and `LIFTED_SDK_INFO.toml` for lifted-package
+//! provenance.
 
 #[allow(
     non_snake_case,
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/availability.rs b/src/mxc-sdk/src/backends/isolation_session/common/availability.rs
index b3ca37e0c..ae3128ce1 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/availability.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/availability.rs
@@ -10,7 +10,7 @@
 use std::sync::OnceLock;
 
 use crate::isolation_session_bindings::bindings::{IsoSessionFeature, IsoSessionOps};
-#[cfg(feature = "lifted_msi")]
+#[cfg(feature = "isolation_session_lifted")]
 use windows::Win32::Foundation::REGDB_E_CLASSNOTREG;
 use windows_core::HRESULT;
 
@@ -41,12 +41,12 @@ fn available_from(probe: Result<i32, HRESULT>) -> bool {
 fn probe_feature_level() -> Result<i32, HRESULT> {
     // Report unavailable if the framework runtime is not verified, so callers
     // never attempt a session they cannot complete.
-    #[cfg(feature = "lifted_msi")]
+    #[cfg(feature = "isolation_session_lifted")]
     if super::regfree::verify_framework().is_err() {
         return Err(REGDB_E_CLASSNOTREG);
     }
 
-    #[cfg(feature = "lifted_msi")]
+    #[cfg(feature = "isolation_session_lifted")]
     let ops = match super::regfree::activate_from_adjacent_shim::<IsoSessionOps>() {
         Some(result) => result.map_err(|error| {
             eprintln!(
@@ -57,7 +57,7 @@ fn probe_feature_level() -> Result<i32, HRESULT> {
         })?,
         None => return Err(REGDB_E_CLASSNOTREG),
     };
-    #[cfg(not(feature = "lifted_msi"))]
+    #[cfg(not(feature = "isolation_session_lifted"))]
     let ops = IsoSessionOps::new().map_err(|e| e.code())?;
 
     ops.GetFeatureLevel(IsoSessionFeature::LocalAgentUser)
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/error.rs b/src/mxc-sdk/src/backends/isolation_session/common/error.rs
index f7e00bb1b..c9ef30e0b 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/error.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/error.rs
@@ -48,7 +48,7 @@ pub(super) mod op {
 
     /// The staged shim's runtime-verification export, called before any session
     /// work to confirm the IsolationSession framework is installed.
-    #[cfg(feature = "lifted_msi")]
+    #[cfg(feature = "isolation_session_lifted")]
     pub(crate) const VERIFY_FRAMEWORK: &str = "IsoSessionApp.VerifyIsoSessionFramework";
 }
 
@@ -319,17 +319,18 @@ pub(super) fn activation_error(code: u32, detail: &str) -> IsolationSessionError
          the OS feature gate is enabled and the platform supports isolation sessions."
                 .to_string()
         } else if code == E_NOINTERFACE_HRESULT {
-            #[cfg(feature = "lifted_msi")]
+            #[cfg(feature = "isolation_session_lifted")]
             {
                 "the co-located IsoSessionApp.dll activated but returned an object that does not \
                  implement the expected IsolationSession interface. This is the classic WinMD/MSI \
-                 version-pin mismatch: the Preview WinMD wxc-exec was built against and the \
+                 version-pin mismatch: the Preview WinMD the current MXC native module was built \
+                 against and the \
                  MSI-installed IsolationSession runtime were produced from different OS versions, \
                  so their interface IIDs differ. Rebuild the MSI and the \
                  Microsoft.AI.IsolationSession.SDK NuGet from the same OS commit."
                     .to_string()
             }
-            #[cfg(not(feature = "lifted_msi"))]
+            #[cfg(not(feature = "isolation_session_lifted"))]
             {
                 format!("IsolationSession runtime API activation failed: {detail}")
             }
@@ -367,7 +368,7 @@ pub(super) fn identity_refusal(err: windows_core::Error) -> IsolationSessionErro
 /// different, unversioned binary set is exactly the failure mode this design
 /// exists to prevent — so the missing payload surfaces as a hard,
 /// actionable error instead.
-#[cfg(feature = "lifted_msi")]
+#[cfg(feature = "isolation_session_lifted")]
 pub(super) fn lifted_payload_missing(operation: &str) -> IsolationSessionError {
     IsolationSessionError::ServiceUnavailable(IsoApiFailure::new(
         operation,
@@ -396,7 +397,7 @@ pub(super) fn lifted_payload_missing(operation: &str) -> IsolationSessionError {
 /// surfaces in the one-shot `ScriptResponse` string and as the state-aware
 /// `MxcError` message), and the shim's ready-to-display fix text, when present,
 /// becomes the `remediation`.
-#[cfg(feature = "lifted_msi")]
+#[cfg(feature = "isolation_session_lifted")]
 pub(super) fn framework_unavailable(
     refusal: super::regfree::FrameworkRefusal,
 ) -> IsolationSessionError {
@@ -885,7 +886,7 @@ mod tests {
     /// `E_NOINTERFACE` from lifted activation is the WinMD/MSI version-pin mismatch
     /// signature: the mapping must name that cause rather than echo the bare
     /// COM detail, so the message points at rebuilding both from one commit.
-    #[cfg(feature = "lifted_msi")]
+    #[cfg(feature = "isolation_session_lifted")]
     #[test]
     fn e_nointerface_activation_names_version_pin_mismatch() {
         let mapped = map_lifecycle_error(activation_error(E_NOINTERFACE_HRESULT, "ignored"));
@@ -895,7 +896,7 @@ mod tests {
         assert!(mapped.message.contains("same OS commit"));
     }
 
-    #[cfg(not(feature = "lifted_msi"))]
+    #[cfg(not(feature = "isolation_session_lifted"))]
     #[test]
     fn inbox_e_nointerface_activation_preserves_platform_detail() {
         let mapped = map_lifecycle_error(activation_error(
@@ -911,7 +912,7 @@ mod tests {
     /// The hard error raised when the lifted payload is absent must carry the
     /// class-not-registered code, an operation, a message that refuses the
     /// inbox fallback, and an actionable remediation.
-    #[cfg(feature = "lifted_msi")]
+    #[cfg(feature = "isolation_session_lifted")]
     #[test]
     fn lifted_payload_missing_is_a_hard_actionable_error() {
         let mapped = map_lifecycle_error(lifted_payload_missing(op::ACTIVATE));
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
index c6d65d086..b1b7a63dc 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/manager.rs
@@ -33,7 +33,7 @@ use super::error::{
     activation_error, check_result, format_iso_error, lifecycle_err, op, transport_err,
     IsolationSessionError, StalePromotion,
 };
-#[cfg(feature = "lifted_msi")]
+#[cfg(feature = "isolation_session_lifted")]
 use super::error::{framework_unavailable, lifted_payload_missing};
 use super::owned_thread::{self, Impersonation};
 use super::pipe_relay::{
@@ -90,7 +90,7 @@ unsafe impl Sync for MtaReference {}
 /// There is **no inbox fallback**: if the lifted payload is not staged beside
 /// this module or executable, this returns a hard [`lifted_payload_missing`]
 /// error rather than silently binding the inbox `System32` runtime.
-#[cfg(feature = "lifted_msi")]
+#[cfg(feature = "isolation_session_lifted")]
 fn check_service_available_and_activate() -> Result<IsoSessionOps, IsolationSessionError> {
     // Refuse before touching the runtime if the framework is not verified.
     super::regfree::verify_framework().map_err(framework_unavailable)?;
@@ -109,7 +109,7 @@ fn check_service_available_and_activate() -> Result<IsoSessionOps, IsolationSess
 
 /// Inbox mode: activates the system-registered OS API through normal WinRT
 /// activation.
-#[cfg(not(feature = "lifted_msi"))]
+#[cfg(not(feature = "isolation_session_lifted"))]
 fn check_service_available_and_activate() -> Result<IsoSessionOps, IsolationSessionError> {
     IsoSessionOps::new().map_err(|e| activation_error(e.code().0 as u32, &e.message()))
 }
@@ -1567,7 +1567,7 @@ mod tests {
                 );
 
                 match failure.operation.as_str() {
-                    #[cfg(feature = "lifted_msi")]
+                    #[cfg(feature = "isolation_session_lifted")]
                     op::VERIFY_FRAMEWORK => assert!(
                         failure.code.is_none(),
                         "framework refusal unexpectedly carried an HRESULT"
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/mod.rs b/src/mxc-sdk/src/backends/isolation_session/common/mod.rs
index 730011e4a..6613d4e0e 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/mod.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/mod.rs
@@ -41,7 +41,7 @@ mod process_options;
 mod sandbox;
 #[cfg(target_os = "windows")]
 pub use sandbox::{spawn_one_shot, spawn_one_shot_pty, OneShotSpawnFailure};
-#[cfg(all(target_os = "windows", feature = "lifted_msi"))]
+#[cfg(all(target_os = "windows", feature = "isolation_session_lifted"))]
 mod regfree;
 #[cfg(target_os = "windows")]
 mod sandbox_id;
diff --git a/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs b/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs
index e215459a2..96024c573 100644
--- a/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs
+++ b/src/mxc-sdk/src/backends/isolation_session/common/process_options.rs
@@ -10,7 +10,7 @@ use crate::mxc_common::models::ExecutionRequest;
 use crate::isolation_session_bindings::bindings::IsoSessionProcessOptions;
 use windows_core::HSTRING;
 
-#[cfg(feature = "lifted_msi")]
+#[cfg(feature = "isolation_session_lifted")]
 use super::error::lifted_payload_missing;
 use super::error::{op, transport_err, IsolationSessionError};
 
@@ -216,7 +216,7 @@ pub(super) fn build_iso_process_options(
     Ok(proc_options)
 }
 
-#[cfg(feature = "lifted_msi")]
+#[cfg(feature = "isolation_session_lifted")]
 fn new_iso_process_options() -> Result<IsoSessionProcessOptions, IsolationSessionError> {
     match super::regfree::activate_from_adjacent_shim::<IsoSessionProcessOptions>() {
         Some(result) => result.map_err(|e| transport_err(op::OPTIONS_NEW, "activation failed", &e)),
@@ -224,7 +224,7 @@ fn new_iso_process_options() -> Result<IsoSessionProcessOptions, IsolationSessio
     }
 }
 
-#[cfg(not(feature = "lifted_msi"))]
+#[cfg(not(feature = "isolation_session_lifted"))]
 fn new_iso_process_options() -> Result<IsoSessionProcessOptions, IsolationSessionError> {
     IsoSessionProcessOptions::new()
         .map_err(|e| transport_err(op::OPTIONS_NEW, "activation failed", &e))
diff --git a/src/mxc-sdk/tests/isolation_session_package_validation.rs b/src/mxc-sdk/tests/isolation_session_package_validation.rs
new file mode 100644
index 000000000..610cba993
--- /dev/null
+++ b/src/mxc-sdk/tests/isolation_session_package_validation.rs
@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+mod package_validation {
+    include!("../build/isolation_session_bindings/package_validation.rs");
+}

From 6401f0c9aca61ab1a069e9295042244f7ba18dab Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Wed, 7 Oct 2026 15:14:44 -0700
Subject: [PATCH 24/26] Retrigger CI after dependency feed seeding

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 1d43372e-f942-4bb7-a358-48f9218c2332

From 9427284251fd37406085216c11f998383ec255ea Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Wed, 7 Oct 2026 16:00:54 -0700
Subject: [PATCH 25/26] Fix lifted restore inputs for workspace builds

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 1d43372e-f942-4bb7-a358-48f9218c2332
---
 src/mxc-sdk/build/build_mxc_build_common.rs   | 33 ++++++++++++++++---
 .../src/core/mxc_common/telemetry/consent.rs  |  2 +-
 2 files changed, 29 insertions(+), 6 deletions(-)

diff --git a/src/mxc-sdk/build/build_mxc_build_common.rs b/src/mxc-sdk/build/build_mxc_build_common.rs
index b4233b084..5a5c124e9 100644
--- a/src/mxc-sdk/build/build_mxc_build_common.rs
+++ b/src/mxc-sdk/build/build_mxc_build_common.rs
@@ -36,9 +36,8 @@ pub mod isolation_session_sdk {
         "b387c9d11808bf8864d3d7e4d6924f79bdcd6e7c4c54c4e2e49ab0e3525b3d2e";
     pub const PACKAGE_PATH_ENV: &str = "ISOLATION_SESSION_SDK_PACKAGE";
 
-    const RESTORE_PROJECT: &str =
-        "build/isolation_session_bindings/IsolationSessionSdk.Restore.csproj";
-    const NUGET_CONFIG: &str = "build/isolation_session_bindings/NuGet.Config";
+    const RESTORE_PROJECT: &str = "IsolationSessionSdk.Restore.csproj";
+    const NUGET_CONFIG: &str = "NuGet.Config";
     const APP_DLL: &str = "IsoSessionApp.dll";
     const RUNTIME_MANIFEST: &str = "IsoSession.manifest";
 
@@ -143,8 +142,9 @@ pub mod isolation_session_sdk {
             std::env::var("CARGO_MANIFEST_DIR")
                 .map_err(|e| format!("CARGO_MANIFEST_DIR is not set: {e}"))?,
         );
-        let restore_project = manifest_dir.join(RESTORE_PROJECT);
-        let nuget_config = manifest_dir.join(NUGET_CONFIG);
+        let restore_inputs = restore_inputs_dir(&manifest_dir)?;
+        let restore_project = restore_inputs.join(RESTORE_PROJECT);
+        let nuget_config = restore_inputs.join(NUGET_CONFIG);
         let cache_root = target_profile_dir()?.join(".mxc-nuget");
         let packages_root = cache_root.join("packages");
         let restore_output = PathBuf::from(
@@ -199,6 +199,29 @@ pub mod isolation_session_sdk {
         ))
     }
 
+    fn restore_inputs_dir(manifest_dir: &Path) -> Result<PathBuf, String> {
+        for ancestor in manifest_dir.ancestors() {
+            for relative in [
+                Path::new("build").join("isolation_session_bindings"),
+                Path::new("mxc-sdk")
+                    .join("build")
+                    .join("isolation_session_bindings"),
+            ] {
+                let candidate = ancestor.join(relative);
+                if candidate.join(RESTORE_PROJECT).is_file()
+                    && candidate.join(NUGET_CONFIG).is_file()
+                {
+                    return Ok(candidate);
+                }
+            }
+        }
+
+        Err(format!(
+            "cannot locate the shared IsolationSession NuGet restore inputs from {}",
+            manifest_dir.display()
+        ))
+    }
+
     fn verify_package(path: &Path) -> Result<(), String> {
         let bytes = std::fs::read(path)
             .map_err(|e| format!("read IsolationSession SDK package {}: {e}", path.display()))?;
diff --git a/src/mxc-sdk/src/core/mxc_common/telemetry/consent.rs b/src/mxc-sdk/src/core/mxc_common/telemetry/consent.rs
index 6833e83e8..75ca9d6ec 100644
--- a/src/mxc-sdk/src/core/mxc_common/telemetry/consent.rs
+++ b/src/mxc-sdk/src/core/mxc_common/telemetry/consent.rs
@@ -1578,7 +1578,7 @@ mod tests {
         let (sender, receiver) = std::sync::mpsc::channel();
         let waker = std::task::Waker::from(std::sync::Arc::new(SignalWaker(sender)));
         let mut context = std::task::Context::from_waker(&waker);
-        let mut task = std::pin::pin!(BlockingTask::spawn(|| -> () { panic!("worker panic") }));
+        let mut task = std::pin::pin!(BlockingTask::spawn(|| panic!("worker panic")));
 
         let propagated = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
             if std::future::Future::poll(task.as_mut(), &mut context).is_pending() {

From 319472d59cbffb8aa0d6a4e78f5f813b18671e7a Mon Sep 17 00:00:00 2001
From: Dan Legg <dalegg@microsoft.com>
Date: Wed, 7 Oct 2026 16:37:20 -0700
Subject: [PATCH 26/26] Complete lifted cross-host and Node packaging
 validation

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: 1d43372e-f942-4bb7-a358-48f9218c2332
---
 build.bat                                   |  8 ++++++++
 sdk/node/tests/integration/package.test.ts  | 14 ++++++++++++++
 sdk/node/tests/integration/test-helpers.ts  |  6 ++++++
 src/ffi/mxc_ffi/Cargo.toml                  |  4 ++--
 src/ffi/mxc_ffi/build.rs                    |  8 ++++++--
 src/mxc-sdk/build.rs                        |  8 +++++---
 src/mxc-sdk/build/build_mxc_build_common.rs |  2 +-
 src/tools/wxc/Cargo.toml                    |  4 ++--
 src/tools/wxc/build.rs                      |  8 ++++++--
 9 files changed, 50 insertions(+), 12 deletions(-)

diff --git a/build.bat b/build.bat
index 34ec121a3..4e436a82e 100644
--- a/build.bat
+++ b/build.bat
@@ -285,6 +285,7 @@ popd
 
 echo.
 echo Building SDK integration tests...
+set "MXC_EXPECT_ISOLATION_SESSION_LIFTED=%WITH_ISOLATION_SESSION_LIFTED%"
 pushd sdk\node\tests\integration
 :: npm caches `file:` deps by package.json version. The local SDK version
 :: rarely bumps between builds, so a plain `npm install` keeps reusing the
@@ -292,6 +293,13 @@ pushd sdk\node\tests\integration
 :: type-checking sees the dist we just rebuilt above.
 if exist node_modules\@microsoft\mxc-sdk rmdir /s /q node_modules\@microsoft\mxc-sdk
 call npm install & call npm run build
+if "%WITH_ISOLATION_SESSION_LIFTED%"=="1" (
+    node --test --test-name-pattern="lifted IsolationSession|unexpected binaries" dist\package.test.js
+    if errorlevel 1 (
+        popd
+        goto :error_root
+    )
+)
 popd
 
 echo.
diff --git a/sdk/node/tests/integration/package.test.ts b/sdk/node/tests/integration/package.test.ts
index fbdb1e693..01b42967f 100644
--- a/sdk/node/tests/integration/package.test.ts
+++ b/sdk/node/tests/integration/package.test.ts
@@ -11,6 +11,7 @@ import {
   EXPECTED_WINDOWS_BINARIES,
   EXPECTED_LINUX_BINARIES,
   EXPECTED_MACOS_BINARIES,
+  ISOLATION_SESSION_LIFTED_BINARIES,
   ALL_KNOWN_BINARIES,
   platformName,
 } from './test-helpers.js';
@@ -56,6 +57,19 @@ describe('SDK package binaries', () => {
     );
   });
 
+  if (process.env.MXC_EXPECT_ISOLATION_SESSION_LIFTED === '1') {
+    it('should include the lifted IsolationSession runtime payload', () => {
+      const missing = ISOLATION_SESSION_LIFTED_BINARIES.filter(
+        binary => !fs.existsSync(path.join(binDir, binary)),
+      );
+      assert.deepStrictEqual(
+        missing,
+        [],
+        `Missing lifted IsolationSession binaries in ${binDir}: ${missing.join(', ')}`,
+      );
+    });
+  }
+
   it('should not contain unexpected binaries', () => {
     if (!fs.existsSync(binDir)) {
       return;
diff --git a/sdk/node/tests/integration/test-helpers.ts b/sdk/node/tests/integration/test-helpers.ts
index 75895b459..98375ea84 100644
--- a/sdk/node/tests/integration/test-helpers.ts
+++ b/sdk/node/tests/integration/test-helpers.ts
@@ -136,9 +136,15 @@ export const EXPECTED_MACOS_BINARIES = [
   'unix-test-proxy',
 ];
 
+export const ISOLATION_SESSION_LIFTED_BINARIES = [
+  'IsoSessionApp.dll',
+  'IsoSession.manifest',
+];
+
 // Binaries that are optional (feature-gated or only present in certain builds)
 // but still legitimate if found in the package.
 const OPTIONAL_BINARIES = [
+  ...ISOLATION_SESSION_LIFTED_BINARIES,
   'wslcsdk.dll',          // Only built with --with-wslc
   'wxc-wslc-daemon.exe',  // Only built with --with-wslc
   'nanvixd.exe',           // Only built with --with-microvm
diff --git a/src/ffi/mxc_ffi/Cargo.toml b/src/ffi/mxc_ffi/Cargo.toml
index d2e4ce225..8f1bceb54 100644
--- a/src/ffi/mxc_ffi/Cargo.toml
+++ b/src/ffi/mxc_ffi/Cargo.toml
@@ -51,9 +51,9 @@ required-features = ["isolation_session"]
 
 [build-dependencies]
 csbindgen = { version = "1", optional = true }
+sha2.workspace = true
+zip = { version = "2", default-features = false, features = ["deflate"] }
 
 [target.'cfg(windows)'.build-dependencies]
 cc = "1"
-sha2.workspace = true
 winresource.workspace = true
-zip = { version = "2", default-features = false, features = ["deflate"] }
diff --git a/src/ffi/mxc_ffi/build.rs b/src/ffi/mxc_ffi/build.rs
index afaff374c..1cd0027f6 100644
--- a/src/ffi/mxc_ffi/build.rs
+++ b/src/ffi/mxc_ffi/build.rs
@@ -26,15 +26,19 @@ fn main() {
     println!("cargo:rerun-if-changed=src/state_aware.rs");
     println!("cargo:rerun-if-changed=build.rs");
 
-    #[cfg(all(windows, feature = "isolation_session"))]
+    #[cfg(feature = "isolation_session")]
     reconcile_isolation_session_runtime();
 
     #[cfg(feature = "dotnetsdk")]
     generate_csharp_bindings();
 }
 
-#[cfg(all(windows, feature = "isolation_session"))]
+#[cfg(feature = "isolation_session")]
 fn reconcile_isolation_session_runtime() {
+    if std::env::var("CARGO_CFG_TARGET_OS").as_deref() != Ok("windows") {
+        return;
+    }
+
     let out_dir = std::path::PathBuf::from(std::env::var("OUT_DIR").expect("OUT_DIR"));
     let target_dir = out_dir
         .parent()
diff --git a/src/mxc-sdk/build.rs b/src/mxc-sdk/build.rs
index f1e593b0b..5c8e96b74 100644
--- a/src/mxc-sdk/build.rs
+++ b/src/mxc-sdk/build.rs
@@ -30,9 +30,11 @@ mod nanvix_common;
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     #[cfg(feature = "isolation_session")]
     build_isolation_session_bindings::run();
-    #[cfg(all(windows, feature = "isolation_session_lifted"))]
-    build_mxc_build_common::isolation_session_sdk::stage_runtime()
-        .unwrap_or_else(|error| panic!("IsolationSession SDK staging failed: {error}"));
+    #[cfg(feature = "isolation_session_lifted")]
+    if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows") {
+        build_mxc_build_common::isolation_session_sdk::stage_runtime()
+            .unwrap_or_else(|error| panic!("IsolationSession SDK staging failed: {error}"));
+    }
     build_mxc_telemetry::run();
     if let Some((bin_dir, use_prefetched_binaries)) = build_nanvix_binaries::run() {
         nanvix_build_common::stage_artifacts_next_to_exe(&bin_dir, !use_prefetched_binaries);
diff --git a/src/mxc-sdk/build/build_mxc_build_common.rs b/src/mxc-sdk/build/build_mxc_build_common.rs
index 5a5c124e9..79bd94dac 100644
--- a/src/mxc-sdk/build/build_mxc_build_common.rs
+++ b/src/mxc-sdk/build/build_mxc_build_common.rs
@@ -14,7 +14,7 @@ use std::io;
 use std::path::Path;
 use std::process::Command;
 
-#[cfg(all(windows, feature = "isolation_session_lifted"))]
+#[cfg(feature = "isolation_session_lifted")]
 pub mod isolation_session_sdk {
     use sha2::{Digest, Sha256};
     use std::io::Read;
diff --git a/src/tools/wxc/Cargo.toml b/src/tools/wxc/Cargo.toml
index b526a7740..e425c2489 100644
--- a/src/tools/wxc/Cargo.toml
+++ b/src/tools/wxc/Cargo.toml
@@ -21,13 +21,13 @@ tempfile.workspace = true
 
 [target.'cfg(windows)'.build-dependencies]
 cc = "1"
-sha2.workspace = true
 winresource.workspace = true
-zip = { version = "2", default-features = false, features = ["deflate"] }
 
 [build-dependencies]
 serde.workspace = true
 serde_json.workspace = true
+sha2.workspace = true
+zip = { version = "2", default-features = false, features = ["deflate"] }
 
 [features]
 default = []
diff --git a/src/tools/wxc/build.rs b/src/tools/wxc/build.rs
index 56d59ba7b..05f091e25 100644
--- a/src/tools/wxc/build.rs
+++ b/src/tools/wxc/build.rs
@@ -7,7 +7,7 @@
 mod mxc_build_common;
 
 fn main() {
-    #[cfg(all(windows, feature = "isolation_session"))]
+    #[cfg(feature = "isolation_session")]
     reconcile_isolation_session_runtime();
 
     mxc_build_common::embed_version_info("MXC sandbox executor", "wxc-exec.exe");
@@ -31,8 +31,12 @@ fn main() {
     println!("cargo:rerun-if-env-changed=PATH");
 }
 
-#[cfg(all(windows, feature = "isolation_session"))]
+#[cfg(feature = "isolation_session")]
 fn reconcile_isolation_session_runtime() {
+    if std::env::var("CARGO_CFG_TARGET_OS").as_deref() != Ok("windows") {
+        return;
+    }
+
     let out_dir = std::path::PathBuf::from(std::env::var("OUT_DIR").expect("OUT_DIR"));
     let target_dir = out_dir
         .parent()