@cowwo/dsh-icon-custom 0.9.1 → 0.10.0

package/README.zh.md

@@ -58,12 +58,13 @@ SVG 会在浏览器里先栅格化成 512×512 PNG 再上传,ICO 则由后端提
 规则:
 
 - 数字 = **几个会话**在等你(不是几件事);同一个会话只占一格。
-- 正在看的那个会话、以及子代理会话一律不计。
-- **已读记在每个浏览器自己身上**(localStorage):打开过 = 处理过,刷新/重启不会"复活";装插件之前的历史结束也不算。
+- 只有子代理会话不计。**你正开着的那个会话也算**——窗口可能被最小化、页面可能切到后台,这里无从判断你在不在看,所以不做这个区分;要清掉它,切走再切回来即可。
+- **已读记在每个浏览器自己身上**(localStorage):进过 = 处理过,刷新/重启不会"复活";装插件之前的历史结束也不算。
+- **可以要求"待够才算已读"**:设置页填一个秒数(默认 0)。填 0 = 进去就算已读(红点立即消失);填 N = 你要在那个会话里**连续待满 N 秒**它才算看过——中途切走、或它又跑完一轮,都清零重数,刷新页面也重新数。上限 600 秒。
 - 数据全部来自官方:`turn/end` 事件经官方 session projection 折叠,加上官方的"等待交互"注册表——**不依赖任何其他插件**。
 - 设置页的**数据来源**可以切到"手动测试",手填数字试看效果。
 - **工作区和会话行上的红点(实验)**:侧栏每个**工作区**那一行的文件夹图标右上角一个小红点,每个**有未读的会话**在标题右边跟一个小红点——一眼看出"事情在哪个工作区的哪个会话"。这一项是**贴着页面结构**做的——DSH 大版本升级后**可能失效**,失效时只会变成"不显示",**不影响**红点数字、清单和跳转;设置页里有一个开关可以随时关掉它。
-- **想知道具体是哪个会话?** 侧栏底部(设置按钮旁边)有一个**铃铛按钮**,上面带待处理数量;点开是待处理会话清单,**按工作区分组**(工作区名 · 会话名 · 在等你/刚结束),点其中一条**直接跳到那个会话**。侧栏折叠成竖条时只显示图标和数字。
+- **想知道具体是哪个会话?** 侧栏「工作区」标题的**右上角**有一个**红底数字**(没有待处理时是灰色 0,位置不变);点开是待处理会话清单,**按工作区分组**(工作区名 · 会话名 · 在等你/刚结束),点其中一条**直接跳到那个会话**。
 
 ## 支持的格式
 

package/client/client.js

@@ -62,7 +62,10 @@ window.__ModuleLoader__.load({
 			unreadPanelOther: "其他",
 			workspaceDotLabel: "在工作区和会话行上显示红点(实验)",
 			workspaceDotHint: "在侧栏工作区那一行的文件夹图标上点一个小红点。这一项是贴着页面结构做的,DSH 升级后可能失效;失效时只会变成\"不显示\",不会影响红点数字、清单、跳转这些功能,随时可以关掉它。",
-			badgeTestHint: "真实未读 = 有会话发生了上面勾选的情况、而且你还没看过它(打开该会话即视为已读)。正在看的会话和子代理不计。手动模式:自己填数字试看效果。刷新页面后回到真实未读。"
+			badgeTestHint: "真实未读 = 有会话发生了上面勾选的情况、而且你还没看过它(打开该会话即视为已读)。你正开着的会话也算——窗口可能被最小化、页面可能切到后台,这里无从判断你在不在看,所以不做这个区分。只有子代理不计。手动模式:自己填数字试看效果。刷新页面后回到真实未读。",
+			clearDelayLabel: "进入会话后多久算已读:",
+			clearDelayUnit: "秒",
+			clearDelayHint: "填 0 = 进去就算已读(红点立即消失)。大于 0 时,你要在那个会话里连续待满这么多秒它才算看过:中途切走、或它又跑完一轮,都会清零重数;刷新页面也重新数。上限 600 秒。"
 		};
 		const en = {
 			nav: "Favicon",
@@ -117,7 +120,10 @@ window.__ModuleLoader__.load({
 			unreadPanelOther: "Other",
 			workspaceDotLabel: "Dots on workspace and session rows (experimental)",
 			workspaceDotHint: "Adds a small red dot to the folder icon of each workspace row. This one reads the page structure, so a DSH upgrade may break it; when it does it simply stops showing, never affecting the counts, the list, or navigation. Turn it off any time.",
-			badgeTestHint: "Real unread = a session ended for one of the checked reasons and you have not looked at it yet (opening a session marks it read). The session you are viewing and sub-agents never count. Manual = type a number to preview. Resets to Real on reload."
+			badgeTestHint: "Real unread = a session ended for one of the checked reasons and you have not looked at it yet (opening a session marks it read). The session you are viewing counts too — the window may be minimised or the page in the background, so this half cannot tell whether you are looking, and does not pretend to. Only sub-agents never count. Manual = type a number to preview. Resets to Real on reload.",
+			clearDelayLabel: "Mark read after staying:",
+			clearDelayUnit: "seconds",
+			clearDelayHint: "0 = read as soon as you enter (the dot clears at once). Above 0 you must stay in that session for this many seconds before it counts as read: leaving it, or a fresh ending in it, resets the clock, and so does a reload. Capped at 600 seconds."
 		};
 		//#endregion
 
@@ -231,8 +237,18 @@ window.__ModuleLoader__.load({
 		};
 		/** Mirror of the host defaults; only used before the first status arrives. */
 		const UNREAD_FALLBACK_REASONS = { completed: true, error: true, blocked: true, "max-tokens": true, interrupted: true, "aborted:user": false, "aborted:other": true };
-		let unreadConfig = { reasons: { ...UNREAD_FALLBACK_REASONS }, pending: true, workspaceDot: true };
+		/** Mirror of the host's cap (see lib/unread.js) — 10 minutes. */
+		const UNREAD_CLEAR_DELAY_MAX_SEC = 600;
+		let unreadConfig = { reasons: { ...UNREAD_FALLBACK_REASONS }, pending: true, workspaceDot: true, clearDelaySec: 0 };
 		const unreadConfigListeners = new Set();
+		/** Mirror of the host's normalizer: any input becomes an integer 0..cap seconds. */
+		function normalizeClearDelay(input) {
+			const value = typeof input === "string" && input.trim() !== "" ? Number(input) : input;
+			if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+			const seconds = Math.floor(value);
+			if (seconds <= 0) return 0;
+			return Math.min(seconds, UNREAD_CLEAR_DELAY_MAX_SEC);
+		}
 		function normalizeUnreadConfig(input) {
 			const source = input !== null && typeof input === "object" ? input : {};
 			const raw = source.reasons !== null && typeof source.reasons === "object" ? source.reasons : {};
@@ -243,7 +259,8 @@ window.__ModuleLoader__.load({
 			return {
 				reasons,
 				pending: typeof source.pending === "boolean" ? source.pending : true,
-				workspaceDot: typeof source.workspaceDot === "boolean" ? source.workspaceDot : true
+				workspaceDot: typeof source.workspaceDot === "boolean" ? source.workspaceDot : true,
+				clearDelaySec: normalizeClearDelay(source.clearDelaySec)
 			};
 		}
 		function emitUnreadConfig(input) {
@@ -326,11 +343,41 @@ window.__ModuleLoader__.load({
 			}
 			return undefined;
 		}
+		/**
+		 * What the "stay here long enough" timer is armed for, or "" when nothing
+		 * should be armed.
+		 *
+		 * Keyed on the session's own `lastTurnEnd.endAt`, deliberately NOT on the
+		 * collected item's `at`: a "waiting for you" item carries `at: Date.now()`,
+		 * which changes on every evaluation — keying on that would tear the timer
+		 * down and re-arm it forever, and a waiting session could never be marked
+		 * read. Including `endAt` is also what makes a NEW ending restart the clock
+		 * instead of inheriting the previous one's progress.
+		 * @param sessionId - the session being viewed.
+		 * @param list - the session list snapshot.
+		 * @returns the key, or "" when there is no session to arm for.
+		 */
+		function stayKeyFor(sessionId, list) {
+			if (typeof sessionId !== "string" || sessionId === "") return "";
+			const byId = list !== null && typeof list === "object" && list.byId !== null && typeof list.byId === "object" ? list.byId : {};
+			const entry = byId[sessionId];
+			const values = entry !== null && typeof entry === "object" ? entry.projectionValues : undefined;
+			const value = values !== null && typeof values === "object" ? values[LAST_TURN_END_KEY] : undefined;
+			const endAt = value !== null && typeof value === "object" && typeof value.endAt === "number" ? value.endAt : 0;
+			return `${sessionId}\u0000${endAt}`;
+		}
 		/**
 		 * How many sessions deserve the badge right now: endings whose reason is
 		 * enabled and that this browser has not seen since, plus sessions waiting
-		 * for you (when that source is enabled). Sub-agent sessions and the session
-		 * you are looking at never count.
+		 * for you (when that source is enabled). Only sub-agent sessions never count.
+		 *
+		 * The session you are LOOKING AT counts too. It used to be excluded, on the
+		 * theory that "you have it open, so you have seen it" — but that premise is
+		 * not knowable from here: the window may be minimised, the tab may be in the
+		 * background, the page may be on another desktop. The browser half cannot
+		 * tell "watching" from "left open", and a rule that cannot tell two cases
+		 * apart should not pretend to: a session counts from the moment it ends until
+		 * it is opened again. Leaving and re-entering it is what clears the entry.
 		 * @param list - the session list snapshot (may be absent).
 		 * @param pending - the pending-interaction map (may be absent).
 		 * @param config - the unread rule to apply.
@@ -344,7 +391,6 @@ window.__ModuleLoader__.load({
 			/** { id, title, waiting, kind, at } — newest first, "in wait" ahead of "ended". */
 			const hits = [];
 			const ids = new Set();
-			const current = currentSessionId(list);
 			const byId = list !== null && typeof list === "object" && list.byId !== null && typeof list.byId === "object" ? list.byId : {};
 			const titleOf = (id, entry) => (entry !== null && typeof entry === "object" && typeof entry.displayTitle === "string" && entry.displayTitle !== "" ? entry.displayTitle : id);
 			// Which workspace the session lives in. The sidebar's own workspace rows are
@@ -363,7 +409,6 @@ window.__ModuleLoader__.load({
 					const entry = byId[id];
 					if (entry === null || typeof entry !== "object") continue;
 					if (entry.origin === "subagent") continue;
-					if (id === current) continue;
 					const values = entry.projectionValues;
 					const value = values !== null && typeof values === "object" ? values[LAST_TURN_END_KEY] : undefined;
 					if (value === null || typeof value !== "object") continue;
@@ -380,7 +425,6 @@ window.__ModuleLoader__.load({
 			if (config === null || typeof config !== "object" || config.pending !== false) {
 				if (pending !== null && pending !== undefined && typeof pending.forEach === "function") {
 					pending.forEach((value, id) => {
-						if (id === current) return;
 						const kind = value !== null && typeof value === "object" && typeof value.kind === "string" ? value.kind : "";
 						if (ids.has(id)) {
 							// Already unread by its last turn: it is waiting too, which wins.
@@ -987,13 +1031,26 @@ window.__ModuleLoader__.load({
 				pruneSeenState();
 				saveSeenState();
 			}, [list]);
-			// Looking at a session marks it seen; the count also excludes it outright.
 			const currentId = currentSessionId(list);
-			React.useEffect(() => {
-				if (noteSeen(currentId)) saveSeenState();
-			}, [currentId]);
 			const items = collectUnread(list, pending, config, seenState.seen);
 			const count = items.length;
+			// Being in a session is what marks it read — but only once you have STAYED
+			// `clearDelaySec` seconds (0 = the moment you enter, the original
+			// behaviour). The timer is torn down whenever you leave, or whenever that
+			// session becomes unread again from a fresh ending, so the clock restarts;
+			// that teardown IS the "continuous stay, leaving resets it" rule. A reload
+			// restarts it too, since the timer only lives in this page.
+			const currentUnread = items.some((item) => item.id === currentId);
+			const stayKey = currentUnread ? stayKeyFor(currentId, list) : "";
+			const delayMs = config.clearDelaySec * 1000;
+			const [, bumpStay] = React.useState(0);
+			React.useEffect(() => {
+				if (stayKey === "") return undefined;
+				const markRead = () => { if (noteSeen(currentId)) { saveSeenState(); bumpStay((n) => n + 1); } };
+				if (delayMs <= 0) { markRead(); return undefined; }
+				const timer = window.setTimeout(markRead, delayMs);
+				return () => window.clearTimeout(timer);
+			}, [stayKey, currentId, delayMs]);
 			React.useEffect(() => { emitRealBadge(count, items); }, [count, items]);
 			// The workspace rows are labelled with the workspace TITLE, which is not
 			// always the cwd basename, so map session → title from the official snapshot.
@@ -1369,6 +1426,11 @@ window.__ModuleLoader__.load({
 			const [badgeSourceValue, setBadgeSourceValue] = React.useState(badgeSource);
 			const [unread, setUnread] = React.useState(unreadConfig);
 			React.useEffect(() => subscribeUnreadConfig(setUnread), []);
+			// Draft text for the delay box: typing must not save on every keystroke,
+			// and the box has to show the CLAMPED value once the save lands (type
+			// 99999 and it settles on the 600 cap instead of lying about it).
+			const [clearDelayDraft, setClearDelayDraft] = React.useState(String(unreadConfig.clearDelaySec));
+			React.useEffect(() => { setClearDelayDraft(String(unread.clearDelaySec)); }, [unread.clearDelaySec]);
 			const inputRef = React.useRef(null);
 
 			const load = React.useCallback(async () => {
@@ -1426,28 +1488,35 @@ window.__ModuleLoader__.load({
 				setBadgeSourceValue(value);
 				emitBadgeSource(value);
 			}, []);
-			// Toggle one unread reason. Applies locally at once; the host keeps the
-			// durable copy so the rule survives a restart and other browsers.
-			const onUnreadToggle = React.useCallback((key, checked) => {
-				const current = unreadConfig;
-				const reasons = Object.assign({}, current.reasons);
-				let pending = current.pending;
-				if (key === "pending") pending = checked;
-				else reasons[key] = checked;
-				const next = normalizeUnreadConfig({ reasons, pending, workspaceDot: current.workspaceDot });
+			// One save path for the whole unread rule: the patch is merged onto the
+			// current config, so every field is carried over by construction. Letting
+			// each control build its own request is how a new field gets silently
+			// dropped by whichever caller forgot it.
+			const saveUnreadRule = React.useCallback((patch) => {
+				const next = normalizeUnreadConfig({ ...unreadConfig, ...patch });
 				emitUnreadConfig(next);
 				rpc.call("/api", "iconCustom/setUnreadRule", {
-					args: { request: { reasons: next.reasons, pending: next.pending, workspaceDot: next.workspaceDot } }
+					args: { request: { reasons: next.reasons, pending: next.pending, workspaceDot: next.workspaceDot, clearDelaySec: next.clearDelaySec } }
 				}).catch(() => {});
 			}, [rpc]);
+			// Toggle one unread reason. Applies locally at once; the host keeps the
+			// durable copy so the rule survives a restart and other browsers.
+			const onUnreadToggle = React.useCallback((key, checked) => {
+				if (key === "pending") { saveUnreadRule({ pending: checked }); return; }
+				const reasons = Object.assign({}, unreadConfig.reasons);
+				reasons[key] = checked;
+				saveUnreadRule({ reasons });
+			}, [saveUnreadRule]);
 			// The fuse for the one fragile piece (see the workspace-dots region).
 			const onWorkspaceDotToggle = React.useCallback((checked) => {
-				const next = normalizeUnreadConfig({ reasons: unreadConfig.reasons, pending: unreadConfig.pending, workspaceDot: checked });
-				emitUnreadConfig(next);
-				rpc.call("/api", "iconCustom/setUnreadRule", {
-					args: { request: { reasons: next.reasons, pending: next.pending, workspaceDot: next.workspaceDot } }
-				}).catch(() => {});
-			}, [rpc]);
+				saveUnreadRule({ workspaceDot: checked });
+			}, [saveUnreadRule]);
+			// Seconds you must stay in a session before it counts as read; 0 = as soon
+			// as you enter. Clamped by the shared normalizer, so a stray keystroke can
+			// never persist an absurd delay.
+			const onClearDelayChange = React.useCallback((value) => {
+				saveUnreadRule({ clearDelaySec: normalizeClearDelay(value) });
+			}, [saveUnreadRule]);
 			/** One unread checkbox; `key === "pending"` is the "someone is waiting" row. */
 			const renderReasonCheckbox = (key, labelKey) => React.createElement("label", {
 				key,
@@ -1683,6 +1752,22 @@ window.__ModuleLoader__.load({
 							renderReasonCheckbox("pending", "reasonPending")
 						)
 					),
+					React.createElement("div", { style: { marginTop: "12px" } },
+						React.createElement("div", { style: style.desc }, t("clearDelayLabel")),
+						React.createElement("label", { style: { display: "inline-flex", alignItems: "center", gap: "6px", marginTop: "6px", fontSize: 12, color: "var(--dsw-alias-label-primary)" } },
+							React.createElement("input", {
+								type: "number", min: 0, max: UNREAD_CLEAR_DELAY_MAX_SEC, step: 1, inputMode: "numeric",
+								"aria-label": t("clearDelayLabel"),
+								value: clearDelayDraft,
+								onChange: (event) => setClearDelayDraft(event.target.value),
+								onBlur: () => onClearDelayChange(clearDelayDraft),
+								onKeyDown: (event) => { if (event.key === "Enter") onClearDelayChange(clearDelayDraft); },
+								style: { width: "76px", padding: "3px 6px", border: "1px solid var(--dsw-alias-border-l2)", borderRadius: "6px", background: "transparent", color: "inherit", font: "inherit", fontSize: 12 }
+							}),
+							React.createElement("span", null, t("clearDelayUnit"))
+						),
+						React.createElement("div", { style: style.hint }, t("clearDelayHint"))
+					),
 					React.createElement("div", { style: { marginTop: "10px" } },
 						React.createElement("label", { style: { display: "inline-flex", alignItems: "center", gap: "6px", fontSize: 12, color: "var(--dsw-alias-label-primary)", cursor: "pointer" } },
 							React.createElement("input", {

package/lib/index.js

@@ -462,14 +462,14 @@ export class FaviconCustomService extends TypertRemoteService {
 	 * @returns `{ reasons, pending }`.
 	 */
 	async getUnreadRule() {
-		return { reasons: this.unread.reasons, pending: this.unread.pending, workspaceDot: this.unread.workspaceDot }
+		return { reasons: this.unread.reasons, pending: this.unread.pending, workspaceDot: this.unread.workspaceDot, clearDelaySec: this.unread.clearDelaySec }
 	}
 
 	/**
 	 * typert endpoint: replace the unread-badge rule — which turn-end reasons
 	 * light the badge. The rule is applied on the client, so this takes effect
 	 * without re-folding any session log.
-	 * @param request - `{ reasons, pending? }`; unknown or missing keys fall back to defaults.
+	 * @param request - `{ reasons, pending?, workspaceDot?, clearDelaySec? }`; unknown or missing keys fall back to defaults.
 	 * @returns the stored rule.
 	 */
 	async setUnreadRule(request) {
@@ -478,7 +478,7 @@ export class FaviconCustomService extends TypertRemoteService {
 		}
 		this.unread = normalizeUnreadConfig(request)
 		await this._saveUnread().catch(() => {}) // rule file is advisory
-		return { reasons: this.unread.reasons, pending: this.unread.pending, workspaceDot: this.unread.workspaceDot }
+		return { reasons: this.unread.reasons, pending: this.unread.pending, workspaceDot: this.unread.workspaceDot, clearDelaySec: this.unread.clearDelaySec }
 	}
 
 	/** typert endpoint: store a new icon uploaded as a data URL and make it active. */

package/lib/typert.host.js

@@ -52,13 +52,16 @@ const unreadRuleSchema = z.object({
 	reasons: z.record(z.string(), z.boolean()),
 	pending: z.boolean(),
 	/** 实验项:工作区图标上的红点(贴产品 DOM,可一键关闭)。 */
-	workspaceDot: z.boolean()
+	workspaceDot: z.boolean(),
+	/** 进入会话后要连续待满多少秒才算"看过";0 = 进入即已读。上限 10 分钟。 */
+	clearDelaySec: z.number().int().nonnegative().max(600)
 })
 
 const setUnreadRuleRequestSchema = z.object({
 	reasons: z.record(z.string(), z.boolean()),
 	pending: z.boolean().optional(),
-	workspaceDot: z.boolean().optional()
+	workspaceDot: z.boolean().optional(),
+	clearDelaySec: z.number().int().nonnegative().max(600).optional()
 })
 
 const setIconResultSchema = statusSchema
@@ -269,7 +272,7 @@ export const TYPERT = {
 					{
 						kind: 'method',
 						name: 'getUnreadRule',
-						signature: 'async getUnreadRule(): Promise<{ reasons: Record<string, boolean>; pending: boolean; workspaceDot: boolean }>',
+						signature: 'async getUnreadRule(): Promise<{ reasons: Record<string, boolean>; pending: boolean; workspaceDot: boolean; clearDelaySec: number }>',
 						description: "Read the unread-badge rule.",
 						summary: "Read the unread-badge rule.",
 						jsDoc: "/** Read the unread-badge rule. */",
@@ -278,7 +281,7 @@ export const TYPERT = {
 					{
 						kind: 'method',
 						name: 'setUnreadRule',
-						signature: 'async setUnreadRule(request: { reasons: Record<string, boolean>; pending?: boolean; workspaceDot?: boolean }): Promise<{ reasons: Record<string, boolean>; pending: boolean; workspaceDot: boolean }>',
+						signature: 'async setUnreadRule(request: { reasons: Record<string, boolean>; pending?: boolean; workspaceDot?: boolean; clearDelaySec?: number }): Promise<{ reasons: Record<string, boolean>; pending: boolean; workspaceDot: boolean; clearDelaySec: number }>',
 						description: "Replace the unread-badge rule: which turn-end reasons light the red dot.",
 						summary: "Set the unread-badge rule.",
 						jsDoc: "/** Set the unread-badge rule. */",

package/lib/unread.js

@@ -52,6 +52,29 @@ export const UNREAD_PENDING_DEFAULT = true
  */
 export const UNREAD_WORKSPACE_DOT_DEFAULT = true
 
+/**
+ * 默认:进入会话即视为已读(0 秒)。
+ * 大于 0 时,你必须在那个会话里**连续**待满这么多秒它才算"看过";中途切走会
+ * 清零重数。填 0 就是"不设置",行为跟没有这一项完全一样。
+ */
+export const UNREAD_CLEAR_DELAY_DEFAULT = 0
+
+/**
+ * 秒数上限:10 分钟。
+ * 挡住误填的大数(想填 5 却打成 50000)——那会让红点实际上永远清不掉,
+ * 而症状是"点进去也不消",很难联想到是这里填错了。
+ */
+export const UNREAD_CLEAR_DELAY_MAX_SEC = 600
+
+/** 把任意输入夹成 `0..上限` 的整数秒(小数向下取整,脏值回落默认)。 */
+export function normalizeClearDelay(input) {
+	const value = typeof input === 'string' && input.trim() !== '' ? Number(input) : input
+	if (typeof value !== 'number' || !Number.isFinite(value)) return UNREAD_CLEAR_DELAY_DEFAULT
+	const seconds = Math.floor(value)
+	if (seconds <= 0) return 0
+	return Math.min(seconds, UNREAD_CLEAR_DELAY_MAX_SEC)
+}
+
 /** 把任意输入夹成一张完整、只有布尔值的开关表(缺项取默认)。 */
 export function normalizeReasons(input) {
 	const out = {}
@@ -64,15 +87,16 @@ export function normalizeReasons(input) {
 
 /**
  * 把任意输入夹成完整设置。
- * @param input - `{ reasons?, pending? }`,可以是脏的、缺项的、null
- * @returns `{ reasons, pending }` —— 两张表都完整
+ * @param input - `{ reasons?, pending?, workspaceDot?, clearDelaySec? }`,可以是脏的、缺项的、null
+ * @returns `{ reasons, pending, workspaceDot, clearDelaySec }` —— 每一项都完整
  */
 export function normalizeUnreadConfig(input) {
 	const source = input !== null && typeof input === 'object' ? input : {}
 	return {
 		reasons: normalizeReasons(source.reasons),
 		pending: typeof source.pending === 'boolean' ? source.pending : UNREAD_PENDING_DEFAULT,
-		workspaceDot: typeof source.workspaceDot === 'boolean' ? source.workspaceDot : UNREAD_WORKSPACE_DOT_DEFAULT
+		workspaceDot: typeof source.workspaceDot === 'boolean' ? source.workspaceDot : UNREAD_WORKSPACE_DOT_DEFAULT,
+		clearDelaySec: normalizeClearDelay(source.clearDelaySec)
 	}
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cowwo/dsh-icon-custom",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "自定义浏览器标签页图标:在设置页上传 SVG/PNG/ICO,立即生效并持久保存,自动适配安卓/iOS/平板 PWA 图标。· Custom browser tab favicon: upload SVG/PNG/ICO from the settings page, applies instantly and persists, auto-sizes PWA icons for Android/iOS/tablets.",
   "type": "module",
   "main": "lib/index.js",