From 51f991a8e77facf9baf62bb6ba1caefe77462c9a Mon Sep 17 00:00:00 2001
From: Nate <124498267+DevsNate@users.noreply.github.com>
Date: Thu, 16 Jul 2026 19:30:04 -0500
Subject: [PATCH] Release companion 1.0.0

---
 README.md          |  48 ++++--
 RELEASE_NOTES.md   |  29 ++++
 backend/main.lua   |  12 ++
 frontend/index.tsx | 361 ++++++++++++++++++++-------------------------
 package-lock.json  |   4 +-
 package.json       |   2 +-
 plugin.json        |   4 +-
 7 files changed, 246 insertions(+), 214 deletions(-)
 create mode 100644 RELEASE_NOTES.md

diff --git a/README.md b/README.md
index 8b3ac0f..f43ff36 100644
--- a/README.md
+++ b/README.md
@@ -8,30 +8,54 @@
   </p>
 </div>
 
-CSS Loader Companion connects the CSS Loader desktop app to Steam. It loads the
-last generated CSS at Millennium startup, layers it over the selected
-Millennium theme, and keeps Big Picture and Steam's isolated side-menu views in
-sync.
+CSS Loader Companion connects the CSS Loader desktop app to Steam. It applies
+the app's ordered, resolved CSS injects directly over the selected Millennium
+theme and keeps Big Picture and Steam's isolated side-menu views in sync.
+
+## Version 1.0
+
+Version 1.0 is the first stable release of the official in-Steam companion for
+CSS Loader for Millennium.
+
+### Main highlights
+
+- Applies CSS Loader's resolved CSS directly as ordered `<style>` elements.
+- Preserves exact CSS text instead of loading converted or rewritten bundles.
+- Reconciles additions, changes, removals, and cascade order every time the
+  desktop backend publishes a new revision.
+- Covers Desktop, Big Picture, popups, Quick Access, Main Menu, and notification
+  BrowserViews.
+- Uses Millennium's controlled in-process APIs and per-plugin CDP proxy without
+  exposing an external debugging port.
+- Keeps the user's selected Millennium theme active and layers CSS Loader after
+  it.
+- Validates matching protocol versions and content hashes before applying new
+  state.
+- Removes stale legacy bundle links during migration to the direct runtime.
+
+The companion intentionally remains lightweight: theme parsing, store access,
+downloads, profiles, dependencies, and configuration continue to belong to the
+CSS Loader desktop app and backend.
 
 > [!IMPORTANT]
 > This plugin is one component of
 > [CSS Loader for Millennium](https://github.com/DevsNate/CSSLoader-Millennium).
 > For a new installation, use the complete desktop installer. It creates the
-> theme library, installs the backend, installs this companion, and generates
-> the local CSS asset host automatically.
+> theme library, installs the backend, installs this companion, and publishes
+> the local runtime state automatically.
 
 ## What it does
 
-- Loads generated CSS as part of Millennium, before Steam's interface becomes
-  visible.
+- Applies resolved CSS as individual style elements without bundle conversion
+  or asset-URL rewriting.
 - Keeps the user's selected Millennium theme active and places CSS Loader last
   in the cascade.
 - Synchronizes Desktop, Big Picture, Quick Access, Main Menu, and notification
   documents.
 - Uses Millennium's in-process APIs; it does not require Steam `-dev` mode, an
   external CDP port, or `.cef-enable-remote-debugging`.
-- Continues applying the last compiled profile while the desktop app and
-  backend are closed.
+- Reconciles additions, changes, removals, and cascade order from the app's
+  direct runtime state.
 
 ## Installation
 
@@ -41,8 +65,8 @@ The complete installer configures this plugin automatically and preserves the
 currently selected Millennium theme.
 
 If this companion is installed from Millennium first, its panel will wait for
-the desktop app. Opening the complete app finishes setup and generates the
-user-specific CSS files.
+the desktop app. Opening the complete app finishes setup and publishes the
+user-specific runtime state.
 
 ## Development
 
diff --git a/RELEASE_NOTES.md b/RELEASE_NOTES.md
new file mode 100644
index 0000000..f21d124
--- /dev/null
+++ b/RELEASE_NOTES.md
@@ -0,0 +1,29 @@
+# CSS Loader Companion for Millennium 1.0.0
+
+Version 1.0 is the first stable release of the official Millennium companion
+for CSS Loader for Millennium.
+
+## Highlights
+
+- Directly applies CSS Loader's ordered, resolved CSS without bundle conversion
+  or asset-URL rewriting.
+- Preserves inline SVG, data URLs, animations, masks, filters, generated
+  variables, and CSS cascade behavior.
+- Synchronizes Desktop, Big Picture, popups, Quick Access, Main Menu, and
+  notification documents.
+- Uses Millennium's supported in-process APIs and controlled per-plugin CDP
+  proxy; no Steam `-dev` mode or external debugging port is required.
+- Reconciles changed, removed, and reordered injections live.
+- Rejects incomplete updates unless the runtime state and revision hashes match.
+- Cleans up legacy generated-bundle links during migration.
+
+## Advantages
+
+- Existing CSS Loader themes do not need Millennium-specific conversion.
+- The selected Millennium theme remains active underneath CSS Loader.
+- Theme parsing, profiles, dependencies, store access, and downloads stay in the
+  desktop app, keeping this plugin small and focused.
+- Exact CSS delivery avoids compiler edge cases with complex third-party themes.
+
+This plugin is designed to be installed through the complete CSS Loader for
+Millennium desktop installer, which bundles the matching backend and companion.
diff --git a/backend/main.lua b/backend/main.lua
index b9cd34f..5ebc98c 100644
--- a/backend/main.lua
+++ b/backend/main.lua
@@ -10,6 +10,14 @@ local REPORT_FILE = fs.join(
     "build-report.json"
 )
 
+local STATE_FILE = fs.join(
+    millennium.steam_path(),
+    "millennium",
+    "themes",
+    "CSS Loader",
+    "runtime-state.json"
+)
+
 local function read_file(path)
     local file = io.open(path, "rb")
     if not file then return "" end
@@ -22,6 +30,10 @@ function get_css_loader_revision()
     return read_file(REPORT_FILE)
 end
 
+function get_css_loader_state()
+    return read_file(STATE_FILE)
+end
+
 local function on_load()
     logger:info("CSS Loader Companion loaded")
     millennium.ready()
diff --git a/frontend/index.tsx b/frontend/index.tsx
index 75edf46..60ced40 100644
--- a/frontend/index.tsx
+++ b/frontend/index.tsx
@@ -11,22 +11,37 @@ import {
 import { useEffect, useState } from 'react';
 
 const POLL_INTERVAL_MS = 1000;
+const PROTOCOL_VERSION = 1;
+const DIRECT_STYLE_SELECTOR = 'style[data-css-loader-runtime-id]';
+const LEGACY_LINK_SELECTOR = 'link[data-css-loader-runtime]';
 const getCssLoaderRevision = callable<[], string | false>('get_css_loader_revision');
+const getCssLoaderState = callable<[], string | false>('get_css_loader_state');
 
 let runtimeTimer: number | undefined;
 let currentContentHash: string | undefined;
-let currentReport: BuildReport | null = null;
+let currentState: RuntimeState | null = null;
 let checkInProgress = false;
 const knownDocuments = new Set<Document>();
 const browserViewSessions = new Map<string, string>();
 
-type BuildReport = {
+type RuntimeRevision = {
   contentHash?: string;
-  runtimeMode?: 'overlay';
-  patches?: Array<{
-    MatchRegexString?: string;
-    TargetCss?: string;
-  }>;
+  protocolVersion?: number;
+  runtimeMode?: 'direct';
+};
+
+type RuntimeInjection = {
+  id: string;
+  target: string;
+  matchRegex: string;
+  source?: string;
+  css: string;
+};
+
+type RuntimeState = {
+  contentHash: string;
+  protocolVersion: number;
+  injections: RuntimeInjection[];
 };
 
 type TargetInfo = {
@@ -35,9 +50,9 @@ type TargetInfo = {
   type?: string;
 };
 
-const parseBuildReport = (revision: string): BuildReport | null => {
+const parseJson = <T,>(value: string): T | null => {
   try {
-    return JSON.parse(revision) as BuildReport;
+    return JSON.parse(value) as T;
   } catch {
     return null;
   }
@@ -66,173 +81,111 @@ const collectSteamDocuments = () => {
   }
 };
 
-const isCssLoaderStylesheet = (link: HTMLLinkElement) => {
-  try {
-    const pathname = new URL(link.href).pathname;
-    return pathname.includes('/v1/themes/CSS%20Loader/generated/')
-      || pathname.includes('/v1/themes/CSS Loader/generated/');
-  } catch {
-    return false;
-  }
-};
-
-const targetCssFromLink = (link: HTMLLinkElement) => {
+const injectionMatchesTitle = (injection: RuntimeInjection, title: string) => {
   try {
-    const pathname = decodeURIComponent(new URL(link.href).pathname);
-    const marker = '/v1/themes/CSS Loader/';
-    const index = pathname.indexOf(marker);
-    return index >= 0 ? pathname.slice(index + marker.length) : null;
-  } catch {
-    return null;
-  }
-};
-
-const patchMatchesDocument = (targetDocument: Document, matchRegex: string) => {
-  try {
-    return new RegExp(matchRegex).test(targetDocument.title);
+    return new RegExp(injection.matchRegex).test(title);
   } catch {
     return false;
   }
 };
 
-const stylesheetUrl = (targetCss: string, contentHash: string) => {
-  const encodedPath = targetCss
-    .split('/')
-    .map((segment) => encodeURIComponent(segment))
-    .join('/');
-  return `https://millennium.host/v1/themes/CSS%20Loader/${encodedPath}?cssloader=${encodeURIComponent(contentHash)}`;
-};
+const injectionsForTitle = (state: RuntimeState, title: string) => (
+  state.injections.filter((injection) => injectionMatchesTitle(injection, title))
+);
 
-const placeOverlayStylesheetLast = (targetDocument: Document, link: HTMLLinkElement) => {
-  const parent = targetDocument.head ?? targetDocument.documentElement;
-  if (link.parentElement !== parent || parent.lastElementChild !== link) {
-    parent.appendChild(link);
-  }
+const removeLegacyBundleLinks = (targetDocument: Document) => {
+  targetDocument.querySelectorAll<HTMLLinkElement>(LEGACY_LINK_SELECTOR).forEach((link) => {
+    link.remove();
+  });
+  targetDocument.querySelectorAll<HTMLLinkElement>('link[rel="stylesheet"]').forEach((link) => {
+    try {
+      const path = decodeURIComponent(new URL(link.href).pathname);
+      if (path.includes('/v1/themes/CSS Loader/generated/')) link.remove();
+    } catch {
+      // Ignore malformed third-party stylesheet URLs.
+    }
+  });
 };
 
-const syncDocumentStylesheets = (
-  targetDocument: Document,
-  report: BuildReport,
-  contentHash: string,
-) => {
-  const desiredTargets = new Set(
-    (report.patches ?? [])
-      .filter((patch) => (
-        typeof patch.MatchRegexString === 'string'
-        && typeof patch.TargetCss === 'string'
-        && patchMatchesDocument(targetDocument, patch.MatchRegexString)
-      ))
-      .map((patch) => patch.TargetCss as string),
-  );
-
-  const existingLinks = Array.from(
-    targetDocument.querySelectorAll<HTMLLinkElement>('link[rel="stylesheet"]'),
-  ).filter(isCssLoaderStylesheet);
+const syncDocumentInjections = (targetDocument: Document, state: RuntimeState) => {
+  removeLegacyBundleLinks(targetDocument);
+  const desired = injectionsForTitle(state, targetDocument.title);
+  const desiredIds = new Set(desired.map((injection) => injection.id));
+  const existing = new Map<string, HTMLStyleElement>();
 
-  existingLinks.forEach((link) => {
-    const targetCss = targetCssFromLink(link);
-    if (link.dataset.cssLoaderRuntime === 'true' && (!targetCss || !desiredTargets.has(targetCss))) {
-      link.remove();
+  targetDocument.querySelectorAll<HTMLStyleElement>(DIRECT_STYLE_SELECTOR).forEach((style) => {
+    const id = style.dataset.cssLoaderRuntimeId;
+    if (!id || !desiredIds.has(id) || existing.has(id)) {
+      style.remove();
+      return;
     }
+    existing.set(id, style);
   });
 
-  let synced = 0;
-  desiredTargets.forEach((targetCss) => {
-    const matchingLinks = existingLinks.filter((link) => targetCssFromLink(link) === targetCss);
-    const existing = matchingLinks.find((link) => link.dataset.cssLoaderRuntime !== 'true')
-      ?? matchingLinks[0];
-    matchingLinks.forEach((link) => {
-      if (link !== existing && link.dataset.cssLoaderRuntime === 'true') link.remove();
-    });
-    const nextHref = stylesheetUrl(targetCss, contentHash);
-    if (existing) {
-      if (existing.href !== nextHref) existing.href = nextHref;
-      placeOverlayStylesheetLast(targetDocument, existing);
-    } else {
-      const link = targetDocument.createElement('link');
-      link.rel = 'stylesheet';
-      link.href = nextHref;
-      link.dataset.cssLoaderRuntime = 'true';
-      placeOverlayStylesheetLast(targetDocument, link);
+  const parent = targetDocument.head ?? targetDocument.documentElement;
+  desired.forEach((injection) => {
+    let style = existing.get(injection.id);
+    if (!style) {
+      style = targetDocument.createElement('style');
+      style.dataset.cssLoaderRuntimeId = injection.id;
+      style.dataset.cssLoaderSource = injection.source ?? '';
     }
-    synced += 1;
+    if (style.textContent !== injection.css) style.textContent = injection.css;
+    // Appending in resolved order preserves CSS Loader's observable cascade
+    // and keeps its overlay after the selected Millennium theme.
+    parent.appendChild(style);
   });
 
-  return synced;
+  return desired.length;
 };
 
-const syncCssLoaderStylesheets = (report: BuildReport, contentHash: string) => {
+const syncKnownDocuments = (state: RuntimeState) => {
   collectSteamDocuments();
   let synced = 0;
-
   knownDocuments.forEach((targetDocument) => {
     if (!targetDocument.defaultView || targetDocument.defaultView.closed) {
       knownDocuments.delete(targetDocument);
       return;
     }
-    synced += syncDocumentStylesheets(targetDocument, report, contentHash);
+    synced += syncDocumentInjections(targetDocument, state);
   });
-
   return synced;
 };
 
-const browserViewTargetsForTitle = (report: BuildReport, title: string) => (
-  (report.patches ?? [])
-    .filter((patch) => {
-      if (typeof patch.MatchRegexString !== 'string' || typeof patch.TargetCss !== 'string') {
-        return false;
-      }
-      try {
-        return new RegExp(patch.MatchRegexString).test(title);
-      } catch {
-        return false;
-      }
-    })
-    .map((patch) => patch.TargetCss as string)
-);
-
-const browserViewSyncExpression = (targetCssFiles: string[], contentHash: string) => {
-  const desired = targetCssFiles.map((targetCss) => ({
-    targetCss,
-    href: stylesheetUrl(targetCss, contentHash),
-  }));
-  return `(() => {
-    const desired = ${JSON.stringify(desired)};
-    const targetCssFromLink = (link) => {
-      try {
-        const pathname = decodeURIComponent(new URL(link.href).pathname);
-        const marker = '/v1/themes/CSS Loader/';
-        const index = pathname.indexOf(marker);
-        return index >= 0 ? pathname.slice(index + marker.length) : null;
-      } catch { return null; }
-    };
-    const desiredTargets = new Set(desired.map((item) => item.targetCss));
-    document.querySelectorAll('link[data-css-loader-runtime="browser-view"]').forEach((link) => {
-      const targetCss = targetCssFromLink(link);
-      if (!targetCss || !desiredTargets.has(targetCss)) link.remove();
-    });
-    desired.forEach(({ targetCss, href }) => {
-      const existing = Array.from(document.querySelectorAll('link[rel="stylesheet"]'))
-        .find((link) => targetCssFromLink(link) === targetCss);
-      if (existing) {
-        if (existing.href !== href) existing.href = href;
-        const parent = document.head || document.documentElement;
-        if (existing.parentElement !== parent || parent.lastElementChild !== existing) {
-          parent.appendChild(existing);
-        }
-      } else {
-        const link = document.createElement('link');
-        link.rel = 'stylesheet';
-        link.href = href;
-        link.dataset.cssLoaderRuntime = 'browser-view';
-        (document.head || document.documentElement).appendChild(link);
-      }
-    });
-    return desired.length;
-  })()`;
-};
+const browserViewSyncExpression = (injections: RuntimeInjection[]) => `(() => {
+  const desired = ${JSON.stringify(injections)};
+  const desiredIds = new Set(desired.map((item) => item.id));
+  const existing = new Map();
+  document.querySelectorAll('${DIRECT_STYLE_SELECTOR}').forEach((style) => {
+    const id = style.dataset.cssLoaderRuntimeId;
+    if (!id || !desiredIds.has(id) || existing.has(id)) {
+      style.remove();
+      return;
+    }
+    existing.set(id, style);
+  });
+  document.querySelectorAll('${LEGACY_LINK_SELECTOR}').forEach((link) => link.remove());
+  document.querySelectorAll('link[rel="stylesheet"]').forEach((link) => {
+    try {
+      const path = decodeURIComponent(new URL(link.href).pathname);
+      if (path.includes('/v1/themes/CSS Loader/generated/')) link.remove();
+    } catch {}
+  });
+  const parent = document.head || document.documentElement;
+  desired.forEach((item) => {
+    let style = existing.get(item.id);
+    if (!style) {
+      style = document.createElement('style');
+      style.dataset.cssLoaderRuntimeId = item.id;
+      style.dataset.cssLoaderSource = item.source || '';
+    }
+    if (style.textContent !== item.css) style.textContent = item.css;
+    parent.appendChild(style);
+  });
+  return desired.length;
+})()`;
 
-const syncBrowserViewStylesheets = async (report: BuildReport, contentHash: string) => {
+const syncBrowserViewInjections = async (state: RuntimeState) => {
   const response = await ChromeDevToolsProtocol.send('Target.getTargets') as {
     targetInfos?: TargetInfo[];
   };
@@ -249,9 +202,6 @@ const syncBrowserViewStylesheets = async (report: BuildReport, contentHash: stri
     if (!targetId || target.type !== 'page') continue;
     if (!/^(QuickAccess|MainMenu|notificationtoasts)/.test(title)) continue;
 
-    const targetCssFiles = browserViewTargetsForTitle(report, title);
-    if (targetCssFiles.length === 0) continue;
-
     try {
       let sessionId = browserViewSessions.get(targetId);
       if (!sessionId) {
@@ -267,7 +217,7 @@ const syncBrowserViewStylesheets = async (report: BuildReport, contentHash: stri
       await ChromeDevToolsProtocol.send(
         'Runtime.evaluate',
         {
-          expression: browserViewSyncExpression(targetCssFiles, contentHash),
+          expression: browserViewSyncExpression(injectionsForTitle(state, title)),
           returnByValue: true,
         },
         sessionId,
@@ -278,14 +228,17 @@ const syncBrowserViewStylesheets = async (report: BuildReport, contentHash: stri
   }
 };
 
+const syncRuntime = async (state: RuntimeState) => {
+  syncKnownDocuments(state);
+  await syncBrowserViewInjections(state);
+};
+
 const handleWindowCreated = (popup: any) => {
   const popupDocument = popup?.m_popup?.document as Document | undefined;
   liveDocument(popupDocument);
-  if (popupDocument && currentReport && currentContentHash) {
+  if (popupDocument && currentState) {
     window.setTimeout(() => {
-      if (currentReport && currentContentHash) {
-        syncDocumentStylesheets(popupDocument, currentReport, currentContentHash);
-      }
+      if (currentState) syncDocumentInjections(popupDocument, currentState);
     }, 0);
   }
 };
@@ -294,46 +247,50 @@ if (Millennium.AddWindowCreateHook) {
   Millennium.AddWindowCreateHook(handleWindowCreated);
 }
 
-const checkForThemeChange = async () => {
+const loadCurrentState = async (revision: RuntimeRevision) => {
+  const rawState = await getCssLoaderState();
+  if (!rawState || typeof rawState !== 'string') return null;
+  const state = parseJson<RuntimeState>(rawState);
+  if (
+    !state
+    || state.protocolVersion !== PROTOCOL_VERSION
+    || state.contentHash !== revision.contentHash
+    || !Array.isArray(state.injections)
+  ) return null;
+  return state;
+};
+
+const checkForRuntimeChange = async () => {
   if (checkInProgress) return;
   checkInProgress = true;
 
   try {
-    const revision = await getCssLoaderRevision();
-    if (!revision || typeof revision !== 'string') return;
-    const report = parseBuildReport(revision);
-    if (!report?.contentHash) return;
-    currentReport = report;
-
-    if (currentContentHash === undefined) {
-      currentContentHash = report.contentHash;
-      syncCssLoaderStylesheets(report, report.contentHash);
-      await syncBrowserViewStylesheets(report, report.contentHash);
-      return;
+    const rawRevision = await getCssLoaderRevision();
+    if (!rawRevision || typeof rawRevision !== 'string') return;
+    const revision = parseJson<RuntimeRevision>(rawRevision);
+    if (
+      !revision?.contentHash
+      || revision.protocolVersion !== PROTOCOL_VERSION
+      || revision.runtimeMode !== 'direct'
+    ) return;
+
+    if (!currentState || revision.contentHash !== currentContentHash) {
+      const state = await loadCurrentState(revision);
+      if (!state) return;
+      currentState = state;
+      currentContentHash = revision.contentHash;
     }
 
-    if (report.contentHash === currentContentHash) {
-      // Popup documents can be created after the report was first read. The
-      // regular sync makes sure Quick Access, Main Menu, and notifications
-      // receive their matching bundle even when Millennium did not attach a
-      // theme link to those BrowserView documents itself.
-      syncCssLoaderStylesheets(report, report.contentHash);
-      await syncBrowserViewStylesheets(report, report.contentHash);
-      return;
-    }
-
-    currentContentHash = report.contentHash;
-    syncCssLoaderStylesheets(report, report.contentHash);
-    await syncBrowserViewStylesheets(report, report.contentHash);
+    await syncRuntime(currentState);
   } finally {
     checkInProgress = false;
   }
 };
 
 const startRuntimeWatcher = () => {
-  void checkForThemeChange();
+  void checkForRuntimeChange();
   if (runtimeTimer === undefined) {
-    runtimeTimer = window.setInterval(() => void checkForThemeChange(), POLL_INTERVAL_MS);
+    runtimeTimer = window.setInterval(() => void checkForRuntimeChange(), POLL_INTERVAL_MS);
   }
 };
 
@@ -342,10 +299,20 @@ const stopRuntimeWatcher = () => {
     window.clearInterval(runtimeTimer);
     runtimeTimer = undefined;
   }
+  knownDocuments.forEach((targetDocument) => {
+    targetDocument.querySelectorAll(DIRECT_STYLE_SELECTOR).forEach((style) => style.remove());
+  });
+  const emptyState: RuntimeState = {
+    protocolVersion: PROTOCOL_VERSION,
+    contentHash: '',
+    injections: [],
+  };
+  // BrowserViews are separate documents, so clear their direct styles through
+  // the same controlled Millennium bridge before dropping attached sessions.
+  void syncBrowserViewInjections(emptyState).finally(() => browserViewSessions.clear());
   currentContentHash = undefined;
-  currentReport = null;
+  currentState = null;
   knownDocuments.clear();
-  browserViewSessions.clear();
 };
 
 const RuntimeStatus = () => {
@@ -353,8 +320,15 @@ const RuntimeStatus = () => {
 
   useEffect(() => {
     let mounted = true;
-    void getCssLoaderRevision().then((revision) => {
-      if (mounted) setConnected(typeof revision === 'string' && revision.length > 0);
+    void Promise.all([getCssLoaderRevision(), getCssLoaderState()]).then(([revision, state]) => {
+      if (!mounted || typeof revision !== 'string' || typeof state !== 'string') return;
+      const parsedRevision = parseJson<RuntimeRevision>(revision);
+      const parsedState = parseJson<RuntimeState>(state);
+      setConnected(
+        parsedRevision?.runtimeMode === 'direct'
+        && parsedRevision.protocolVersion === PROTOCOL_VERSION
+        && parsedState?.contentHash === parsedRevision.contentHash,
+      );
     });
     return () => {
       mounted = false;
@@ -369,23 +343,16 @@ const RuntimeStatus = () => {
       {connected ? (
         <>
           <PanelSectionRow>
-            Mode: Overlay (your selected Millennium theme stays active)
+            Mode: Direct CSS Loader injections
           </PanelSectionRow>
           <PanelSectionRow>
-            Generated styles stay applied even when the desktop app is closed.
+            Resolved theme CSS is applied without bundle conversion or asset rewriting.
           </PanelSectionRow>
         </>
       ) : (
-        <>
-          <PanelSectionRow>
-            Install and open CSS Loader for Millennium to finish setup and generate your styles.
-          </PanelSectionRow>
-          <PanelSectionRow>
-            <a href="https://github.com/DevsNate/CSSLoader-Millennium/releases/latest">
-              Download the complete app
-            </a>
-          </PanelSectionRow>
-        </>
+        <PanelSectionRow>
+          Open CSS Loader for Millennium to publish the direct runtime state.
+        </PanelSectionRow>
       )}
     </PanelSection>
   );
diff --git a/package-lock.json b/package-lock.json
index ed2dfe1..894fa3a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@css-loader-for-millennium/companion",
-  "version": "0.2.0",
+  "version": "1.0.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@css-loader-for-millennium/companion",
-      "version": "0.2.0",
+      "version": "1.0.0",
       "license": "GPL-3.0-only",
       "devDependencies": {
         "@steambrew/api": "^5.8.4",
diff --git a/package.json b/package.json
index ec2499f..54826aa 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@css-loader-for-millennium/companion",
-  "version": "0.2.0",
+  "version": "1.0.0",
   "description": "Official Millennium companion for CSS Loader for Millennium.",
   "author": "Nate and contributors",
   "license": "GPL-3.0-only",
diff --git a/plugin.json b/plugin.json
index 7bb4ffd..faf035b 100644
--- a/plugin.json
+++ b/plugin.json
@@ -2,8 +2,8 @@
   "$schema": "https://raw.githubusercontent.com/SteamClientHomebrew/Millennium/main/src/sys/plugin-schema.json",
   "name": "css-loader-companion",
   "common_name": "CSS Loader Companion",
-  "description": "Connects CSS Loader for Millennium to Steam and keeps generated styles applied across Steam windows.",
-  "version": "0.2.0",
+  "description": "Applies CSS Loader's resolved styles directly across Steam windows.",
+  "version": "1.0.0",
   "backendType": "lua",
   "webkitApiVersion": "2.0.0",
   "frontend": "frontend",