dsh-qoder-connect 0.2.1 → 0.2.3-alpha.1

package/lib/client.js

@@ -158,11 +158,11 @@ window.__ModuleLoader__.load({
 			global: void 0
 		};
 		/**
-		* Publish one variant's freshly fetched status document. Downstream
-		* subscribers (both sidebar cards and the dashboard, through whichever
-		* observable wraps this store) re-render on the revision bump.
+		* Store one variant's document and sign-in fact — the raw publish, with no
+		* sequence bookkeeping. Direct callers go through {@link noteQuotaStatus};
+		* read results go through {@link publishRead}.
 		*/
-		function noteQuotaStatus(variantId, status) {
+		function storeStatus(variantId, status) {
 			if (variantId === "qoder" && statusDocuments.cn !== status) {
 				statusDocuments.cn = status;
 				statusFetchedAt.cn = Date.now();
@@ -174,6 +174,16 @@ window.__ModuleLoader__.load({
 			}
 			noteQuotaSignIn(variantId, status.status === "signed-in");
 		}
+		/**
+		* Publish one variant's document as an AUTHORITATIVE fact: the host just
+		* answered a write, or a surface synthesized the outcome (clearing a PAT).
+		* It supersedes every read that started before it, so a response predating
+		* the write cannot roll the screen back.
+		*/
+		function noteQuotaStatus(variantId, status) {
+			storeStatus(variantId, status);
+			if (variantId === "qoder" || variantId === "qoder-global") publishedSeq[variantId] = readSeq[variantId];
+		}
 		/** Read one variant's latest status document. */
 		function quotaStatus(variantId) {
 			return variantId === "qoder" ? statusDocuments.cn : statusDocuments.global;
@@ -207,6 +217,186 @@ window.__ModuleLoader__.load({
 			if (fetchedAt === void 0 || document === void 0) return false;
 			return Date.now() - fetchedAt < maxAgeMs;
 		}
+		/** The last read failure per variant, cleared by the next successful read. */
+		const readFailures = {
+			qoder: void 0,
+			"qoder-global": void 0
+		};
+		/** Read one variant's last read failure, if the last read failed. */
+		function quotaReadFailure(variantId) {
+			return variantId === "qoder" ? readFailures.qoder : readFailures["qoder-global"];
+		}
+		/**
+		* Cadence an expanded card reads at — one request per variant per minute,
+		* whatever the number of cards showing it.
+		*/
+		const CARD_POLL_MS = 6e4;
+		/** The status route each variant polls (mirrors the host's locked route table). */
+		const STATUS_ROUTES = {
+			qoder: QODER_STATUS_PATH,
+			"qoder-global": QODER_GLOBAL_STATUS_PATH
+		};
+		/**
+		* Who needs a variant live. A `card` holder (an expanded settings card) reads
+		* every minute; a `surface` holder (an enabled sidebar card, an open quota
+		* panel) reads at the settings interval. A variant with any holder is read at
+		* the TIGHTEST cadence its holders ask for — an expanded card beside an
+		* enabled sidebar card costs ONE request a minute between them, not two.
+		*/
+		const demand = {
+			qoder: {
+				cards: 0,
+				surfaces: 0
+			},
+			"qoder-global": {
+				cards: 0,
+				surfaces: 0
+			}
+		};
+		/** The single ticker every holder shares; undefined while nothing is live. */
+		let ticker;
+		/**
+		* Read-start sequences per variant, and the sequence of the last PUBLISHED
+		* read. A read publishes only when no later-started read has published yet,
+		* so a response that predates a newer one can never roll the screen back —
+		* the guard the per-card `readSeq` used to provide, now shared across every
+		* surface of the variant.
+		*/
+		const readSeq = {
+			qoder: 0,
+			"qoder-global": 0
+		};
+		const publishedSeq = {
+			qoder: 0,
+			"qoder-global": 0
+		};
+		/** Whether the page is visible; a hidden page reads nothing and catches up on return. */
+		function pageHidden() {
+			return typeof document !== "undefined" && document.hidden === true;
+		}
+		/**
+		* Publish one read's outcome under the sequence guard: a read publishes only
+		* when no read that started later has published yet, so a response that
+		* predates a newer one — whichever surface started it — can never roll the
+		* screen back.
+		*/
+		function publishRead(variantId, seq, outcome) {
+			if (seq <= publishedSeq[variantId]) return;
+			if ("doc" in outcome) {
+				storeStatus(variantId, outcome.doc);
+				publishReadFailure(variantId, void 0);
+			} else publishReadFailure(variantId, outcome.failure);
+			publishedSeq[variantId] = seq;
+		}
+		/** Publish (or clear) one variant's read failure; identity-stable between changes. */
+		function publishReadFailure(variantId, failure) {
+			const previous = readFailures[variantId];
+			if (previous === failure) return;
+			if (previous !== void 0 && failure !== void 0 && previous.kind === failure.kind && (previous.kind !== "transport" || failure.kind !== "transport" || previous.message === failure.message)) return;
+			readFailures[variantId] = failure;
+			bump();
+		}
+		/** A 200 whose body is not a status document — reported as `invalid`, not as a transport failure. */
+		var InvalidStatusDocumentError = class extends Error {};
+		/**
+		* Fetch one variant's status document and publish it (or its failure) for
+		* every surface. The request is never shared with another read: a tick reads
+		* each live variant once, and an explicit read must be able to postdate a
+		* write, so it starts its own request.
+		*
+		* @returns the published document, or undefined when the read failed.
+		*/
+		async function readVariant(variantId) {
+			const seq = ++readSeq[variantId];
+			try {
+				const response = await fetch(STATUS_ROUTES[variantId], {
+					headers: { accept: "application/json" },
+					credentials: "same-origin"
+				});
+				const body = await response.json().catch(() => void 0);
+				if (!response.ok) throw new Error(`HTTP ${response.status}`);
+				if (!isQoderWebStatus(body)) throw new InvalidStatusDocumentError();
+				publishRead(variantId, seq, { doc: body });
+				return body;
+			} catch (error) {
+				publishRead(variantId, seq, { failure: error instanceof InvalidStatusDocumentError ? { kind: "invalid" } : {
+					kind: "transport",
+					message: error instanceof Error ? error.message : "request failed"
+				} });
+				return;
+			}
+		}
+		/** Whether a variant is due for its next read: held at all, past its cadence, and not parked signed-out. */
+		function dueForRead(variantId) {
+			const holders = demand[variantId];
+			if (holders.cards === 0 && holders.surfaces === 0) return false;
+			if (holders.cards > 0 && holders.surfaces === 0 && quotaStatus(variantId)?.status === "signed-out") return false;
+			if (holders.cards > 0) return true;
+			return !quotaStatusIsFresh(variantId, Math.max(CARD_POLL_MS, pollIntervalMs));
+		}
+		/** One tick: read every variant that is due, once, whatever the number of holders. */
+		function tickQuotaPoll() {
+			if (pageHidden()) return;
+			for (const variantId of ["qoder", "qoder-global"]) if (dueForRead(variantId)) readVariant(variantId);
+		}
+		function startTicker() {
+			if (ticker !== void 0) return;
+			ticker = window.setInterval(tickQuotaPoll, CARD_POLL_MS);
+			if (typeof document !== "undefined") document.addEventListener("visibilitychange", tickQuotaPoll);
+		}
+		function stopTicker() {
+			if (ticker === void 0) return;
+			window.clearInterval(ticker);
+			ticker = void 0;
+			if (typeof document !== "undefined") document.removeEventListener("visibilitychange", tickQuotaPoll);
+		}
+		/** Record one holder of `kind` and start the shared ticker when it is the first. */
+		function addHolder(variantId, kind) {
+			const holders = demand[variantId];
+			holders[kind] += 1;
+			if (holders.cards + holders.surfaces === 1) startTicker();
+		}
+		/** Drop one holder and stop the shared ticker when nothing is live any more. */
+		function removeHolder(variantId, kind) {
+			const holders = demand[variantId];
+			holders[kind] = Math.max(0, holders[kind] - 1);
+			if (demand.qoder.cards + demand.qoder.surfaces === 0 && demand["qoder-global"].cards + demand["qoder-global"].surfaces === 0) stopTicker();
+		}
+		/** Sync the holder count with the ticker, reading at once when the document is due. */
+		function acquire(variantId, kind) {
+			const readNow = !quotaStatusIsFresh(variantId, kind === "cards" ? CARD_POLL_MS : Math.max(CARD_POLL_MS, pollIntervalMs));
+			addHolder(variantId, kind);
+			if (readNow) readVariant(variantId);
+			return () => {
+				removeHolder(variantId, kind);
+			};
+		}
+		/**
+		* Acquire one variant as an EXPANDED CARD shows it: reads every minute while
+		* any card holds it, stops on a signed-out document (nothing changes without
+		* a PAT). The release disposer belongs to the card's effect lifetime.
+		*/
+		function acquireLiveCard(variantId) {
+			return acquire(variantId, "cards");
+		}
+		/**
+		* Acquire one variant as a CADENCE-BOUND SURFACE shows it (an enabled sidebar
+		* card, an open quota panel): reads at the settings interval, whatever the
+		* sign-in state. The release disposer belongs to the surface's lifetime.
+		*/
+		function acquireLiveSurface(variantId) {
+			return acquire(variantId, "surfaces");
+		}
+		/**
+		* Force one shared read now. The explicit path — a manual refresh, or the
+		* re-read that follows a write — always starts its own request, so its answer
+		* can postdate the write that preceded it.
+		*
+		* @returns whether the read produced a document.
+		*/
+		function refreshQuotaStatus(variantId) {
+			return readVariant(variantId).then((doc) => doc !== void 0);
+		}
 		//#endregion
 		//#region src/client/QuotaSettingsCard.tsx
 		/**
@@ -706,7 +896,6 @@ window.__ModuleLoader__.load({
 		};
 		/** Both cards, in display order (China first). */
 		const QODER_CARD_VARIANTS = [QODER_CN_CARD, QODER_GLOBAL_CARD];
-		const POLL_INTERVAL_MS = 6e4;
 		const cardStyle = {
 			listStyle: "none",
 			borderWidth: "0.5px",
@@ -1584,18 +1773,15 @@ window.__ModuleLoader__.load({
 		}
 		/** Render Qoder PAT state, quota, catalog, and context capacities as one expandable card. */
 		function QoderPluginCard(props) {
-			const { t, scope, signedIn, variant, unified } = props;
+			const { t, scope, signedIn, variant, unified, defaultOpen } = props;
 			if (t === void 0) throw new Error("Qoder plugin card requires its translation function");
 			const isUnified = unified === true;
 			const liveSignIn = (0, react.useSyncExternalStore)(onQuotaSettingsChange, quotaSignInState);
 			const [activeVariantId, setActiveVariantId] = (0, react.useState)("qoder");
 			const currentVariant = isUnified ? activeVariantId === "qoder" ? QODER_CN_CARD : QODER_GLOBAL_CARD : variant ?? QODER_CN_CARD;
-			const [open, setOpen] = (0, react.useState)(false);
+			const [open, setOpen] = (0, react.useState)(defaultOpen === true);
 			const [hovered, setHovered] = (0, react.useState)(false);
 			const [headerFocused, setHeaderFocused] = (0, react.useState)(false);
-			const [status, setStatus] = (0, react.useState)();
-			const [signedInState, setSignedInState] = (0, react.useState)();
-			const [readFailure, setReadFailure] = (0, react.useState)();
 			const [busy, setBusy] = (0, react.useState)(false);
 			const [patDraft, setPatDraft] = (0, react.useState)("");
 			const [replacing, setReplacing] = (0, react.useState)(false);
@@ -1607,8 +1793,9 @@ window.__ModuleLoader__.load({
 			const [checkingIn, setCheckingIn] = (0, react.useState)(false);
 			const [clearingLogs, setClearingLogs] = (0, react.useState)(false);
 			const [checkInNotice, setCheckInNotice] = (0, react.useState)();
+			/** A write action's failure, reported on the same line as a read failure. */
+			const [writeFailure, setWriteFailure] = (0, react.useState)();
 			const mounted = (0, react.useRef)(true);
-			const readSeq = (0, react.useRef)(0);
 			const manualControllers = (0, react.useRef)(/* @__PURE__ */ new Set());
 			(0, react.useEffect)(() => {
 				mounted.current = true;
@@ -1623,83 +1810,70 @@ window.__ModuleLoader__.load({
 				manualControllers.current.add(controller);
 				return controller;
 			}, []);
+			/**
+			* The shown variant's shared read state.
+			*
+			* The document and the last read failure arrive through ONE revision bump,
+			* whichever surface read them: the shared poller reads each live variant
+			* once for every surface that shows it, so this card expanded here and the
+			* same card in the plugin-manager panel cost one request a minute between
+			* them, not two. Before the first document lands a failed read shows as an
+			* error document; beside a document already on screen it shows as a notice
+			* under the account row, exactly as the per-card fetch did.
+			*/
+			(0, react.useSyncExternalStore)(onQuotaSettingsChange, quotaSettingsRevision);
+			const readFailure = quotaReadFailure(currentVariant.id);
+			const sharedDocument = quotaStatus(currentVariant.id);
+			const status = readFailure !== void 0 && sharedDocument === void 0 ? {
+				status: "error",
+				message: readFailure.kind === "invalid" ? t("statusResponseInvalid") : readFailure.message
+			} : sharedDocument;
+			const signedInState = status?.status === "signed-in" ? true : status?.status === "signed-out" ? false : void 0;
 			const authKey = status === void 0 || status.status === "error" ? void 0 : status.authKey;
-			const refresh = (0, react.useCallback)(async (signal) => {
-				const seq = ++readSeq.current;
-				const current = () => mounted.current && signal?.aborted !== true && seq === readSeq.current;
-				try {
-					const response = await fetch(currentVariant.statusPath, {
-						headers: { accept: "application/json" },
-						credentials: "same-origin",
-						...signal === void 0 ? {} : { signal }
-					});
-					const value = await response.json().catch(() => void 0);
-					if (!response.ok) throw new Error(`HTTP ${response.status}`);
-					if (!isQoderWebStatus(value)) throw new Error(t("statusResponseInvalid"));
-					if (!current()) return false;
-					setStatus(value);
-					if (value.status === "signed-in") {
-						setSignedInState(true);
-						noteQuotaStatus(currentVariant.id, value);
-					} else if (value.status === "signed-out") {
-						setSignedInState(false);
-						noteQuotaStatus(currentVariant.id, value);
-					}
-					setReadFailure(void 0);
-					return true;
-				} catch (error) {
-					const message = error instanceof Error ? error.message : t("requestFailed");
-					if (current()) {
-						setReadFailure(message);
-						setStatus((previous) => previous === void 0 ? {
-							status: "error",
-							message
-						} : previous);
-					}
-					return false;
-				}
-			}, [currentVariant.statusPath, t]);
+			/**
+			* Force one shared read of the shown variant.
+			*
+			* The store's read always starts its own request — an explicit read must be
+			* able to postdate the write or the click that precedes it — and publishes
+			* for every surface of the variant, so a manual refresh here updates the
+			* sidebar cards and the quota panel too. A successful read also clears a
+			* write action's notice, exactly as the per-card fetch did.
+			*/
+			const refresh = (0, react.useCallback)(async () => {
+				const ok = await refreshQuotaStatus(currentVariant.id);
+				if (ok) setWriteFailure(void 0);
+				return ok;
+			}, [currentVariant.id]);
+			/**
+			* The expanded card is a poll holder of the shown variant.
+			*
+			* The shared ticker reads the variant once a minute while any card holds it
+			* and parks it on a signed-out document (nothing changes without a PAT);
+			* collapsing or unmounting releases the demand. Opening re-reads at once
+			* only when the shared document is past its minute — a second card opening
+			* beside a live one shows the numbers already on screen.
+			*/
+			(0, react.useEffect)(() => {
+				if (!open) return void 0;
+				return acquireLiveCard(currentVariant.id);
+			}, [open, currentVariant.id]);
+			/**
+			* Opening (or switching variant) clears the transient entry state — a
+			* discarded draft must not wait for the user on the next open. The document
+			* itself is shared state now and stays on screen while the card re-opens.
+			*/
 			(0, react.useEffect)(() => {
 				if (!open) return;
-				setStatus(void 0);
-				setSignedInState(void 0);
-				setReadFailure(void 0);
 				setPatDraft("");
 				setReplacing(false);
 				setPatError(void 0);
 				setPatNotice(void 0);
-				const controller = new AbortController();
-				refresh(controller.signal);
-				return () => {
-					controller.abort();
-				};
-			}, [
-				open,
-				currentVariant.statusPath,
-				refresh
-			]);
-			(0, react.useEffect)(() => {
-				if (!open || signedInState === false) return;
-				const controller = new AbortController();
-				const timer = window.setInterval(() => {
-					refresh(controller.signal);
-				}, POLL_INTERVAL_MS);
-				return () => {
-					window.clearInterval(timer);
-					controller.abort();
-				};
-			}, [
-				open,
-				refresh,
-				signedInState
-			]);
+			}, [open, currentVariant.id]);
 			const manualRefresh = async () => {
 				setBusy(true);
-				const controller = trackController();
 				try {
-					await refresh(controller.signal);
+					await refresh();
 				} finally {
-					manualControllers.current.delete(controller);
 					if (mounted.current) setBusy(false);
 				}
 			};
@@ -1729,14 +1903,14 @@ window.__ModuleLoader__.load({
 					});
 					if (!response.ok) throw new Error(`HTTP ${response.status}`);
 				} catch (error) {
-					if (mounted.current && controller.signal.aborted !== true) setReadFailure(error instanceof Error ? error.message : t("requestFailed"));
+					if (mounted.current && controller.signal.aborted !== true) setWriteFailure(error instanceof Error ? error.message : t("requestFailed"));
 					manualControllers.current.delete(controller);
 					return;
 				} finally {
 					if (mounted.current) setBusy(false);
 				}
 				try {
-					await refresh(controller.signal);
+					await refresh();
 				} finally {
 					manualControllers.current.delete(controller);
 				}
@@ -1777,7 +1951,7 @@ window.__ModuleLoader__.load({
 					if (mounted.current) setCheckingIn(false);
 				}
 				try {
-					await refresh(controller.signal);
+					await refresh();
 				} finally {
 					manualControllers.current.delete(controller);
 				}
@@ -1813,7 +1987,7 @@ window.__ModuleLoader__.load({
 					if (mounted.current) setClearingLogs(false);
 				}
 				try {
-					await refresh(controller.signal);
+					await refresh();
 				} finally {
 					manualControllers.current.delete(controller);
 				}
@@ -1856,9 +2030,9 @@ window.__ModuleLoader__.load({
 						const reason = typeof value === "object" && value !== null && "reason" in value ? String(value["reason"]) : t("requestFailed");
 						throw new Error(reason);
 					}
-					await refresh(controller.signal);
+					await refresh();
 				} catch (error) {
-					if (mounted.current && controller.signal.aborted !== true) setReadFailure(error instanceof Error ? error.message : t("requestFailed"));
+					if (mounted.current && controller.signal.aborted !== true) setWriteFailure(error instanceof Error ? error.message : t("requestFailed"));
 				} finally {
 					manualControllers.current.delete(controller);
 					if (mounted.current) setBusy(false);
@@ -1916,7 +2090,7 @@ window.__ModuleLoader__.load({
 					setReplacing(false);
 					setPatNotice(t("patSaved"));
 					noteQuotaSignIn(currentVariant.id, true);
-					await refresh(controller.signal);
+					await refresh();
 				} catch (error) {
 					if (mounted.current && controller.signal.aborted !== true) setPatError(t("patSaveFailed", { message: error instanceof Error ? error.message : t("requestFailed") }));
 				} finally {
@@ -1960,15 +2134,11 @@ window.__ModuleLoader__.load({
 						return;
 					}
 					setPatDraft("");
-					const signedOutDoc = {
+					noteQuotaStatus(currentVariant.id, {
 						status: "signed-out",
 						authKey: key
-					};
-					setStatus(signedOutDoc);
-					setSignedInState(false);
-					noteQuotaStatus(currentVariant.id, signedOutDoc);
-					noteQuotaSignIn(currentVariant.id, false);
-					await refresh(controller.signal);
+					});
+					await refresh();
 				} catch (error) {
 					if (mounted.current && controller.signal.aborted !== true) setPatError(t("patSaveFailed", { message: error instanceof Error ? error.message : t("requestFailed") }));
 				} finally {
@@ -2208,9 +2378,9 @@ window.__ModuleLoader__.load({
 								})] })
 							]
 						}),
-						readFailure === void 0 || signedInState === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						readFailure === void 0 && writeFailure === void 0 || signedInState === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
 							style: errorStyle,
-							children: t("statusRefreshFailed", { message: readFailure })
+							children: t("statusRefreshFailed", { message: readFailure !== void 0 ? readFailure.kind === "invalid" ? t("statusResponseInvalid") : readFailure.message : writeFailure })
 						}),
 						status?.status === "signed-in" ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
 							status.pat === void 0 ? null : patSummaryLine(status.pat),
@@ -3032,9 +3202,11 @@ window.__ModuleLoader__.load({
 		* row, and opens a dashboard in the layout's keyed `main` slot on click. In
 		* the 56px rail it collapses to a 36px icon button carrying the ring.
 		*
-		* Data comes from the variant's status route (poll, paused while hidden);
-		* strings come from the `panel.qoder-quota` locale namespace; classes come
-		* from `./quota-styles.ts` (`qdp-` prefix).
+		* Data comes from the shared status store: the card acquires its variant and
+		* the store's ONE ticker reads each live variant once for every surface
+		* (this card, the settings cards, the dashboard), paused while the page is
+		* hidden; strings come from the `panel.qoder-quota` locale namespace; classes
+		* come from `./quota-styles.ts` (`qdp-` prefix).
 		*/
 		/** Fallback translator: renders keys bare rather than throwing unbound. */
 		const fallbackT = (key) => key;
@@ -3138,51 +3310,14 @@ window.__ModuleLoader__.load({
 			const variantId = statusPath !== void 0 ? variantOfStatusPath(statusPath) : "qoder";
 			const nameKey = variantId === "qoder-global" ? "quotaCardGlobal" : "quotaCardCN";
 			const wide = props.wide !== false;
-			const [failed, setFailed] = (0, react.useState)(false);
 			(0, react.useSyncExternalStore)(onQuotaSettingsChange, quotaSettingsRevision);
 			const enabled = variantId === "qoder" ? quotaToggles().cn : quotaToggles().global;
+			const failed = quotaReadFailure(variantId) !== void 0;
 			const status = quotaStatus(variantId);
 			const signedIn = status?.status === "signed-in";
 			(0, react.useEffect)(() => {
 				if (statusPath === void 0 || !enabled) return void 0;
-				let disposed = false;
-				let timer;
-				const controller = new AbortController();
-				const refresh = async () => {
-					try {
-						const response = await fetch(statusPath, {
-							signal: controller.signal,
-							headers: { accept: "application/json" }
-						});
-						const body = await response.json();
-						if (disposed) return;
-						if (!response.ok || !isQoderWebStatus(body)) {
-							setFailed(true);
-							return;
-						}
-						setFailed(false);
-						noteQuotaStatus(variantId, body);
-					} catch {
-						if (!disposed) setFailed(true);
-					}
-				};
-				const isHidden = () => typeof document !== "undefined" && document.hidden;
-				const loop = () => {
-					if (isHidden()) return;
-					refresh();
-				};
-				timer = window.setInterval(loop, Math.max(6e4, quotaPollMs()));
-				refresh();
-				const onVisible = () => {
-					if (!isHidden()) loop();
-				};
-				if (typeof document !== "undefined") document.addEventListener("visibilitychange", onVisible);
-				return () => {
-					disposed = true;
-					controller.abort();
-					if (timer !== void 0) window.clearInterval(timer);
-					if (typeof document !== "undefined") document.removeEventListener("visibilitychange", onVisible);
-				};
+				return acquireLiveSurface(variantId);
 			}, [
 				statusPath,
 				enabled,
@@ -3301,10 +3436,11 @@ window.__ModuleLoader__.load({
 		* pattern): CN and international are separate accounts with separate package
 		* lists, so mixing them into one column would misattribute every number.
 		*
-		* The panel fetches BOTH routes itself on mount and on the shared poll
-		* interval — a user opening the panel must never wait for the sidebar cards'
-		* next tick, and must never see a stale "sign in" just because no poll had
-		* run yet. The tab defaults to the variant whose card was clicked.
+		* The panel holds its shown variant live through the shared store — it reads
+		* at once on open (unless the shared document is still within the settings
+		* interval, which a click then shows as cached numbers) and the shared ticker
+		* keeps it current from then on, so a user opening the panel never waits for
+		* a poll and never meets a stale "sign in" because nothing had read yet.
 		*/
 		function QuotaDashboard(props) {
 			const { t = fallbackT, statusPaths, refresh, close, useQuotaDashboard, onVariantPicked } = props;
@@ -3316,7 +3452,7 @@ window.__ModuleLoader__.load({
 			const activeVariant = variantOfStatusPath(activePathResolved);
 			const status = quotaStatus(activeVariant);
 			const loading = state.loading;
-			const fetchedAt = state.fetchedAt;
+			const fetchedAt = quotaStatusFetchedAt(activeVariant);
 			const credits = status !== void 0 && "credits" in status ? status.credits : void 0;
 			const rows = credits === void 0 ? [] : buildPackageRows(credits.accounts ?? []);
 			const nameKey = activeVariant === "qoder-global" ? "quotaCardGlobal" : "quotaCardCN";
@@ -4078,6 +4214,20 @@ window.__ModuleLoader__.load({
 		/** The shared block's title, fixed by the contract so all three plugins agree. */
 		const SHARED_SECTION_LABEL = "插件设置";
 		/**
+		* The plugin manager's bundle-configuration seat and this bundle's key in it.
+		*
+		* The sidebar's Plugins panel (the `plugins` main panel the Host's plugin
+		* manager registers) renders one bundle's own configuration on the bundle's
+		* detail page — between the description and the component rows — through the
+		* `plugins.bundle.config` keyed slot, keyed by the bundle's npm package name.
+		* The key is what the page's configuration ledger reads to decide whether the
+		* configuration section shows at all, so it must spell this package's name
+		* exactly; the slot itself is declared by the Host (see
+		* `plugin-manager-slots.ts` for the structural restatement).
+		*/
+		const PLUGIN_MANAGER_SLOT = "plugins.bundle.config";
+		const PLUGIN_MANAGER_KEY = "dsh-qoder-connect";
+		/**
 		* The shared 《插件设置》 section the 0.1.7 card list lives in.
 		*
 		* It renders nothing but its child slot: every connect plugin contributes its
@@ -4102,7 +4252,8 @@ window.__ModuleLoader__.load({
 		}
 		/**
 		* Register card copy, the shared quota-settings card, the two variant cards,
-		* and the sidebar quota cards.
+		* the sidebar quota cards, and the same unified card on this bundle's page in
+		* the sidebar's Plugins panel.
 		*
 		* The entire body is wrapped so that a DSH slot-API breaking change (for
 		* example the rc.6→rc.7 `id`→`key` / `order`→`priority` rename) degrades
@@ -4157,20 +4308,27 @@ window.__ModuleLoader__.load({
 					applySnapshot();
 					scope.subscribe(applySnapshot);
 				};
-				const registerUnifiedCard = () => {
-					const inject = () => ({
-						t,
-						scope: quotaScope,
-						signedIn: () => quotaSignInState(),
-						unified: true
-					});
-					return ctx.slots.inject(SHARED_ITEM_SLOT, () => ctx.slots.register({
-						name: SHARED_ITEM_SLOT,
-						id: SHARED_ITEM_ID,
-						order: 30,
-						inject
-					}, QoderPluginCard));
-				};
+				/**
+				* The unified card's inject face, shared by its two surfaces: the shared
+				* 《插件设置》 block and this bundle's own page in the sidebar's Plugins
+				* panel. One face keeps both cards reading the same live values — the same
+				* scope, the same sign-in fact, the same `unified` layout — so a save on
+				* either surface is a save for both. The Plugins-panel registration opens
+				* the card at once; the settings block lists it collapsed.
+				*/
+				const unifiedCardInject = (defaultOpen = false) => ({
+					t,
+					signedIn: () => quotaSignInState(),
+					scope: quotaScope,
+					unified: true,
+					defaultOpen
+				});
+				const registerUnifiedCard = () => ctx.slots.inject(SHARED_ITEM_SLOT, () => ctx.slots.register({
+					name: SHARED_ITEM_SLOT,
+					id: SHARED_ITEM_ID,
+					order: 30,
+					inject: unifiedCardInject
+				}, QoderPluginCard));
 				/**
 				* Attach this plugin's card to the shared 《插件设置》 block, building the
 				* block first if nobody has.
@@ -4209,6 +4367,33 @@ window.__ModuleLoader__.load({
 					});
 				};
 				/**
+				* Contribute the same unified card to this bundle's page in the sidebar's
+				* Plugins panel, beside its enable switch and component rows.
+				*
+				* `ctx.slots.inject` defers the factory until the Host's plugin manager
+				* declares the seat (its `main` registration commits the child table), so
+				* a deployment that ships no plugin manager — or loads it after this
+				* bundle — never throws: the callback simply never runs, and the shared
+				* 《插件设置》 block stays the single surface, exactly as before. The
+				* keyed key is this package's name, the same key the page's configuration
+				* ledger reads to decide whether the configuration section shows.
+				*
+				* Its own boundary mirrors the dashboard and footer-card ones: a slot-API
+				* breaking change degrades to a console.error instead of taking the
+				* settings block or the model channel with it.
+				*/
+				const joinPluginManagerBlock = () => {
+					try {
+						ctx.slots.inject(PLUGIN_MANAGER_SLOT, () => ctx.slots.register({
+							name: PLUGIN_MANAGER_SLOT,
+							key: PLUGIN_MANAGER_KEY,
+							inject: () => unifiedCardInject(true)
+						}, QoderPluginCard));
+					} catch (error) {
+						console.error("[dsh-qoder-connect] could not join the plugin manager page:", error);
+					}
+				};
+				/**
 				* 插件自有配置（`<profile>/.dsh-qoder-connect/settings.json`）：两条宿主线的
 				* 读写都走宿主半的 settings face，不再经过 settingsScope / configForms。
 				*
@@ -4220,13 +4405,9 @@ window.__ModuleLoader__.load({
 				ownQuotaScope.load();
 				adoptQuotaScope(ownQuotaScope);
 				joinSharedSettingsBlock();
+				joinPluginManagerBlock();
 				const QUOTA_PANEL_ID = "qoder-quota-panel";
 				const CONVERSATION_PANEL_ID = "conversation";
-				const dashboardDocuments = {
-					cn: void 0,
-					global: void 0
-				};
-				let dashboardFetchedAt;
 				let dashboardLoading = false;
 				let dashboardRequestedPath = QODER_STATUS_PATH;
 				/** Whether the dashboard is the CURRENT center panel (its mount owns this). */
@@ -4250,15 +4431,11 @@ window.__ModuleLoader__.load({
 				* mutator builds the next snapshot and publishes exactly once.
 				*/
 				let dashboardSnap = {
-					documents: [void 0, void 0],
-					fetchedAt: void 0,
 					loading: false,
 					activePath: QODER_STATUS_PATH
 				};
 				const rebuildSnapshot = () => {
 					const next = {
-						documents: [dashboardDocuments.cn, dashboardDocuments.global],
-						fetchedAt: dashboardFetchedAt,
 						loading: dashboardLoading,
 						activePath: dashboardRequestedPath
 					};
@@ -4291,6 +4468,12 @@ window.__ModuleLoader__.load({
 				* variant with NO result yet always fetches. A manual Refresh click
 				* (force=true) bypasses the freshness check: an explicit user action
 				* always re-reads.
+				*
+				* The read itself is the SHARED one: it publishes through the store's
+				* sequence guard, so this panel, the sidebar cards and the settings cards
+				* converge on the same document — and a settings card polling the variant
+				* already keeps this panel current, which is why the panel no longer
+				* keeps a timer of its own.
 				*/
 				const refreshDashboard = async (options = {}) => {
 					if (dashboardLoading) return;
@@ -4299,44 +4482,36 @@ window.__ModuleLoader__.load({
 					dashboardLoading = true;
 					rebuildSnapshot();
 					try {
-						const result = await fetchStatusDocument(variantId === "qoder" ? QODER_STATUS_PATH : QODER_GLOBAL_STATUS_PATH);
-						if (result !== void 0) noteQuotaStatus(variantId, result);
-						dashboardFetchedAt = Date.now();
+						await refreshQuotaStatus(variantId);
 					} finally {
 						dashboardLoading = false;
 						rebuildSnapshot();
 					}
 				};
-				let dashboardTimer;
-				const startDashboardPoll = () => {
-					if (dashboardTimer !== void 0) return;
-					refreshDashboard();
-					dashboardTimer = window.setInterval(() => {
-						if (document.hidden) return;
-						refreshDashboard();
-					}, Math.max(6e4, quotaPollMs()));
+				/**
+				* The panel's hold on its shown variant. The hold is what keeps the
+				* variant live: the shared ticker reads it at the settings interval while
+				* the panel stands — the cadence the panel's own timer used to keep — and
+				* an expanded settings card beside it tightens the read to once a minute.
+				* A variant switch moves the hold to the newly shown variant.
+				*/
+				let dashboardHold;
+				const holdDashboardVariant = (path) => {
+					dashboardHold?.();
+					dashboardHold = acquireLiveSurface(variantOfStatusPath(path));
 				};
-				const stopDashboardPoll = () => {
-					if (dashboardTimer === void 0) return;
-					window.clearInterval(dashboardTimer);
-					dashboardTimer = void 0;
+				const releaseDashboardVariant = () => {
+					dashboardHold?.();
+					dashboardHold = void 0;
 				};
-				async function fetchStatusDocument(path) {
-					try {
-						const response = await fetch(path, { headers: { accept: "application/json" } });
-						const body = await response.json();
-						return response.ok && isQoderWebStatus(body) ? body : void 0;
-					} catch {
-						return;
-					}
-				}
 				function QuotaDashboardWithLifecycle(props) {
 					(0, react.useEffect)(() => {
 						quotaPanelOpen = true;
-						startDashboardPoll();
+						holdDashboardVariant(dashboardRequestedPath);
+						refreshDashboard();
 						return () => {
 							quotaPanelOpen = false;
-							stopDashboardPoll();
+							releaseDashboardVariant();
 						};
 					}, []);
 					return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(QuotaDashboard, { ...props });
@@ -4350,6 +4525,7 @@ window.__ModuleLoader__.load({
 					},
 					onVariantPicked: (path) => {
 						dashboardRequestedPath = path;
+						holdDashboardVariant(path);
 						notifyDashboard();
 						refreshDashboard();
 					},