harness-mix 0.1.0

package/src/native-ui/renderer-extension/src/assets/codexhost-readme.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 640 180" role="img" aria-labelledby="title description">
+  <title id="title">codexhost supported agents</title>
+  <desc id="description">Codex, Claude Code, and Pi marks</desc>
+  <rect x="10" y="10" width="620" height="160" rx="30" fill="#F2EDE7"/>
+  <image href="data:image/png;base64,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" x="104" y="42" width="96" height="96"/>
+  <image href="data:image/svg+xml;base64,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" x="272" y="42" width="96" height="96"/>
+  <image href="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA4MDAgODAwIiByb2xlPSJpbWciIGFyaWEtbGFiZWw9IlBpIj4KICA8cGF0aCBmaWxsPSIjMTExMTExIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik0xNjUuMjkgMTY1LjI5SDUxNy4zNlY0MDBINDAwVjUxNy4zNkgyODIuNjVWNjM0LjcySDE2NS4yOVpNMjgyLjY1IDI4Mi42NVY0MDBINDAwVjI4Mi42NVoiLz4KICA8cGF0aCBmaWxsPSIjMTExMTExIiBkPSJNNTE3LjM2IDQwMEg2MzQuNzJWNjM0LjcySDUxNy4zNloiLz4KPC9zdmc+Cg==" x="440" y="42" width="96" height="96"/>
+</svg>

package/src/native-ui/renderer-extension/src/assets/kiro-agent.svg

@@ -0,0 +1,11 @@
+<svg width="1200" height="1200" viewBox="0 0 1200 1200" fill="none" xmlns="http://www.w3.org/2000/svg">
+<rect width="1200" height="1200" rx="260" fill="#9046FF"/>
+<mask id="mask0_1106_4856" style="mask-type:luminance" maskUnits="userSpaceOnUse" x="272" y="202" width="655" height="796">
+<path d="M926.578 202.793H272.637V997.857H926.578V202.793Z" fill="white"/>
+</mask>
+<g mask="url(#mask0_1106_4856)">
+<path d="M398.554 818.914C316.315 1001.03 491.477 1046.74 620.672 940.156C658.687 1059.66 801.052 970.473 852.234 877.795C964.787 673.567 919.318 465.357 907.64 422.374C827.637 129.443 427.623 128.946 358.8 423.865C342.651 475.544 342.402 534.18 333.458 595.051C328.986 625.86 325.507 645.488 313.83 677.785C306.873 696.424 297.68 712.819 282.773 740.645C259.915 783.881 269.604 867.113 387.87 823.883L399.051 818.914H398.554Z" fill="white"/>
+<path d="M636.123 549.353C603.328 549.353 598.359 510.097 598.359 486.742C598.359 465.623 602.086 448.977 609.293 438.293C615.504 428.852 624.697 424.131 636.123 424.131C647.555 424.131 657.492 428.852 664.447 438.541C672.398 449.474 676.623 466.12 676.623 486.742C676.623 525.998 661.471 549.353 636.375 549.353H636.123Z" fill="black"/>
+<path d="M771.24 549.353C738.445 549.353 733.477 510.097 733.477 486.742C733.477 465.623 737.203 448.977 744.41 438.293C750.621 428.852 759.814 424.131 771.24 424.131C782.672 424.131 792.609 428.852 799.564 438.541C807.516 449.474 811.74 466.12 811.74 486.742C811.74 525.998 796.588 549.353 771.492 549.353H771.24Z" fill="black"/>
+</g>
+</svg>

package/src/native-ui/renderer-extension/src/assets/omp-agent.svg

@@ -0,0 +1,14 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <defs>
+    <linearGradient id="omp-gradient" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0" stop-color="#ed4abf" />
+      <stop offset=".5" stop-color="#9b4dff" />
+      <stop offset="1" stop-color="#5ad8e6" />
+    </linearGradient>
+  </defs>
+  <path
+    fill="url(#omp-gradient)"
+    transform="translate(-14.4 -20.2) scale(1.45)"
+    d="M14 16h36v8H40v32h-8V24h-6v22h-8V24h-4z"
+  />
+</svg>

package/src/native-ui/renderer-extension/src/assets/pi-agent.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 800" role="img" aria-label="Pi">
+  <path fill="#111111" fill-rule="evenodd" d="M165.29 165.29H517.36V400H400V517.36H282.65V634.72H165.29ZM282.65 282.65V400H400V282.65Z"/>
+  <path fill="#111111" d="M517.36 400H634.72V634.72H517.36Z"/>
+</svg>

package/src/native-ui/renderer-extension/src/assets.d.ts

@@ -0,0 +1,26 @@
+declare module "*.png" {
+  const dataUrl: string;
+  export default dataUrl;
+}
+
+declare module "*.svg" {
+  const dataUrl: string;
+  export default dataUrl;
+}
+
+declare module "*.css" {
+  const cssText: string;
+  export default cssText;
+}
+
+declare module "lucide/dist/esm/createElement.mjs" {
+  import type { IconNode, SVGProps } from "lucide";
+  const createElement: (iconNode: IconNode, customAttributes?: SVGProps) => SVGElement;
+  export default createElement;
+}
+
+declare module "lucide/dist/esm/icons/*.mjs" {
+  import type { IconNode } from "lucide";
+  const iconNode: IconNode;
+  export default iconNode;
+}

package/src/native-ui/renderer-extension/src/audit-entry.ts

@@ -0,0 +1,5 @@
+import { inspectRendererContracts } from "./contract-audit.js";
+
+window.__codexhostContractAuditV1 = Object.freeze({
+  inspect: () => inspectRendererContracts(window),
+});

package/src/native-ui/renderer-extension/src/codex-locale-adapter.ts

@@ -0,0 +1,321 @@
+const GET_LOCALE_OVERRIDE_URL = "vscode://codex/get-setting";
+const GET_LOCALE_INFO_URL = "vscode://codex/locale-info";
+const SET_LOCALE_OVERRIDE_URL = "vscode://codex/set-setting";
+const DEFAULT_LOCALE_REQUEST_TIMEOUT_MS = 750;
+
+interface ElectronLocaleBridge {
+  sendMessageFromView(message: unknown): unknown;
+}
+
+interface ElectronLocaleWindow extends Window {
+  electronBridge?: ElectronLocaleBridge;
+}
+
+interface LocaleOverrideResponse {
+  value: string | null;
+}
+
+interface LocaleInfoResponse {
+  ideLocale: string | undefined;
+  systemLocale: string | undefined;
+}
+
+interface SetLocaleOverrideResponse {
+  success: true;
+}
+
+type FixedLocaleRequest =
+  | {
+      kind: "locale-override";
+      url: typeof GET_LOCALE_OVERRIDE_URL;
+      body: string;
+    }
+  | {
+      kind: "locale-info";
+      url: typeof GET_LOCALE_INFO_URL;
+      body?: undefined;
+    }
+  | {
+      kind: "set-locale-override";
+      url: typeof SET_LOCALE_OVERRIDE_URL;
+      body: string;
+    };
+
+export type CodexLocaleOverride = "en-US" | "zh-CN" | null;
+export type CodexLocaleReadStatus = "ready" | "fallback";
+export type CodexLocaleMode = "explicit" | "automatic" | "unavailable";
+export type CodexLocaleSource = "override" | "ide" | "system" | "navigator" | "default";
+
+export interface CodexLocaleSettings {
+  readonly status: CodexLocaleReadStatus;
+  readonly mode: CodexLocaleMode;
+  readonly localeOverride: string | null | undefined;
+  readonly ideLocale: string | undefined;
+  readonly systemLocale: string | undefined;
+  readonly preferredLocale: string;
+  readonly source: CodexLocaleSource;
+}
+
+export interface CodexLocaleRequestOptions {
+  ownerWindow?: Window;
+  signal?: AbortSignal;
+  timeoutMs?: number;
+}
+
+export type ReadCodexLocaleSettingsOptions = CodexLocaleRequestOptions;
+export type SetCodexLocaleOverrideOptions = CodexLocaleRequestOptions;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function canonicalLocale(value: unknown): string | undefined {
+  if (typeof value !== "string" || value.trim().length === 0) return undefined;
+  try {
+    return Intl.getCanonicalLocales(value.trim())[0];
+  } catch {
+    return undefined;
+  }
+}
+
+function firstNavigatorLocale(ownerWindow: Window): string | undefined {
+  for (const candidate of ownerWindow.navigator.languages) {
+    const locale = canonicalLocale(candidate);
+    if (locale) return locale;
+  }
+  return canonicalLocale(ownerWindow.navigator.language);
+}
+
+function abortError(): DOMException {
+  return new DOMException("The operation was aborted", "AbortError");
+}
+
+function parseLocaleOverride(value: unknown): LocaleOverrideResponse {
+  if (!isRecord(value) || !("value" in value)) {
+    throw new Error("Codex locale override response is malformed");
+  }
+  if (value.value === null) return { value: null };
+  const locale = canonicalLocale(value.value);
+  if (!locale) throw new Error("Codex locale override is invalid");
+  return { value: locale };
+}
+
+function optionalLocale(value: unknown, field: string): string | undefined {
+  if (value === undefined || value === null) return undefined;
+  const locale = canonicalLocale(value);
+  if (!locale) throw new Error(`Codex ${field} is invalid`);
+  return locale;
+}
+
+function parseLocaleInfo(value: unknown): LocaleInfoResponse {
+  if (!isRecord(value)) throw new Error("Codex locale info response is malformed");
+  return {
+    ideLocale: optionalLocale(value.ideLocale, "IDE locale"),
+    systemLocale: optionalLocale(value.systemLocale, "system locale"),
+  };
+}
+
+function parseSetLocaleOverride(value: unknown): SetLocaleOverrideResponse {
+  if (!isRecord(value) || value.success !== true) {
+    throw new Error("Codex locale update response is malformed");
+  }
+  return { success: true };
+}
+
+function sendFixedLocaleRequest(
+  request: FixedLocaleRequest,
+  ownerWindow: Window,
+  signal: AbortSignal | undefined,
+  timeoutMs: number,
+): Promise<unknown> {
+  const bridge = (ownerWindow as ElectronLocaleWindow).electronBridge;
+  if (typeof bridge?.sendMessageFromView !== "function") {
+    return Promise.reject(new Error("Codex locale bridge is unavailable"));
+  }
+  if (signal?.aborted) return Promise.reject(abortError());
+
+  const requestId = ownerWindow.crypto.randomUUID();
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = (): void => {
+      ownerWindow.clearTimeout(timer);
+      ownerWindow.removeEventListener("message", onMessage);
+      signal?.removeEventListener("abort", onAbort);
+    };
+    const settle = (operation: () => void): void => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      operation();
+    };
+    const onAbort = (): void => settle(() => reject(abortError()));
+    const onMessage = (event: MessageEvent): void => {
+      const message = event.data;
+      if (!isRecord(message) || message.type !== "fetch-response") return;
+      if (message.requestId !== requestId) return;
+      if (
+        message.responseType !== "success" ||
+        typeof message.status !== "number" ||
+        message.status < 200 ||
+        message.status >= 300 ||
+        typeof message.bodyJsonString !== "string"
+      ) {
+        settle(() => reject(new Error("Codex locale request failed")));
+        return;
+      }
+      try {
+        const body: unknown = JSON.parse(message.bodyJsonString);
+        settle(() => resolve(body));
+      } catch {
+        settle(() => reject(new Error("Codex locale response is not valid JSON")));
+      }
+    };
+    const timer = ownerWindow.setTimeout(
+      () => settle(() => reject(new Error("Codex locale request timed out"))),
+      timeoutMs,
+    );
+
+    ownerWindow.addEventListener("message", onMessage);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    const message = {
+      type: "fetch",
+      requestId,
+      method: "POST",
+      url: request.url,
+      ...(request.body === undefined ? {} : { body: request.body }),
+      reportUploadProgress: false,
+    };
+    try {
+      Promise.resolve(bridge.sendMessageFromView(message)).catch((error: unknown) => {
+        settle(() => reject(error));
+      });
+    } catch (error) {
+      settle(() => reject(error));
+    }
+  });
+}
+
+async function readLocaleOverride(
+  ownerWindow: Window,
+  signal: AbortSignal | undefined,
+  timeoutMs: number,
+): Promise<LocaleOverrideResponse> {
+  const response = await sendFixedLocaleRequest(
+    {
+      kind: "locale-override",
+      url: GET_LOCALE_OVERRIDE_URL,
+      body: JSON.stringify({ key: "localeOverride" }),
+    },
+    ownerWindow,
+    signal,
+    timeoutMs,
+  );
+  return parseLocaleOverride(response);
+}
+
+async function readLocaleInfo(
+  ownerWindow: Window,
+  signal: AbortSignal | undefined,
+  timeoutMs: number,
+): Promise<LocaleInfoResponse> {
+  const response = await sendFixedLocaleRequest(
+    { kind: "locale-info", url: GET_LOCALE_INFO_URL },
+    ownerWindow,
+    signal,
+    timeoutMs,
+  );
+  return parseLocaleInfo(response);
+}
+
+export async function setCodexLocaleOverride(
+  localeOverride: CodexLocaleOverride,
+  options: SetCodexLocaleOverrideOptions = {},
+): Promise<void> {
+  if (localeOverride !== null && localeOverride !== "en-US" && localeOverride !== "zh-CN") {
+    throw new Error("Unsupported Codex locale override");
+  }
+  const ownerWindow = options.ownerWindow ?? window;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_LOCALE_REQUEST_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("Codex locale request timeout must be positive");
+  }
+  const response = await sendFixedLocaleRequest(
+    {
+      kind: "set-locale-override",
+      url: SET_LOCALE_OVERRIDE_URL,
+      body: JSON.stringify({ key: "localeOverride", value: localeOverride }),
+    },
+    ownerWindow,
+    options.signal,
+    timeoutMs,
+  );
+  parseSetLocaleOverride(response);
+}
+
+export async function readCodexLocaleSettings(
+  options: ReadCodexLocaleSettingsOptions = {},
+): Promise<CodexLocaleSettings> {
+  const ownerWindow = options.ownerWindow ?? window;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_LOCALE_REQUEST_TIMEOUT_MS;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("Codex locale request timeout must be positive");
+  }
+  if (options.signal?.aborted) throw abortError();
+
+  const [overrideResult, localeInfoResult] = await Promise.allSettled([
+    readLocaleOverride(ownerWindow, options.signal, timeoutMs),
+    readLocaleInfo(ownerWindow, options.signal, timeoutMs),
+  ]);
+  if (options.signal?.aborted) throw abortError();
+
+  const navigatorLocale = firstNavigatorLocale(ownerWindow);
+  const overrideKnown = overrideResult.status === "fulfilled";
+  const localeOverride = overrideKnown ? overrideResult.value.value : undefined;
+  const localeInfo: LocaleInfoResponse =
+    localeInfoResult.status === "fulfilled"
+      ? localeInfoResult.value
+      : { ideLocale: undefined, systemLocale: undefined };
+
+  if (typeof localeOverride === "string") {
+    return Object.freeze({
+      status: "ready",
+      mode: "explicit",
+      localeOverride,
+      ideLocale: localeInfo.ideLocale,
+      systemLocale: localeInfo.systemLocale,
+      preferredLocale: localeOverride,
+      source: "override",
+    });
+  }
+
+  if (overrideKnown) {
+    const preferredLocale =
+      localeInfo.ideLocale ?? localeInfo.systemLocale ?? navigatorLocale ?? "en-US";
+    const source: CodexLocaleSource = localeInfo.ideLocale
+      ? "ide"
+      : localeInfo.systemLocale
+        ? "system"
+        : navigatorLocale
+          ? "navigator"
+          : "default";
+    return Object.freeze({
+      status: "ready",
+      mode: "automatic",
+      localeOverride: null,
+      ideLocale: localeInfo.ideLocale,
+      systemLocale: localeInfo.systemLocale,
+      preferredLocale,
+      source,
+    });
+  }
+
+  return Object.freeze({
+    status: "fallback",
+    mode: "unavailable",
+    localeOverride: undefined,
+    ideLocale: localeInfo.ideLocale,
+    systemLocale: localeInfo.systemLocale,
+    preferredLocale: navigatorLocale ?? "en-US",
+    source: navigatorLocale ? "navigator" : "default",
+  });
+}

package/src/native-ui/renderer-extension/src/collaboration-icon.ts

@@ -0,0 +1,13 @@
+import { projectIcon } from './harness-mix-icons.js';
+
+export function collaborationIcon(id: string, name: string, size = 22): HTMLElement {
+  const aliases: Record<string, string> = { 'claude-code': 'claude', 'deepseek-harness': 'dsh', 'codex-harness': 'codex' };
+  const key = id.toLowerCase();
+  const icon = projectIcon('harnesses', aliases[key] ?? key, size, document);
+  if (icon) return icon;
+  const fallback = document.createElement('span');
+  fallback.textContent = name.slice(0, 1).toUpperCase();
+  fallback.setAttribute('aria-hidden', 'true');
+  fallback.style.cssText = `display:inline-grid;place-items:center;width:${size}px;height:${size}px;flex:none;border-radius:6px;background:#8882;font-size:12px`;
+  return fallback;
+}

package/src/native-ui/renderer-extension/src/contract-audit.ts

@@ -0,0 +1,102 @@
+import {
+  CODEX_COMPOSER_SELECTOR,
+  inspectRendererComposerContract,
+  type RendererComposerContractInspection,
+} from "./renderer-composer-dom.js";
+import {
+  inspectRendererForkContract,
+  type RendererForkContractInspection,
+} from "./renderer-fork-control.js";
+import {
+  inspectRendererSidebarContract,
+  type RendererSidebarContractInspection,
+} from "./renderer-sidebar-agent-icons.js";
+import {
+  inspectRendererTranscriptContract,
+  type RendererTranscriptContractInspection,
+} from "./renderer-transcript-dom.js";
+import {
+  inspectRendererSettingsContract,
+  type RendererSettingsContractInspection,
+} from "./settings/trigger.js";
+import {
+  inspectComposerModelContract,
+  type RendererComposerModelContractState,
+} from "./versioned-renderer-adapter.js";
+
+export const RENDERER_CONTRACT_AUDIT_SCHEMA_VERSION = 1 as const;
+
+export interface RendererContractAuditApi {
+  inspect(): RendererContractAuditInspection;
+}
+
+export interface RendererContractAuditInspection {
+  schemaVersion: typeof RENDERER_CONTRACT_AUDIT_SCHEMA_VERSION;
+  composer: RendererComposerContractInspection;
+  model: {
+    draftCount: number;
+    conversationCount: number;
+    missingCount: number;
+    ambiguousCount: number;
+  };
+  settings: RendererSettingsContractInspection;
+  sidebar: RendererSidebarContractInspection;
+  transcript: RendererTranscriptContractInspection;
+  fork: RendererForkContractInspection;
+  production: {
+    bindingPresent: boolean;
+    adapterState: "installing" | "ready" | "unsupported" | "absent";
+    adapterReason: string;
+    titlePolicyState: "ready" | "absent" | "unknown";
+    draftPrewarmPolicyState: "ready" | "absent" | "unknown";
+  };
+}
+
+declare global {
+  interface Window {
+    __codexhostContractAuditV1?: RendererContractAuditApi;
+  }
+}
+
+function modelCounts(states: readonly RendererComposerModelContractState[]): {
+  draftCount: number;
+  conversationCount: number;
+  missingCount: number;
+  ambiguousCount: number;
+} {
+  return {
+    draftCount: states.filter((state) => state === "draft").length,
+    conversationCount: states.filter((state) => state === "conversation").length,
+    missingCount: states.filter((state) => state === "missing").length,
+    ambiguousCount: states.filter((state) => state === "ambiguous").length,
+  };
+}
+
+export function inspectRendererContracts(
+  ownerWindow: Window = window,
+): RendererContractAuditInspection {
+  const composers = [...ownerWindow.document.querySelectorAll<Element>(CODEX_COMPOSER_SELECTOR)];
+  const binding = ownerWindow.__codexhostRendererBindingProbeV1;
+  const status = binding?.status();
+  const adapterState = status?.adapter.state ?? "absent";
+  const titlePolicy = ownerWindow.__codexhostMainProcessTitlePolicyV1;
+  const draftPolicy = ownerWindow.__codexhostDraftPrewarmPolicyV1;
+  return {
+    schemaVersion: RENDERER_CONTRACT_AUDIT_SCHEMA_VERSION,
+    composer: inspectRendererComposerContract(ownerWindow.document),
+    model: modelCounts(composers.map(inspectComposerModelContract)),
+    settings: inspectRendererSettingsContract(ownerWindow.document),
+    sidebar: inspectRendererSidebarContract(ownerWindow.document),
+    transcript: inspectRendererTranscriptContract(ownerWindow.document),
+    fork: inspectRendererForkContract(ownerWindow.document),
+    production: {
+      bindingPresent: binding !== undefined,
+      adapterState,
+      adapterReason: status?.adapter.state ?? "absent",
+      titlePolicyState:
+        titlePolicy === undefined ? "absent" : titlePolicy.state === "ready" ? "ready" : "unknown",
+      draftPrewarmPolicyState:
+        draftPolicy === undefined ? "absent" : draftPolicy.state === "ready" ? "ready" : "unknown",
+    },
+  };
+}

package/src/native-ui/renderer-extension/src/harness-mix-icons.ts

@@ -0,0 +1,24 @@
+// Project-owned assets compiled by scripts/build-native.cjs.
+export function projectIcon(kind: 'harnesses' | 'models', id: string, size: number, doc: Document): HTMLImageElement | null {
+  const globals = globalThis as any;
+  const svg = globals.__HARNESS_MIX_ICONS__?.[kind]?.[id === 'codex-harness' ? 'codex' : id]?.svg;
+  if (!svg) return null;
+  const image = doc.createElement('img');
+  image.src = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+  // An SVG loaded as an image cannot inherit the surrounding text color.
+  // Mask monochrome marks so they remain visible when the desktop theme changes.
+  if (svg.includes('fill="currentColor"')) {
+    const mask = `url("${image.src}")`;
+    image.src = 'data:image/svg+xml,%3Csvg xmlns="http://www.w3.org/2000/svg" width="24" height="24"/%3E';
+    Object.assign(image.style, { backgroundColor: 'currentColor', maskImage: mask, maskSize: 'contain', maskRepeat: 'no-repeat', maskPosition: 'center' });
+  }
+  image.alt = '';
+  image.draggable = false;
+  image.dataset.harnessMixIcon = `${kind}/${id}`;
+  Object.assign(image.style, { width: `${size}px`, height: `${size}px`, flex: 'none', objectFit: 'contain' });
+  return image;
+}
+export function projectModelIcon(label: string, doc: Document): HTMLImageElement {
+  const family = ((globalThis as any).__HARNESS_MIX_MODEL_FAMILIES__ ?? []).find((f: any) => new RegExp(f.pattern, 'i').test(label));
+  return projectIcon('models', family?.id ?? 'astra', 18, doc)!;
+}

package/src/native-ui/renderer-extension/src/harness-mix-settings.ts

@@ -0,0 +1,80 @@
+import {
+  rendererSettingsMessages,
+  resolveRendererSettingsLocale,
+  type RendererSettingsLocale,
+} from './settings/localization.js';
+import {
+  createConnectionsSettingsPage,
+} from './settings/connections-page.js';
+import { aboutPage } from './settings/pages.js';
+import { installRendererSettingsShell, type RendererSettingsShell } from './settings/shell.js';
+import {
+  installRendererSettingsHeaderTrigger,
+  type RendererSettingsHeaderTriggerControl,
+} from './settings/trigger.js';
+import type {
+  RendererSettingsLifecycleOptions,
+  RendererSettingsLifecycleControl,
+} from './renderer-settings-lifecycle.js';
+
+export function installRendererSettingsLifecycle(
+  ownerWindow: Window,
+  options: RendererSettingsLifecycleOptions = {},
+): RendererSettingsLifecycleControl {
+  let locale: RendererSettingsLocale = resolveRendererSettingsLocale(ownerWindow.navigator.languages);
+  let shell: RendererSettingsShell | null = null;
+  let trigger: RendererSettingsHeaderTriggerControl | null = null;
+  let disposed = false;
+
+  const mount = () => {
+    const messages = rendererSettingsMessages(locale);
+    const pages = [
+      createConnectionsSettingsPage(messages, options.getConnectionDiagnostics ?? (() => null)),
+      aboutPage(messages),
+    ];
+    const nextShell = installRendererSettingsShell(pages, messages, ownerWindow.document);
+    const nextTrigger = installRendererSettingsHeaderTrigger({
+      available: nextShell.supported,
+      messages,
+      ownerDocument: ownerWindow.document,
+      onOpen(opener, pageId) {
+        if (disposed) return;
+        const currentOpener = opener?.isConnected
+          ? opener
+          : (nextTrigger.root?.querySelector<HTMLButtonElement>('button') ?? undefined);
+        nextShell.openSettings(currentOpener, pageId ?? 'connections');
+      },
+    });
+    shell = nextShell;
+    trigger = nextTrigger;
+  };
+
+  const onKeyDown = (event: KeyboardEvent) => {
+    if ((event.ctrlKey || event.metaKey) && event.key === ',') {
+      event.preventDefault();
+      shell?.openSettings(undefined, 'connections');
+    }
+  };
+
+  mount();
+  ownerWindow.addEventListener('keydown', onKeyDown);
+
+  return {
+    get locale() {
+      return locale;
+    },
+    refresh() {
+      if (disposed) return false;
+      return trigger?.refresh() ?? false;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      ownerWindow.removeEventListener('keydown', onKeyDown);
+      trigger?.dispose();
+      shell?.dispose();
+      trigger = null;
+      shell = null;
+    },
+  };
+}