diff --git a/README.md b/README.md
index 234ff31..1c59e4c 100644
--- a/README.md
+++ b/README.md
@@ -26,6 +26,36 @@ Loader loses the CDP injection path it requires when Millennium runs normally.
 > layer, normal Millennium and stock CSS Loader conflict over the external CDP
 > mechanism, so CSS Loader does not function correctly in the first place.
 
+## Version 1.0
+
+Version 1.0 is the first stable release of the complete CSS Loader for
+Millennium experience: the desktop manager, compatibility backend, direct
+runtime publisher, and official Millennium companion.
+
+Its defining advantage is fidelity. Existing CSS Loader themes remain in their
+native format and are resolved by CSS Loader's own theme engine. The resulting
+styles are delivered directly to Steam without flattening them into converted
+Millennium bundles or rewriting valid CSS constructs.
+
+### Main highlights
+
+- Full CSS Loader configuration model: themes, profiles, dependencies, patch
+  controls, colors, generated variables, enable state, and cascade order.
+- Direct CSS delivery that preserves inline SVG, data URLs, animations, local
+  assets, and advanced CSS exactly as authored.
+- Desktop, Big Picture, Quick Access, Main Menu, notification, and popup target
+  routing through Millennium's supported in-process interfaces.
+- Normal Millennium operation with no Steam `-dev` mode, external debugging
+  port, or `.cef-enable-remote-debugging` marker.
+- Overlay behavior that keeps Fluenty, SpaceTheme, Pebble, or another selected
+  Millennium theme active underneath CSS Loader.
+- Desktop management for installed themes, profiles, settings, store browsing,
+  downloads, updates, and the always-on Windows backend.
+- Atomic runtime updates: the companion accepts new state only when its revision
+  and content hash match.
+- Compatibility regression coverage for real-world themes, including nested
+  inline-SVG filters and `/themes_custom` images and fonts.
+
 ## How this resolves the conflict
 
 CSS Loader for Millennium replaces the incompatible injection path while
@@ -36,7 +66,7 @@ colors, components, class translations, and activation order.
 | Stock CSS Loader path | Millennium-compatible replacement |
 | --- | --- |
 | Creates `.cef-enable-remote-debugging` | Does not create or depend on the marker |
-| Requires an externally reachable CDP port | Compiles the selected state into persistent CSS bundles |
+| Requires an externally reachable CDP port | Publishes resolved injects to the Millennium companion |
 | Needs Millennium's `-dev` mode to expose that port | Works with Millennium's normal runtime mode |
 | Injects every Steam document through external CDP | Uses an in-process Millennium overlay plus its controlled per-plugin CDP proxy for isolated BrowserViews |
 
@@ -49,27 +79,27 @@ separate browser bridge.
 
 Eliminating the delayed theming flash is an additional benefit of this design,
 not the entire purpose of the project. The compatibility runtime persists the
-last compiled configuration on disk, and its companion starts as part of
-Millennium instead of waiting for a late external standalone injection pass.
+latest resolved injection state on disk, and its companion starts as part of
+Millennium instead of waiting for an external standalone CDP connection.
 
 ## Highlights
 
-- Replaces CSS Loader's external CDP injection path with a Millennium-compatible
-  generated-theme runtime.
+- Replaces CSS Loader's external CDP injection path with ordered, direct style
+  injection inside Millennium.
 - Requires neither Millennium `-dev` mode nor `.cef-enable-remote-debugging`.
 - Uses existing themes from `~/homebrew/themes`; no manual conversion required.
 - Preserves profiles, dependencies, patch options, colors, CSS variables, local
   images/fonts, class translations, and CSS cascade order.
 - Defaults to overlay mode, keeping Fluenty, SpaceTheme, Pebble, or another
   selected Millennium theme active beneath CSS Loader.
-- Produces **CSS Loader (Standalone)** as an optional CSS Loader-only theme and
-  as the internal host for generated CSS and assets.
+- Preserves each resolved inject as CSS text instead of flattening it into a
+  rewritten bundle.
 - Bundles the backend and the separately maintained
   [CSS Loader Companion for Millennium](https://github.com/DevsNate/CSSLoader-Companion-Millennium)
   inside one desktop installer.
 - Bootstraps a new `%USERPROFILE%\homebrew\themes` library automatically; Decky
   or a pre-existing CSS Loader installation is not required.
-- Reloads the generated theme when settings or watched CSS files change.
+- Republishes direct runtime state when settings or watched CSS files change.
 - Keeps Desktop, Big Picture, Quick Access, Main Menu, and notification targets
   separate, matching CSS Loader's real document routing.
 
@@ -96,20 +126,19 @@ reference warning in [Compatibility verification](docs/verification.md).
 1. Install Millennium and start Steam once so Millennium creates its config.
 2. Download and install the latest MSI from this repository's Releases page.
 3. Open **CSS Loader for Millennium**. First-run setup creates the theme library,
-   installs the backend and companion, and generates a valid empty overlay.
-4. Leave your preferred Millennium theme selected. The generated **CSS Loader
-   (Standalone)** entry is optional and is only needed for CSS Loader-only mode.
+   installs the backend and companion, and publishes a valid empty state.
+4. Leave your preferred Millennium theme selected; CSS Loader is layered over it.
 5. Restart Steam once, then manage themes, profiles, and every patch option from
    the desktop app.
 
 The installer places the backend in the current user's Windows Startup folder,
 copies and enables the companion in Steam, and creates
-`%USERPROFILE%\homebrew\themes` when it does not exist. Your generated
-configuration stays active at Steam startup even while the desktop app and
-backend are closed.
+`%USERPROFILE%\homebrew\themes` when it does not exist. The backend publishes
+the app's resolved state and the companion applies it inside Steam.
 
 The local `Steam\millennium\themes\CSS Loader` folder is generated uniquely for
-each user. It is an asset host, not a separately published Marketplace theme.
+each user. It is a runtime-state mailbox, not a separately published Marketplace
+theme.
 See [Clean installation](docs/clean-installation.md) for the complete first-run
 contract and migration behavior.
 
@@ -144,7 +173,7 @@ available for `build:backend`, `build:plugin`, and `sync:desktop`.
 
 | Path | Purpose |
 | --- | --- |
-| `runtime/backend` | CSS Loader compatibility logic and generated-theme compiler |
+| `runtime/backend` | CSS Loader compatibility logic and direct-state publisher |
 | `plugins/millennium` | Pinned [CSS Loader Companion for Millennium](https://github.com/DevsNate/CSSLoader-Companion-Millennium) submodule used for MSI builds |
 | `apps/desktop` | Tauri theme manager and bundled installer |
 | `tools/audit` | Reference capture, parity, and Steam class-map auditing |
@@ -168,8 +197,8 @@ runtime and desktop projects; see [Attribution and provenance](NOTICE.md).
 
 | Repository | Purpose |
 | --- | --- |
-| [`CSSLoader-Millennium`](https://github.com/DevsNate/CSSLoader-Millennium) | Desktop app, CSS Loader-compatible backend, installer, compiler, and verification |
-| [`CSSLoader-Companion-Millennium`](https://github.com/DevsNate/CSSLoader-Companion-Millennium) | Millennium Marketplace plugin that applies the generated output inside Steam |
+| [`CSSLoader-Millennium`](https://github.com/DevsNate/CSSLoader-Millennium) | Desktop app, CSS Loader-compatible backend, installer, runtime publisher, and verification |
+| [`CSSLoader-Companion-Millennium`](https://github.com/DevsNate/CSSLoader-Companion-Millennium) | Millennium Marketplace plugin that applies resolved CSS Loader injects inside Steam |
 
 ## License
 
diff --git a/apps/desktop/package-lock.json b/apps/desktop/package-lock.json
index daff726..92eeafb 100644
--- a/apps/desktop/package-lock.json
+++ b/apps/desktop/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@css-loader-for-millennium/desktop",
-  "version": "0.2.0",
+  "version": "1.0.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@css-loader-for-millennium/desktop",
-      "version": "0.2.0",
+      "version": "1.0.0",
       "license": "GPL-3.0-only",
       "dependencies": {
         "@radix-ui/react-alert-dialog": "^1.0.4",
diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index fbf9ebe..0231119 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@css-loader-for-millennium/desktop",
-  "version": "0.2.0",
+  "version": "1.0.0",
   "private": true,
   "description": "Desktop theme manager and installer for CSS Loader on Millennium.",
   "author": "Nate and contributors",
diff --git a/apps/desktop/src-tauri/Cargo.lock b/apps/desktop/src-tauri/Cargo.lock
index 405a125..c913d89 100644
--- a/apps/desktop/src-tauri/Cargo.lock
+++ b/apps/desktop/src-tauri/Cargo.lock
@@ -452,7 +452,7 @@ dependencies = [
 
 [[package]]
 name = "css-loader-for-millennium"
-version = "0.2.0"
+version = "1.0.0"
 dependencies = [
  "directories",
  "home",
diff --git a/apps/desktop/src-tauri/Cargo.toml b/apps/desktop/src-tauri/Cargo.toml
index b546860..cf7b247 100644
--- a/apps/desktop/src-tauri/Cargo.toml
+++ b/apps/desktop/src-tauri/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "css-loader-for-millennium"
-version = "0.2.0"
+version = "1.0.0"
 description = "Desktop theme manager and installer for CSS Loader on Millennium"
 authors = ["Nate and contributors"]
 license = "GPL-3.0-only"
diff --git a/docs/architecture.md b/docs/architecture.md
index 943c033..4a9a1a3 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -15,8 +15,8 @@ flowchart LR
   T["Existing CSS Loader themes"] --> R["Python compatibility runtime"]
   C["Profiles and patch settings"] --> R
   M["Steam class translations"] --> R
-  R --> G["Generated CSS bundles and asset host"]
-  G --> P["Millennium overlay companion"]
+  R --> G["Ordered direct-injection state"]
+  G --> P["Millennium companion"]
   P --> D["Desktop and Big Picture"]
   P --> I["Quick Access, Main Menu, notifications"]
   S["Selected Millennium theme"] --> D
@@ -24,34 +24,38 @@ flowchart LR
   A["Desktop manager"] --> R
 ```
 
-## Runtime compiler
+## Runtime publisher
 
 `runtime/backend` retains CSS Loader's manifest reader, dependency handling,
 patch components, profiles, class translation, and theme-store integration. It
-compiles enabled payloads in activation order, rewrites local asset URLs, and
-writes a Millennium-served asset host whose optional selector entry is named
-**CSS Loader (Standalone)**.
+publishes every enabled payload in activation order without flattening bundles,
+rewriting asset URLs, or parsing nested CSS constructs. File-backed injects are
+read from their original source so legacy JavaScript-string escaping cannot
+leak into the direct protocol.
 
-The generated bundles are persisted on disk, so the desktop manager does not
-need to be running when Steam starts. Overlay mode leaves the user's selected
-Millennium theme untouched and layers the last compiled CSS Loader state over
-it. Selecting **CSS Loader (Standalone)** remains available for a CSS
-Loader-only presentation.
+CSS Loader's existing `/themes_custom/...` contract is preserved. When Steam's
+`themes_custom` path is not linked to the homebrew library, the publisher mirrors
+active theme files there without modifying their CSS.
+
+The publisher atomically writes `runtime-state.json` followed by a small
+`build-report.json` revision. The companion accepts a state only when both
+content hashes match. The user's selected Millennium theme remains untouched,
+and CSS Loader's ordered style elements are layered over it.
 
 ## Millennium companion
 
 The separately maintained
 [CSS Loader Companion for Millennium](https://github.com/DevsNate/CSSLoader-Companion-Millennium),
 pinned into this repository at `plugins/millennium` for release builds, is the
-primary overlay runtime. It synchronizes Desktop
-and Big Picture directly inside Steam, then reaches Quick Access, Main Menu,
-and notification toasts through Millennium's per-plugin Chrome DevTools
-Protocol proxy because those targets live in isolated BrowserViews.
+primary runtime. It reconciles individual `<style>` elements in Desktop and Big
+Picture, then does the same for Quick Access, Main Menu, and notification toasts
+through Millennium's per-plugin Chrome DevTools Protocol proxy because those
+targets live in isolated BrowserViews.
 
 This is not an external CDP setup: the project does not open port 8080, require
 Millennium `-dev` mode, or run a separate browser bridge. The generated theme
-directory is a persistent content host; it does not need to be the active
-Millennium theme.
+directory is only a local runtime-state mailbox; it does not need to be the
+active Millennium theme.
 
 ## Desktop manager
 
@@ -64,14 +68,13 @@ unrelated upstream backend.
 
 On a clean machine, first launch is an idempotent bootstrap: it creates the
 theme library, copies the backend, installs or migrates the companion, preserves
-the selected Millennium theme, and then starts the compiler. The generated
-Millennium theme folder is user-specific runtime output and is not published as
-a theme repository.
+the selected Millennium theme, and then starts the publisher. The local runtime
+folder is user-specific output and is not published as a theme repository.
 
 ## Data flow and ordering
 
 CSS Loader's cascade order is observable behavior. Toggling a component removes
-its old payload and appends its replacement, so the compiler tracks activation
-order rather than sorting by theme name or file path. Target bundles are kept
-separate; Quick Access or Main Menu CSS is never folded into Big Picture merely
-because all three are gamepad UI surfaces.
+its old payload and appends its replacement, so the publisher tracks activation
+order rather than sorting by theme name or file path. Each payload retains its
+own target match; Quick Access or Main Menu CSS is never folded into Big Picture
+merely because all three are gamepad UI surfaces.
diff --git a/docs/clean-installation.md b/docs/clean-installation.md
index c5efe86..4552447 100644
--- a/docs/clean-installation.md
+++ b/docs/clean-installation.md
@@ -18,8 +18,8 @@ Opening the desktop app performs one idempotent setup operation:
 3. Copy the bundled backend into the current user's Windows Startup folder.
 4. Install **CSS Loader Companion** into Millennium's plugin directory.
 5. Enable `css-loader-companion` while preserving the selected Millennium theme.
-6. Start the backend, fetch CSS class translations, and generate a valid empty
-   overlay when no themes have been installed yet.
+6. Start the backend, fetch CSS class translations, and publish a valid empty
+   direct runtime state when no themes have been installed yet.
 
 The first empty theme library normally contains only:
 
@@ -29,7 +29,7 @@ The first empty theme library normally contains only:
 The `STORE` configuration file is created when the user first saves a setting
 or profile.
 
-## Generated output
+## Runtime output
 
 The backend writes the user's current combination to:
 
@@ -37,14 +37,17 @@ The backend writes the user's current combination to:
 %STEAM%\millennium\themes\CSS Loader
 ```
 
-This directory is a local asset host. Its bundles, copied images, fonts, build
-report, and optional **CSS Loader (Standalone)** selector are generated from the
-current user's themes and settings. It is deliberately not distributed as a
-public Millennium theme.
+This directory is a local mailbox containing `runtime-state.json`, a matching
+build report, and a metadata-only `skin.json`. The state contains CSS Loader's
+resolved, ordered injects without bundle conversion or asset rewriting. It is
+deliberately not distributed as a public Millennium theme.
 
-Regeneration removes bundles and copied theme assets that are no longer part of
-the selected profile. The last valid build remains usable by the companion when
-the desktop app and backend are closed.
+Local images and fonts continue using CSS Loader's `/themes_custom/...` path.
+The backend links that path to the homebrew library when possible and otherwise
+mirrors active theme files into the existing custom directory.
+
+Republishing atomically replaces the previous state. The companion only accepts
+it when the state and report hashes match.
 
 ## Upgrade migration
 
@@ -55,7 +58,7 @@ Versions before 0.2.0 installed the plugin as `css-loader-runtime`. Setup now:
 3. removes the old plugin directory after the new files are in place;
 4. retains a one-time `config.json.css-loader-backup` beside Millennium's config.
 
-All theme downloads, profiles, patch values, and generated configuration remain
+All theme downloads, profiles, patch values, and runtime configuration remain
 in the user's theme library.
 
 ## Companion-first installation
@@ -63,4 +66,4 @@ in the user's theme library.
 If a user installs CSS Loader Companion from Millennium before installing the
 desktop app, the plugin waits safely and displays a link to the complete
 installer. Opening the desktop app completes setup and creates the user-specific
-generated output.
+runtime state.
diff --git a/docs/releases/v1.0.0.md b/docs/releases/v1.0.0.md
new file mode 100644
index 0000000..7438225
--- /dev/null
+++ b/docs/releases/v1.0.0.md
@@ -0,0 +1,51 @@
+# CSS Loader for Millennium 1.0.0
+
+CSS Loader for Millennium 1.0 is the first stable release of the complete
+Windows desktop application, CSS Loader-compatible backend, installer, and
+Millennium companion integration.
+
+## Highlights
+
+- Runs existing CSS Loader themes without converting their manifests or option
+  models into a limited Millennium theme format.
+- Preserves profiles, dependencies, multi-theme layering, patch values, color
+  pickers, sliders, checkboxes, generated CSS variables, and activation order.
+- Publishes resolved styles as ordered direct injections rather than rewritten
+  bundles, preserving inline SVG, data URLs, animations, masks, filters, and
+  other advanced CSS.
+- Applies themes across Desktop, Big Picture, Quick Access, Main Menu,
+  notifications, and popup documents.
+- Works with Millennium's normal runtime: no Steam `-dev` mode, external CDP
+  port, or deprecated `.cef-enable-remote-debugging` marker.
+- Layers CSS Loader over the user's selected Millennium theme instead of taking
+  ownership of the active-theme setting.
+- Keeps `/themes_custom` images and fonts available by linking or mirroring
+  active theme assets without modifying their CSS.
+- Provides the desktop theme manager, profile controls, store browsing,
+  downloads, updates, live settings, startup integration, and diagnostics in a
+  single installer.
+
+## Why direct injection matters
+
+Earlier preview builds compiled active themes into generated CSS bundles. That
+approach could misinterpret valid nested CSS such as an SVG filter reference
+inside a data URL. Version 1.0 removes that conversion boundary. The backend
+uses CSS Loader's own parser and class translation, publishes each resolved
+inject in cascade order, and lets the companion apply the exact CSS text.
+
+## Advantages
+
+- Existing theme libraries work without manual migration.
+- Theme authors do not need a Millennium-specific manifest.
+- Complex CSS is less likely to be altered by an intermediary compiler.
+- The desktop app remains the single source of truth for store, configuration,
+  dependency, and profile behavior.
+- The companion stays small and focused on applying state inside Steam.
+- Matching state and revision hashes prevent partially published updates from
+  reaching the UI.
+
+## Included artifacts
+
+- Windows x64 MSI installer
+- CSS Loader for Millennium backend executable
+- Bundled CSS Loader Companion for Millennium 1.0.0
diff --git a/package.json b/package.json
index 3e8ab7d..83b5581 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "css-loader-for-millennium",
-  "version": "0.2.0",
+  "version": "1.0.0",
   "private": true,
   "description": "A CSS Loader overlay runtime and desktop manager for Millennium on Windows.",
   "license": "GPL-3.0-only",
diff --git a/plugins/millennium b/plugins/millennium
index 889c95a..29741c3 160000
--- a/plugins/millennium
+++ b/plugins/millennium
@@ -1 +1 @@
-Subproject commit 889c95a45242cda9609cf07f5414d102336245e1
+Subproject commit 29741c3b7ab63ef7c99ea93004c7cc41d50b5a3c
diff --git a/runtime/backend/build_millennium_theme.py b/runtime/backend/build_millennium_theme.py
index 5af87b5..99f848e 100644
--- a/runtime/backend/build_millennium_theme.py
+++ b/runtime/backend/build_millennium_theme.py
@@ -7,12 +7,12 @@
 
 
 def main() -> None:
-    parser = argparse.ArgumentParser(description="Build the CSS Loader for Millennium overlay from existing CSS Loader themes.")
+    parser = argparse.ArgumentParser(description="Publish direct CSS Loader state for the Millennium companion.")
     parser.add_argument(
         "--output",
         type=Path,
         default=default_millennium_theme_path(),
-        help="Destination for the generated Millennium CSS and asset host.",
+        help="Destination for the Millennium runtime state files.",
     )
     args = parser.parse_args()
     report = asyncio.run(build_from_disk(args.output))
diff --git a/runtime/backend/css_loader.py b/runtime/backend/css_loader.py
index 68f82e1..06bda39 100644
--- a/runtime/backend/css_loader.py
+++ b/runtime/backend/css_loader.py
@@ -73,7 +73,7 @@ async def set_theme_state(self, name : str, state : bool, set_deps : bool = True
             return Result(False, str(e))
 
     async def change_preset(self, name : str) -> Result:
-        """Apply a profile and publish the generated runtime exactly once."""
+        """Apply a profile and publish the direct runtime state exactly once."""
         await self.lock()
         try:
             preset = None
@@ -85,7 +85,7 @@ async def change_preset(self, name : str) -> Result:
                     return Result(False, f"Theme {name} is not a profile")
 
             # Profile switching used to call set_theme_state concurrently for
-            # every enabled theme. Each call published an intermediate build,
+            # every enabled theme. Each call published an intermediate state,
             # including a zero-patch manifest that could make Millennium reload
             # before the selected profile had been enabled.
             for theme in self.themes:
diff --git a/runtime/backend/css_millennium.py b/runtime/backend/css_millennium.py
index 62dc306..186c85e 100644
--- a/runtime/backend/css_millennium.py
+++ b/runtime/backend/css_millennium.py
@@ -1,5 +1,5 @@
-import json
 import hashlib
+import json
 import os
 import re
 import shutil
@@ -13,8 +13,10 @@
 
 
 THEME_NAME = "CSS Loader"
-THEME_DISPLAY_NAME = "CSS Loader (Standalone)"
-RUNTIME_MODE = "overlay"
+THEME_DISPLAY_NAME = "CSS Loader Runtime"
+RUNTIME_MODE = "direct"
+PROTOCOL_VERSION = 1
+STATE_FILE = "runtime-state.json"
 
 
 @dataclass(frozen=True)
@@ -69,13 +71,7 @@ def _target_for_tab(tab: str) -> MillenniumTarget:
 
 
 def _targets_for_tab(tab: str) -> list[MillenniumTarget]:
-    """Return the same document target used by Decky's CSS Loader.
-
-    Steam exposes Main Menu and Quick Access as separate browser-view
-    documents.  Millennium's runtime bridge is responsible for reaching those
-    documents; folding their bundles into Big Picture changes selector scope
-    and cascade order compared with Decky's reference behavior.
-    """
+    """Return the same document target used by Decky's CSS Loader."""
     return [_target_for_tab(tab)]
 
 
@@ -93,36 +89,6 @@ def _translate_classes(css: str) -> str:
     return "".join(split_css)
 
 
-def _relative_asset_url(source_css: Path, themes_root: Path, raw_url: str) -> str:
-    value = raw_url.strip().strip('"\'')
-    lower = value.lower()
-    if not value or lower.startswith(("data:", "http:", "https:", "blob:", "var(")) or value.startswith("#"):
-        return raw_url
-
-    normalized = value.replace("\\", "/")
-    if normalized.lower().startswith("/themes_custom/"):
-        relative = normalized[len("/themes_custom/") :]
-    elif normalized.startswith("/"):
-        return raw_url
-    else:
-        try:
-            relative = (source_css.parent / normalized).resolve().relative_to(themes_root.resolve()).as_posix()
-        except ValueError:
-            return raw_url
-
-    return '"../assets/themes/' + relative.replace('"', '\\"') + '"'
-
-
-URL_PATTERN = re.compile(r"url\(\s*([^)]*?)\s*\)", re.IGNORECASE)
-
-
-def _rewrite_asset_urls(css: str, source_css: Path, themes_root: Path) -> str:
-    return URL_PATTERN.sub(
-        lambda match: "url(" + _relative_asset_url(source_css, themes_root, match.group(1)) + ")",
-        css,
-    )
-
-
 def _atomic_write(path: Path, content: str) -> None:
     path.parent.mkdir(parents=True, exist_ok=True)
     if path.exists() and path.read_text(encoding="utf-8", errors="replace") == content:
@@ -132,25 +98,6 @@ def _atomic_write(path: Path, content: str) -> None:
     os.replace(temporary, path)
 
 
-def _copy_theme_sources(loader: Loader, themes_root: Path, output_root: Path) -> list[str]:
-    copied = []
-    destination_root = output_root / "assets" / "themes"
-    if destination_root.exists():
-        shutil.rmtree(destination_root)
-    destination_root.mkdir(parents=True, exist_ok=True)
-
-    for theme in sorted((theme for theme in loader.themes if theme.enabled), key=lambda item: item.name.lower()):
-        source = Path(theme.themePath)
-        try:
-            relative = source.resolve().relative_to(themes_root.resolve())
-        except ValueError:
-            continue
-        destination = destination_root / relative
-        shutil.copytree(source, destination, dirs_exist_ok=True)
-        copied.append(relative.as_posix())
-    return copied
-
-
 def _enabled_injects() -> Iterable:
     return iter(
         sorted(
@@ -160,103 +107,160 @@ def _enabled_injects() -> Iterable:
     )
 
 
+def _resolved_inject_css(inject, themes_root: Path) -> tuple[str, str]:
+    """Return CSS Loader's translated CSS without JavaScript-string escaping.
+
+    File-backed Inject objects may already contain an escaped copy in
+    ``inject.css`` after legacy CDP use. Reading the source again prevents those
+    escape characters from leaking into the Millennium direct-style protocol.
+    Generated variables and patch components have no real source file, so their
+    in-memory CSS remains authoritative.
+    """
+    source_css = Path(inject.cssPath) if inject.cssPath else None
+    if source_css is not None and source_css.is_file():
+        css = source_css.read_text(encoding="utf-8", errors="replace")
+        try:
+            origin = source_css.resolve().relative_to(themes_root.resolve()).as_posix()
+        except ValueError:
+            origin = str(source_css)
+        return _translate_classes(css), origin
+
+    return inject.css or "", "generated CSS"
+
+
+def _remove_legacy_compiler_output(output_root: Path) -> None:
+    for directory_name in ("generated", "assets"):
+        directory = output_root / directory_name
+        if directory.exists():
+            shutil.rmtree(directory)
+
+
+def _sync_active_theme_assets(loader: Loader, themes_root: Path, destination_root: Path) -> list[str]:
+    """Keep CSS Loader's /themes_custom asset path current without rewriting CSS."""
+    try:
+        destination_root.mkdir(parents=True, exist_ok=True)
+    except OSError as error:
+        Log(f"Could not prepare CSS Loader asset path '{destination_root}': {error}")
+        return []
+    try:
+        if destination_root.resolve() == themes_root.resolve():
+            return []
+    except OSError:
+        pass
+
+    synced = []
+    for theme in (theme for theme in loader.themes if theme.enabled):
+        source = Path(theme.themePath)
+        if not source.is_dir():
+            continue
+        try:
+            relative = source.resolve().relative_to(themes_root.resolve())
+        except ValueError:
+            continue
+        try:
+            shutil.copytree(source, destination_root / relative, dirs_exist_ok=True)
+            synced.append(relative.as_posix())
+        except OSError as error:
+            Log(f"Could not sync CSS Loader assets for '{theme.name}': {error}")
+    return synced
+
+
 def compile_millennium_theme(
     loader: Loader,
     output_root: Path | str | None = None,
     themes_root: Path | str | None = None,
 ) -> dict:
+    """Publish CSS Loader's resolved injects for the Millennium companion.
+
+    Despite the historical function name, this no longer compiles or rewrites
+    CSS bundles. The app publishes exact translated payloads in CSS Loader
+    cascade order and the companion applies them as individual style elements.
+    """
+    publish_to_live_runtime = output_root is None
     output_root = Path(output_root) if output_root is not None else default_millennium_theme_path()
     themes_root = Path(themes_root) if themes_root is not None else Path(get_theme_path())
     output_root.mkdir(parents=True, exist_ok=True)
 
-    copied_themes = _copy_theme_sources(loader, themes_root, output_root)
-    bundles: dict[MillenniumTarget, list[str]] = {}
-    selected_injects = 0
+    synced_theme_assets = []
+    if publish_to_live_runtime:
+        synced_theme_assets = _sync_active_theme_assets(
+            loader,
+            themes_root,
+            Path(get_steam_path()) / "steamui" / "themes_custom",
+        )
 
-    for inject in _enabled_injects():
-        selected_injects += 1
-        # CSS variables and patch components are generated in memory. Some
-        # component injects retain a placeholder path ("/" on CSS Loader
-        # Desktop), so prefer their generated CSS before considering cssPath.
-        if inject.css is not None:
-            css = inject.css.replace("/themes_custom/", "../assets/themes/")
-            origin = "generated CSS variable"
-        elif inject.cssPath:
-            source_css = Path(inject.cssPath)
-            css = source_css.read_text(encoding="utf-8", errors="replace")
-            css = _translate_classes(css)
-            css = _rewrite_asset_urls(css, source_css, themes_root)
-            origin = source_css.resolve().relative_to(themes_root.resolve()).as_posix()
-        else:
-            css = ""
-            origin = "generated CSS variable"
+    injections = []
+    target_report: dict[str, dict] = {}
 
-        block = f"\n/* CSS Loader source: {origin} */\n{css.rstrip()}\n"
+    for inject in _enabled_injects():
+        css, origin = _resolved_inject_css(inject, themes_root)
+        seen_targets = set()
         for tab in inject.tabs:
             for target in _targets_for_tab(tab):
-                if block not in bundles.setdefault(target, []):
-                    bundles[target].append(block)
-
-    patches = []
-    bundle_report = {}
-    content_hash = hashlib.sha256()
-    generated_root = output_root / "generated"
-    generated_root.mkdir(parents=True, exist_ok=True)
-    expected_bundle_names = {f"{target.key}.css" for target in bundles}
-
-    for target in sorted(bundles, key=lambda item: item.key):
-        relative_path = f"generated/{target.key}.css"
-        content = (
-            "/* Generated by CSS Loader. Changes will be overwritten. */\n"
-            + "".join(bundles[target])
-        )
-        _atomic_write(output_root / relative_path, content)
-        content_hash.update(target.key.encode("utf-8"))
-        content_hash.update(b"\0")
-        content_hash.update(content.encode("utf-8"))
-        patches.append({"MatchRegexString": target.match_regex, "TargetCss": relative_path})
-        bundle_report[target.key] = {
-            "match": target.match_regex,
-            "blocks": len(bundles[target]),
-            "bytes": len(content.encode("utf-8")),
-        }
-
-    skin = {
-        "name": THEME_DISPLAY_NAME,
-        "author": "CSS Loader contributors",
-        "description": (
-            "Generated CSS Loader asset host. Leave your preferred Millennium theme selected "
-            "for overlay mode, or select this theme for CSS Loader-only mode."
-        ),
-        "version": "0.2.0",
-        "Patches": patches,
+                if target.key in seen_targets:
+                    continue
+                seen_targets.add(target.key)
+                injection_id = f"{inject.activation_order}:{target.key}"
+                injections.append(
+                    {
+                        "id": injection_id,
+                        "target": target.key,
+                        "matchRegex": target.match_regex,
+                        "source": origin,
+                        "css": css,
+                    }
+                )
+                summary = target_report.setdefault(
+                    target.key,
+                    {"match": target.match_regex, "injections": 0, "bytes": 0},
+                )
+                summary["injections"] += 1
+                summary["bytes"] += len(css.encode("utf-8"))
+
+    hash_input = json.dumps(injections, ensure_ascii=False, separators=(",", ":"))
+    content_hash = hashlib.sha256(hash_input.encode("utf-8")).hexdigest()
+    state = {
+        "protocolVersion": PROTOCOL_VERSION,
+        "contentHash": content_hash,
+        "injections": injections,
     }
-    _atomic_write(output_root / "skin.json", json.dumps(skin, indent=2) + "\n")
-
     report = {
         "theme": THEME_NAME,
         "themeDisplayName": THEME_DISPLAY_NAME,
         "runtimeMode": RUNTIME_MODE,
+        "protocolVersion": PROTOCOL_VERSION,
+        "stateFile": STATE_FILE,
         "output": str(output_root),
         "enabledThemes": [theme.name for theme in loader.themes if theme.enabled],
-        "copiedThemeFolders": copied_themes,
-        "selectedInjects": selected_injects,
-        "contentHash": content_hash.hexdigest(),
-        "bundles": bundle_report,
-        "patches": patches,
+        "syncedThemeAssets": synced_theme_assets,
+        "selectedInjects": len(list(_enabled_injects())),
+        "publishedInjections": len(injections),
+        "contentHash": content_hash,
+        "targets": target_report,
+        # An empty patch list makes older companion versions remove their
+        # generated bundle links while the new direct runtime takes over.
+        "patches": [],
+    }
+    skin = {
+        "name": THEME_DISPLAY_NAME,
+        "author": "CSS Loader contributors",
+        "description": "Runtime state host for the CSS Loader Millennium companion.",
+        "version": "1.0.0",
+        "Patches": [],
     }
-    _atomic_write(output_root / "build-report.json", json.dumps(report, indent=2) + "\n")
 
-    # The build report is the source of truth used by the companion. Remove
-    # bundles from older profiles only after publishing the new report so a
-    # running Steam session never observes a report that references a deleted
-    # file.
-    for existing_bundle in generated_root.glob("*.css"):
-        if existing_bundle.name not in expected_bundle_names:
-            existing_bundle.unlink()
+    _remove_legacy_compiler_output(output_root)
+    _atomic_write(output_root / "skin.json", json.dumps(skin, indent=2) + "\n")
+    # Publish state before its revision. The companion only accepts a state
+    # whose hash matches the latest report, avoiding partially-written updates.
+    _atomic_write(
+        output_root / STATE_FILE,
+        json.dumps(state, indent=2, ensure_ascii=False) + "\n",
+    )
+    _atomic_write(output_root / "build-report.json", json.dumps(report, indent=2) + "\n")
     Log(
-        f"Generated Millennium theme '{THEME_NAME}' with "
-        f"{selected_injects} selected injects across {len(bundles)} target bundles"
+        f"Published {len(injections)} direct CSS Loader injections "
+        f"across {len(target_report)} Millennium targets"
     )
     return report
 
diff --git a/runtime/backend/main.py b/runtime/backend/main.py
index 7700188..89aa4d9 100644
--- a/runtime/backend/main.py
+++ b/runtime/backend/main.py
@@ -242,9 +242,10 @@ async def _main(self):
 
         millennium_theme_mode = use_millennium_theme_runtime()
         if millennium_theme_mode:
-            Log("Using Millennium generated-theme runtime; external CDP injection is disabled")
-        else:
-            create_steam_symlink()
+            Log("Using Millennium direct-injection runtime; external CDP injection is disabled")
+        # Directly injected CSS keeps CSS Loader's /themes_custom asset URLs.
+        # Maintain the same Steam-side path in both runtime modes.
+        create_steam_symlink()
 
         self.loader = Loader()
         await self.loader.load(False)
diff --git a/runtime/backend/tests/test_css_millennium.py b/runtime/backend/tests/test_css_millennium.py
index 1755a53..1534a1b 100644
--- a/runtime/backend/tests/test_css_millennium.py
+++ b/runtime/backend/tests/test_css_millennium.py
@@ -7,10 +7,12 @@
 
 from css_millennium import (
     KNOWN_TARGETS,
+    PROTOCOL_VERSION,
     RUNTIME_MODE,
+    STATE_FILE,
     THEME_DISPLAY_NAME,
     _enabled_injects,
-    _rewrite_asset_urls,
+    _sync_active_theme_assets,
     _target_for_tab,
     _targets_for_tab,
     _translate_classes,
@@ -67,28 +69,6 @@ def test_class_translation_matches_cssloader_behavior(self):
             '.newClass, [class*="newClass"] { color: red; }',
         )
 
-    def test_asset_urls_are_rebased_into_generated_theme(self):
-        with tempfile.TemporaryDirectory() as temporary:
-            themes_root = Path(temporary) / "themes"
-            source_css = themes_root / "Example" / "styles" / "theme.css"
-            source_css.parent.mkdir(parents=True)
-            css = 'a { background: url("../images/background.png"); }'
-            self.assertEqual(
-                _rewrite_asset_urls(css, source_css, themes_root),
-                'a { background: url("../assets/themes/Example/images/background.png"); }',
-            )
-
-    def test_legacy_themes_custom_urls_are_rebased(self):
-        with tempfile.TemporaryDirectory() as temporary:
-            themes_root = Path(temporary) / "themes"
-            source_css = themes_root / "Example" / "theme.css"
-            source_css.parent.mkdir(parents=True)
-            css = 'a { background: url("/themes_custom/Example/image.png"); }'
-            self.assertEqual(
-                _rewrite_asset_urls(css, source_css, themes_root),
-                'a { background: url("../assets/themes/Example/image.png"); }',
-            )
-
     def test_generated_component_css_takes_precedence_over_placeholder_path(self):
         with tempfile.TemporaryDirectory() as temporary:
             themes_root = Path(temporary) / "themes"
@@ -116,14 +96,81 @@ def test_generated_component_css_takes_precedence_over_placeholder_path(self):
 
             self.assertEqual(report["selectedInjects"], 1)
             self.assertEqual(report["runtimeMode"], RUNTIME_MODE)
-            self.assertIn("bigpicture", report["bundles"])
-            self.assertIn(
-                "--obsidian-main-color: #111111",
-                (output_root / "generated" / "bigpicture.css").read_text(encoding="utf-8"),
-            )
+            self.assertEqual(report["protocolVersion"], PROTOCOL_VERSION)
+            self.assertIn("bigpicture", report["targets"])
+            state = json.loads((output_root / STATE_FILE).read_text(encoding="utf-8"))
+            self.assertEqual(state["contentHash"], report["contentHash"])
+            self.assertEqual(len(state["injections"]), 1)
+            self.assertIn("--obsidian-main-color: #111111", state["injections"][0]["css"])
             skin = json.loads((output_root / "skin.json").read_text(encoding="utf-8"))
             self.assertEqual(skin["name"], THEME_DISPLAY_NAME)
-            self.assertIn("overlay mode", skin["description"].lower())
+            self.assertEqual(skin["Patches"], [])
+
+    def test_inline_svg_data_urls_are_published_byte_for_byte(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            themes_root = Path(temporary) / "themes"
+            theme_root = themes_root / "Animated PSP Waves Background"
+            output_root = Path(temporary) / "output"
+            theme_root.mkdir(parents=True)
+            source_css = theme_root / "wave.css"
+            svg_css = (
+                ":root { --wave: url(\"data:image/svg+xml,%3Csvg%3E"
+                "%3Cg filter='url(%23blur1)'/%3E%3C/svg%3E\"); }"
+            )
+            source_css.write_text(svg_css, encoding="utf-8")
+            theme = SimpleNamespace(
+                enabled=True,
+                name="Animated PSP Waves Background",
+                themePath=str(theme_root),
+            )
+            inject = Inject(str(source_css), ["bigpicture"], theme)
+            inject.activate()
+
+            previous_injects = list(ALL_INJECTS)
+            try:
+                ALL_INJECTS.clear()
+                ALL_INJECTS.append(inject)
+                compile_millennium_theme(
+                    SimpleNamespace(themes=[theme]),
+                    output_root=output_root,
+                    themes_root=themes_root,
+                )
+            finally:
+                ALL_INJECTS.clear()
+                ALL_INJECTS.extend(previous_injects)
+
+            state = json.loads((output_root / STATE_FILE).read_text(encoding="utf-8"))
+            self.assertEqual(state["injections"][0]["css"], svg_css)
+            self.assertIn("filter='url(%23blur1)'", state["injections"][0]["css"])
+            self.assertNotIn("assets/themes", state["injections"][0]["css"])
+
+    def test_active_theme_assets_are_mirrored_without_css_rewriting(self):
+        with tempfile.TemporaryDirectory() as temporary:
+            root = Path(temporary)
+            themes_root = root / "themes"
+            theme_root = themes_root / "Asset Theme"
+            destination = root / "steamui" / "themes_custom"
+            (theme_root / "images").mkdir(parents=True)
+            (theme_root / "images" / "background.png").write_bytes(b"image")
+            css = 'a { background: url("/themes_custom/Asset Theme/images/background.png"); }'
+            (theme_root / "theme.css").write_text(css, encoding="utf-8")
+            theme = SimpleNamespace(enabled=True, name="Asset Theme", themePath=str(theme_root))
+
+            synced = _sync_active_theme_assets(
+                SimpleNamespace(themes=[theme]),
+                themes_root,
+                destination,
+            )
+
+            self.assertEqual(synced, ["Asset Theme"])
+            self.assertEqual(
+                (destination / "Asset Theme" / "theme.css").read_text(encoding="utf-8"),
+                css,
+            )
+            self.assertEqual(
+                (destination / "Asset Theme" / "images" / "background.png").read_bytes(),
+                b"image",
+            )
 
     def test_reactivated_payload_moves_to_end_of_decky_cascade(self):
         theme = SimpleNamespace(name="Example")
@@ -144,7 +191,7 @@ def test_reactivated_payload_moves_to_end_of_decky_cascade(self):
             ALL_INJECTS.clear()
             ALL_INJECTS.extend(previous_injects)
 
-    def test_regeneration_removes_disabled_theme_assets_and_stale_bundles(self):
+    def test_direct_publish_removes_legacy_assets_and_stale_bundles(self):
         with tempfile.TemporaryDirectory() as temporary:
             themes_root = Path(temporary) / "themes"
             output_root = Path(temporary) / "output"
@@ -167,9 +214,11 @@ def test_regeneration_removes_disabled_theme_assets_and_stale_bundles(self):
                 ALL_INJECTS.clear()
                 ALL_INJECTS.extend(previous_injects)
 
-            self.assertEqual(report["bundles"], {})
+            self.assertEqual(report["targets"], {})
             self.assertFalse(old_theme_assets.exists())
             self.assertFalse((generated_root / "desktop.css").exists())
+            state = json.loads((output_root / STATE_FILE).read_text(encoding="utf-8"))
+            self.assertEqual(state["injections"], [])
 
 
 class MillenniumProfileTests(unittest.IsolatedAsyncioTestCase):