@anionex/dsh-eye-care 0.1.0 → 0.1.2

package/lib/client.js

@@ -5,9 +5,8 @@ window.__ModuleLoader__.load({
 		var exports = module.exports;
 		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 		let react_jsx_runtime = require("react/jsx-runtime");
-		let _deepseek_ai_dsh_client_runtime_client = require("@deepseek-ai/dsh-client-runtime/client");
-		//#region \0dsh-eye-care-css:/Users/davidyang/.codex/worktrees/dsh-eye-care-anionex/src/client/EyeCareRow.module.css.mjs
-		const css = ".akRDxW_row{border-bottom:1px solid var(--dsw-alias-border-l2);grid-template-columns:minmax(170px,.8fr) minmax(360px,1.2fr);gap:20px;padding:16px 0;display:grid}.akRDxW_copy{min-width:0}.akRDxW_title{color:var(--dsw-alias-label-primary);margin:0;font-size:14px;font-weight:500;line-height:22px}.akRDxW_description{color:var(--dsw-alias-label-tertiary);margin:4px 0 0;font-size:12px;line-height:18px}.akRDxW_controls{align-content:start;gap:8px;display:grid}.akRDxW_controlGroup{flex-wrap:wrap;gap:6px;display:flex}.akRDxW_option,.akRDxW_smallOption{border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-secondary);font:inherit;cursor:pointer}.akRDxW_option:focus-visible,.akRDxW_smallOption:focus-visible{outline:2px solid var(--dsw-alias-button-info-fill);outline-offset:2px}.akRDxW_option{border-radius:9px;min-width:68px;padding:7px 11px;font-size:12px;line-height:18px}.akRDxW_smallOption{border-radius:7px;padding:4px 9px;font-size:11px;line-height:16px}.akRDxW_option:hover:not(:disabled),.akRDxW_smallOption:hover:not(:disabled){background:var(--dsw-alias-interactive-bg-hover-solid)}.akRDxW_selected{border-color:var(--dsw-alias-button-info-fill);background:var(--dsw-alias-interactive-bg-active);color:var(--dsw-alias-label-primary)}.akRDxW_option:disabled,.akRDxW_smallOption:disabled{cursor:wait;opacity:.65}.akRDxW_primaryLine,.akRDxW_settingLine{flex-wrap:wrap;align-items:center;gap:8px;display:flex}.akRDxW_settingLabel,.akRDxW_status{color:var(--dsw-alias-label-tertiary);font-size:11px;line-height:16px}.akRDxW_settingLabel{min-width:56px}.akRDxW_advanced{border:1px solid var(--dsw-alias-border-l2);border-radius:9px;overflow:hidden}.akRDxW_advanced>summary{color:var(--dsw-alias-label-secondary);cursor:pointer;padding:8px 10px;font-size:11px;line-height:16px}.akRDxW_advancedBody{gap:8px;padding:0 10px 10px;display:grid}.akRDxW_status{min-height:16px}@media (width<=640px){.akRDxW_row{grid-template-columns:1fr;gap:10px}}";
+		//#region \0dsh-eye-care-css:/Users/davidyang/dsh-worktrees/dsh-eye-care/compat-20261001/src/client/EyeCareRow.module.css.mjs
+		const css = "._5STowG_row{border-bottom:1px solid var(--dsw-alias-border-l2);grid-template-columns:minmax(170px,.8fr) minmax(360px,1.2fr);gap:20px;padding:16px 0;display:grid}._5STowG_copy{min-width:0}._5STowG_title{color:var(--dsw-alias-label-primary);margin:0;font-size:14px;font-weight:500;line-height:22px}._5STowG_description{color:var(--dsw-alias-label-tertiary);margin:4px 0 0;font-size:12px;line-height:18px}._5STowG_controls{align-content:start;gap:8px;display:grid}._5STowG_controlGroup{flex-wrap:wrap;gap:6px;display:flex}._5STowG_option,._5STowG_smallOption{border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-secondary);font:inherit;cursor:pointer}._5STowG_option:focus-visible,._5STowG_smallOption:focus-visible{outline:2px solid var(--dsw-alias-button-info-fill);outline-offset:2px}._5STowG_option{border-radius:9px;min-width:68px;padding:7px 11px;font-size:12px;line-height:18px}._5STowG_smallOption{border-radius:7px;padding:4px 9px;font-size:11px;line-height:16px}._5STowG_option:hover:not(:disabled),._5STowG_smallOption:hover:not(:disabled){background:var(--dsw-alias-interactive-bg-hover-solid)}._5STowG_selected{border-color:var(--dsw-alias-button-info-fill);background:var(--dsw-alias-interactive-bg-active);color:var(--dsw-alias-label-primary)}._5STowG_option:disabled,._5STowG_smallOption:disabled{cursor:wait;opacity:.65}._5STowG_primaryLine,._5STowG_settingLine{flex-wrap:wrap;align-items:center;gap:8px;display:flex}._5STowG_settingLabel,._5STowG_status{color:var(--dsw-alias-label-tertiary);font-size:11px;line-height:16px}._5STowG_settingLabel{min-width:56px}._5STowG_advanced{border:1px solid var(--dsw-alias-border-l2);border-radius:9px;overflow:hidden}._5STowG_advanced>summary{color:var(--dsw-alias-label-secondary);cursor:pointer;padding:8px 10px;font-size:11px;line-height:16px}._5STowG_advancedBody{gap:8px;padding:0 10px 10px;display:grid}._5STowG_status{min-height:16px}@media (width<=640px){._5STowG_row{grid-template-columns:1fr;gap:10px}}";
 		const tagId = "@anionex/dsh-eye-care/EyeCareRow.module.css";
 		if (typeof document !== "undefined" && document.querySelector(`style[data-plugin-css=${JSON.stringify(tagId)}]`) === null) {
 			const tag = document.createElement("style");
@@ -17,21 +16,21 @@ window.__ModuleLoader__.load({
 			document.head.appendChild(tag);
 		}
 		var EyeCareRow_module_css_default = {
-			"advancedBody": "akRDxW_advancedBody",
-			"controls": "akRDxW_controls",
-			"controlGroup": "akRDxW_controlGroup",
-			"copy": "akRDxW_copy",
-			"description": "akRDxW_description",
-			"smallOption": "akRDxW_smallOption",
-			"settingLine": "akRDxW_settingLine",
-			"option": "akRDxW_option",
-			"advanced": "akRDxW_advanced",
-			"selected": "akRDxW_selected",
-			"row": "akRDxW_row",
-			"title": "akRDxW_title",
-			"primaryLine": "akRDxW_primaryLine",
-			"status": "akRDxW_status",
-			"settingLabel": "akRDxW_settingLabel"
+			"description": "_5STowG_description",
+			"advancedBody": "_5STowG_advancedBody",
+			"selected": "_5STowG_selected",
+			"primaryLine": "_5STowG_primaryLine",
+			"copy": "_5STowG_copy",
+			"title": "_5STowG_title",
+			"option": "_5STowG_option",
+			"settingLine": "_5STowG_settingLine",
+			"settingLabel": "_5STowG_settingLabel",
+			"controls": "_5STowG_controls",
+			"status": "_5STowG_status",
+			"smallOption": "_5STowG_smallOption",
+			"row": "_5STowG_row",
+			"controlGroup": "_5STowG_controlGroup",
+			"advanced": "_5STowG_advanced"
 		};
 		//#endregion
 		//#region src/client/EyeCareRow.tsx
@@ -177,6 +176,678 @@ window.__ModuleLoader__.load({
 			});
 		}
 		//#endregion
+		//#region node_modules/.pnpm/zustand@4.4.7_@types+react@18.3.31_immer@10.1.1_react@18.3.1/node_modules/zustand/esm/vanilla.mjs
+		const createStoreImpl = (createState) => {
+			let state;
+			const listeners = /* @__PURE__ */ new Set();
+			const setState = (partial, replace) => {
+				const nextState = typeof partial === "function" ? partial(state) : partial;
+				if (!Object.is(nextState, state)) {
+					const previousState = state;
+					state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+					listeners.forEach((listener) => listener(state, previousState));
+				}
+			};
+			const getState = () => state;
+			const subscribe = (listener) => {
+				listeners.add(listener);
+				return () => listeners.delete(listener);
+			};
+			const destroy = () => {
+				if (({}.env ? "production" : void 0) !== "production") console.warn("[DEPRECATED] The `destroy` method will be unsupported in a future version. Instead use unsubscribe function returned by subscribe. Everything will be garbage-collected if store is garbage-collected.");
+				listeners.clear();
+			};
+			const api = {
+				setState,
+				getState,
+				subscribe,
+				destroy
+			};
+			state = createState(setState, getState, api);
+			return api;
+		};
+		const createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
+		//#endregion
+		//#region node_modules/.pnpm/zustand@4.4.7_@types+react@18.3.31_immer@10.1.1_react@18.3.1/node_modules/zustand/esm/middleware.mjs
+		const subscribeWithSelectorImpl = (fn) => (set, get, api) => {
+			const origSubscribe = api.subscribe;
+			api.subscribe = (selector, optListener, options) => {
+				let listener = selector;
+				if (optListener) {
+					const equalityFn = (options == null ? void 0 : options.equalityFn) || Object.is;
+					let currentSlice = selector(api.getState());
+					listener = (state) => {
+						const nextSlice = selector(state);
+						if (!equalityFn(currentSlice, nextSlice)) {
+							const previousSlice = currentSlice;
+							optListener(currentSlice = nextSlice, previousSlice);
+						}
+					};
+					if (options == null ? void 0 : options.fireImmediately) optListener(currentSlice, currentSlice);
+				}
+				return origSubscribe(listener);
+			};
+			return fn(set, get, api);
+		};
+		const subscribeWithSelector = subscribeWithSelectorImpl;
+		//#endregion
+		//#region node_modules/.pnpm/immer@10.1.1/node_modules/immer/dist/immer.mjs
+		var NOTHING = Symbol.for("immer-nothing");
+		var DRAFTABLE = Symbol.for("immer-draftable");
+		var DRAFT_STATE = Symbol.for("immer-state");
+		function die(error, ...args) {
+			throw new Error(`[Immer] minified error nr: ${error}. Full error at: https://bit.ly/3cXEKWf`);
+		}
+		var getPrototypeOf = Object.getPrototypeOf;
+		function isDraft(value) {
+			return !!value && !!value[DRAFT_STATE];
+		}
+		function isDraftable(value) {
+			if (!value) return false;
+			return isPlainObject(value) || Array.isArray(value) || !!value[DRAFTABLE] || !!value.constructor?.[DRAFTABLE] || isMap(value) || isSet(value);
+		}
+		var objectCtorString = Object.prototype.constructor.toString();
+		function isPlainObject(value) {
+			if (!value || typeof value !== "object") return false;
+			const proto = getPrototypeOf(value);
+			if (proto === null) return true;
+			const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+			if (Ctor === Object) return true;
+			return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
+		}
+		function each(obj, iter) {
+			if (getArchtype(obj) === 0) Reflect.ownKeys(obj).forEach((key) => {
+				iter(key, obj[key], obj);
+			});
+			else obj.forEach((entry, index) => iter(index, entry, obj));
+		}
+		function getArchtype(thing) {
+			const state = thing[DRAFT_STATE];
+			return state ? state.type_ : Array.isArray(thing) ? 1 : isMap(thing) ? 2 : isSet(thing) ? 3 : 0;
+		}
+		function has(thing, prop) {
+			return getArchtype(thing) === 2 ? thing.has(prop) : Object.prototype.hasOwnProperty.call(thing, prop);
+		}
+		function set(thing, propOrOldValue, value) {
+			const t = getArchtype(thing);
+			if (t === 2) thing.set(propOrOldValue, value);
+			else if (t === 3) thing.add(value);
+			else thing[propOrOldValue] = value;
+		}
+		function is(x, y) {
+			if (x === y) return x !== 0 || 1 / x === 1 / y;
+			else return x !== x && y !== y;
+		}
+		function isMap(target) {
+			return target instanceof Map;
+		}
+		function isSet(target) {
+			return target instanceof Set;
+		}
+		function latest(state) {
+			return state.copy_ || state.base_;
+		}
+		function shallowCopy(base, strict) {
+			if (isMap(base)) return new Map(base);
+			if (isSet(base)) return new Set(base);
+			if (Array.isArray(base)) return Array.prototype.slice.call(base);
+			const isPlain = isPlainObject(base);
+			if (strict === true || strict === "class_only" && !isPlain) {
+				const descriptors = Object.getOwnPropertyDescriptors(base);
+				delete descriptors[DRAFT_STATE];
+				let keys = Reflect.ownKeys(descriptors);
+				for (let i = 0; i < keys.length; i++) {
+					const key = keys[i];
+					const desc = descriptors[key];
+					if (desc.writable === false) {
+						desc.writable = true;
+						desc.configurable = true;
+					}
+					if (desc.get || desc.set) descriptors[key] = {
+						configurable: true,
+						writable: true,
+						enumerable: desc.enumerable,
+						value: base[key]
+					};
+				}
+				return Object.create(getPrototypeOf(base), descriptors);
+			} else {
+				const proto = getPrototypeOf(base);
+				if (proto !== null && isPlain) return { ...base };
+				const obj = Object.create(proto);
+				return Object.assign(obj, base);
+			}
+		}
+		function freeze(obj, deep = false) {
+			if (isFrozen(obj) || isDraft(obj) || !isDraftable(obj)) return obj;
+			if (getArchtype(obj) > 1) obj.set = obj.add = obj.clear = obj.delete = dontMutateFrozenCollections;
+			Object.freeze(obj);
+			if (deep) Object.entries(obj).forEach(([key, value]) => freeze(value, true));
+			return obj;
+		}
+		function dontMutateFrozenCollections() {
+			die(2);
+		}
+		function isFrozen(obj) {
+			return Object.isFrozen(obj);
+		}
+		var plugins = {};
+		function getPlugin(pluginKey) {
+			const plugin = plugins[pluginKey];
+			if (!plugin) die(0, pluginKey);
+			return plugin;
+		}
+		var currentScope;
+		function getCurrentScope() {
+			return currentScope;
+		}
+		function createScope(parent_, immer_) {
+			return {
+				drafts_: [],
+				parent_,
+				immer_,
+				canAutoFreeze_: true,
+				unfinalizedDrafts_: 0
+			};
+		}
+		function usePatchesInScope(scope, patchListener) {
+			if (patchListener) {
+				getPlugin("Patches");
+				scope.patches_ = [];
+				scope.inversePatches_ = [];
+				scope.patchListener_ = patchListener;
+			}
+		}
+		function revokeScope(scope) {
+			leaveScope(scope);
+			scope.drafts_.forEach(revokeDraft);
+			scope.drafts_ = null;
+		}
+		function leaveScope(scope) {
+			if (scope === currentScope) currentScope = scope.parent_;
+		}
+		function enterScope(immer2) {
+			return currentScope = createScope(currentScope, immer2);
+		}
+		function revokeDraft(draft) {
+			const state = draft[DRAFT_STATE];
+			if (state.type_ === 0 || state.type_ === 1) state.revoke_();
+			else state.revoked_ = true;
+		}
+		function processResult(result, scope) {
+			scope.unfinalizedDrafts_ = scope.drafts_.length;
+			const baseDraft = scope.drafts_[0];
+			if (result !== void 0 && result !== baseDraft) {
+				if (baseDraft[DRAFT_STATE].modified_) {
+					revokeScope(scope);
+					die(4);
+				}
+				if (isDraftable(result)) {
+					result = finalize(scope, result);
+					if (!scope.parent_) maybeFreeze(scope, result);
+				}
+				if (scope.patches_) getPlugin("Patches").generateReplacementPatches_(baseDraft[DRAFT_STATE].base_, result, scope.patches_, scope.inversePatches_);
+			} else result = finalize(scope, baseDraft, []);
+			revokeScope(scope);
+			if (scope.patches_) scope.patchListener_(scope.patches_, scope.inversePatches_);
+			return result !== NOTHING ? result : void 0;
+		}
+		function finalize(rootScope, value, path) {
+			if (isFrozen(value)) return value;
+			const state = value[DRAFT_STATE];
+			if (!state) {
+				each(value, (key, childValue) => finalizeProperty(rootScope, state, value, key, childValue, path));
+				return value;
+			}
+			if (state.scope_ !== rootScope) return value;
+			if (!state.modified_) {
+				maybeFreeze(rootScope, state.base_, true);
+				return state.base_;
+			}
+			if (!state.finalized_) {
+				state.finalized_ = true;
+				state.scope_.unfinalizedDrafts_--;
+				const result = state.copy_;
+				let resultEach = result;
+				let isSet2 = false;
+				if (state.type_ === 3) {
+					resultEach = new Set(result);
+					result.clear();
+					isSet2 = true;
+				}
+				each(resultEach, (key, childValue) => finalizeProperty(rootScope, state, result, key, childValue, path, isSet2));
+				maybeFreeze(rootScope, result, false);
+				if (path && rootScope.patches_) getPlugin("Patches").generatePatches_(state, path, rootScope.patches_, rootScope.inversePatches_);
+			}
+			return state.copy_;
+		}
+		function finalizeProperty(rootScope, parentState, targetObject, prop, childValue, rootPath, targetIsSet) {
+			if (isDraft(childValue)) {
+				const res = finalize(rootScope, childValue, rootPath && parentState && parentState.type_ !== 3 && !has(parentState.assigned_, prop) ? rootPath.concat(prop) : void 0);
+				set(targetObject, prop, res);
+				if (isDraft(res)) rootScope.canAutoFreeze_ = false;
+				else return;
+			} else if (targetIsSet) targetObject.add(childValue);
+			if (isDraftable(childValue) && !isFrozen(childValue)) {
+				if (!rootScope.immer_.autoFreeze_ && rootScope.unfinalizedDrafts_ < 1) return;
+				finalize(rootScope, childValue);
+				if ((!parentState || !parentState.scope_.parent_) && typeof prop !== "symbol" && Object.prototype.propertyIsEnumerable.call(targetObject, prop)) maybeFreeze(rootScope, childValue);
+			}
+		}
+		function maybeFreeze(scope, value, deep = false) {
+			if (!scope.parent_ && scope.immer_.autoFreeze_ && scope.canAutoFreeze_) freeze(value, deep);
+		}
+		function createProxyProxy(base, parent) {
+			const isArray = Array.isArray(base);
+			const state = {
+				type_: isArray ? 1 : 0,
+				scope_: parent ? parent.scope_ : getCurrentScope(),
+				modified_: false,
+				finalized_: false,
+				assigned_: {},
+				parent_: parent,
+				base_: base,
+				draft_: null,
+				copy_: null,
+				revoke_: null,
+				isManual_: false
+			};
+			let target = state;
+			let traps = objectTraps;
+			if (isArray) {
+				target = [state];
+				traps = arrayTraps;
+			}
+			const { revoke, proxy } = Proxy.revocable(target, traps);
+			state.draft_ = proxy;
+			state.revoke_ = revoke;
+			return proxy;
+		}
+		var objectTraps = {
+			get(state, prop) {
+				if (prop === DRAFT_STATE) return state;
+				const source = latest(state);
+				if (!has(source, prop)) return readPropFromProto(state, source, prop);
+				const value = source[prop];
+				if (state.finalized_ || !isDraftable(value)) return value;
+				if (value === peek(state.base_, prop)) {
+					prepareCopy(state);
+					return state.copy_[prop] = createProxy(value, state);
+				}
+				return value;
+			},
+			has(state, prop) {
+				return prop in latest(state);
+			},
+			ownKeys(state) {
+				return Reflect.ownKeys(latest(state));
+			},
+			set(state, prop, value) {
+				const desc = getDescriptorFromProto(latest(state), prop);
+				if (desc?.set) {
+					desc.set.call(state.draft_, value);
+					return true;
+				}
+				if (!state.modified_) {
+					const current2 = peek(latest(state), prop);
+					const currentState = current2?.[DRAFT_STATE];
+					if (currentState && currentState.base_ === value) {
+						state.copy_[prop] = value;
+						state.assigned_[prop] = false;
+						return true;
+					}
+					if (is(value, current2) && (value !== void 0 || has(state.base_, prop))) return true;
+					prepareCopy(state);
+					markChanged(state);
+				}
+				if (state.copy_[prop] === value && (value !== void 0 || prop in state.copy_) || Number.isNaN(value) && Number.isNaN(state.copy_[prop])) return true;
+				state.copy_[prop] = value;
+				state.assigned_[prop] = true;
+				return true;
+			},
+			deleteProperty(state, prop) {
+				if (peek(state.base_, prop) !== void 0 || prop in state.base_) {
+					state.assigned_[prop] = false;
+					prepareCopy(state);
+					markChanged(state);
+				} else delete state.assigned_[prop];
+				if (state.copy_) delete state.copy_[prop];
+				return true;
+			},
+			getOwnPropertyDescriptor(state, prop) {
+				const owner = latest(state);
+				const desc = Reflect.getOwnPropertyDescriptor(owner, prop);
+				if (!desc) return desc;
+				return {
+					writable: true,
+					configurable: state.type_ !== 1 || prop !== "length",
+					enumerable: desc.enumerable,
+					value: owner[prop]
+				};
+			},
+			defineProperty() {
+				die(11);
+			},
+			getPrototypeOf(state) {
+				return getPrototypeOf(state.base_);
+			},
+			setPrototypeOf() {
+				die(12);
+			}
+		};
+		var arrayTraps = {};
+		each(objectTraps, (key, fn) => {
+			arrayTraps[key] = function() {
+				arguments[0] = arguments[0][0];
+				return fn.apply(this, arguments);
+			};
+		});
+		arrayTraps.deleteProperty = function(state, prop) {
+			return arrayTraps.set.call(this, state, prop, void 0);
+		};
+		arrayTraps.set = function(state, prop, value) {
+			return objectTraps.set.call(this, state[0], prop, value, state[0]);
+		};
+		function peek(draft, prop) {
+			const state = draft[DRAFT_STATE];
+			return (state ? latest(state) : draft)[prop];
+		}
+		function readPropFromProto(state, source, prop) {
+			const desc = getDescriptorFromProto(source, prop);
+			return desc ? `value` in desc ? desc.value : desc.get?.call(state.draft_) : void 0;
+		}
+		function getDescriptorFromProto(source, prop) {
+			if (!(prop in source)) return void 0;
+			let proto = getPrototypeOf(source);
+			while (proto) {
+				const desc = Object.getOwnPropertyDescriptor(proto, prop);
+				if (desc) return desc;
+				proto = getPrototypeOf(proto);
+			}
+		}
+		function markChanged(state) {
+			if (!state.modified_) {
+				state.modified_ = true;
+				if (state.parent_) markChanged(state.parent_);
+			}
+		}
+		function prepareCopy(state) {
+			if (!state.copy_) state.copy_ = shallowCopy(state.base_, state.scope_.immer_.useStrictShallowCopy_);
+		}
+		var Immer2 = class {
+			constructor(config) {
+				this.autoFreeze_ = true;
+				this.useStrictShallowCopy_ = false;
+				/**
+				* The `produce` function takes a value and a "recipe function" (whose
+				* return value often depends on the base state). The recipe function is
+				* free to mutate its first argument however it wants. All mutations are
+				* only ever applied to a __copy__ of the base state.
+				*
+				* Pass only a function to create a "curried producer" which relieves you
+				* from passing the recipe function every time.
+				*
+				* Only plain objects and arrays are made mutable. All other objects are
+				* considered uncopyable.
+				*
+				* Note: This function is __bound__ to its `Immer` instance.
+				*
+				* @param {any} base - the initial state
+				* @param {Function} recipe - function that receives a proxy of the base state as first argument and which can be freely modified
+				* @param {Function} patchListener - optional function that will be called with all the patches produced here
+				* @returns {any} a new state, or the initial state if nothing was modified
+				*/
+				this.produce = (base, recipe, patchListener) => {
+					if (typeof base === "function" && typeof recipe !== "function") {
+						const defaultBase = recipe;
+						recipe = base;
+						const self = this;
+						return function curriedProduce(base2 = defaultBase, ...args) {
+							return self.produce(base2, (draft) => recipe.call(this, draft, ...args));
+						};
+					}
+					if (typeof recipe !== "function") die(6);
+					if (patchListener !== void 0 && typeof patchListener !== "function") die(7);
+					let result;
+					if (isDraftable(base)) {
+						const scope = enterScope(this);
+						const proxy = createProxy(base, void 0);
+						let hasError = true;
+						try {
+							result = recipe(proxy);
+							hasError = false;
+						} finally {
+							if (hasError) revokeScope(scope);
+							else leaveScope(scope);
+						}
+						usePatchesInScope(scope, patchListener);
+						return processResult(result, scope);
+					} else if (!base || typeof base !== "object") {
+						result = recipe(base);
+						if (result === void 0) result = base;
+						if (result === NOTHING) result = void 0;
+						if (this.autoFreeze_) freeze(result, true);
+						if (patchListener) {
+							const p = [];
+							const ip = [];
+							getPlugin("Patches").generateReplacementPatches_(base, result, p, ip);
+							patchListener(p, ip);
+						}
+						return result;
+					} else die(1, base);
+				};
+				this.produceWithPatches = (base, recipe) => {
+					if (typeof base === "function") return (state, ...args) => this.produceWithPatches(state, (draft) => base(draft, ...args));
+					let patches, inversePatches;
+					return [
+						this.produce(base, recipe, (p, ip) => {
+							patches = p;
+							inversePatches = ip;
+						}),
+						patches,
+						inversePatches
+					];
+				};
+				if (typeof config?.autoFreeze === "boolean") this.setAutoFreeze(config.autoFreeze);
+				if (typeof config?.useStrictShallowCopy === "boolean") this.setUseStrictShallowCopy(config.useStrictShallowCopy);
+			}
+			createDraft(base) {
+				if (!isDraftable(base)) die(8);
+				if (isDraft(base)) base = current(base);
+				const scope = enterScope(this);
+				const proxy = createProxy(base, void 0);
+				proxy[DRAFT_STATE].isManual_ = true;
+				leaveScope(scope);
+				return proxy;
+			}
+			finishDraft(draft, patchListener) {
+				const state = draft && draft[DRAFT_STATE];
+				if (!state || !state.isManual_) die(9);
+				const { scope_: scope } = state;
+				usePatchesInScope(scope, patchListener);
+				return processResult(void 0, scope);
+			}
+			/**
+			* Pass true to automatically freeze all copies created by Immer.
+			*
+			* By default, auto-freezing is enabled.
+			*/
+			setAutoFreeze(value) {
+				this.autoFreeze_ = value;
+			}
+			/**
+			* Pass true to enable strict shallow copy.
+			*
+			* By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+			*/
+			setUseStrictShallowCopy(value) {
+				this.useStrictShallowCopy_ = value;
+			}
+			applyPatches(base, patches) {
+				let i;
+				for (i = patches.length - 1; i >= 0; i--) {
+					const patch = patches[i];
+					if (patch.path.length === 0 && patch.op === "replace") {
+						base = patch.value;
+						break;
+					}
+				}
+				if (i > -1) patches = patches.slice(i + 1);
+				const applyPatchesImpl = getPlugin("Patches").applyPatches_;
+				if (isDraft(base)) return applyPatchesImpl(base, patches);
+				return this.produce(base, (draft) => applyPatchesImpl(draft, patches));
+			}
+		};
+		function createProxy(value, parent) {
+			const draft = isMap(value) ? getPlugin("MapSet").proxyMap_(value, parent) : isSet(value) ? getPlugin("MapSet").proxySet_(value, parent) : createProxyProxy(value, parent);
+			(parent ? parent.scope_ : getCurrentScope()).drafts_.push(draft);
+			return draft;
+		}
+		function current(value) {
+			if (!isDraft(value)) die(10, value);
+			return currentImpl(value);
+		}
+		function currentImpl(value) {
+			if (!isDraftable(value) || isFrozen(value)) return value;
+			const state = value[DRAFT_STATE];
+			let copy;
+			if (state) {
+				if (!state.modified_) return state.base_;
+				state.finalized_ = true;
+				copy = shallowCopy(value, state.scope_.immer_.useStrictShallowCopy_);
+			} else copy = shallowCopy(value, true);
+			each(copy, (key, childValue) => {
+				set(copy, key, currentImpl(childValue));
+			});
+			if (state) state.finalized_ = false;
+			return copy;
+		}
+		var immer = new Immer2();
+		var produce = immer.produce;
+		immer.produceWithPatches.bind(immer);
+		immer.setAutoFreeze.bind(immer);
+		immer.setUseStrictShallowCopy.bind(immer);
+		immer.applyPatches.bind(immer);
+		immer.createDraft.bind(immer);
+		immer.finishDraft.bind(immer);
+		//#endregion
+		//#region node_modules/.pnpm/@deepseek-ai+dsh-client-store@0.2.0-rc.2_@deepseek-ai+cordis@4.0.4/node_modules/@deepseek-ai/dsh-client-store/lib/index.js
+		/**
+		* React-free snapshot store engine (zustand vanilla + immer + subscribeWithSelector +
+		* rafFlush middleware + opt-in persist + dev freeze) plus the declarative
+		* shell over it: {@link defineStore} bakes an init/persist/actions literal
+		* into a {@link StoreHandle}, the registration-side store seat of slot
+		* terminals. Engine products are bare observables — subscribe/getSnapshot/
+		* update/set, NO selector hook. Hook synthesis is ui-renderer's (the one
+		* uSES bridge, cached per source at the binding site).
+		*/
+		/**
+		* Notify an observer set without allowing one callback to starve the rest.
+		* @param listeners - current observer callbacks; copied before dispatch.
+		* @param label - diagnostic owner prefix.
+		* @param args - callback arguments.
+		*/
+		function notifySubscribers(listeners, label, ...args) {
+			for (const listener of [...listeners]) try {
+				listener(...args);
+			} catch (error) {
+				console.error(`${label} subscriber failed:`, error);
+			}
+		}
+		/** Batches subscriber notification into one flush per animation frame. */
+		function rafBatch(notify) {
+			const schedule = typeof requestAnimationFrame === "function" ? (fn) => {
+				requestAnimationFrame(() => {
+					fn();
+				});
+			} : (fn) => {
+				queueMicrotask(fn);
+			};
+			let scheduled = false;
+			return () => {
+				if (scheduled) return;
+				scheduled = true;
+				schedule(() => {
+					scheduled = false;
+					notify();
+				});
+			};
+		}
+		/**
+		* Create a snapshot store.
+		*
+		* Flush default is 'sync' (controlled inputs need same-tick echo); frame-driven
+		* stores opt into 'raf', where a frame's worth of updates coalesces into one
+		* notification. Known raf-mode tradeoff: a component mounting mid-frame reads
+		* fresh state while existing subscribers hear it next flush — transient
+		* frame-level skew, same nature as the object layer's microtask batching.
+		*
+		* @param init - initial state.
+		* @param opts - flush mode and opt-in persistence (localStorage, keyed by name).
+		* @returns the store.
+		*/
+		function createSnapshotStore(init, opts) {
+			const withSelector = subscribeWithSelector(() => init);
+			const api = createStore()(withSelector);
+			if (opts?.persist) attachPersistence(api, opts.persist.name);
+			let subscribe = (fn) => api.subscribe(() => {
+				notifySubscribers([fn], "[client-store]");
+			});
+			if (opts?.flush === "raf") {
+				const listeners = /* @__PURE__ */ new Set();
+				const flush = rafBatch(() => {
+					notifySubscribers(listeners, "[client-store]");
+				});
+				api.subscribe(flush);
+				subscribe = (fn) => {
+					listeners.add(fn);
+					return () => {
+						listeners.delete(fn);
+					};
+				};
+			}
+			return {
+				getSnapshot: () => api.getState(),
+				subscribe: (fn) => subscribe(fn),
+				update: (mutator) => {
+					api.setState(produce(api.getState(), (draft) => {
+						mutator(draft);
+					}), true);
+				},
+				set: (next) => {
+					api.setState(devFreeze(next), true);
+				}
+			};
+		}
+		/**
+		* Whole-value JSON persistence to localStorage. Hand-rolled instead of the
+		* zustand persist middleware: its write path spreads state into an object
+		* (`partialize({ ...get() })`), exploding primitive state (a persisted string
+		* draft becomes {0:'h',1:'e',...}) — not fixable via merge/deserialize options
+		* because the corruption happens before serialization. Storage failures
+		* (quota, private mode) only disable persistence, never break the store.
+		*/
+		function attachPersistence(api, name) {
+			if (typeof localStorage === "undefined") return;
+			try {
+				const raw = localStorage.getItem(name);
+				if (raw !== null) api.setState(devFreeze(JSON.parse(raw)), true);
+			} catch (error) {
+				console.error(`snapshot store '${name}' rehydration failed:`, error);
+			}
+			api.subscribe((state) => {
+				try {
+					localStorage.setItem(name, JSON.stringify(state));
+				} catch (error) {
+					console.error(`snapshot store '${name}' persistence failed:`, error);
+				}
+			});
+		}
+		/** Deep-freeze draftable wholesale-set state outside production: set() bypasses immer's freeze. */
+		function devFreeze(value) {
+			return freeze(value, true);
+		}
+		//#endregion
 		//#region src/shared.ts
 		/** Browser-safe eye-care settings and RPC wire values. */
 		/** User-selectable eye-care operating modes. */
@@ -220,9 +891,12 @@ window.__ModuleLoader__.load({
 			if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
 			const record = value;
 			if (!isEyeCareMode(record["mode"]) || !isEyeCareIntensity(record["intensity"])) return void 0;
+			const restoreTheme = record["restoreTheme"];
+			if (restoreTheme !== void 0 && restoreTheme !== "light" && restoreTheme !== "dark" && restoreTheme !== "system") return void 0;
 			return {
 				mode: record[MODE_FIELD],
-				intensity: record[INTENSITY_FIELD]
+				intensity: record[INTENSITY_FIELD],
+				...restoreTheme === void 0 ? {} : { restoreTheme }
 			};
 		}
 		/** Decode one complete Host snapshot from the RPC boundary. */
@@ -639,7 +1313,7 @@ window.__ModuleLoader__.load({
 		/** Stateful controller shared by theme listeners and the Settings row. */
 		var EyeCareController = class {
 			/** Reactive row source. */
-			store = (0, _deepseek_ai_dsh_client_runtime_client.createSnapshotStore)(INITIAL_STATE);
+			store = createSnapshotStore(INITIAL_STATE);
 			theme;
 			rpc;
 			media;
@@ -657,6 +1331,8 @@ window.__ModuleLoader__.load({
 			acceptedRemoteSnapshot = false;
 			startupBaseTheme;
 			startupBaseThemeDeadline = 0;
+			removeTokenLayer;
+			activeBaseTheme;
 			/**
 			* Register the concrete themes and lifecycle listeners.
 			* @param options - theme, transport, and system-scheme collaborators.
@@ -756,7 +1432,10 @@ window.__ModuleLoader__.load({
 				this.unsubscribeMedia = void 0;
 				this.unsubscribeTheme = void 0;
 				await this.tail;
-				if (isEyeCareThemeId(this.theme.getTheme().preference)) try {
+				const current = this.theme.getTheme();
+				this.removeTokenLayer?.();
+				this.removeTokenLayer = void 0;
+				if (isEyeCareThemeId(current.preference) || current.preference === this.activeBaseTheme) try {
 					this.setTheme(this.resolveRestoreTheme());
 				} catch (error) {
 					failures.push(error);
@@ -802,7 +1481,11 @@ window.__ModuleLoader__.load({
 					this.setUnavailable(state.error);
 					return Promise.resolve();
 				}
-				this.pendingSettings = { ...settings };
+				this.pendingSettings = {
+					mode: settings.mode,
+					intensity: settings.intensity
+				};
+				if (this.theme.overrideTokens !== void 0 && settings.mode !== "off" && (this.restoreTheme === "light" || this.restoreTheme === "dark" || this.restoreTheme === "system")) this.pendingSettings.restoreTheme = this.restoreTheme;
 				return this.enqueue(async () => {
 					await this.flushPending();
 				});
@@ -900,7 +1583,7 @@ window.__ModuleLoader__.load({
 						this.hasRestoreTheme = true;
 					}
 				} else if (firstRemote) {
-					const base = snapshot.baseThemePreference;
+					const base = next.restoreTheme ?? snapshot.baseThemePreference;
 					if (base === void 0) {
 						if (!this.hasRestoreTheme) this.captureRestoreTheme();
 					} else {
@@ -943,12 +1626,36 @@ window.__ModuleLoader__.load({
 				const { mode, intensity } = this.store.getSnapshot().settings;
 				const current = this.theme.getTheme().preference;
 				if (mode === "off") {
-					if (isEyeCareThemeId(current)) this.setTheme(this.resolveRestoreTheme());
+					this.applyingTheme += 1;
+					try {
+						this.removeTokenLayer?.();
+						this.removeTokenLayer = void 0;
+						if (isEyeCareThemeId(current) || current === this.activeBaseTheme) this.setTheme(this.resolveRestoreTheme());
+						this.activeBaseTheme = void 0;
+					} finally {
+						this.applyingTheme -= 1;
+					}
 					this.hasRestoreTheme = false;
 					return;
 				}
 				if (!this.hasRestoreTheme) this.captureRestoreTheme();
 				const scheme = mode === "auto" ? this.media?.matches === true ? "dark" : "light" : mode;
+				if (this.theme.overrideTokens !== void 0) {
+					const definition = EYE_CARE_THEMES.find((theme) => theme.id === eyeCareThemeId(scheme, intensity));
+					const tokens = Object.fromEntries(Object.entries(definition.tokens).map(([name, value]) => [name, {
+						light: value,
+						dark: value
+					}]));
+					this.applyingTheme += 1;
+					try {
+						this.activeBaseTheme = mode === "auto" ? "system" : mode;
+						this.removeTokenLayer = this.theme.overrideTokens("@anionex/dsh-eye-care", tokens);
+						this.setTheme(this.activeBaseTheme);
+					} finally {
+						this.applyingTheme -= 1;
+					}
+					return;
+				}
 				this.setTheme(eyeCareThemeId(scheme, intensity));
 			}
 			setTheme(id) {
@@ -962,6 +1669,7 @@ window.__ModuleLoader__.load({
 			}
 			onThemeChanged(snapshot) {
 				if (this.disposed || this.applyingTheme > 0 || isEyeCareThemeId(snapshot.preference)) return;
+				if (snapshot.preference === this.activeBaseTheme) return;
 				if (this.startupBaseTheme !== void 0) {
 					const expected = this.startupBaseTheme;
 					const withinStartupWindow = this.now() <= this.startupBaseThemeDeadline;
@@ -986,6 +1694,7 @@ window.__ModuleLoader__.load({
 					next.settings = settings;
 					next.error = null;
 				});
+				this.applyCurrentTheme();
 				this.persist(settings);
 			}
 		};
@@ -1067,7 +1776,7 @@ window.__ModuleLoader__.load({
 			}), "dsh-eye-care: dictionaries");
 			ctx.effect(() => {
 				const refresh = (namespace) => {
-					if (namespace !== void 0 && namespace !== "eye-care") return;
+					if (namespace !== void 0 && namespace !== "eye-care" && namespace !== "dsh-eye-care") return;
 					controller.refresh();
 				};
 				const disposers = [ctx.remote.$on("settings/document-updated", refresh), ctx.on("connection/reset", () => {