@qilin-agent/client-ui-theme 0.0.0-stage → 3.1.4

package/lib/index.js

@@ -0,0 +1,112 @@
+import z from "@qilin-agent/schemastery";
+//#region lib/types/theme-settings.js
+/** Theme preferences stored in the Host user-settings document. */
+/** Built-in preferences accepted at the registry and settings boundaries. */
+const THEME_PREFERENCES = [
+	"light",
+	"dark",
+	"system"
+];
+/** Settings namespace owned by the theme plugin. */
+const THEME_SETTINGS_NAMESPACE = "ui-theme";
+/** Field carrying the selected built-in theme preference. */
+const THEME_PREFERENCE_FIELD = "preference";
+/** Field carrying the conversation content font size. */
+const FONT_SIZE_FIELD = "fontSize";
+/** Default preference when the user-settings document has no override. */
+const DEFAULT_PREFERENCE = "system";
+/** Smallest accepted content font size (px). */
+const FONT_SIZE_MIN = 10;
+/** Largest accepted content font size (px). */
+const FONT_SIZE_MAX = 22;
+/** Content font size when the user-settings document has no override (px). */
+const DEFAULT_FONT_SIZE = 14;
+/** Durable theme schema; also the wire envelope the browser scope validates against. */
+const ThemeSettingsSchema = z.object({
+	[THEME_PREFERENCE_FIELD]: z.union([...THEME_PREFERENCES]).default(DEFAULT_PREFERENCE),
+	[FONT_SIZE_FIELD]: z.number().step(1).min(10).max(22).default(14)
+});
+//#endregion
+//#region lib/types/boot-theme.js
+/**
+* Theme bootstrap row for the browser's pre-plugin interval. Each index
+* render embeds the current durable built-in preference, content font size,
+* and content font size. Head CSS colors the document canvas before script
+* execution; the body script installs the palette selector and both content
+* axes that ui-layout's ThemePresenter adopts after the client plugin tree
+* activates.
+*/
+const LIGHT_BACKGROUND = "#fff";
+const DARK_BACKGROUND = "#151517";
+/** CSS that colors the document canvas before any script executes. */
+function bootThemeStyle(preference) {
+	const light = `:root{color-scheme:light}body{background-color:${LIGHT_BACKGROUND};--qilin-boot-bg:${LIGHT_BACKGROUND}}`;
+	const dark = `:root{color-scheme:dark}body{background-color:${DARK_BACKGROUND};--qilin-boot-bg:${DARK_BACKGROUND}}`;
+	if (preference === "light") return light;
+	if (preference === "dark") return dark;
+	return `${light}@media(prefers-color-scheme:dark){${dark}}`;
+}
+/** Build the body script that installs the palette selector, font size, and leading. */
+function bootThemeBodyScript(preference, fontSize) {
+	return `(() => {
+  const preference = ${JSON.stringify(preference)}
+  const systemDark = preference === 'system'
+    && typeof matchMedia !== 'undefined'
+    && matchMedia('(prefers-color-scheme: dark)').matches
+  const dark = preference === 'dark' || systemDark
+  document.documentElement.dataset.dsThemeSource = preference
+  document.body.toggleAttribute('data-ds-dark-theme', dark)
+  document.body.style.setProperty('--qilin-content-font-size', ${JSON.stringify(`${fontSize}px`)})
+})()`;
+}
+/**
+* Theme bootstrap rows: head CSS colors the document canvas before
+* first paint, then the body script installs the palette selector and the
+* content font size and leading before the shell mount and module script.
+* @param preference - Current Host-backed built-in preference.
+* @param fontSize - Current Host-backed content font size in px.
+* @returns head style and body script rows in execution order.
+*/
+function bootThemeInjections(preference = DEFAULT_PREFERENCE, fontSize = 14) {
+	return [{
+		kind: "style",
+		text: bootThemeStyle(preference)
+	}, {
+		kind: "script",
+		placement: "body",
+		text: bootThemeBodyScript(preference, fontSize)
+	}];
+}
+//#endregion
+//#region lib/types/index.js
+/** Host registration for the browser theme preference and pre-plugin palette. */
+const THEME_NAMESPACE = THEME_SETTINGS_NAMESPACE;
+/** Read the registered theme section or the schema defaults without a settings provider. */
+function readSection(ctx) {
+	const fallback = {
+		preference: DEFAULT_PREFERENCE,
+		fontSize: 14
+	};
+	const settings = ctx.get("settings");
+	if (settings === void 0) return fallback;
+	const section = settings.get(THEME_NAMESPACE);
+	if (section === void 0) return fallback;
+	return section;
+}
+/**
+* Register the durable theme section when the optional settings service is
+* composed, and answer every index injection collection with the current
+* theme bootstrap row.
+* @param ctx - Host context that may acquire the settings service.
+*/
+function apply(ctx) {
+	ctx.inject(["settings"], (settingsCtx) => {
+		settingsCtx.settings.register(THEME_NAMESPACE, ThemeSettingsSchema);
+	});
+	ctx.on("webserver/index-inject", (table) => {
+		const section = readSection(ctx);
+		table.push(...bootThemeInjections(section.preference, section.fontSize));
+	}, { prepend: true });
+}
+//#endregion
+export { DEFAULT_FONT_SIZE, DEFAULT_PREFERENCE, FONT_SIZE_FIELD, FONT_SIZE_MAX, FONT_SIZE_MIN, THEME_PREFERENCES, THEME_PREFERENCE_FIELD, THEME_SETTINGS_NAMESPACE, apply };

package/lib/types/boot-theme.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Theme bootstrap row for the browser's pre-plugin interval. Each index
+ * render embeds the current durable built-in preference, content font size,
+ * and content font size. Head CSS colors the document canvas before script
+ * execution; the body script installs the palette selector and both content
+ * axes that ui-layout's ThemePresenter adopts after the client plugin tree
+ * activates.
+ */
+import type { IndexInjection } from '@qilin-agent/host-webserver';
+import { type ThemePreference } from './theme-settings.ts';
+/**
+ * Theme bootstrap rows: head CSS colors the document canvas before
+ * first paint, then the body script installs the palette selector and the
+ * content font size and leading before the shell mount and module script.
+ * @param preference - Current Host-backed built-in preference.
+ * @param fontSize - Current Host-backed content font size in px.
+ * @returns head style and body script rows in execution order.
+ */
+export declare function bootThemeInjections(preference?: ThemePreference, fontSize?: number): IndexInjection[];
+//# sourceMappingURL=boot-theme.d.ts.map

package/lib/types/client/AppearanceRow.d.ts

@@ -0,0 +1,17 @@
+import type { PropsLocale, PropsRuntime, PropsStore } from '@qilin-agent/client-ui-slots';
+import type { ThemePreference } from '../theme-settings.ts';
+import type { createAppearanceRowStore } from './settings-store.ts';
+/** Injected business face: the preference write (t rides the standard locale seat). */
+export interface AppearanceRowInjected {
+    /** Switch the theme preference. */
+    setTheme: (id: ThemePreference) => void;
+}
+/** Full component props: runtime share + store share + locale seat + injected face. */
+export type AppearanceRowComponentProps = PropsRuntime<'settings.general.item'> & PropsStore<ReturnType<typeof createAppearanceRowStore>> & PropsLocale<'settings.theme'> & AppearanceRowInjected;
+/**
+ * Render the Appearance row.
+ * @param props - composed slot props.
+ * @returns the row element tree.
+ */
+export declare function AppearanceRow({ t, setTheme, useStore }: AppearanceRowComponentProps): import("react").JSX.Element;
+//# sourceMappingURL=AppearanceRow.d.ts.map

package/lib/types/client/FontSizeRow.d.ts

@@ -0,0 +1,16 @@
+import type { PropsLocale, PropsRuntime, PropsStore } from '@qilin-agent/client-ui-slots';
+import type { createTypographyRowStore } from './settings-store.ts';
+/** Injected business face: the preference write (t rides the standard locale seat). */
+export interface FontSizeRowInjected {
+    /** Change the content font size (integer px within FONT_SIZE_MIN..FONT_SIZE_MAX). */
+    setFontSize: (px: number) => void;
+}
+/** Full component props: runtime share + store share + locale seat + injected face. */
+export type FontSizeRowComponentProps = PropsRuntime<'settings.general.item'> & PropsStore<ReturnType<typeof createTypographyRowStore>> & PropsLocale<'settings.theme'> & FontSizeRowInjected;
+/**
+ * Render the font-size row.
+ * @param props - composed slot props.
+ * @returns the row element tree.
+ */
+export declare function FontSizeRow({ t, setFontSize, useStore }: FontSizeRowComponentProps): import("react").JSX.Element;
+//# sourceMappingURL=FontSizeRow.d.ts.map

package/lib/types/client/index.d.ts

@@ -0,0 +1,202 @@
+/**
+ * Browser theme registry over the `--qilin-*` token stylesheets. The service
+ * owns the live theme preference (light/dark/system), resolves `system` through
+ * `prefers-color-scheme`, and publishes immutable snapshots; it never touches
+ * the DOM — ui-layout's presenter consumes the resolved snapshot. The Host
+ * settings scope loads and stores the preference in the user-settings
+ * document. The plugin also registers the Appearance preference row into the
+ * settings General section — the theme feature owns its own settings surface.
+ */
+import type { Context as ClientContext } from '@qilin-agent/kylin';
+import type { ConfigForm } from '@qilin-agent/client-ui-settings/client';
+import { type ThemeKey } from './locales.ts';
+import { type ThemePreference, type ThemeSettings } from '../theme-settings.ts';
+export type { FontSizeRowComponentProps, FontSizeRowInjected } from './FontSizeRow.tsx';
+export type { AppearanceRowComponentProps, AppearanceRowInjected } from './AppearanceRow.tsx';
+export type { AppearanceRowState, TypographyRowState } from './settings-store.ts';
+export type { ThemeKey } from './locales.ts';
+export type { ThemePreference, ThemeSettings } from '../theme-settings.ts';
+/** Namespace owning this feature's settings-row copy. */
+export declare const SETTINGS_NS = "settings.theme";
+declare module '@qilin-agent/client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** The Appearance settings row's copy. */
+        'settings.theme': ThemeKey;
+    }
+}
+/** Theme token dictionary: --qilin-alias-* overrides keyed by variable name. */
+export type ThemeTokens = Record<string, string>;
+/**
+ * One override-layer token value: both palette modes are mandatory (repeat
+ * the same value when the token is scheme-invariant) so an override never
+ * goes illegible when the user switches to the other scheme.
+ */
+export interface ThemeTokenModes {
+    /** Value applied while the light base palette is active. */
+    light: string;
+    /** Value applied while the dark base palette is active. */
+    dark: string;
+}
+/** Override-layer dictionary: token names to per-mode value pairs. */
+export type ThemeTokenOverrides = Record<string, ThemeTokenModes>;
+/** One selectable theme: id, dark/light semantics, and alias-token overrides. */
+export interface ThemeDefinition {
+    /** Theme id (the setTheme argument for concrete themes). */
+    id: string;
+    /**
+     * Which base palette this theme builds on. The presenter switches
+     * `body[data-ds-dark-theme]` from this field — never from the id.
+     */
+    colorScheme: 'light' | 'dark';
+    /** Alias-layer overrides applied as inline CSS variables over the base palette. */
+    tokens: ThemeTokens;
+}
+/** Immutable theme state published on every change. */
+export interface ThemeSnapshot {
+    /** The persisted preference (may be `system`). */
+    preference: ThemePreference;
+    /** Conversation content font size in px (integer within FONT_SIZE_MIN..FONT_SIZE_MAX). */
+    fontSize: number;
+    /**
+     * The resolved active theme (`system` resolved via prefers-color-scheme)
+     * with override layers folded into its tokens (seq order, later layers win
+     * per-token; each value picked for the active color scheme).
+     */
+    active: ThemeDefinition;
+    /** Registered themes in registration order. */
+    themes: readonly ThemeDefinition[];
+    /** Monotonic change counter (registry or active changes). */
+    revision: number;
+}
+/** One theme token exposed to pre-definition Cordis inspection. */
+export interface ThemeTokenInspection {
+    /** Token name accepted by {@link ThemeRuntime.overrideTokens}. */
+    name: string;
+    /** Intended visual role. */
+    description: string;
+    /** CSS value category. */
+    valueType: string;
+    /** Whether override layers must supply both palette modes. */
+    requiresLightAndDark: boolean;
+    /** CSS custom property consumed by UI styles. */
+    cssVariable?: string;
+}
+declare module '@qilin-agent/kylin' {
+    interface Context {
+        theme: ThemeRuntime;
+    }
+    interface Events {
+        /**
+         * Theme state changed (preference switched, registry updated, or the OS
+         * color scheme changed while the preference is `system`).
+         * @param snapshot - Current immutable theme snapshot.
+         * @mode emit
+         */
+        'theme/change'(snapshot: ThemeSnapshot): void;
+    }
+}
+/**
+ * Theme registry and preference owner. `light`/`dark` are built in (the base
+ * stylesheets carry both palettes); third-party themes register alias-layer
+ * overrides. Reads go through {@link getTheme}; preference writes only
+ * through {@link setTheme}; continuous sync only through the `theme/change`
+ * event. {@link overrideTokens} stacks partial token layers over the active
+ * theme without touching the registry.
+ * The service holds the `prefers-color-scheme` media query (environment
+ * sensing, not presentation) and re-emits when the OS scheme flips while the
+ * preference is `system`.
+ */
+export declare class ThemeRuntime {
+    private readonly ctx;
+    private readonly host;
+    private themes;
+    private preference;
+    private fontSize;
+    private revision;
+    private snapshot;
+    private readonly media;
+    /** Override layers by source; seq (monotonic) is the stacking order. */
+    private readonly overrides;
+    private overrideSeq;
+    /**
+     * @param ctx - owning context (change events are emitted on it; the
+     * media-query and scope listeners are released through ctx.effect on dispose).
+     * @param host - durable preference scope owned by the same plugin.
+     */
+    constructor(ctx: ClientContext, host: ConfigForm<ThemeSettings>);
+    /**
+     * Read the current immutable theme snapshot.
+     * @returns the current snapshot (stable reference until the next change).
+     */
+    getTheme(): ThemeSnapshot;
+    /**
+     * Export the current token directory without reading DOM or computed styles.
+     * @returns stable JSON-safe token descriptions, including registered and override-only names.
+     */
+    exportInspectTokens(): ThemeTokenInspection[];
+    /**
+     * Switch the theme preference — the only user preference write entry.
+     * Built-in preferences are written through the settings scope and every
+     * accepted value emits `theme/change`.
+     * @param id - a registered theme id or `system`; unknown ids throw.
+     */
+    setTheme(id: string): void;
+    /**
+     * Change the conversation content font size — the only font-size write
+     * entry. Accepted values are written through the settings scope and emit
+     * `theme/change`.
+     * @param px - integer px within FONT_SIZE_MIN..FONT_SIZE_MAX; out-of-range or fractional values throw.
+     */
+    setFontSize(px: number): void;
+    /** Adopt the scope's accepted durable preference without writing it back. */
+    private adopt;
+    /**
+     * Register a theme. Duplicate id throws (single occupant per id; the
+     * built-in pair counts; `system` is a preference, not a registrable id).
+     * @param definition - theme id, colorScheme, and alias-token overrides.
+     * @returns disposer. Disposing the theme backing the active preference
+     * resets the preference to the default so the UI never keeps tokens of an
+     * unregistered theme.
+     */
+    register(definition: ThemeDefinition): () => void;
+    /**
+     * Stack a token override layer on top of the active theme — the token-level
+     * analogue of slot shading: the base theme stays untouched, layers compose
+     * in seq order with later layers winning per-token, and removing a layer
+     * restores whatever it covered. Calling again with the same source replaces
+     * that source's whole layer and restacks it on top (effect re-registration
+     * semantics). Emits `theme/change` with the recomposed snapshot.
+     * @param source - layer identity; one layer per source (dynamic packages
+     * pass their package id — the façade pins it, so it also names the layer's
+     * origin for inspection).
+     * @param tokens - token-name → `{ light, dark }` value pairs. Validated at
+     * runtime (model-authored callers reach this boundary with untyped JS);
+     * a bare string value throws a teaching error.
+     * @returns disposer removing exactly the layer this call created; a no-op
+     * once the source has re-overridden (the newer layer is not torn down).
+     */
+    overrideTokens(source: string, tokens: ThemeTokenOverrides): () => void;
+    private buildSnapshot;
+    /**
+     * Fold the override layers into the active definition: seq order, later
+     * layers win per-token, each value picked for the active color scheme (the
+     * presenter consumes the composed snapshot and needs no override awareness).
+     * Without layers the registered definition passes through by identity.
+     */
+    private composeActive;
+    private publish;
+}
+/**
+ * Required services: settings transport plus slots/locale for the Appearance
+ * row. `remote` carries the forwarded settings invalidation that
+ * `ctx.configForms.get(entryId)` subscribes to on this context.
+ */
+export declare const inject: string[];
+/**
+ * Client plugin body: provide the theme service and register the
+ * feature-owned Appearance, font-size, and line-spacing preference rows into
+ * the General section's item slot (a feature owns its settings surface).
+ * @param ctx - client cordis context.
+ */
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/locales.d.ts

@@ -0,0 +1,28 @@
+/** `settings.theme` namespace dictionaries (the Appearance, font-size, and line-spacing rows' copy). */
+/** Simplified Chinese dictionary (the key-set source of truth). */
+export declare const zh: {
+    'appearance.title': string;
+    'appearance.light': string;
+    'appearance.dark': string;
+    'appearance.system': string;
+    'fontSize.title': string;
+    'fontSize.description': string;
+    'fontSize.unit': string;
+    'fontSize.increase': string;
+    'fontSize.decrease': string;
+};
+/** The settings.theme namespace key union. */
+export type ThemeKey = keyof typeof zh;
+/** English dictionary, checked complete against the zh key set. */
+export declare const en: {
+    'appearance.title': string;
+    'appearance.light': string;
+    'appearance.dark': string;
+    'appearance.system': string;
+    'fontSize.title': string;
+    'fontSize.description': string;
+    'fontSize.unit': string;
+    'fontSize.increase': string;
+    'fontSize.decrease': string;
+};
+//# sourceMappingURL=locales.d.ts.map

package/lib/types/client/settings-store.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Appearance and typography settings-row slot stores: mirrors of the theme
+ * service snapshot. The plugin's apply-world change listener is the only
+ * writer; the rows read their fields via props.useStore.
+ */
+import { type EngineStoreHandle } from '@qilin-agent/client-store';
+import { type ThemePreference } from '../theme-settings.ts';
+/** Store state mirrored from the theme snapshot's appearance preference. */
+export interface AppearanceRowState {
+    /** Persisted preference (selection state reads this, never the resolved active theme). */
+    preference: ThemePreference;
+    /** Service revision; -1 until first sync so revision 0 lands as a change. */
+    revision: number;
+}
+/** Declared action shape giving the exported factory a stable return type. */
+type AppearanceRowActions = {
+    sync: (draft: AppearanceRowState, preference: ThemePreference, revision: number) => void;
+};
+/**
+ * Declares the Appearance row state and write surface.
+ * @returns the store handle.
+ */
+export declare function createAppearanceRowStore(): EngineStoreHandle<AppearanceRowState, AppearanceRowActions>;
+/** Store state mirrored from the theme snapshot's typography fields. */
+export interface TypographyRowState {
+    /** Persisted content font size in px. */
+    fontSize: number;
+    /** Service revision; -1 until first sync so revision 0 lands as a change. */
+    revision: number;
+}
+/** Declared action shape giving the exported factory a stable return type. */
+type TypographyRowActions = {
+    sync: (draft: TypographyRowState, fontSize: number, revision: number) => void;
+};
+/**
+ * Declares the shared typography-row state and write surface.
+ * @returns the store handle.
+ */
+export declare function createTypographyRowStore(): EngineStoreHandle<TypographyRowState, TypographyRowActions>;
+export {};
+//# sourceMappingURL=settings-store.d.ts.map

package/lib/types/client/styles.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from '@qilin-agent/kylin';
+/**
+ * Mount the global theme sheets for exactly the owning plugin lifetime.
+ * @param ctx - Owning plugin context.
+ */
+export declare function installThemeStyles(ctx: Context): void;
+//# sourceMappingURL=styles.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,11 @@
+/** Host registration for the browser theme preference and pre-plugin palette. */
+import type { Context } from '@qilin-agent/kylin';
+export { DEFAULT_FONT_SIZE, DEFAULT_PREFERENCE, FONT_SIZE_FIELD, FONT_SIZE_MAX, FONT_SIZE_MIN, THEME_PREFERENCE_FIELD, THEME_PREFERENCES, THEME_SETTINGS_NAMESPACE, type ThemePreference, type ThemeSettings, } from './theme-settings.ts';
+/**
+ * Register the durable theme section when the optional settings service is
+ * composed, and answer every index injection collection with the current
+ * theme bootstrap row.
+ * @param ctx - Host context that may acquire the settings service.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/theme-settings.d.ts

@@ -0,0 +1,36 @@
+/** Theme preferences stored in the Host user-settings document. */
+import z from '@qilin-agent/schemastery';
+/** Built-in preferences accepted at the registry and settings boundaries. */
+export declare const THEME_PREFERENCES: readonly ["light", "dark", "system"];
+/** Settings namespace owned by the theme plugin. */
+export declare const THEME_SETTINGS_NAMESPACE = "ui-theme";
+/** Field carrying the selected built-in theme preference. */
+export declare const THEME_PREFERENCE_FIELD = "preference";
+/** Field carrying the conversation content font size. */
+export declare const FONT_SIZE_FIELD = "fontSize";
+/** Theme preference persisted by the product Appearance row. */
+export type ThemePreference = typeof THEME_PREFERENCES[number];
+/** Default preference when the user-settings document has no override. */
+export declare const DEFAULT_PREFERENCE: ThemePreference;
+/** Smallest accepted content font size (px). */
+export declare const FONT_SIZE_MIN = 10;
+/** Largest accepted content font size (px). */
+export declare const FONT_SIZE_MAX = 22;
+/** Content font size when the user-settings document has no override (px). */
+export declare const DEFAULT_FONT_SIZE = 14;
+/** Durable theme section shared by the Host schema and the browser scope. */
+export interface ThemeSettings {
+    /** Selected built-in preference. */
+    preference: ThemePreference;
+    /** Conversation content font size in px (integer within {@link FONT_SIZE_MIN}..{@link FONT_SIZE_MAX}). */
+    fontSize: number;
+}
+/** Durable theme schema; also the wire envelope the browser scope validates against. */
+export declare const ThemeSettingsSchema: z<ThemeSettings>;
+/**
+ * Narrow one wire or registry value to a persistable preference.
+ * @param value - value crossing the settings or registry boundary.
+ * @returns whether the value is a built-in preference.
+ */
+export declare function isThemePreference(value: unknown): value is ThemePreference;
+//# sourceMappingURL=theme-settings.d.ts.map

package/package.json

@@ -1,6 +1,78 @@
 {
   "name": "@qilin-agent/client-ui-theme",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "description": "Theme plugin: Host bootstrap for the pre-plugin palette; DOM-free ThemeRuntime for light/dark/system state; --qilin-* token styles and Appearance settings row",
+  "version": "3.1.4",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kkutysllb/QiLin.git",
+    "directory": "packages/client/ui-theme"
+  },
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "qilin": {
+    "client": {
+      "inject": [
+        "@qilin-agent/client-connection",
+        "@qilin-agent/client-locale",
+        "@qilin-agent/client-ui-renderer",
+        "@qilin-agent/client-ui-settings",
+        "@qilin-agent/api-remotes"
+      ],
+      "platform": "web",
+      "immediately": true
+    }
+  },
+  "license": "MIT",
+  "peerDependencies": {
+    "@qilin-agent/kylin": "~4.0.3"
+  },
+  "devDependencies": {
+    "@types/react": "~18.3.1",
+    "react": "^18.2.0",
+    "clsx": "^2.0.0",
+    "@qilin-agent/api-remotes": "3.1.4",
+    "@qilin-agent/kylin": "~4.0.3",
+    "@qilin-agent/client-connection": "3.1.4",
+    "@qilin-agent/client-locale": "3.1.4",
+    "@qilin-agent/client-store": "3.1.4",
+    "@qilin-agent/client-test-runtime": "3.1.4",
+    "@qilin-agent/client-ui-settings": "3.1.4",
+    "@qilin-agent/client-ui-renderer": "3.1.4",
+    "@qilin-agent/client-ui-slots": "3.1.4",
+    "@qilin-agent/settings": "3.1.4",
+    "@qilin-agent/host-webserver": "3.1.4",
+    "@qilin-agent/client-ui-primitives": "3.1.4"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/client.js",
+    "lib/styles",
+    "lib/types/**/*.d.ts"
+  ],
+  "dependencies": {
+    "@qilin-agent/schemastery": "~3.18.3"
+  },
+  "scripts": {
+    "bundle": "tsdown",
+    "watch": "tsdown --watch"
+  }
 }