@lmzhen/dsh-evolution-settings-ui 0.17.0 → 0.18.0

package/README.md

@@ -42,18 +42,70 @@ Its states are deliberately distinct: **reading** ("正在读取待批项…"),
 **failed** (the reason plus a retry). Merging the first two is what once made a slow answer read as lost data
 (E7), so the state machine lives in `pending-state.ts` and the three are asserted without a browser.
 
+It reads BOTH windows the route serves — `?status=pending` and `?status=executing` — and orders them the way
+the CLI does. A record stuck in `executing` (an approve that died between the claim and the decision, or
+another process running it) is NOT waiting for a decision: its row carries no approve/reject pair, says the
+write may already have landed, and the header counts it apart ("{n} 项执行中"). Reading only the pending window
+is what made such a record invisible here while `/evolution pending` and doctor both listed it.
+
+The card re-reads the window on demand: a **refresh** control in the body and a window `focus`. It reads once
+per mount otherwise — deliberately no timer, since the family has no polling precedent — because an agent can
+stage a write while the reader is looking at the card, and the empty sentence standing there afterwards is the
+"empty vs. actually something" lie.
+
 A decision re-reads the window instead of editing the list locally (the host owns the state) and shows the
-host's own sentence when it refuses. **Preview** opens one row at a time: the facts line (`n 行新增` /
+host's own sentence when it refuses. **Restore to default** (`unset`) is judged the same way as a save: the
+reset's verdict is the next snapshot — the id must be GONE from the user layer, the opposite evidence a `set`
+needs — so a host refusal prints "恢复默认值没有生效…" instead of leaving a chip that looks like a broken button,
+the control reports its in-flight state, and a throwing settings service reaches the reader rather than
+escaping as an unhandled rejection. `settle.ts` holds that one verdict function for both ops. **Preview** opens one row at a time: the facts line (`n 行新增` /
 `n 行删除` / truncated) and the source block with `-`/`+` lines, the same shape the history panel's diff
 uses; an unavailable preview prints the host's reason. A late answer for a row the reader already left is
 dropped rather than painted under another row's heading.
 
+## A seat that arrives late revives the card
+
+The seat is probed lazily (never captured at apply time), but probing alone only answers the NEXT read —
+a card that already painted 「本部署没有这个座位」 never asks again, and its row subscription was never
+attached at all. `apply()` therefore subscribes to the platform's own arrival channel
+(`ctx.inject(['configForms'], () => sources.revive())`): `revive` force-re-binds the form (a REPLACED
+seat is picked up too), attaches the subscription and wakes every listener, so the card turns into a form
+without a re-render and without a timer. The mechanism sentence this replaced — "the platform has no
+service arrival signal" — was wrong: `ctx.inject` is exactly that signal (v46 S5.2 / T5-11).
+
+## One save is one write, on both faces
+
+A save hands the seat ONE op list (`mutateOnce(ops)`) instead of one call per field. The Plugins page
+fences that list with the revision the render read, which is the platform's own form model ("apply
+ordered field edits in one revision-fenced write"); the section path passes no fence, exactly as before.
+Per-field calls with one shared render-time revision were the T5-01 bug: the host accepted the first
+field, the revision moved, and every later field of the SAME save was refused with a conflict — the
+change silently did not land while the card showed one generic refusal.
+
+The stylesheet carries two structural invariants, both pinned by `tests/styles.client.spec.ts`: one
+selector never carries two rules (the row chip and the preview's diff block were both
+`.evolution-param-source`, so the diff rule's padding/border/overflow landed on a 20px chip and the
+chip's `inline-flex` laid every diff line out in one row), and the family scale is declared on the
+CARD root as well as the section root (the Plugins page renders the same card outside
+`.evolution-params`, where a section-only declaration left every `--evo-*` undefined — no border, zero
+padding, square corners).
+
 ## The `hooks` compartment never reaches the component
 
 A card's inject face carries `hooks: { paramSection: source }` — that is the SHELL's seat, not a prop. The renderer binds each entry to a `use<Name>` seat and hands the component the face with `hooks` REMOVED (the slot contract is `PropsHooks<face['hooks']>` plus `Omit<face, 'hooks'>`). Reading `props.hooks` therefore reads a prop that never exists, and the failure only shows up at runtime, inside the save path.
 
 The props type is spelled the way the renderer derives it — `Omit<ParamCardFace, 'hooks'> & { useParamSection }` — so re-introducing that mistake fails `tsc` instead of failing the operator's save. 0.7.0 shipped the mistake; 0.7.1 fixed it and derived the type this way.
 
+## The seat contract: lazy probe, stable snapshot, one source object
+
+`src/client/source.ts` is the one place that turns `configForms.get(namespace)` into the three things a card needs — a snapshot, a subscription and the two write calls — and it holds three obligations the platform's renderer imposes:
+
+- **The seat is probed lazily.** `apply()` may run before the settings shell that declares this section and provides `configForms`, so a seat captured at apply time would pin the row to the empty state for the life of its fiber. The source reads a `SeatProbe` on every snapshot read; the write face re-probes per call.
+- **The projected snapshot keeps ONE reference until the row's raw snapshot moves.** The renderer binds the `hooks` compartment through `useSyncExternalStoreWithSelector`, which compares by reference: a projection that builds an object per call never compares equal, so React aborts the card (minified invariant #185) and the slot error boundary replaces it with an empty placeholder — that is 0.17.0's "all the cards disappeared". The projection caches per raw snapshot reference, and a projection failure returns the frozen `PROJECTION_FAILED` snapshot instead of throwing: a throw from `getSnapshot()` happens inside the renderer's render pass, where this bundle cannot catch it and where a `try`/`catch` around a hook call would not be legal React.
+- **One source object per namespace.** The renderer caches a hook binding per SOURCE object, so a source built per render re-binds the hook and remounts the card. `createSourceCache(probe)` owns the per-namespace cache and goes away with the fiber.
+
+A card therefore tells three unavailable reasons apart — `seat-missing` (no settings surface composed), `projection-failed` (the seat served the row and reading it failed; the error is logged once) and `not-served` (the row itself is unavailable) — instead of painting one blank state. `N29`/`N30` in the family guard hold the shape of this seam, and `tests/section.client.spec.ts` pins the stable reference, the re-projection on change, the frozen failure value, the per-namespace identity and the late seat.
+
 ## Styling
 
 The card draws from the FAMILY's scale, not from magic numbers: `src/client/tokens.ts` is generated from `packages/scripts/client-tokens.json` (identical bytes in the history panel, which shares it), and its type steps are relative to the surface that hosts the card — `calc(1em - 2px)` for a hint, `calc(1em + 2px)` for the title — so the card no longer resizes itself with the `--dsh-content-font-size*` setting, which is documented as affecting conversation content only and which the platform's own surfaces never read. Fields take the family's single focus ring (`outline: var(--evo-focus-ring)`), the same one the history panel draws, instead of a recoloured border. The design system's CSS is not exported to packages outside the platform repository, so this bundle carries its own stylesheet and injects it once behind a `<style data-plugin-css="…">` tag — the mechanism the platform's own client bundles use. Every rule reads a `--dsw-alias-*` design token, so light and dark follow the theme without a colour of our own, and the field metrics (12px padding, 6px gap, 13px label, 12px hint) copy the platform's settings fields.
@@ -72,4 +124,4 @@ The browser half ships as the client module system's lazy CJS factory artifact (
 - The section renders plain controls styled with the design tokens rather than the platform's `@deepseek-ai/dsh-client-ui-primitives` kit: that module IS available to out-of-repo bundles (the market plugin requires it), but its prop shapes are not published, and guessing them would break the live GUI.
 - An unsaved draft lives in the card's own component state and the settings shell renders only the active section, so switching to another section drops a draft that was not saved yet. Values already written are unaffected; moving the draft into an apply-time store is the 0.7.x follow-up.
 - A deployment that overrides a field through the `evolution-policy` row does not show on the card: the card reports the deployment value the settings scope serves, while the policy snapshot can differ. That divergence stays a doctor / `/evolution params` matter.
-- The parameter card has no RENDERED spec: the family specs are Node-level and the family carries no React runtime, so it is covered by `tsc`, the bundle build, the gate steps and a live pass on the installed artifact (0.7.0's save defect was found exactly there). The verdict is pinned instead by `tests/settle.spec.ts` (the pure `landedWrites` decision, including the already-overridden refusal case); rendering the card with the props the renderer actually builds — no `hooks`, the bound seat stubbed — remains the follow-up that would catch the wiring in CI.
+- The parameter card's spec covers the **wiring**, not the **assembly**. `tests/section.client.spec.ts` renders the real card component with the props the renderer actually builds — no `hooks`, the settings seat stubbed — so a wrong prop name or a missing `useParamSection` binding fails in CI, on top of `tests/settle.spec.ts` (the pure `landedWrites` decision, including the already-overridden refusal case). What no Node-level spec can see is the assembly the loader performs: the framework's real kit, the style scoping, the module identity handed to the bundle. Defects of that layer — two same-named classes overwriting each other, styles scoped to the wrong root — still surface only in a live pass on the installed artifact (0.7.0's save defect was found exactly there).

package/lib/client.js

@@ -68,7 +68,7 @@ window.__ModuleLoader__.load({
 				body: JSON.stringify({ id })
 			});
 			return {
-				pending: async () => await read(doFetch, APPROVAL_CLIENT_ROUTES.pending),
+				pending: async (status) => await read(doFetch, status === void 0 ? APPROVAL_CLIENT_ROUTES.pending : APPROVAL_CLIENT_ROUTES.pending + "?status=" + status),
 				approve: async (id) => await post(APPROVAL_CLIENT_ROUTES.approve, id),
 				reject: async (id) => await post(APPROVAL_CLIENT_ROUTES.reject, id),
 				preview: async (id) => await read(doFetch, APPROVAL_CLIENT_ROUTES.preview + "?id=" + encodeURIComponent(id))
@@ -79,6 +79,7 @@ window.__ModuleLoader__.load({
 		const CLIENT_PARAM_SECTIONS = [
 			{
 				namespace: "evolution-curator",
+				seatKey: "evolution-curator",
 				fields: [
 					{
 						id: "curatorIntervalHours",
@@ -216,6 +217,7 @@ window.__ModuleLoader__.load({
 			},
 			{
 				namespace: "evolution-review",
+				seatKey: "evolution-review",
 				fields: [
 					{
 						id: "reviewSkillInterval",
@@ -306,6 +308,7 @@ window.__ModuleLoader__.load({
 			},
 			{
 				namespace: "memory-files",
+				seatKey: "memory-files",
 				fields: [
 					{
 						id: "memoryChars",
@@ -355,6 +358,7 @@ window.__ModuleLoader__.load({
 			},
 			{
 				namespace: "tool-memory",
+				seatKey: "tool-memory",
 				fields: [{
 					id: "entryPreviewChars",
 					group: "memory",
@@ -369,6 +373,7 @@ window.__ModuleLoader__.load({
 			},
 			{
 				namespace: "tool-skill-manage",
+				seatKey: "tool-skill-manage",
 				fields: [
 					{
 						id: "skillContentChars",
@@ -654,13 +659,37 @@ window.__ModuleLoader__.load({
 				latest.current = value;
 				setState(value);
 			};
+			/**
+			* Read the window the card is about: the writes WAITING and the writes RUNNING.
+			*
+			* T4-05/A47: the route has always taken `?status=` — the CLI asks for both lists — but this card
+			* asked for neither, so a record whose approve died between the claim and the decision showed as
+			* "nothing is waiting for a decision" while `/evolution pending` and doctor listed it. The two
+			* answers are ordered the way the CLI orders them (waiting first); either one failing fails the
+			* read, because a half-list would read as a complete window.
+			*/
 			const load = async () => {
 				apply(loading);
-				const answer = await api.pending();
-				apply((current) => answer.ok ? loaded(current, answer.data) : failed(current, answer.message));
+				const [waiting, running] = await Promise.all([api.pending(), api.pending("executing")]);
+				if (!waiting.ok) {
+					apply((current) => failed(current, waiting.message));
+					return;
+				}
+				if (!running.ok) {
+					apply((current) => failed(current, running.message));
+					return;
+				}
+				apply((current) => loaded(current, [...waiting.data, ...running.data]));
 			};
 			(0, react.useEffect)(() => {
 				load();
+				const onFocus = () => {
+					load();
+				};
+				window.addEventListener("focus", onFocus);
+				return () => {
+					window.removeEventListener("focus", onFocus);
+				};
 			}, []);
 			const decide = (id, action) => {
 				apply((current) => beginAction(current, id));
@@ -738,9 +767,13 @@ window.__ModuleLoader__.load({
 						}, "+ " + line));
 					}
 				}
-				return (0, react.createElement)("div", null, (0, react.createElement)("p", { className: "evolution-param-facts" }, ...facts), (0, react.createElement)("pre", { className: "evolution-param-source" }, ...lines.length === 0 ? ["±"] : lines));
+				return (0, react.createElement)("div", null, (0, react.createElement)("p", { className: "evolution-param-facts" }, ...facts), (0, react.createElement)("pre", { className: "evolution-param-diff" }, ...lines.length === 0 ? ["±"] : lines));
 			};
 			const row = (entry) => {
+				if (entry.status === "executing") return (0, react.createElement)("div", {
+					className: "evolution-param-field",
+					key: entry.id
+				}, (0, react.createElement)("div", { className: "evolution-param-label" }, (0, react.createElement)("span", { className: "evolution-param-source" }, t(KIND_KEYS[entry.kind])), (0, react.createElement)("span", { className: "evolution-param-value" }, entry.summary)), (0, react.createElement)("p", { className: "evolution-param-hint" }, age(entry)), (0, react.createElement)("p", { className: "evolution-param-note" }, t("approvalExecuting")), entry.claimedBy === void 0 ? null : (0, react.createElement)("p", { className: "evolution-param-hint" }, entry.claimedBy));
 				const busy = state.busy.includes(entry.id);
 				const button = (label, action) => (0, react.createElement)("button", {
 					className: "evolution-param-button",
@@ -773,7 +806,9 @@ window.__ModuleLoader__.load({
 				}, t("approvalRetry")));
 				return (0, react.createElement)("div", null, ...state.view.rows.map(row), state.notice === null ? null : (0, react.createElement)("p", { className: "evolution-param-error" }, state.notice));
 			};
-			const count = state.view.kind === "ready" ? state.view.rows.length : 0;
+			const rows = state.view.kind === "ready" ? state.view.rows : [];
+			const waiting = rows.filter((entry) => entry.status !== "executing").length;
+			const running = rows.length - waiting;
 			return (0, react.createElement)("section", { className: "evolution-param-card" }, (0, react.createElement)("button", {
 				className: "evolution-param-head",
 				type: "button",
@@ -781,7 +816,13 @@ window.__ModuleLoader__.load({
 					setOpen(!open);
 				},
 				"aria-expanded": open
-			}, (0, react.createElement)("span", { className: "evolution-param-card-title" }, t("approvalTitle")), count === 0 ? null : (0, react.createElement)("span", { className: "evolution-param-count" }, t("approvalCount").replace("{n}", String(count))), (0, react.createElement)("span", { className: "evolution-param-chevron" }, open ? "▲" : "▼")), open ? (0, react.createElement)("div", { className: "evolution-param-body" }, body()) : null);
+			}, (0, react.createElement)("span", { className: "evolution-param-card-title" }, t("approvalTitle")), waiting === 0 ? null : (0, react.createElement)("span", { className: "evolution-param-count" }, t("approvalCount").replace("{n}", String(waiting))), running === 0 ? null : (0, react.createElement)("span", { className: "evolution-param-count" }, t("approvalRunningCount").replace("{n}", String(running))), (0, react.createElement)("span", { className: "evolution-param-chevron" }, open ? "▲" : "▼")), open ? (0, react.createElement)("div", { className: "evolution-param-body" }, (0, react.createElement)("div", { className: "evolution-param-actions" }, (0, react.createElement)("button", {
+				className: "evolution-param-button",
+				type: "button",
+				onClick: () => {
+					load();
+				}
+			}, t("approvalRefresh"))), body()) : null);
 		}
 		//#endregion
 		//#region src/client/messages.ts
@@ -806,6 +847,7 @@ window.__ModuleLoader__.load({
 			loading: "正在读取设置…",
 			unavailable: "这个功能没有启动（对应的插件没有安装）",
 			seatMissing: "这个界面没有提供设置服务，参数只能看不能改",
+			projectionFailed: "这一块读设置时出错，已记入日志；其它参数不受影响",
 			readonly: "本次会话不允许写入设置（临时运行模式）",
 			apply: "保存",
 			reset: "恢复默认值",
@@ -813,7 +855,9 @@ window.__ModuleLoader__.load({
 			changed: "{n} 项已改",
 			discard: "放弃修改",
 			saving: "保存中…",
+			resetting: "恢复中…",
 			refused: "这个值没有被接受（界面上保持原样）。想看原因：运行 /evolution params 或 /evolution doctor。",
+			resetRefused: "恢复默认值没有生效（这一行还是你的值）。想看原因：运行 /evolution params 或 /evolution doctor。",
 			cardReview: "会话回顾",
 			cardMemory: "长期记忆",
 			cardToolMemory: "记忆写入",
@@ -827,6 +871,9 @@ window.__ModuleLoader__.load({
 			approvalApprove: "批准",
 			approvalReject: "拒绝",
 			approvalCount: "{n} 项待批",
+			approvalRunningCount: "{n} 项执行中",
+			approvalRefresh: "刷新",
+			approvalExecuting: "执行中：这条的写效果可能已经落地，不要重复批准；要清掉它请用拒绝。",
 			approvalKindMemory: "记忆",
 			approvalKindSkill: "技能",
 			approvalKindCapability: "能力",
@@ -852,6 +899,7 @@ window.__ModuleLoader__.load({
 			loading: "reading settings…",
 			unavailable: "this feature is not running (its plugin is not installed)",
 			seatMissing: "this shell serves no settings surface, so the parameters cannot be edited here",
+			projectionFailed: "reading this row failed and the error is in the log; the other parameters are unaffected",
 			readonly: "settings cannot be written in this session (temporary mode)",
 			apply: "Save",
 			reset: "Reset to default",
@@ -859,7 +907,9 @@ window.__ModuleLoader__.load({
 			changed: "{n} changed",
 			discard: "Discard",
 			saving: "Saving…",
+			resetting: "Resetting…",
 			refused: "The value was not accepted (the page keeps what you see). For the reason run /evolution params or /evolution doctor.",
+			resetRefused: "The reset did not take (this row still holds your value). For the reason run /evolution params or /evolution doctor.",
 			cardReview: "Session review",
 			cardMemory: "Long-term memory",
 			cardToolMemory: "Writing memory",
@@ -873,6 +923,9 @@ window.__ModuleLoader__.load({
 			approvalApprove: "Approve",
 			approvalReject: "Reject",
 			approvalCount: "{n} waiting",
+			approvalRunningCount: "{n} running",
+			approvalRefresh: "Refresh",
+			approvalExecuting: "Running: this write may already have landed — do not approve it twice; reject it to clear it.",
 			approvalKindMemory: "memory",
 			approvalKindSkill: "skill",
 			approvalKindCapability: "capability",
@@ -914,24 +967,38 @@ window.__ModuleLoader__.load({
 		//#region src/client/settle.ts
 		/**
 		* Structural equality for the values a parameter can hold.
+		*
+		* T5-10: the comparison walks the value instead of comparing serializations, because key ORDER is
+		* not part of an object's value — `{ a: 1, b: 2 }` and `{ b: 2, a: 1 }` are the same value, but
+		* their `JSON.stringify` output differs, and the card then read a save that HAD landed as refused
+		* (draft kept, error line shown). Array order IS part of an array's value, so arrays compare
+		* element-wise. `NaN` equals itself through the `Object.is` fast path; other primitives use `===`,
+		* which keeps `0` and `-0` equal exactly as the serialization comparison did.
 		* @param a - one side of the comparison.
 		* @param b - the other side.
 		* @returns true when the two are the same value.
 		*/
 		function sameValue(a, b) {
 			if (Object.is(a, b)) return true;
-			if (typeof a !== typeof b || a === null || b === null) return false;
-			return JSON.stringify(a) === JSON.stringify(b);
+			if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return a === b;
+			if (Array.isArray(a) || Array.isArray(b)) {
+				if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+				return a.every((item, index) => sameValue(item, b[index]));
+			}
+			const left = a;
+			const right = b;
+			const keys = Object.keys(left);
+			return keys.length === Object.keys(right).length && keys.every((key) => Object.hasOwn(right, key) && sameValue(left[key], right[key]));
 		}
 		/**
-		* Whether every staged write is visible in the user layer.
-		* @param pending - the writes awaiting a verdict.
+		* Whether every staged operation is visible in the user layer.
+		* @param pending - the operations awaiting a verdict.
 		* @param user - the user layer of the post-write snapshot; a non-section reads as empty.
-		* @returns true when each staged id now holds the value that was requested.
+		* @returns true when each staged id now holds the requested value, or is gone after an `unset`.
 		*/
-		function landedWrites(pending, user) {
+		function landedSettlements(pending, user) {
 			const section = typeof user === "object" && user !== null && !Array.isArray(user) ? user : {};
-			return pending.every((entry) => sameValue(section[entry.id], entry.want));
+			return pending.every((entry) => entry.op === "unset" ? !Object.hasOwn(section, entry.id) : sameValue(section[entry.id], entry.want));
 		}
 		//#endregion
 		//#region src/client/ParamCard.ts
@@ -1030,11 +1097,11 @@ window.__ModuleLoader__.load({
 			}, props.overridden ? t("overridden") : t("deployment"))), FieldControl(props), (0, react.createElement)("p", { className: "evolution-param-hint" }, field.hint === "" ? field.doc : field.hint), props.overridden ? (0, react.createElement)("div", { className: "evolution-param-actions" }, (0, react.createElement)("button", {
 				type: "button",
 				className: "evolution-param-button",
-				disabled: props.disabled,
+				disabled: props.disabled || props.clearing,
 				onClick: () => {
-					props.clear(field.id);
+					props.onClear(field.id);
 				}
-			}, t("reset"))) : null);
+			}, props.clearing ? t("resetting") : t("reset"))) : null);
 		}
 		/**
 		* Render one row's card body from a supplied snapshot.
@@ -1042,18 +1109,19 @@ window.__ModuleLoader__.load({
 		* @returns the card.
 		*/
 		function ParamCardView(props) {
-			const { t, fields, write, clear, namespace, snapshot } = props;
+			const { t, fields, mutateOnce, clear, namespace, snapshot } = props;
 			const [open, setOpen] = (0, react.useState)(false);
 			const [draft, setDraft] = (0, react.useState)({});
 			const [busy, setBusy] = (0, react.useState)(false);
 			const [error, setError] = (0, react.useState)("");
 			const [pending, setPending] = (0, react.useState)(null);
+			const [clearing, setClearing] = (0, react.useState)(null);
 			if (snapshot.status === "loading") return (0, react.createElement)("p", { className: "evolution-param-note" }, t("loading"));
-			if (snapshot.status === "unavailable") return (0, react.createElement)("p", { className: "evolution-param-note" }, t(snapshot.reason === "seat-missing" ? "seatMissing" : "unavailable"));
+			if (snapshot.status === "unavailable") return (0, react.createElement)("p", { className: "evolution-param-note" }, t(snapshot.reason === "seat-missing" ? "seatMissing" : snapshot.reason === "projection-failed" ? "projectionFailed" : "unavailable"));
 			const user = isSection$1(snapshot.user) ? snapshot.user : {};
 			const value = isSection$1(snapshot.value) ? snapshot.value : {};
 			const disabled = !snapshot.writable;
-			const locked = disabled || busy;
+			const locked = disabled || busy || clearing !== null;
 			const titleKey = NAMESPACE_TITLES[namespace];
 			const title = titleKey === void 0 ? namespace : t(titleKey);
 			const changed = fields.filter((field) => Object.hasOwn(user, field.id)).length;
@@ -1082,20 +1150,54 @@ window.__ModuleLoader__.load({
 				if (pending === null) return;
 				setPending(null);
 				setBusy(false);
-				if (landedWrites(pending, snapshot.user)) setDraft({});
-				else setError(t("refused"));
+				setClearing(null);
+				if (!landedSettlements(pending, snapshot.user)) {
+					setError(t(pending.every((entry) => entry.op === "unset") ? "resetRefused" : "refused"));
+					return;
+				}
+				if (pending.some((entry) => entry.op === "set")) setDraft({});
 			}, [
 				pending,
 				snapshot.user,
 				t
 			]);
+			/**
+			* Restore one field's deployment default (T5-05/A60).
+			*
+			* The scope's own boolean is NOT the verdict — same reason the save path judges the settled
+			* snapshot instead: a host refusal leaves the user layer untouched, which is precisely what a
+			* structural check sees and a dropped return value does not. A throw (the settings service
+			* rejecting a non-volatile path) used to escape as an unhandled rejection.
+			*/
+			const reset = (field) => {
+				setClearing(field);
+				setError("");
+				(async () => {
+					try {
+						await clear(field);
+					} catch (caught) {
+						setClearing(null);
+						setError(caught instanceof Error && caught.message !== "" ? caught.message : t("resetRefused"));
+						return;
+					}
+					setPending([{
+						op: "unset",
+						id: field
+					}]);
+				})();
+			};
 			const save = () => {
 				setBusy(true);
 				setError("");
 				(async () => {
 					try {
-						for (const field of dirty) await write(field.id, parseFor(field.control, textOf(field)));
+						await mutateOnce(dirty.map((field) => ({
+							op: "set",
+							path: [field.id],
+							value: parseFor(field.control, textOf(field))
+						})));
 						setPending(dirty.map((field) => ({
+							op: "set",
 							id: field.id,
 							want: parseFor(field.control, textOf(field))
 						})));
@@ -1118,9 +1220,10 @@ window.__ModuleLoader__.load({
 				text: textOf(field),
 				overridden: Object.hasOwn(user, field.id),
 				disabled: locked,
+				clearing: clearing === field.id,
 				t,
 				onChange: change,
-				clear
+				onClear: reset
 			})), error === "" ? null : (0, react.createElement)("p", { className: "evolution-param-error" }, error), fields.length === 0 ? null : (0, react.createElement)("div", { className: "evolution-param-footer" }, (0, react.createElement)("button", {
 				type: "button",
 				className: "evolution-param-button",
@@ -1133,7 +1236,7 @@ window.__ModuleLoader__.load({
 				type: "button",
 				className: "evolution-param-button",
 				"data-primary": "true",
-				disabled: disabled || busy || dirty.length === 0,
+				disabled: locked || dirty.length === 0,
 				onClick: save
 			}, busy ? t("saving") : t("apply")))) : null);
 		}
@@ -1149,7 +1252,7 @@ window.__ModuleLoader__.load({
 				namespace: props.namespace,
 				fields: props.fields,
 				t: props.t,
-				write: props.write,
+				mutateOnce: props.mutateOnce,
 				clear: props.clear,
 				snapshot: props.useParamSection((state) => state)
 			});
@@ -1164,6 +1267,16 @@ window.__ModuleLoader__.load({
 			writable: false,
 			reason: "seat-missing"
 		});
+		/** What a card shows when the seat served the row but projecting it failed. A frozen constant
+		* so a failing row keeps ONE reference: a fresh object per call would reintroduce the
+		* render loop this module exists to prevent. */
+		const PROJECTION_FAILED = Object.freeze({
+			status: "unavailable",
+			value: void 0,
+			user: void 0,
+			writable: false,
+			reason: "projection-failed"
+		});
 		/**
 		* Whether a value is a plain section object.
 		* @param value - the value to test.
@@ -1187,39 +1300,141 @@ window.__ModuleLoader__.load({
 			};
 		}
 		/**
+		* Bind one row's form to a projection that is stable per raw snapshot and never throws.
+		* @param form - the row's client form, as the settings seat hands it over.
+		* @returns the projection the card's hook reads.
+		*/
+		function stableProjection(form) {
+			let lastRaw;
+			let lastOut;
+			let reported = false;
+			const failed = (error) => {
+				if (!reported) {
+					reported = true;
+					console.error("[evolution-settings] projecting one row failed:", error);
+				}
+				return PROJECTION_FAILED;
+			};
+			return () => {
+				let raw;
+				try {
+					raw = form.getSnapshot();
+				} catch (error) {
+					return failed(error);
+				}
+				if (lastOut !== void 0 && raw === lastRaw) return lastOut;
+				try {
+					const next = sectionSnapshotOf(raw);
+					lastRaw = raw;
+					lastOut = next;
+					return next;
+				} catch (error) {
+					return failed(error);
+				}
+			};
+		}
+		/**
 		* The live source one row's card binds.
-		* @param seat - the probed settings seat, when the deployment composed it.
+		* @param probe - the lazily probed settings seat.
 		* @param namespace - the row's entry id.
-		* @returns the source; without a seat it reports the stated empty state and never notifies.
+		* @returns the source; without a seat it reports the stated empty state, and it re-probes on
+		*   every read so a seat that appears later is picked up without a timer.
 		*/
-		function sourceFor(seat, namespace) {
-			if (seat === void 0) return {
-				getSnapshot: () => SEAT_MISSING,
-				subscribe: () => () => {}
+		function sourceFor(probe, namespace) {
+			const listeners = /* @__PURE__ */ new Set();
+			let form;
+			let projected;
+			let offForm;
+			/**
+			* Bind the seat's form for this row.
+			* @param force - re-read the seat even when one is already bound, so a REPLACED seat (the shell
+			*   re-composed, a different form object for the same row) is picked up instead of kept stale.
+			*/
+			const bind = (force = false) => {
+				if (form !== void 0 && !force) return;
+				const seat = probe();
+				if (seat === void 0) return;
+				const next = seat.get(namespace);
+				if (next === form) return;
+				offForm?.();
+				offForm = void 0;
+				form = next;
+				projected = stableProjection(form);
+			};
+			const attach = () => {
+				if (form === void 0 || offForm !== void 0) return;
+				offForm = form.subscribe(() => {
+					for (const listener of listeners) listener();
+				});
 			};
-			const form = seat.get(namespace);
 			return {
-				getSnapshot: () => sectionSnapshotOf(form.getSnapshot()),
-				subscribe: (listener) => form.subscribe(listener)
+				getSnapshot: () => {
+					bind();
+					return projected === void 0 ? SEAT_MISSING : projected();
+				},
+				revive: () => {
+					bind(true);
+					attach();
+					for (const listener of listeners) listener();
+				},
+				subscribe: (listener) => {
+					listeners.add(listener);
+					bind();
+					attach();
+					return () => {
+						listeners.delete(listener);
+						if (listeners.size === 0) {
+							offForm?.();
+							offForm = void 0;
+						}
+					};
+				}
 			};
 		}
 		/**
 		* The write pair for one row.
-		* @param seat - the probed settings seat, when the deployment composed it.
+		* @param probe - the lazily probed settings seat.
 		* @param namespace - the row's entry id.
 		* @returns the two calls a card's save/reset path uses; without a seat they resolve without writing.
 		*/
-		function writeFaceFor(seat, namespace) {
-			const form = () => seat?.get(namespace);
+		function writeFaceFor(probe, namespace) {
+			const form = () => probe()?.get(namespace);
 			return {
-				write: async (field, value) => {
-					await form()?.set(field, value);
+				mutateOnce: async (ops) => {
+					await form()?.mutate(ops);
 				},
 				clear: async (field) => {
 					await form()?.unset(field);
 				}
 			};
 		}
+		/**
+		* One source object per namespace, for the life of the plugin fiber.
+		*
+		* The renderer caches a hook binding per SOURCE OBJECT, so building a source per render
+		* would re-bind the hook and remount the card. The cache is owned by the caller's fiber and
+		* cleared on dispose.
+		* @param probe - the lazily probed settings seat.
+		* @returns the per-namespace source cache and its disposer.
+		*/
+		function createSourceCache(probe) {
+			const sources = /* @__PURE__ */ new Map();
+			return {
+				sourceFor: (namespace) => {
+					const existing = sources.get(namespace);
+					if (existing !== void 0) return existing;
+					const source = sourceFor(probe, namespace);
+					sources.set(namespace, source);
+					return source;
+				},
+				revive: () => {
+					for (const source of sources.values()) source.revive();
+				},
+				dispose: () => {
+					sources.clear();
+				}
+			};
+		}
 		//#endregion
 		//#region src/client/RowConfigCard.ts
 		/**
@@ -1257,12 +1472,8 @@ window.__ModuleLoader__.load({
 				fields,
 				t,
 				snapshot: sectionSnapshotOf(form.state),
-				write: async (field, value) => {
-					await form.mutate([{
-						op: "set",
-						path: [field],
-						value
-					}], form.state.revision);
+				mutateOnce: async (ops) => {
+					await form.mutate(ops, form.state.revision);
 				},
 				clear: async (field) => {
 					await form.mutate([{
@@ -1362,7 +1573,7 @@ window.__ModuleLoader__.load({
 		const CSS_TAG_ID = "@lmzhen/dsh-evolution-settings-ui/settings.css";
 		/** The stylesheet the section injects once. */
 		const CSS = [
-			tokenVars(".evolution-params"),
+			tokenVars(".evolution-params,.evolution-param-card"),
 			".evolution-params{display:flex;flex-direction:column}",
 			".evolution-params-title{margin:0 0 var(--evo-space-4);color:var(--dsw-alias-label-primary);font-size:var(--evo-type-lg);font-weight:600;line-height:var(--evo-leading-base)}",
 			".evolution-params-subtitle{margin:0 0 var(--evo-space-16);color:var(--dsw-alias-label-tertiary);font-size:var(--evo-type-xs);line-height:var(--evo-leading-base)}",
@@ -1400,7 +1611,7 @@ window.__ModuleLoader__.load({
 			".evolution-param-error{margin:0;color:var(--dsw-alias-state-error-primary);font-size:var(--evo-type-xs);line-height:var(--evo-leading-base)}",
 			".evolution-param-facts{display:flex;flex-wrap:wrap;align-items:baseline;margin:0;color:var(--dsw-alias-label-tertiary);font-size:var(--evo-type-xs);line-height:var(--evo-leading-base)}",
 			".evolution-param-fact+.evolution-param-fact::before{content:\"·\";margin:0 var(--evo-space-6);color:var(--dsw-alias-label-tertiary)}",
-			".evolution-param-source{margin:0;padding:var(--evo-space-12) var(--evo-space-16);max-height:var(--evo-cap-block);overflow:auto;border:var(--evo-hairline-width) solid var(--dsw-alias-border-l1);border-radius:var(--evo-radius-surface);background:var(--dsw-alias-markdown-code-block);color:var(--dsw-alias-label-primary);font:var(--dsw-font-markdown-code-block-small);white-space:pre-wrap}",
+			".evolution-param-diff{margin:0;padding:var(--evo-space-12) var(--evo-space-16);max-height:var(--evo-cap-block);overflow:auto;border:var(--evo-hairline-width) solid var(--dsw-alias-border-l1);border-radius:var(--evo-radius-surface);background:var(--dsw-alias-markdown-code-block);color:var(--dsw-alias-label-primary);font:var(--dsw-font-markdown-code-block-small);white-space:pre-wrap}",
 			".evolution-param-line-add{color:var(--evo-tone-success)}",
 			".evolution-param-line-del{color:var(--evo-tone-danger)}"
 		].join("\n");
@@ -1448,7 +1659,8 @@ window.__ModuleLoader__.load({
 					});
 					registered = true;
 					return dispose;
-				} catch {
+				} catch (error) {
+					ctx.logger.warn(`evolution-settings-ui: the locale seat refused the "${NS}" dictionary registration (${error instanceof Error ? error.message : String(error)}) — the cards fall back to the bundle's own copy`);
 					return () => {};
 				}
 			}, "evolution-settings: dictionaries");
@@ -1462,7 +1674,14 @@ window.__ModuleLoader__.load({
 				}
 				return bound(key);
 			};
-			const configForms = ctx.get("configForms");
+			const probe = () => ctx.get("configForms");
+			const sources = createSourceCache(probe);
+			ctx.effect(() => () => {
+				sources.dispose();
+			}, "evolution-settings: sources");
+			ctx.inject?.(["configForms"], () => {
+				sources.revive();
+			});
 			seam.slots.inject("settings.section", function* () {
 				yield seam.slots.register({
 					name: "settings.section",
@@ -1478,13 +1697,13 @@ window.__ModuleLoader__.load({
 			});
 			seam.slots.inject(CARD_SLOT, function* () {
 				for (const section of CLIENT_PARAM_SECTIONS) {
-					const source = sourceFor(configForms, section.namespace);
-					const { write, clear } = writeFaceFor(configForms, section.namespace);
+					const source = sources.sourceFor(section.seatKey);
+					const { mutateOnce, clear } = writeFaceFor(probe, section.namespace);
 					const face = () => ({
 						namespace: section.namespace,
 						fields: section.fields,
 						t,
-						write,
+						mutateOnce,
 						clear,
 						hooks: { paramSection: source }
 					});

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

@@ -16,7 +16,7 @@
 import { type ReactNode } from 'react';
 import type { ClientParamField } from './generated-params.ts';
 import { type MessageKey } from './messages.ts';
-import type { ParamSectionSnapshot, ParamSectionSource } from './seam.ts';
+import type { ParamSectionSnapshot, ParamSectionSource, SettingsPathOpLike } from './seam.ts';
 /**
  * Injected face: plain data and callbacks, plus the hook seat.
  *
@@ -29,7 +29,8 @@ export interface ParamCardFace {
     namespace: string;
     fields: readonly ClientParamField[];
     t: (key: MessageKey) => string;
-    write: (field: string, value: unknown) => Promise<void>;
+    /** ONE call per save, carrying every dirty field as one op list (T5-01/A56). */
+    mutateOnce: (ops: readonly SettingsParamOp[]) => Promise<void>;
     clear: (field: string) => Promise<void>;
     hooks: {
         paramSection: ParamSectionSource;
@@ -44,6 +45,8 @@ export type ParamCardProps = Omit<ParamCardFace, 'hooks'> & {
     /** Bound from \`hooks.paramSection\` by the renderer. */
     readonly useParamSection: <T>(selector: (state: ParamSectionSnapshot) => T) => T;
 };
+/** The op list a save hands to the seat — the seam's own shape, never a second vocabulary. */
+export type SettingsParamOp = SettingsPathOpLike;
 /**
  * Render one namespace's card.
  * @param props - the card data, its callbacks, and the bound section hook.
@@ -54,7 +57,9 @@ export interface ParamCardViewProps {
     namespace: string;
     fields: readonly ClientParamField[];
     t: (key: MessageKey) => string;
-    write: (field: string, value: unknown) => Promise<void>;
+    /** ONE call per save, carrying every dirty field as one op list (T5-01/A56). */
+    mutateOnce: (ops: readonly SettingsParamOp[]) => Promise<void>;
+    /** Ask the scope to drop one override; resolves when the scope answered, not when it landed. */
     clear: (field: string) => Promise<void>;
     /** The current row state, from whichever source owns it (the bound hook or the page). */
     snapshot: ParamSectionSnapshot;

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

@@ -41,10 +41,18 @@ export type ApprovalAnswer<T> = {
     readonly ok: false;
     readonly message: string;
 };
+/**
+ * Which window the pending route is asked for. The host route has always taken `?status=` (the CLI
+ * asks for both); this half asked for neither, so a record stuck in `executing` — an approve that
+ * died between the claim and the decision, or another process running it — was invisible in the GUI
+ * while `/evolution pending` and doctor both listed it (T4-05/A47). `PendingRow.status` even declared
+ * the member, so the type face expected data the data face could not reach.
+ */
+export type PendingWindow = 'pending' | 'executing';
 /** How this bundle reaches the host. Injectable so a spec drives it without a server. */
 export interface ApprovalApi {
-    /** The staged writes waiting for a decision. */
-    pending: () => Promise<ApprovalAnswer<readonly PendingRow[]>>;
+    /** The staged writes in one window; `pending` when the caller does not say. */
+    pending: (status?: PendingWindow) => Promise<ApprovalAnswer<readonly PendingRow[]>>;
     /** Ask the host to replay one staged write. */
     approve: (id: string) => Promise<ApprovalAnswer<unknown>>;
     /** Close one staged write without replaying it. */

package/lib/types/client/generated-params.d.ts

@@ -23,9 +23,15 @@ export interface ClientParamField {
     /** Display names for `values`, same order ([] shows the raw value). */
     valueLabels: readonly string[];
 }
-/** One card: the settings namespace plus the fields it exposes. */
+/** One card: the settings namespace it writes through, the SEAT key its source is looked up by,
+ * and the fields it exposes. A73 (`ClientParamSection.namespace` 一名字两义): the two roles are
+ * spelled separately so a Host may key them differently — `namespace` is what a save writes into
+ * (`update(namespace, patch)`) and what the card title is looked up by; `seatKey` is what the
+ * shell's `sources.sourceFor(...)` probes. Both are the LOADER ROW ID today. */
 export interface ClientParamSection {
     namespace: string;
+    /** The settings-card seat key the shell probes for this section's source. */
+    seatKey: string;
     fields: readonly ClientParamField[];
 }
 export declare const CLIENT_PARAM_SECTIONS: readonly ClientParamSection[];

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

@@ -19,6 +19,7 @@ export declare const zh: {
     readonly loading: "正在读取设置…";
     readonly unavailable: "这个功能没有启动（对应的插件没有安装）";
     readonly seatMissing: "这个界面没有提供设置服务，参数只能看不能改";
+    readonly projectionFailed: "这一块读设置时出错，已记入日志；其它参数不受影响";
     readonly readonly: "本次会话不允许写入设置（临时运行模式）";
     readonly apply: "保存";
     readonly reset: "恢复默认值";
@@ -26,7 +27,9 @@ export declare const zh: {
     readonly changed: "{n} 项已改";
     readonly discard: "放弃修改";
     readonly saving: "保存中…";
+    readonly resetting: "恢复中…";
     readonly refused: "这个值没有被接受（界面上保持原样）。想看原因：运行 /evolution params 或 /evolution doctor。";
+    readonly resetRefused: "恢复默认值没有生效（这一行还是你的值）。想看原因：运行 /evolution params 或 /evolution doctor。";
     readonly cardReview: "会话回顾";
     readonly cardMemory: "长期记忆";
     readonly cardToolMemory: "记忆写入";
@@ -40,6 +43,9 @@ export declare const zh: {
     readonly approvalApprove: "批准";
     readonly approvalReject: "拒绝";
     readonly approvalCount: "{n} 项待批";
+    readonly approvalRunningCount: "{n} 项执行中";
+    readonly approvalRefresh: "刷新";
+    readonly approvalExecuting: "执行中：这条的写效果可能已经落地，不要重复批准；要清掉它请用拒绝。";
     readonly approvalKindMemory: "记忆";
     readonly approvalKindSkill: "技能";
     readonly approvalKindCapability: "能力";

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

@@ -47,12 +47,22 @@ export interface ParamSectionSnapshot {
      * all, or the seat is there and serves no such row. The two read differently to the
      * operator (one is the UI's own gap, the other is a row that is not composed).
      */
-    reason?: 'seat-missing' | 'not-served';
+    reason?: 'seat-missing' | 'not-served' | 'projection-failed';
 }
 /** The reactive source the renderer binds to a `use<Name>` seat. */
 export interface ParamSectionSource {
     getSnapshot(): ParamSectionSnapshot;
     subscribe(listener: () => void): () => void;
+    /**
+     * T5-11/A66: the seat ARRIVED (or was replaced) — bind it and wake every listener.
+     *
+     * The source re-probes on every READ, which covers a card that has not rendered yet; it does not
+     * cover a card that already rendered its "no settings surface" state, because nothing tells React to
+     * read again. `ctx.inject` is the platform's own arrival channel (it runs the callback when the
+     * service appears and re-runs it when the service changes), so the bundle subscribes there instead of
+     * inventing a timer.
+     */
+    revive(): void;
 }
 /** One ordered field operation, as the client settings seat takes them. */
 export interface SettingsPathOpLike {

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

@@ -8,18 +8,28 @@
  * too — so the verdict compares what each staged id holds now against what was requested.
  * @module @lmzhen/dsh-evolution-settings-ui
  */
-/** One staged write awaiting its verdict. */
-export interface PendingWrite {
-    /** Parameter id the write named. */
+/**
+ * One staged operation awaiting its verdict, in the platform's own two op kinds.
+ *
+ * `unset` is here because "restore the default" had NO verdict at all (T5-05/A60): the reset path
+ * called the scope and dropped its answer, so a host refusal changed nothing on screen — the row kept
+ * its "edited by you" chip and the reader concluded the button was broken. The two ops need different
+ * evidence (a set landed when the id holds the value; an unset landed when the id is GONE), which is
+ * exactly why they are one union judged by one function instead of two look-alike helpers.
+ */
+export type Settlement = {
+    readonly op: 'set';
     readonly id: string;
-    /** The value handed to the scope's `set`. */
     readonly want: unknown;
-}
+} | {
+    readonly op: 'unset';
+    readonly id: string;
+};
 /**
- * Whether every staged write is visible in the user layer.
- * @param pending - the writes awaiting a verdict.
+ * Whether every staged operation is visible in the user layer.
+ * @param pending - the operations awaiting a verdict.
  * @param user - the user layer of the post-write snapshot; a non-section reads as empty.
- * @returns true when each staged id now holds the value that was requested.
+ * @returns true when each staged id now holds the requested value, or is gone after an `unset`.
  */
-export declare function landedWrites(pending: readonly PendingWrite[], user: unknown): boolean;
+export declare function landedSettlements(pending: readonly Settlement[], user: unknown): boolean;
 //# sourceMappingURL=settle.d.ts.map

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

@@ -4,11 +4,31 @@
  * One place maps `configForms.get(entryId)` to the three things a card needs — a
  * snapshot, a subscription and the two write calls — so our own section's cards and the
  * Plugins page's per-row entry cannot drift apart in how they read or write a row.
+ *
+ * Two invariants live here, both required by the renderer's hook seam:
+ *
+ * - **Stable references.** The renderer binds this source through
+ *   `useSyncExternalStoreWithSelector`, which compares the projected snapshot by reference.
+ *   A `getSnapshot()` that builds a new object on every call never compares equal, so the
+ *   card re-renders until React aborts it (minified invariant #185) and the slot error
+ *   boundary replaces the card with an empty placeholder. The projection therefore caches
+ *   per raw snapshot reference.
+ * - **Never throws.** A throw from `getSnapshot()` happens inside the renderer's render pass,
+ *   where this bundle cannot catch it and a card-level `try`/`catch` around a hook call is
+ *   not legal React. Projection failures return a frozen unavailable snapshot instead.
+ *
+ * The seat itself is probed LAZILY: `apply()` runs before the settings shell may be active
+ * (the shell declares `settings.section` and provides `configForms`), so reading the seat at
+ * apply time would capture `undefined` for the whole life of the fiber.
  * @module @lmzhen/dsh-evolution-settings-ui/client
  */
-import type { ConfigFormSnapshotLike, ConfigFormsSeat, ParamSectionSnapshot, ParamSectionSource } from './seam.ts';
+import type { ConfigFormLike, ConfigFormSnapshotLike, ConfigFormsSeat, ParamSectionSnapshot, ParamSectionSource, SettingsPathOpLike } from './seam.ts';
 /** What a card shows when this UI found no settings seat at all. */
 export declare const SEAT_MISSING: ParamSectionSnapshot;
+/** What a card shows when the seat served the row but projecting it failed. A frozen constant
+ * so a failing row keeps ONE reference: a fresh object per call would reintroduce the
+ * render loop this module exists to prevent. */
+export declare const PROJECTION_FAILED: ParamSectionSnapshot;
 /**
  * Whether a value is a plain section object.
  * @param value - the value to test.
@@ -21,21 +41,52 @@ export declare function isSection(value: unknown): value is Record<string, unkno
  * @returns the card's snapshot, with the reason an unavailable one is unavailable.
  */
 export declare function sectionSnapshotOf(snapshot: ConfigFormSnapshotLike): ParamSectionSnapshot;
+/**
+ * Bind one row's form to a projection that is stable per raw snapshot and never throws.
+ * @param form - the row's client form, as the settings seat hands it over.
+ * @returns the projection the card's hook reads.
+ */
+export declare function stableProjection(form: ConfigFormLike): () => ParamSectionSnapshot;
+/**
+ * The lazily probed client settings seat.
+ *
+ * Probed at read time rather than captured at apply time: this row may activate before the
+ * settings shell, and a captured `undefined` would pin every card to the empty state.
+ * @returns the seat, or undefined while no settings surface is composed.
+ */
+export type SeatProbe = () => ConfigFormsSeat | undefined;
 /**
  * The live source one row's card binds.
- * @param seat - the probed settings seat, when the deployment composed it.
+ * @param probe - the lazily probed settings seat.
  * @param namespace - the row's entry id.
- * @returns the source; without a seat it reports the stated empty state and never notifies.
+ * @returns the source; without a seat it reports the stated empty state, and it re-probes on
+ *   every read so a seat that appears later is picked up without a timer.
  */
-export declare function sourceFor(seat: ConfigFormsSeat | undefined, namespace: string): ParamSectionSource;
+export declare function sourceFor(probe: SeatProbe, namespace: string): ParamSectionSource;
 /**
  * The write pair for one row.
- * @param seat - the probed settings seat, when the deployment composed it.
+ * @param probe - the lazily probed settings seat.
  * @param namespace - the row's entry id.
  * @returns the two calls a card's save/reset path uses; without a seat they resolve without writing.
  */
-export declare function writeFaceFor(seat: ConfigFormsSeat | undefined, namespace: string): {
-    write: (field: string, value: unknown) => Promise<void>;
+export declare function writeFaceFor(probe: SeatProbe, namespace: string): {
+    mutateOnce: (ops: readonly SettingsPathOpLike[]) => Promise<void>;
     clear: (field: string) => Promise<void>;
 };
+/**
+ * One source object per namespace, for the life of the plugin fiber.
+ *
+ * The renderer caches a hook binding per SOURCE OBJECT, so building a source per render
+ * would re-bind the hook and remount the card. The cache is owned by the caller's fiber and
+ * cleared on dispose.
+ * @param probe - the lazily probed settings seat.
+ * @returns the per-namespace source cache and its disposer.
+ */
+export declare function createSourceCache(probe: SeatProbe): {
+    sourceFor: (namespace: string) => ParamSectionSource;
+    /** T5-11/A66: the seat arrived — wake every source this cache built (the cached ones are exactly the
+     * ones whose cards are already mounted and waiting). */
+    revive: () => void;
+    dispose: () => void;
+};
 //# sourceMappingURL=source.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-settings-ui",
   "description": "Web settings cards for the evolution family's parameter namespaces (community build)",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "publishConfig": {
     "access": "public"
   },