dsh-quick-actions 0.1.0-rc.3

package/lib/client.js

@@ -0,0 +1,3901 @@
+window.__ModuleLoader__.load({
+	id: "dsh-quick-actions",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let react = require("react");
+		let react_jsx_runtime = require("react/jsx-runtime");
+		let _deepseek_ai_dsh_client_ui_primitives = require("@deepseek-ai/dsh-client-ui-primitives");
+		let react_dom = require("react-dom");
+		//#region src/model/types.ts
+		/** Every layout value, in the order the management panel offers them. */
+		const QUICK_ACTION_LAYOUTS = [
+			"ribbon",
+			"bar",
+			"launcher"
+		];
+		/**
+		* The identity of a reference as one comparable string. Source and id together
+		* are the identity: the same id under a different source is a different action.
+		*/
+		function quickActionRefKey(ref) {
+			return `${ref.source}:${ref.id}`;
+		}
+		//#endregion
+		//#region src/model/json.ts
+		/**
+		* JSON structural comparison shared by the mutation planner and the Host's
+		* canonical rewrite.
+		*
+		* Structural, not canonical-JSON: object key order carries no meaning here.
+		* A stored section round-tripped through YAML, and a tombstone written by a
+		* higher version, both come back with whatever key order their writer chose —
+		* comparing serialized text would report a difference that is not one, and the
+		* rewrite would then write on every start instead of being idempotent.
+		*/
+		function deepEqualJson(left, right) {
+			if (left === right) return true;
+			if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) return false;
+			if (Array.isArray(left) || Array.isArray(right)) {
+				if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
+				return left.every((item, index) => deepEqualJson(item, right[index]));
+			}
+			const leftKeys = Object.keys(left);
+			const rightKeys = Object.keys(right);
+			if (leftKeys.length !== rightKeys.length) return false;
+			return leftKeys.every((key) => Object.hasOwn(right, key) && deepEqualJson(left[key], right[key]));
+		}
+		//#endregion
+		//#region src/model/text.ts
+		/**
+		* Unicode primitives shared by every Quick Action entry point (spec 4.3).
+		* Config loading, the management form, migration and Settings mutations must all
+		* measure and trim text through these functions so one rule cannot drift from another.
+		*/
+		/**
+		* Reference placeholder code points DSH reserves and strips inside `setDraft`:
+		* the reference marker block plus the legacy object replacement character.
+		* Static text carrying one of them would submit something other than what the
+		* user configured, so the model rejects it as a field error (spec 4.3).
+		*
+		* Source: `REFERENCE_PLACEHOLDER_RE` in `@deepseek-ai/dsh-client-ui-conversation`
+		* (`lib/client.js`, input machine), applied by `setDraft` before it rebuilds the
+		* draft. Verified identical in 0.1.1-rc.2, 0.1.2-rc.1 and 0.1.5-rc.1 — the release
+		* that renamed `imageIds` left this range untouched (ticket 29). Its tail is
+		* published as a named constant, which 0.1.5-rc.1 moved and renamed:
+		* `PLACEHOLDER = "\uFFFC"` in `lib/types/client/input/machine.d.ts` became
+		* `ATOMIC_CHAR = "\uFFFC"` in `lib/types/client/input/editor/projection.d.ts`.
+		* Re-check this range when the supported DSH range moves.
+		*/
+		const RESERVED_REFERENCE_PLACEHOLDER = /[\u{E100}-\u{E11D}\u{FFFC}]/u;
+		/** Unicode code point length — the counting unit for every length limit (spec 4.3). */
+		function countCodePoints(value) {
+			let count = 0;
+			for (const _ of value) count += 1;
+			return count;
+		}
+		/** Whether a text holds no character outside ECMAScript `trim()` whitespace (spec 4.3). */
+		function isBlankQuickActionText(text) {
+			return text.trim().length === 0;
+		}
+		/** Whether a text carries a DSH-reserved reference placeholder code point (spec 4.3). */
+		function containsReservedReferencePlaceholder(text) {
+			return RESERVED_REFERENCE_PLACEHOLDER.test(text);
+		}
+		/**
+		* Whether a static text is a Command Send Action: its first non-whitespace
+		* character is `/` (spec 4.3). Whitespace is ECMAScript `trim()` whitespace.
+		*/
+		function isCommandSendActionText(text) {
+			return text.trimStart().startsWith("/");
+		}
+		/** Code points allowed to appear inside an emoji grapheme cluster. */
+		const EMOJI_CLUSTER_MEMBER = /^[\p{Extended_Pictographic}\p{Emoji_Component}\p{Emoji_Modifier}\u{FE0E}\u{FE0F}\u{200D}]+$/u;
+		/** A keycap sequence carries no pictographic code point of its own. */
+		const KEYCAP_CLUSTER = /^[0-9#*]\u{FE0F}?\u{20E3}$/u;
+		/** A flag is a pair of regional indicators, also without a pictographic code point. */
+		const FLAG_CLUSTER = /^\p{Regional_Indicator}{2}$/u;
+		const graphemeSegmenter = new Intl.Segmenter("en", { granularity: "grapheme" });
+		function isEmojiCluster(cluster) {
+			if (!EMOJI_CLUSTER_MEMBER.test(cluster)) return false;
+			return /\p{Extended_Pictographic}/u.test(cluster) || KEYCAP_CLUSTER.test(cluster) || FLAG_CLUSTER.test(cluster);
+		}
+		/**
+		* Segment an icon candidate into grapheme clusters and report whether each one
+		* is an emoji cluster, so validation can tell `too-long` from `not-emoji`.
+		*/
+		function scanEmojiClusters(icon) {
+			let clusters = 0;
+			let emojiOnly = true;
+			for (const { segment } of graphemeSegmenter.segment(icon)) {
+				clusters += 1;
+				if (!isEmojiCluster(segment)) emojiOnly = false;
+			}
+			return {
+				clusters,
+				emojiOnly
+			};
+		}
+		/** Static text limit, in Unicode code points, measured without trimming (spec 4.3). */
+		const QUICK_ACTION_TEXT_MAX_CODE_POINTS = 4e3;
+		/** Trimmed label, or the reason it cannot be stored. */
+		function labelIssue(label) {
+			const trimmed = label.trim();
+			if (trimmed.length === 0) return {
+				field: "label",
+				reason: "blank"
+			};
+			if (countCodePoints(trimmed) > 40) return {
+				field: "label",
+				reason: "too-long"
+			};
+		}
+		/** The reason a static text cannot be stored, if any. */
+		function textIssue(text) {
+			if (isBlankQuickActionText(text)) return {
+				field: "text",
+				reason: "blank"
+			};
+			if (countCodePoints(text) > 4e3) return {
+				field: "text",
+				reason: "too-long"
+			};
+			if (containsReservedReferencePlaceholder(text)) return {
+				field: "text",
+				reason: "reserved-placeholder"
+			};
+		}
+		/** The reason a non-empty icon cannot be stored, if any. */
+		function iconIssue(icon) {
+			const { clusters, emojiOnly } = scanEmojiClusters(icon);
+			if (!emojiOnly) return {
+				field: "icon",
+				reason: "not-emoji"
+			};
+			if (clusters > 4) return {
+				field: "icon",
+				reason: "too-long"
+			};
+		}
+		/**
+		* Validate one edited or created action. Issues come back in field declaration
+		* order — label, text, icon — so the form can render them deterministically.
+		*/
+		function validateQuickActionDraft(draft) {
+			const issues = [
+				labelIssue(draft.label),
+				textIssue(draft.text),
+				draft.icon === "" ? void 0 : iconIssue(draft.icon)
+			].filter((issue) => issue !== void 0);
+			if (issues.length > 0) return {
+				ok: false,
+				issues
+			};
+			return {
+				ok: true,
+				value: {
+					label: draft.label.trim(),
+					text: draft.text,
+					icon: draft.icon === "" ? void 0 : draft.icon,
+					confirm: draft.confirm
+				}
+			};
+		}
+		function fieldIssue(field, reason) {
+			return {
+				field,
+				reason
+			};
+		}
+		function readId(entry) {
+			const { id } = entry;
+			if (id === void 0) return { issue: fieldIssue("id", "missing") };
+			if (typeof id !== "string") return { issue: fieldIssue("id", "invalid-type") };
+			if (id.trim().length === 0) return { issue: fieldIssue("id", "blank") };
+			return { id };
+		}
+		function readPreset(entry, id) {
+			if (entry.kind !== void 0 && entry.kind !== "send") return { issue: fieldIssue("kind", "unsupported") };
+			const { label, text, icon, confirm } = entry;
+			if (typeof label !== "string") return { issue: fieldIssue("label", label === void 0 ? "missing" : "invalid-type") };
+			const labelProblem = labelIssue(label);
+			if (labelProblem !== void 0) return { issue: labelProblem };
+			if (typeof text !== "string") return { issue: fieldIssue("text", text === void 0 ? "missing" : "invalid-type") };
+			const textProblem = textIssue(text);
+			if (textProblem !== void 0) return { issue: textProblem };
+			if (icon !== void 0 && typeof icon !== "string") return { issue: fieldIssue("icon", "invalid-type") };
+			if (icon === "") return { issue: fieldIssue("icon", "blank") };
+			if (icon !== void 0) {
+				const iconProblem = iconIssue(icon);
+				if (iconProblem !== void 0) return { issue: iconProblem };
+			}
+			if (confirm !== void 0 && typeof confirm !== "boolean") return { issue: fieldIssue("confirm", "invalid-type") };
+			return { preset: {
+				id,
+				kind: "send",
+				label: label.trim(),
+				text,
+				...icon === void 0 ? {} : { icon },
+				confirm: confirm ?? true
+			} };
+		}
+		/**
+		* Read one published catalog snapshot back (spec 17.2). The Host is the catalog's
+		* single validation authority, so this is a defensive decode of an already
+		* confirmed snapshot rather than a second authority — but it is a decode, not a
+		* cast: a snapshot this release cannot read in full yields no catalog at all.
+		*
+		* All-or-nothing on purpose. Dropping the entries it cannot read would show the
+		* user a silently truncated action list, which is exactly what spec 5.1 forbids
+		* the Host to do; the consumer reports a catalog error instead (spec 10).
+		*
+		* The Host's `revision` is carried through rather than recomputed. It is the
+		* catalog's published identity, and a Client that recomputed it would be
+		* asserting an authority it does not have.
+		*/
+		function decodeCatalogSnapshot(raw) {
+			if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return void 0;
+			const { schemaVersion, revision, presets } = raw;
+			if (schemaVersion !== 1) return void 0;
+			if (typeof revision !== "string" || revision === "") return void 0;
+			if (!Array.isArray(presets)) return void 0;
+			const read = readPublishedPresets(presets);
+			if (read === void 0) return void 0;
+			return {
+				schemaVersion: 1,
+				revision,
+				presets: read
+			};
+		}
+		/**
+		* Validate an already-published preset list against the same field rules the
+		* Host applied. Nothing is reported field by field: the Host is the authority
+		* that names an author's mistake, and a Client can only refuse the snapshot.
+		*/
+		function readPublishedPresets(entries) {
+			if (entries.length > 50) return void 0;
+			const presets = [];
+			const seen = /* @__PURE__ */ new Set();
+			for (const entry of entries) {
+				if (typeof entry !== "object" || entry === null || Array.isArray(entry)) return void 0;
+				const record = entry;
+				const identity = readId(record);
+				if ("issue" in identity || seen.has(identity.id)) return void 0;
+				const read = readPreset(record, identity.id);
+				if ("issue" in read) return void 0;
+				seen.add(identity.id);
+				presets.push(read.preset);
+			}
+			return presets;
+		}
+		//#endregion
+		//#region src/model/settings.ts
+		/**
+		* Settings V1 decoding (spec 4.2, 6.3). Decoding is defensive and lossless: it
+		* coerces shapes it recognises, falls back to documented defaults, and preserves
+		* anything it cannot render as a tombstone rather than repairing or dropping it.
+		* Catalog-aware canonicalization lives in `normalize.ts`.
+		*/
+		/**
+		* The one namespace holding user data (spec 4.2); renaming it orphans every
+		* stored section. It lives in the shared model because both faces address it:
+		* the Host registers it, the Client binds the same name.
+		*/
+		const QUICK_ACTIONS_SETTINGS_NAMESPACE = "composer-quick-actions";
+		/**
+		* The read-only namespace carrying the Preset Catalog to Clients (spec 17.2).
+		* The plugin never writes its user layer, so it holds no persisted section —
+		* `composer-quick-actions` remains the only persisted namespace (spec 4.2).
+		*/
+		const QUICK_ACTIONS_CATALOG_NAMESPACE = "composer-quick-actions-catalog";
+		/** The state a fresh install starts from (spec 4.2). */
+		const DEFAULT_QUICK_ACTION_SETTINGS = Object.freeze({
+			schemaVersion: 1,
+			layout: "ribbon",
+			userActionsById: Object.freeze({}),
+			actionOrder: Object.freeze([]),
+			presetStateById: Object.freeze({})
+		});
+		function asRecord(value) {
+			if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+			return value;
+		}
+		/**
+		* Whether a stored entry is a live Send Action this release can render.
+		* Everything else is a tombstone: a higher version's `kind`, or a value whose
+		* label/text are not readable strings.
+		*/
+		function isLiveQuickAction(value) {
+			return value.kind === "send" && typeof value.label === "string" && typeof value.text === "string";
+		}
+		/** Whether a stored entry must be preserved untouched and kept out of every projection (spec 5.3). */
+		function isQuickActionTombstone(value) {
+			return !isLiveQuickAction(value);
+		}
+		function decodeLayout(value) {
+			return QUICK_ACTION_LAYOUTS.find((layout) => layout === value) ?? DEFAULT_QUICK_ACTION_SETTINGS.layout;
+		}
+		/**
+		* Read one stored custom action into canonical form. A missing `kind` reads as
+		* `'send'` because V1 always writes the tag; anything else marks a tombstone and
+		* is handed straight back by identity, so a value written by a higher version
+		* survives the round trip intact.
+		*
+		* A live result always carries `kind`, `confirm` and `enabled` explicitly, which
+		* is what spec 4.3 requires of every normalized action. `confirm` is only
+		* defaulted when it is absent — never derived from the text.
+		*/
+		function decodeStoredQuickAction(value) {
+			const entry = asRecord(value);
+			if (entry === void 0) return void 0;
+			if ((entry.kind ?? "send") !== "send" || typeof entry.label !== "string" || typeof entry.text !== "string") return entry;
+			const { icon, confirm, enabled, clonedFromPresetId } = entry;
+			return {
+				kind: "send",
+				label: entry.label,
+				text: entry.text,
+				...typeof icon === "string" && icon !== "" ? { icon } : {},
+				confirm: typeof confirm === "boolean" ? confirm : true,
+				enabled: typeof enabled === "boolean" ? enabled : true,
+				...typeof clonedFromPresetId === "string" ? { clonedFromPresetId } : {}
+			};
+		}
+		function decodeUserActions(value) {
+			const entries = asRecord(value);
+			if (entries === void 0) return {};
+			const decoded = {};
+			for (const [id, raw] of Object.entries(entries)) {
+				const action = decodeStoredQuickAction(raw);
+				if (action !== void 0) decoded[id] = action;
+			}
+			return decoded;
+		}
+		function decodeRef(value) {
+			const entry = asRecord(value);
+			if (entry === void 0) return void 0;
+			if (typeof entry.id !== "string" || entry.id === "") return void 0;
+			if (entry.source === "preset") return {
+				source: "preset",
+				id: entry.id
+			};
+			if (entry.source === "custom") return {
+				source: "custom",
+				id: entry.id
+			};
+		}
+		function decodeOrder(value) {
+			if (!Array.isArray(value)) return [];
+			return value.map(decodeRef).filter((ref) => ref !== void 0);
+		}
+		/**
+		* Canonicalize one preset state: `hidden` becomes an explicit boolean or
+		* disappears, and every other field is carried through so a higher version's own
+		* preference survives a downgrade (spec 5.3).
+		*/
+		function canonicalPresetState(state) {
+			const rest = { ...state };
+			delete rest.hidden;
+			return state.hidden === true ? {
+				...rest,
+				hidden: true
+			} : rest;
+		}
+		/** Whether a canonical preset state carries no user preference at all. */
+		function isEmptyPresetState(state) {
+			return Object.keys(state).length === 0;
+		}
+		function decodePresetState(value) {
+			const entries = asRecord(value);
+			if (entries === void 0) return {};
+			const decoded = {};
+			for (const [id, raw] of Object.entries(entries)) {
+				const state = asRecord(raw);
+				if (state === void 0) continue;
+				decoded[id] = canonicalPresetState(state);
+			}
+			return decoded;
+		}
+		/**
+		* Decode any published snapshot into V1. The stored `schemaVersion` is not a
+		* gate: a snapshot written by a higher version still yields every field this
+		* release understands, which is what makes a downgrade round trip lossless.
+		*/
+		function decodeQuickActionSettings(raw) {
+			const stored = asRecord(raw);
+			if (stored === void 0) return DEFAULT_QUICK_ACTION_SETTINGS;
+			return {
+				schemaVersion: 1,
+				layout: decodeLayout(stored.layout),
+				userActionsById: decodeUserActions(stored.userActionsById),
+				actionOrder: decodeOrder(stored.actionOrder),
+				presetStateById: decodePresetState(stored.presetStateById)
+			};
+		}
+		//#endregion
+		//#region src/model/normalize.ts
+		/**
+		* Deterministic, idempotent canonicalization of decoded Settings against the
+		* current Preset Catalog (spec 5.3). The same input and catalog always produce
+		* the same result, and normalizing twice changes nothing — which is what lets the
+		* Host rewrite behind a revision fence without fighting its own writes.
+		*
+		* Normalization repairs references and re-states the discriminant, never content.
+		* In particular it never derives `confirm` from the text: that default is
+		* initialized when an action is created or cloned, so rewriting it here would undo
+		* the user's choice on every load and break idempotence.
+		*/
+		/**
+		* Canonicalize one decoded snapshot against a catalog.
+		*
+		* Order: existing references keep their positions, minus repeats and minus
+		* references to custom actions that are gone; references to presets this catalog
+		* no longer carries stay put, because the same Preset Action ID coming back must
+		* restore the user's preference. Known actions with no reference are appended —
+		* presets in catalog order, then custom actions in stored order. Tombstones are
+		* never given a new reference, so a downgrade round trip returns their exact order.
+		*/
+		function normalizeQuickActionSettings(settings, catalog) {
+			const knownPresetIds = new Set(catalog.presets.map((preset) => preset.id));
+			const placed = /* @__PURE__ */ new Set();
+			const actionOrder = [];
+			const place = (ref) => {
+				const key = quickActionRefKey(ref);
+				if (placed.has(key)) return;
+				placed.add(key);
+				actionOrder.push(ref);
+			};
+			const userActionsById = {};
+			for (const [id, stored] of Object.entries(settings.userActionsById)) {
+				const value = decodeStoredQuickAction(stored);
+				if (value !== void 0) userActionsById[id] = value;
+			}
+			for (const ref of settings.actionOrder) {
+				if (ref.source === "custom" && userActionsById[ref.id] === void 0) continue;
+				place(ref);
+			}
+			for (const preset of catalog.presets) place({
+				source: "preset",
+				id: preset.id
+			});
+			for (const [id, value] of Object.entries(userActionsById)) if (isLiveQuickAction(value)) place({
+				source: "custom",
+				id
+			});
+			const presetStateById = {};
+			for (const [id, stored] of Object.entries(settings.presetStateById)) {
+				const state = canonicalPresetState(stored);
+				if (!knownPresetIds.has(id)) presetStateById[id] = state;
+				else if (!isEmptyPresetState(state)) presetStateById[id] = state;
+			}
+			return {
+				schemaVersion: 1,
+				layout: settings.layout,
+				userActionsById,
+				actionOrder,
+				presetStateById
+			};
+		}
+		/**
+		* Project one snapshot against a catalog. The snapshot is canonicalized first, so
+		* the counts are the real totals even when the caller hands over state the catalog
+		* has moved on from — a known preset or a live action missing from the order must
+		* never slip past the action ceiling.
+		*/
+		function projectQuickActions(raw, catalog) {
+			const settings = normalizeQuickActionSettings(raw, catalog);
+			const presets = new Map(catalog.presets.map((preset) => [preset.id, preset]));
+			const managed = [];
+			const referenced = /* @__PURE__ */ new Set();
+			let preserved = 0;
+			for (const ref of settings.actionOrder) {
+				if (ref.source === "preset") {
+					const preset = presets.get(ref.id);
+					if (preset === void 0) {
+						preserved += 1;
+						continue;
+					}
+					managed.push({
+						ref,
+						label: preset.label,
+						text: preset.text,
+						icon: preset.icon,
+						confirm: preset.confirm,
+						command: isCommandSendActionText(preset.text),
+						editable: false,
+						hidden: settings.presetStateById[ref.id]?.hidden === true,
+						clonedFromPresetId: void 0
+					});
+					continue;
+				}
+				referenced.add(ref.id);
+				const value = settings.userActionsById[ref.id];
+				if (value === void 0 || !isLiveQuickAction(value)) {
+					preserved += 1;
+					continue;
+				}
+				managed.push({
+					ref,
+					label: value.label,
+					text: value.text,
+					icon: value.icon,
+					confirm: value.confirm,
+					command: isCommandSendActionText(value.text),
+					editable: true,
+					hidden: !value.enabled,
+					clonedFromPresetId: value.clonedFromPresetId
+				});
+			}
+			for (const [id, value] of Object.entries(settings.userActionsById)) if (!referenced.has(id) && isQuickActionTombstone(value)) preserved += 1;
+			const composer = managed.filter((action) => !action.hidden);
+			const total = managed.length;
+			return {
+				layout: settings.layout,
+				managed,
+				composer,
+				counts: {
+					total,
+					limit: 50,
+					overflow: total > 50,
+					canAdd: total < 50,
+					visible: composer.length,
+					hidden: total - composer.length,
+					preserved
+				}
+			};
+		}
+		//#endregion
+		//#region src/model/mutations.ts
+		/**
+		* Revision-fenced Settings mutation planning (spec 5.2, 5.4, 6.3, 10).
+		*
+		* A planner is pure: it takes the last Host-confirmed snapshot and returns the
+		* canonical snapshot to persist together with the revision the write must be
+		* fenced to. It performs no I/O and mints no identity — the caller supplies each
+		* new Custom Action ID, so a UUID collision comes back as a refusal to retry
+		* rather than as a silent overwrite.
+		*/
+		/** The draft the management form opens on; the only place the confirm default is applied. */
+		function newQuickActionDraft() {
+			return {
+				label: "",
+				text: "",
+				icon: "",
+				confirm: true
+			};
+		}
+		function refuse(reason, issues = []) {
+			return {
+				ok: false,
+				rejection: {
+					reason,
+					issues
+				}
+			};
+		}
+		function unknownAction() {
+			return refuse("unknown-action", [{
+				field: "id",
+				reason: "missing"
+			}]);
+		}
+		function planFrom(context, current, next) {
+			const canonical = normalizeQuickActionSettings(next, context.catalog);
+			return {
+				ok: true,
+				plan: {
+					expectedRevision: context.revision,
+					next: canonical,
+					changed: !deepEqualJson(current, canonical)
+				}
+			};
+		}
+		/** Every planner starts from the canonical reading of the confirmed snapshot. */
+		function currentOf(context) {
+			return normalizeQuickActionSettings(context.settings, context.catalog);
+		}
+		function withUserActions(settings, userActionsById) {
+			return {
+				...settings,
+				userActionsById
+			};
+		}
+		function liveActionOf(settings, id) {
+			const value = settings.userActionsById[id];
+			if (value === void 0 || !isLiveQuickAction(value)) return void 0;
+			return value;
+		}
+		/** Build one stored Send Action with every field spec 4.3 requires stated explicitly. */
+		function sendActionValue(input) {
+			return {
+				kind: "send",
+				label: input.label,
+				text: input.text,
+				...input.icon === void 0 ? {} : { icon: input.icon },
+				confirm: input.confirm,
+				enabled: input.enabled,
+				...input.clonedFromPresetId === void 0 ? {} : { clonedFromPresetId: input.clonedFromPresetId }
+			};
+		}
+		/**
+		* Check a caller-minted Custom Action ID before it is persisted. A taken id comes
+		* back as `id-in-use` so the caller mints another UUID and retries; normalization
+		* must never renumber an id that is already stored (spec 4.1).
+		*/
+		function identityRefusal(settings, id) {
+			if (id === "") return refuse("invalid-fields", [{
+				field: "id",
+				reason: "blank"
+			}]);
+			if (settings.userActionsById[id] !== void 0) return refuse("id-in-use", [{
+				field: "id",
+				reason: "duplicate"
+			}]);
+		}
+		function planWithAction(context, current, id, value) {
+			return planFrom(context, current, withUserActions(current, {
+				...current.userActionsById,
+				[id]: value
+			}));
+		}
+		/** Create a Custom Quick Action under a caller-minted identity (spec 5.2, 5.4). */
+		function planCreateCustomQuickAction(context, input) {
+			const current = currentOf(context);
+			if (!projectQuickActions(current, context.catalog).counts.canAdd) return refuse("limit-reached");
+			const refusal = identityRefusal(current, input.id);
+			if (refusal !== void 0) return refusal;
+			const validated = validateQuickActionDraft(input.draft);
+			if (!validated.ok) return refuse("invalid-fields", validated.issues);
+			return planWithAction(context, current, input.id, sendActionValue({
+				...validated.value,
+				enabled: true,
+				clonedFromPresetId: void 0
+			}));
+		}
+		/**
+		* Clone a Preset Quick Action into a new Custom Quick Action (spec 5.2).
+		* The confirmation policy is copied as it stands — including a Command Send
+		* Action the author left unconfirmed — never re-defaulted.
+		*/
+		function planClonePresetQuickAction(context, input) {
+			const current = currentOf(context);
+			if (!projectQuickActions(current, context.catalog).counts.canAdd) return refuse("limit-reached");
+			const preset = context.catalog.presets.find((candidate) => candidate.id === input.presetId);
+			if (preset === void 0) return unknownAction();
+			const refusal = identityRefusal(current, input.id);
+			if (refusal !== void 0) return refusal;
+			return planWithAction(context, current, input.id, sendActionValue({
+				label: preset.label,
+				text: preset.text,
+				icon: preset.icon,
+				confirm: preset.confirm,
+				enabled: true,
+				clonedFromPresetId: preset.id
+			}));
+		}
+		/**
+		* Save edited content onto an existing Custom Quick Action. `enabled` and the
+		* Clone Provenance survive the edit; `confirm` comes from the form, which is the
+		* only place the user can change it.
+		*/
+		function planUpdateCustomQuickAction(context, input) {
+			const current = currentOf(context);
+			const existing = liveActionOf(current, input.id);
+			if (existing === void 0) return unknownAction();
+			const validated = validateQuickActionDraft(input.draft);
+			if (!validated.ok) return refuse("invalid-fields", validated.issues);
+			return planWithAction(context, current, input.id, sendActionValue({
+				...validated.value,
+				enabled: existing.enabled,
+				clonedFromPresetId: existing.clonedFromPresetId
+			}));
+		}
+		/** Disable or re-enable a Custom Quick Action; disabled actions stay in the management panel (spec 3). */
+		function planSetCustomQuickActionEnabled(context, input) {
+			const current = currentOf(context);
+			const existing = liveActionOf(current, input.id);
+			if (existing === void 0) return unknownAction();
+			return planWithAction(context, current, input.id, {
+				...existing,
+				enabled: input.enabled
+			});
+		}
+		/** Delete a Custom Quick Action; normalization drops its order reference with it. */
+		function planDeleteCustomQuickAction(context, input) {
+			const current = currentOf(context);
+			if (liveActionOf(current, input.id) === void 0) return unknownAction();
+			const userActionsById = { ...current.userActionsById };
+			delete userActionsById[input.id];
+			return planFrom(context, current, withUserActions(current, userActionsById));
+		}
+		/** Hide or restore a Preset Quick Action; the author's definition is never touched (spec 5.1). */
+		function planSetPresetQuickActionHidden(context, input) {
+			const current = currentOf(context);
+			if (!context.catalog.presets.some((preset) => preset.id === input.presetId)) return unknownAction();
+			const presetStateById = { ...current.presetStateById };
+			if (input.hidden) presetStateById[input.presetId] = { hidden: true };
+			else delete presetStateById[input.presetId];
+			return planFrom(context, current, {
+				...current,
+				presetStateById
+			});
+		}
+		/**
+		* Apply a new order to the actions the management panel lists. Preserved
+		* references — unknown presets and tombstones — keep their exact positions, so a
+		* reorder here never disturbs data a higher version owns.
+		*/
+		function planReorderQuickActions(context, input) {
+			const current = currentOf(context);
+			const managed = projectQuickActions(current, context.catalog).managed.map((action) => action.ref);
+			const managedKeys = new Set(managed.map(quickActionRefKey));
+			const wanted = input.order.map(quickActionRefKey);
+			if (wanted.length !== managedKeys.size || new Set(wanted).size !== wanted.length) return refuse("invalid-order");
+			if (!wanted.every((key) => managedKeys.has(key))) return refuse("invalid-order");
+			const queue = [...input.order];
+			const actionOrder = current.actionOrder.map((ref) => managedKeys.has(quickActionRefKey(ref)) ? queue.shift() ?? ref : ref);
+			return planFrom(context, current, {
+				...current,
+				actionOrder
+			});
+		}
+		/** Move one managed action to another position in the management list. */
+		function planMoveQuickAction(context, input) {
+			const managed = projectQuickActions(currentOf(context), context.catalog).managed.map((action) => action.ref);
+			const from = managed.findIndex((candidate) => quickActionRefKey(candidate) === quickActionRefKey(input.ref));
+			if (from === -1) return unknownAction();
+			if (!Number.isInteger(input.toIndex) || input.toIndex < 0 || input.toIndex >= managed.length) return refuse("invalid-order");
+			const order = [...managed];
+			const [moved] = order.splice(from, 1);
+			if (moved === void 0) return refuse("invalid-order");
+			order.splice(input.toIndex, 0, moved);
+			return planReorderQuickActions(context, { order });
+		}
+		/** Switch the global Quick Action Layout (spec 8.1). */
+		function planSetQuickActionLayout(context, input) {
+			const current = currentOf(context);
+			return planFrom(context, current, {
+				...current,
+				layout: input.layout
+			});
+		}
+		//#endregion
+		//#region src/client/controller.ts
+		/**
+		* The Client's single owner of authoritative Quick Action state (spec 7.1).
+		*
+		* It binds the two Settings namespaces the Host registers — the read-only
+		* catalog namespace, read off its composition `base` layer, and the user-state
+		* namespace — derives the projection every surface renders, and serializes
+		* revision-fenced writes back through the same scope.
+		*
+		* What it deliberately does not own:
+		*
+		* - **Validation and migration authority.** The Host owns both (spec 6.3). Every
+		*   rule applied here comes from the shared model, and a snapshot is decoded
+		*   defensively rather than repaired: this face never rewrites before validating,
+		*   never writes a file, and never treats browser storage as a source of truth.
+		* - **Anything session-scoped.** No Session, InputState, Slot props or
+		*   `InputActions` object reaches this module — long-lived global state must not
+		*   pin a session's runtime objects (spec 7.1). Draft occupancy, confirmation and
+		*   send single-flight belong to the per-session execution layer (spec 7.2).
+		* - **Its own copy of the settings document.** Both bindings derive from the one
+		*   browser-side describe mirror, so the catalog costs no read of its own and
+		*   refreshes with that mirror after a reconnect (spec 17.3).
+		*/
+		/**
+		* How many Custom Action IDs a create or clone tries before giving up.
+		* Normalization must never renumber a stored id (spec 4.1), so the planner
+		* refuses a taken id and the controller mints another rather than overwriting
+		* anything; exhausting the attempts surfaces the refusal instead of hiding it.
+		*/
+		const ID_MINT_ATTEMPTS = 4;
+		/** The five top-level fields of the persisted section (spec 4.2). */
+		function sectionOps(next) {
+			return [
+				{
+					op: "set",
+					path: ["schemaVersion"],
+					value: next.schemaVersion
+				},
+				{
+					op: "set",
+					path: ["layout"],
+					value: next.layout
+				},
+				{
+					op: "set",
+					path: ["userActionsById"],
+					value: next.userActionsById
+				},
+				{
+					op: "set",
+					path: ["actionOrder"],
+					value: next.actionOrder
+				},
+				{
+					op: "set",
+					path: ["presetStateById"],
+					value: next.presetStateById
+				}
+			];
+		}
+		/**
+		* Read the catalog off a bound namespace.
+		*
+		* `base` is read, never `value`: `base` is the author's own layer, so a user who
+		* hand-writes a section of that name into the settings document still sees the
+		* Host's catalog (spec 17.2).
+		*/
+		function readCatalog(snapshot, document) {
+			if (snapshot.status === "loading") {
+				if (document.view !== void 0) return {
+					status: "error",
+					reason: "unavailable"
+				};
+				return document.error === null ? { status: "loading" } : {
+					status: "error",
+					reason: "unreadable"
+				};
+			}
+			if (snapshot.status === "unavailable" || snapshot.base === void 0) return {
+				status: "error",
+				reason: "unavailable"
+			};
+			const catalog = decodeCatalogSnapshot(snapshot.base);
+			if (catalog === void 0) return {
+				status: "error",
+				reason: "undecodable"
+			};
+			return {
+				status: "ready",
+				catalog
+			};
+		}
+		/**
+		* Read the confirmed user state off a bound namespace.
+		*
+		* Decoded, not canonicalized: canonicalization is catalog-relative, and whether
+		* a namespace is readable has nothing to do with whether the catalog is. Every
+		* consumer that needs the canonical form — the projection, each planner, the
+		* post-write comparison — derives it against the catalog it already holds.
+		*/
+		function readSettings(snapshot) {
+			if (snapshot.status === "loading") return { status: "loading" };
+			if (snapshot.status === "unavailable" || snapshot.revision === void 0) return { status: "unavailable" };
+			return {
+				status: "ready",
+				settings: decodeQuickActionSettings(snapshot.value),
+				revision: snapshot.revision,
+				writable: snapshot.writable
+			};
+		}
+		function writeGate(catalog, settings, stale) {
+			if (catalog.status !== "ready" || settings.status !== "ready") return {
+				ok: false,
+				failure: { kind: "not-ready" }
+			};
+			if (!settings.writable || stale) return {
+				ok: false,
+				failure: { kind: "read-only" }
+			};
+			return {
+				ok: true,
+				context: {
+					settings: settings.settings,
+					catalog: catalog.catalog,
+					revision: String(settings.revision)
+				},
+				catalog: catalog.catalog,
+				revision: settings.revision
+			};
+		}
+		/**
+		* Create the controller. Both bindings are made on the calling fiber, so the
+		* scope disposers the binder registers are withdrawn with it; `dispose()`
+		* releases what this module owns on top of that.
+		*/
+		function createQuickActionsController(options) {
+			const mintId = options.mintCustomActionId ?? (() => crypto.randomUUID());
+			const catalogScope = options.settingsScope.bind({
+				namespace: QUICK_ACTIONS_CATALOG_NAMESPACE,
+				decode: (value) => value ?? null
+			});
+			const settingsScope = options.settingsScope.bind({
+				namespace: QUICK_ACTIONS_SETTINGS_NAMESPACE,
+				decode: (value) => decodeQuickActionSettings(value)
+			});
+			const mirror = options.settingsScope.describe();
+			const listeners = /* @__PURE__ */ new Set();
+			let disposed = false;
+			let manager = { open: false };
+			let writing = 0;
+			let failure;
+			let connectionState = options.connection.state.getSnapshot();
+			let state = derive();
+			/** Serializes this controller's own writes so each plan reads the previous one back. */
+			let tail = Promise.resolve();
+			function derive() {
+				const catalog = readCatalog(catalogScope.getSnapshot(), mirror.getSnapshot());
+				const settings = readSettings(settingsScope.getSnapshot());
+				const projection = catalog.status === "ready" ? projectQuickActions(settings.status === "ready" ? settings.settings : DEFAULT_QUICK_ACTION_SETTINGS, catalog.catalog) : void 0;
+				const stale = connectionState !== void 0 && connectionState !== "connected";
+				return {
+					catalog,
+					settings,
+					projection,
+					readOnly: !writeGate(catalog, settings, stale).ok,
+					stale,
+					manager,
+					writing: writing > 0,
+					...failure === void 0 ? {} : { failure }
+				};
+			}
+			/** Republish only on a real change, so a subscriber never re-renders for nothing. */
+			function publish() {
+				if (disposed) return;
+				const next = derive();
+				if (deepEqualJson(state, next)) return;
+				state = next;
+				for (const listener of Array.from(listeners)) listener();
+			}
+			const stopSources = [
+				mirror.subscribe(publish),
+				catalogScope.subscribe(publish),
+				settingsScope.subscribe(publish)
+			];
+			const stopConnection = options.connection.state.subscribe(() => {
+				connectionState = options.connection.state.getSnapshot();
+				publish();
+			});
+			/**
+			* Run one planner, re-minting on a taken Custom Action ID. Only a planner that
+			* mints can answer `id-in-use`, so this loop costs nothing for the others.
+			*/
+			function plan(planner, context) {
+				let outcome = planner(context);
+				for (let attempt = 1; attempt < ID_MINT_ATTEMPTS; attempt += 1) {
+					if (outcome.ok || outcome.rejection.reason !== "id-in-use") return outcome;
+					outcome = planner(context);
+				}
+				return outcome;
+			}
+			/**
+			* Classify one settled write against the snapshot the scope published for it.
+			*
+			* The stored state reading back as the plan is the only positive evidence of a
+			* commit. Failing that, a namespace revision that moved elsewhere is a lost
+			* fence and anything else is a Host refusal — with one bounded blind spot: if
+			* the recovery read that follows a refusal also fails, a lost fence is
+			* indistinguishable from a refusal and is reported as the latter. In that
+			* window the connection is down, so the surfaces are already read-only, and
+			* retrying against the stale fence is refused again rather than overwriting
+			* the writer that won.
+			*/
+			function classify(catalog, next, fence) {
+				const snapshot = settingsScope.getSnapshot();
+				const settings = readSettings(snapshot);
+				if (settings.status === "ready" && deepEqualJson(normalizeQuickActionSettings(settings.settings, catalog), next)) return {
+					ok: true,
+					changed: true
+				};
+				if (snapshot.revision !== fence) return {
+					ok: false,
+					failure: { kind: "conflict" }
+				};
+				return {
+					ok: false,
+					failure: { kind: "refused" }
+				};
+			}
+			function settle(outcome) {
+				failure = outcome.ok ? void 0 : outcome.failure;
+				return outcome;
+			}
+			function submit(planner) {
+				if (disposed) return Promise.resolve({
+					ok: false,
+					failure: { kind: "not-ready" }
+				});
+				writing += 1;
+				publish();
+				const task = tail.then(async () => {
+					if (disposed) return {
+						ok: false,
+						failure: { kind: "not-ready" }
+					};
+					const gate = writeGate(state.catalog, state.settings, state.stale);
+					if (!gate.ok) return settle(gate);
+					try {
+						const outcome = plan(planner, gate.context);
+						if (!outcome.ok) return settle({
+							ok: false,
+							failure: {
+								kind: "rejected",
+								rejection: outcome.rejection
+							}
+						});
+						if (!outcome.plan.changed) return settle({
+							ok: true,
+							changed: false
+						});
+						await settingsScope.mutate(sectionOps(outcome.plan.next), gate.revision);
+						return settle(classify(gate.catalog, outcome.plan.next, gate.revision));
+					} catch (error) {
+						await mirror.load().catch(() => void 0);
+						return settle({
+							ok: false,
+							failure: {
+								kind: "failed",
+								message: messageOf$1(error)
+							}
+						});
+					}
+				});
+				tail = task.catch(() => void 0);
+				return task.finally(() => {
+					writing -= 1;
+					publish();
+				});
+			}
+			return {
+				getSnapshot: () => state,
+				subscribe(listener) {
+					listeners.add(listener);
+					return () => {
+						listeners.delete(listener);
+					};
+				},
+				refresh: async () => {
+					if (disposed) return;
+					await mirror.load();
+				},
+				openManager() {
+					manager = { open: true };
+					publish();
+				},
+				closeManager() {
+					manager = { open: false };
+					publish();
+				},
+				dismissFailure() {
+					failure = void 0;
+					publish();
+				},
+				createCustomAction: (draft) => submit((context) => planCreateCustomQuickAction(context, {
+					id: mintId(),
+					draft
+				})),
+				clonePreset: (presetId) => submit((context) => planClonePresetQuickAction(context, {
+					presetId,
+					id: mintId()
+				})),
+				updateCustomAction: (id, draft) => submit((context) => planUpdateCustomQuickAction(context, {
+					id,
+					draft
+				})),
+				setCustomActionEnabled: (id, enabled) => submit((context) => planSetCustomQuickActionEnabled(context, {
+					id,
+					enabled
+				})),
+				deleteCustomAction: (id) => submit((context) => planDeleteCustomQuickAction(context, { id })),
+				setPresetHidden: (presetId, hidden) => submit((context) => planSetPresetQuickActionHidden(context, {
+					presetId,
+					hidden
+				})),
+				reorderActions: (order) => submit((context) => planReorderQuickActions(context, { order })),
+				moveAction: (ref, toIndex) => submit((context) => planMoveQuickAction(context, {
+					ref,
+					toIndex
+				})),
+				setLayout: (layout) => submit((context) => planSetQuickActionLayout(context, { layout })),
+				/**
+				* Release what this module owns. The two scope bindings are withdrawn by the
+				* binder's own disposer on the fiber this controller was created on, so the
+				* fiber and this call together leave nothing behind.
+				*/
+				dispose() {
+					disposed = true;
+					for (const stop of stopSources) stop();
+					stopConnection();
+					listeners.clear();
+				}
+			};
+		}
+		function messageOf$1(error) {
+			return error instanceof Error ? error.message : String(error);
+		}
+		//#endregion
+		//#region src/client/session/guards.ts
+		/**
+		* Whether one published list field carries content, read totally.
+		*
+		* A field that is absent or not an array counts as content. The snapshot is the
+		* only evidence this guard has, and DSH has renamed a field of it out from
+		* under this plugin once already (`imageIds` → `attachmentIds` in 0.1.5-rc.1,
+		* ticket 29). If that happens again, a Quick Action must go inert rather than
+		* load a draft whose remaining content this guard can no longer see — an action
+		* that fired blind would submit its own text *plus* whatever the user had
+		* attached.
+		*
+		* This is not the compatibility fallback spec 21.3 rules out: no superseded
+		* field name is ever read, and nothing degrades to a working state. The only
+		* thing it buys is that an unreadable snapshot reports `occupied-draft` instead
+		* of throwing through `derive → publish → observe` and taking the whole surface
+		* down with it.
+		*/
+		function holdsContent(field) {
+			if (!Array.isArray(field)) return true;
+			return field.length > 0;
+		}
+		/**
+		* Whether the draft is occupied (spec 9.2). Occupancy is any text — pure
+		* whitespace included, so the raw string is compared against `''` and never
+		* trimmed — any attachment, and any rich reference.
+		*
+		* The public snapshot exposes exactly `{ draft, attachmentIds, draftRev, phase,
+		* claim?, occurrences, queue }`. Occupancy reads three of them:
+		*
+		* - `draft` — the clipboard-text projection of the whole document. Compared
+		*   against `''`, so a snapshot without it is occupied for the same reason
+		*   {@link holdsContent} gives;
+		* - `attachmentIds` — the ordered draft attachments, and the only public
+		*   attachment field there is. Since 0.1.5-rc.1 it admits any attachment kind,
+		*   not just images;
+		* - `occurrences` — the reference chips. They are already expanded inside
+		*   `draft`, so this test is redundant today; it is kept because a future chip
+		*   whose clipboard projection is empty must still count as content the send
+		*   action would carry away.
+		*
+		* The remaining fields are not occupancy: `draftRev` is a revision counter,
+		* `phase`/`claim` are the submit plane (handled by {@link composerGate}), and
+		* `queue` is the Session's transient inbox, which spec 9.2 explicitly allows a
+		* send to join.
+		*/
+		function isOccupiedDraft(input) {
+			return input.draft !== "" || holdsContent(input.attachmentIds) || holdsContent(input.occurrences);
+		}
+		/**
+		* The composer-level guard, reproducing the shipped send button's own
+		* conditions from public state alone (spec 9.2).
+		*
+		* `disabled` in spec 9.2's list is the shipped bar's inert state, which is
+		* reached only without a Session or on the blank-session hero. Neither can
+		* occur here: both dock Slots are session-scoped, and the Quick Action surfaces
+		* render only where the Resident Composer predicate holds.
+		*/
+		function composerGate(input, session, block) {
+			if (session.removed) return "session-removed";
+			if (block !== void 0) return "composer-blocked";
+			if (session.subagent?.address.mode === "continuable" && session.subagent.parentAvailable !== true) return "parent-offline";
+			if (input.phase !== "plain") return "composer-busy";
+			if (isOccupiedDraft(input)) return "occupied-draft";
+		}
+		//#endregion
+		//#region src/client/session/execution.ts
+		/**
+		* The per-Session Quick Action execution layer (spec 7.2, 9.2–9.5).
+		*
+		* One engine per Session owns the current `InputActions`, the confirmation in
+		* flight and the send single-flight. Nothing global holds it: the registry below
+		* hands the same engine to whichever Slot entry is currently rendering the
+		* layout, so switching layouts re-mounts a component without ever minting a
+		* second lock for the same Session (spec 7.2).
+		*
+		* ## The single-flight window
+		*
+		* Spec 9.5 asks for a window that runs from the first activation until the
+		* official submission stage ends, judged only from the published Input snapshot
+		* `{ draft, attachmentIds, draftRev, phase, claim?, occurrences, queue }`, with the
+		* hard acceptance criterion that it never produces a duplicate send.
+		*
+		* The mutex itself is this module's own: {@link QuickActionSessionEngine.activate}
+		* claims it synchronously, before any await and before the draft is touched. It
+		* is deliberately not derived from draft occupancy — the official default sink
+		* clears optimistically, so a second activation one frame later would find an
+		* empty draft and pass every precondition. That is the duplicate-send trap, and
+		* the regression test for it pins two activations in the same tick.
+		*
+		* What the public snapshot is used for is deciding *when the window may close*,
+		* and the answer differs by the path the official machine took. Both readings
+		* come from one place: `SessionInputShell.submit()` feeds an `enter` event to a
+		* pure submit machine and executes the resulting effects synchronously, then
+		* publishes. So the first snapshot observed after `submit()` returns already
+		* carries the machine's verdict.
+		*
+		* - **The machine kept the frozen slot** (`phase` is `adjudicating` or
+		*   `submitting`). Our attempt owns that slot exclusively — the machine refuses
+		*   another `enter` while it is held — so the phase is attributable to this
+		*   submission. The window stays open until the phase leaves those states; that
+		*   is the latest reliable public boundary of the official stage, and past it
+		*   every outcome belongs to DSH's own feedback (spec 9.5).
+		* - **The machine committed an ordinary send** (`phase` back to `plain` and
+		*   `draft` empty). The optimistic commit is the official stage's last publicly
+		*   observable step: the default sink runs detached, and nothing about it
+		*   reaches the public snapshot. So the commit is the latest boundary
+		*   attributable to this submission, and the window closes there.
+		* - **The machine refused the submission** (`phase` still `plain` and `draft`
+		*   still holding content). Nothing was sent; the text stays exactly as loaded
+		*   and the window closes with "not sent, text retained".
+		*
+		* The ordinary-send test is emptiness, not equality with the text that was
+		* loaded: `draft` is the editor's clipboard-text projection rather than the
+		* string handed to `setDraft`, so comparing the two would make the verdict
+		* depend on that round trip. Emptiness needs no such assumption — the load only
+		* ever runs against a verified-unoccupied draft, so anything in `draft` after it
+		* is this feature's own text, and only the official commit clears it.
+		*
+		* The window also never closes inside the activation that opened it: settlement
+		* is read from {@link QuickActionSessionEngine.observe}, which the owning entry
+		* calls once per commit, so two activations in one tick can only ever produce
+		* one send however fast the official sink empties the draft.
+		*
+		* Nothing here reads the DOM, Lexical, a private event or a private state, and
+		* no DSH object is retained beyond the Session it belongs to.
+		*/
+		/**
+		* The executable identity of an action: everything a re-verification must find
+		* unchanged before the draft is touched (spec 9.3). `command` is included even
+		* though it is derived from `text`, so a rewrite that moves the action across
+		* the Command Send Action boundary is rejected under its own name.
+		*/
+		function identityOf(action) {
+			return JSON.stringify([
+				quickActionRefKey(action.ref),
+				action.label,
+				action.text,
+				action.confirm,
+				action.command,
+				action.hidden
+			]);
+		}
+		function messageOf(error) {
+			return error instanceof Error ? error.message : String(error);
+		}
+		/** Create the execution engine for one Session. */
+		function createQuickActionSessionEngine(sessionId) {
+			const listeners = /* @__PURE__ */ new Set();
+			let disposed = false;
+			let observed;
+			let actions;
+			let composer = [];
+			let flight;
+			let confirming;
+			let identity;
+			let feedback;
+			/** True while `run` is on the stack, so no settlement can close its own flight. */
+			let running = false;
+			let state = derive();
+			function derive() {
+				return {
+					unavailable: flight !== void 0 ? "sending" : observed === void 0 ? "composer-busy" : composerGate(observed.input, observed.session, observed.block),
+					confirming,
+					sending: flight !== void 0,
+					activeRef: flight?.ref,
+					feedback
+				};
+			}
+			function publish() {
+				if (disposed) return;
+				const next = derive();
+				if (next.unavailable === state.unavailable && next.confirming === state.confirming && next.sending === state.sending && next.activeRef === state.activeRef && next.feedback === state.feedback) return;
+				state = next;
+				for (const listener of Array.from(listeners)) listener();
+			}
+			/** End the flight, optionally reporting why. */
+			function settle(next) {
+				flight = void 0;
+				confirming = void 0;
+				identity = void 0;
+				feedback = next;
+				publish();
+			}
+			/** The action as the current Composer projection carries it, if it still does. */
+			function shownAction(ref) {
+				const key = quickActionRefKey(ref);
+				const found = composer.find((action) => quickActionRefKey(action.ref) === key);
+				return found === void 0 || found.hidden ? void 0 : found;
+			}
+			/** Re-read everything spec 9.3 lists, immediately before the draft is touched. */
+			function reverify(ref) {
+				const found = shownAction(ref);
+				if (found === void 0) return void 0;
+				if (identity !== void 0 && identityOf(found) !== identity) return void 0;
+				if (observed === void 0 || observed.session.sessionId !== sessionId) return void 0;
+				if (composerGate(observed.input, observed.session, observed.block) !== void 0) return void 0;
+				return found;
+			}
+			/**
+			* Load the static text and hand it to the official submit path (spec 9.4).
+			* The two calls are the whole write side of this feature; everything before
+			* them is verification and everything after is observation.
+			*/
+			function run(action) {
+				const face = actions;
+				if (face === void 0 || observed === void 0) {
+					settle({ kind: "state-changed" });
+					return;
+				}
+				running = true;
+				try {
+					try {
+						face.setDraft(action.text);
+					} catch (error) {
+						settle({
+							kind: "failed",
+							message: messageOf(error)
+						});
+						return;
+					}
+					flight = {
+						stage: "submitted",
+						ref: action.ref
+					};
+					confirming = void 0;
+					try {
+						face.submit();
+					} catch (error) {
+						settle({ kind: "retained" });
+						return;
+					}
+				} finally {
+					running = false;
+				}
+				publish();
+			}
+			return {
+				getSnapshot: () => state,
+				subscribe(listener) {
+					listeners.add(listener);
+					return () => {
+						listeners.delete(listener);
+					};
+				},
+				observe(input, session, block) {
+					if (disposed) return;
+					observed = {
+						input,
+						session,
+						block
+					};
+					if (running) return;
+					if (flight?.stage === "submitted") {
+						if (input.phase === "adjudicating" || input.phase === "submitting") {
+							flight = {
+								stage: "official",
+								ref: flight.ref
+							};
+							confirming = void 0;
+							feedback = void 0;
+						} else if (input.draft === "") settle(void 0);
+						else settle({ kind: "retained" });
+					} else if (flight?.stage === "official" && input.phase !== "adjudicating" && input.phase !== "submitting") settle(void 0);
+					publish();
+				},
+				bind(face, projection) {
+					if (disposed) return;
+					actions = face;
+					composer = projection;
+					if (confirming !== void 0 && shownAction(confirming.ref) === void 0) settle(void 0);
+					publish();
+				},
+				activate(action) {
+					if (disposed) return;
+					if (flight !== void 0) return;
+					if (observed === void 0 || observed.session.sessionId !== sessionId) {
+						settle({ kind: "state-changed" });
+						return;
+					}
+					if (shownAction(action.ref) === void 0 || composerGate(observed.input, observed.session, observed.block) !== void 0) {
+						settle({ kind: "state-changed" });
+						return;
+					}
+					identity = identityOf(action);
+					feedback = void 0;
+					flight = {
+						stage: "pending",
+						ref: action.ref
+					};
+					if (action.confirm) {
+						confirming = {
+							ref: action.ref,
+							label: action.label,
+							text: action.text,
+							command: action.command
+						};
+						publish();
+						return;
+					}
+					const fresh = reverify(action.ref);
+					if (fresh === void 0) {
+						settle({ kind: "state-changed" });
+						return;
+					}
+					run(fresh);
+				},
+				confirm() {
+					if (disposed || flight?.stage !== "pending" || confirming === void 0) return;
+					const fresh = reverify(flight.ref);
+					if (fresh === void 0) {
+						settle({ kind: "state-changed" });
+						return;
+					}
+					run(fresh);
+				},
+				cancel() {
+					if (disposed || flight?.stage !== "pending" || confirming === void 0) return;
+					settle(void 0);
+				},
+				dismissFeedback() {
+					if (disposed || feedback === void 0) return;
+					feedback = void 0;
+					publish();
+				},
+				cancelPending() {
+					if (disposed || flight === void 0) return;
+					if (flight.stage !== "pending") return;
+					settle(void 0);
+				},
+				dispose() {
+					disposed = true;
+					listeners.clear();
+					actions = void 0;
+					observed = void 0;
+					composer = [];
+				}
+			};
+		}
+		function createQuickActionSessionRegistry() {
+			const engines = /* @__PURE__ */ new Map();
+			return {
+				engineFor(sessionId) {
+					let engine = engines.get(sessionId);
+					if (engine === void 0) {
+						engine = createQuickActionSessionEngine(sessionId);
+						engines.set(sessionId, engine);
+					}
+					return engine;
+				},
+				dispose() {
+					for (const engine of engines.values()) {
+						engine.cancelPending();
+						engine.dispose();
+					}
+					engines.clear();
+				}
+			};
+		}
+		//#endregion
+		//#region src/client/surfaces/residency.ts
+		function createResidentComposerRegistry() {
+			const marks = /* @__PURE__ */ new Map();
+			const listeners = /* @__PURE__ */ new Set();
+			function publish() {
+				for (const listener of Array.from(listeners)) listener();
+			}
+			return {
+				mark(sessionId) {
+					marks.set(sessionId, (marks.get(sessionId) ?? 0) + 1);
+					publish();
+					let withdrawn = false;
+					return () => {
+						if (withdrawn) return;
+						withdrawn = true;
+						const held = (marks.get(sessionId) ?? 1) - 1;
+						if (held > 0) marks.set(sessionId, held);
+						else marks.delete(sessionId);
+						publish();
+					};
+				},
+				isResident: (sessionId) => marks.has(sessionId),
+				primarySessionId: () => marks.keys().next().value,
+				subscribe(listener) {
+					listeners.add(listener);
+					return () => {
+						listeners.delete(listener);
+					};
+				}
+			};
+		}
+		//#endregion
+		//#region src/client/surfaces/ErrorBoundary.tsx
+		/**
+		* One Slot entry's local error boundary (spec 7.3).
+		*
+		* A render error inside the Quick Action surfaces replaces the Quick Action
+		* area and nothing else: the Composer, its draft and its submit button keep
+		* working, and the user can ask for the surface back. Retrying remounts the
+		* subtree by changing its key, so a transient failure clears without a reload.
+		*
+		* DSH's own submission errors never reach here — they are reported by the
+		* Composer, and this feature must not repeat them (spec 9.5).
+		*/
+		var SurfaceErrorBoundary = class extends react.Component {
+			state = {
+				failed: false,
+				attempt: 0
+			};
+			static getDerivedStateFromError() {
+				return { failed: true };
+			}
+			componentDidCatch(error, info) {
+				console.error("[composer-quick-actions] surface failed", error, info.componentStack);
+			}
+			retry = () => {
+				this.setState((current) => ({
+					failed: false,
+					attempt: current.attempt + 1
+				}));
+			};
+			render() {
+				const { t, children } = this.props;
+				if (!this.state.failed) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react.Fragment, { children }, this.state.attempt);
+				return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					className: "dsh-cqa-note",
+					role: "status",
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+						className: "dsh-cqa-note-text",
+						children: t("crash.title")
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+						type: "button",
+						className: "dsh-cqa-link",
+						onClick: this.retry,
+						children: t("crash.retry")
+					})]
+				});
+			}
+		};
+		//#endregion
+		//#region src/client/surfaces/ActionFace.tsx
+		function ActionFace({ action, t }) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+				action.icon === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					className: "dsh-cqa-icon",
+					"aria-hidden": "true",
+					children: action.icon
+				}),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					className: "dsh-cqa-label",
+					children: action.label
+				}),
+				action.command ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Pill, {
+					className: "dsh-cqa-badge",
+					children: t("command.badge")
+				}) : null
+			] });
+		}
+		function densityFor(width) {
+			return width > 0 && width < 480 ? "narrow" : "wide";
+		}
+		/**
+		* How many leading actions the `bar` layout shows (spec 8.1). The rest fold into
+		* the shared action panel behind "more", and the management entry stays visible
+		* whatever the answer is.
+		*
+		* Before the first measurement — a fresh mount, or a headless environment with
+		* no layout — every width reads as zero. That answers "all of them": showing the
+		* full row and letting the browser's own overflow handle it for one frame is
+		* better than flashing a "more" button that the next frame withdraws.
+		*/
+		function fitActionCount(input) {
+			const { available, widths, reserved, gap } = input;
+			if (widths.length === 0) return 0;
+			if (available <= 0 || widths.every((width) => width <= 0)) return widths.length;
+			let used = reserved;
+			let shown = 0;
+			for (const width of widths) {
+				const next = used + width + (shown === 0 && reserved === 0 ? 0 : gap);
+				if (next > available) break;
+				used = next;
+				shown += 1;
+			}
+			return shown;
+		}
+		//#endregion
+		//#region src/client/manager/search.ts
+		/** The fields a query is compared against. */
+		const SEARCH_FIELDS = ["label", "text"];
+		/**
+		* The one normalization both sides of a comparison go through. Applying it to
+		* the query and to the haystack through the same function is what keeps the two
+		* from drifting apart.
+		*/
+		function normalizeQuickActionSearchText(value) {
+			return value.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ").trim();
+		}
+		/**
+		* Whether a query asks for anything at all. A whitespace-only box is an empty
+		* one, and telling the two apart is what lets a panel say "nothing matched"
+		* rather than "nothing to run".
+		*/
+		function hasQuickActionQuery(query) {
+			return normalizeQuickActionSearchText(query) !== "";
+		}
+		/**
+		* The actions matching `query`, in their original relative order.
+		*
+		* An empty or whitespace-only query hands the same array back by identity: an
+		* unsearched panel is not a filtered panel, and returning a copy would remount
+		* every row for nothing.
+		*/
+		function filterQuickActions(actions, query) {
+			const needle = normalizeQuickActionSearchText(query);
+			if (needle === "") return actions;
+			return actions.filter((action) => SEARCH_FIELDS.some((field) => normalizeQuickActionSearchText(action[field]).includes(needle)));
+		}
+		//#endregion
+		//#region src/client/modal.ts
+		/**
+		* The modal semantics every Quick Action panel shares (spec 8.4).
+		*
+		* Spec 8.4 makes Escape cancellation, a clear focus ring, keyboard traversal and
+		* focus return after a panel closes hard gates. A Slot entry renders in place,
+		* inside the composer stack, so without a Tab boundary a keyboard user would tab
+		* straight out of an open panel into the draft behind it, and every route back
+		* into the panel would take the Escape handler with it.
+		*
+		* That holds for the management overlay too, even though ticket 26 moved it onto
+		* `document.body` through a portal: a portal relocates the DOM node, not the
+		* React tree, so its events still bubble to the dock and its Tab order still
+		* follows document order — which is now the end of the body, further from the
+		* draft rather than nearer it. Both hooks below are unaffected either way,
+		* because both work off the panel element they are handed.
+		*
+		* This module is a leaf beside `dsh.ts`, owned by no directory of spec 14's
+		* source map: the confirmation panel (`session/`), the action panel and the
+		* management panel (`manager/`) all need it, and putting it inside any one of
+		* them would make another depend on that one's directory for something that is
+		* neither an action nor an execution concern.
+		*
+		* Both hooks are deliberately tiny and DOM-only: they read `document.activeElement`
+		* and call `focus()`, which is the browser's own focus contract, not DSH's. No
+		* Composer state, private event or Lexical path is touched (spec 9.1).
+		*/
+		/**
+		* What Tab may reach inside a panel. Disabled controls are excluded, which is
+		* what keeps the boundary correct while a write is in flight and half the
+		* panel's buttons are inert.
+		*/
+		const FOCUSABLE_SELECTOR = [
+			"a[href]",
+			"button:not([disabled])",
+			"input:not([disabled])",
+			"select:not([disabled])",
+			"textarea:not([disabled])",
+			"[tabindex]:not([tabindex=\"-1\"])"
+		].join(",");
+		/**
+		* Escape cancels, and Tab stays inside.
+		*
+		* The focusable set is recomputed on every keystroke rather than cached: a
+		* management panel grows a form, a form's Save button goes inert while a write
+		* is in flight, and a stale boundary would trap focus on a control that is no
+		* longer there.
+		*/
+		function useModalKeys(onCancel) {
+			const panelRef = (0, react.useRef)(null);
+			return {
+				panelRef,
+				onKeyDown: (0, react.useCallback)((event) => {
+					if (event.key === "Escape") {
+						event.stopPropagation();
+						onCancel();
+						return;
+					}
+					if (event.key !== "Tab") return;
+					const focusable = Array.from(panelRef.current?.querySelectorAll(FOCUSABLE_SELECTOR) ?? []);
+					const first = focusable[0];
+					const last = focusable[focusable.length - 1];
+					if (first === void 0 || last === void 0) return;
+					const edge = event.shiftKey ? first : last;
+					if (event.target !== edge) return;
+					event.preventDefault();
+					(event.shiftKey ? last : first).focus();
+				}, [onCancel])
+			};
+		}
+		/**
+		* Return focus to whatever opened this panel, when it closes (spec 8.4).
+		*
+		* The opener is captured in a layout effect, so it must be declared *before* any
+		* effect that moves focus into the panel: effects run in declaration order
+		* within a component, and layout effects run before passive ones, so the capture
+		* always sees the control the user actually activated.
+		*
+		* An opener that has since been unmounted — an action picked from a list that
+		* closed with it — is skipped rather than focused, and the caller is free to
+		* offer a fallback of its own.
+		*
+		* @param scope - the closing context's own element, for an editing context
+		* nested inside a panel (the management form inside the management panel).
+		* When the outer panel closes, React runs the outer cleanup first, the inner
+		* cleanup next, and only then removes the outer DOM: by the time the nested
+		* context returns focus, the panel has already handed it to *its* opener, and
+		* the nested opener is a control about to leave the document. So a nested
+		* context returns focus only while focus is still inside it (or fell to the
+		* body); focus that has already left belongs to whoever moved it.
+		*/
+		function useFocusReturn(scope) {
+			const opener = (0, react.useRef)(null);
+			(0, react.useLayoutEffect)(() => {
+				const active = typeof document === "undefined" ? null : document.activeElement;
+				opener.current = active === document.body ? null : active;
+				return () => {
+					const element = opener.current;
+					opener.current = null;
+					if (element === null || !element.isConnected) return;
+					const current = document.activeElement;
+					if (scope?.current != null && current !== null && current !== document.body && !scope.current.contains(current)) return;
+					element.focus();
+				};
+			}, []);
+		}
+		/**
+		* Move focus into a panel once, on open, addressing the target through the
+		* panel rather than through a ref (spec 8.4).
+		*
+		* `@deepseek-ai/dsh-client-ui-primitives` publishes no `forwardRef` at all, so
+		* an official `Button` or `Input` cannot carry one. Addressing the opening
+		* target by marker attribute — the way the Tab boundary above already addresses
+		* the focusable set — keeps that limitation in this one module instead of
+		* pushing every panel back onto native controls.
+		*
+		* @param container - the panel whose subtree holds the target.
+		* @param selector - CSS selector for the control that should open focused.
+		*/
+		function useInitialFocusIn(container, selector) {
+			(0, react.useEffect)(() => {
+				container.current?.querySelector(selector)?.focus();
+			}, [container, selector]);
+		}
+		//#endregion
+		//#region src/client/session/availability.ts
+		/**
+		* The reason this action cannot run right now, or `undefined` when it can.
+		*
+		* While a send holds the Session's single flight, only the action holding it
+		* explains itself as "sending"; the rest are simply unavailable while the
+		* Composer is busy with it (spec 9.5).
+		*/
+		function unavailableReasonFor(action, session) {
+			if (session.unavailable === "sending") return session.activeRef !== void 0 && quickActionRefKey(session.activeRef) === quickActionRefKey(action.ref) ? "sending" : "composer-busy";
+			return session.unavailable;
+		}
+		//#endregion
+		//#region src/client/manager/ActionPanel.tsx
+		/**
+		* The shared searchable action panel (spec 8.1).
+		*
+		* One panel serves both entries that need a list rather than a row: the `bar`
+		* layout's "more" overflow and the `launcher` layout's single entry. Sharing it
+		* is a spec requirement, not a convenience — the two entries must not drift into
+		* offering different search behaviour or different keyboard handling.
+		*
+		* The search itself is `./search.js`: it really filters, it keeps the matches in
+		* their `actionOrder` relative order, and its field, case and Unicode policy is
+		* stated and pinned there. The panel adds only the UI around it — a search field
+		* with a visible text label, the same disabled-with-a-reason projection the
+		* layouts use (spec 3), and the modal semantics of spec 8.4.
+		*
+		* Nothing here executes anything: activation is handed straight to the caller's
+		* per-Session engine, which owns the single flight and the final re-verification
+		* (spec 9.3, 9.5). The panel never mints a second lock.
+		*/
+		function ActionPanel(props) {
+			const { actions, session, t, labelledBy, onActivate, onClose } = props;
+			const [query, setQuery] = (0, react.useState)("");
+			const { panelRef, onKeyDown } = useModalKeys(onClose);
+			useInitialFocusIn(panelRef, "[data-quick-actions-search]");
+			const matches = filterQuickActions(actions, query);
+			const emptyKey = hasQuickActionQuery(query) ? "panel.search.empty" : "empty";
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				className: "dsh-cqa-backdrop",
+				"data-quick-actions-backdrop": "",
+				"aria-hidden": "true",
+				onClick: onClose
+			}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "dsh-cqa-panel",
+				ref: panelRef,
+				role: "dialog",
+				"aria-modal": "true",
+				"aria-labelledby": labelledBy,
+				"data-quick-actions-panel": "",
+				onKeyDown,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "dsh-cqa-panel-head",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: "dsh-cqa-panel-title",
+							id: labelledBy,
+							children: t("panel.title")
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							className: "dsh-cqa-link",
+							"data-quick-actions-panel-close": "",
+							onClick: onClose,
+							children: t("panel.close")
+						})]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", {
+						className: "dsh-cqa-field",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: "dsh-cqa-field-label",
+							children: t("panel.search")
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Input, {
+							icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconSearchOutline16, {}),
+							type: "search",
+							value: query,
+							"data-quick-actions-search": "",
+							onChange: (event) => {
+								setQuery(event.target.value);
+							}
+						})]
+					}),
+					matches.length === 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						className: "dsh-cqa-panel-title",
+						children: t(emptyKey)
+					}) : null,
+					matches.map((action) => {
+						const reason = unavailableReasonFor(action, session);
+						return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							className: "dsh-cqa-panel-item",
+							"data-quick-action": quickActionRefKey(action.ref),
+							disabled: reason !== void 0,
+							title: reason === void 0 ? action.text : t(`unavailable.${reason}`),
+							onClick: () => {
+								onActivate(action);
+								onClose();
+							},
+							children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ActionFace, {
+								action,
+								t
+							})
+						}, quickActionRefKey(action.ref));
+					})
+				]
+			})] });
+		}
+		//#endregion
+		//#region src/client/session/ConfirmPanel.tsx
+		function ConfirmPanel({ pending, t, onConfirm, onCancel }) {
+			const { panelRef, onKeyDown } = useModalKeys(onCancel);
+			useInitialFocusIn(panelRef, "[data-quick-actions-confirm-send]");
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				className: "dsh-cqa-backdrop",
+				"data-quick-actions-backdrop": "",
+				"aria-hidden": "true",
+				onClick: onCancel
+			}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "dsh-cqa-panel",
+				ref: panelRef,
+				role: "dialog",
+				"aria-modal": "true",
+				"aria-label": t("confirm.title"),
+				"data-quick-actions-confirm": "",
+				onKeyDown,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						className: "dsh-cqa-panel-title",
+						children: pending.label
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						className: "dsh-cqa-confirm-text",
+						children: pending.text
+					}),
+					pending.command ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "dsh-cqa-note",
+						"data-quick-actions-command-notice": "",
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: "dsh-cqa-note-text",
+							children: t("confirm.command")
+						})
+					}) : null,
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "dsh-cqa-confirm-actions",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+							variant: "toolbar",
+							size: "sm",
+							className: "dsh-cqa-entry",
+							onClick: onCancel,
+							children: t("confirm.cancel")
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+							variant: "toolbar",
+							size: "sm",
+							className: "dsh-cqa-entry",
+							"data-quick-actions-confirm-send": "",
+							onClick: onConfirm,
+							children: t("confirm.send")
+						})]
+					})
+				]
+			})] });
+		}
+		//#endregion
+		//#region src/client/surfaces/QuickActionsSurface.tsx
+		/**
+		* The three Quick Action Layouts and the control they share (spec 8.1, 8.2).
+		*
+		* | layout     | Slot                        | body                                                        |
+		* |------------|-----------------------------|-------------------------------------------------------------|
+		* | `ribbon`   | `conversation.input.dock`   | title, the actions in shared order, and "manage" on one line |
+		* | `bar`      | `conversation.composer.dock`| the leading actions that fit, then "more", then "manage"     |
+		* | `launcher` | `conversation.input.dock`   | one compact entry carrying the Composer projection's count   |
+		*
+		* Three rules hold across all of them:
+		*
+		* - the management entry is always rendered, so hiding or disabling every action
+		*   still leaves a compact, operable entry rather than an empty strip;
+		* - controls keep a visible text label at every width — a narrow surface drops
+		*   the section title and tightens spacing, and nothing else (spec 8.2, 8.4);
+		* - an action that cannot run right now is shown disabled with its reason, never
+		*   removed. Removal is the Hidden Quick Action projection, and that is the
+		*   management panel's business (spec 3).
+		*/
+		/** Gap between adjacent controls; mirrors `--gap` in the stylesheet. */
+		const CONTROL_GAP = 8;
+		function ActionControl(props) {
+			const { action, reason, t, onActivate } = props;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+				variant: "toolbar",
+				size: "sm",
+				className: "dsh-cqa-action",
+				"data-quick-action": quickActionRefKey(action.ref),
+				disabled: reason !== void 0,
+				title: reason === void 0 ? action.text : t(`unavailable.${reason}`),
+				onClick: () => {
+					onActivate(action);
+				},
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ActionFace, {
+					action,
+					t
+				})
+			});
+		}
+		/**
+		* Measure one element's inner width, republishing on every resize. Used twice:
+		* on the whole row for the density rule, and on the action region alone for the
+		* bar's overflow split — the region is `flex: 1 1 auto`, so its width is already
+		* what is left after the controls that must stay visible.
+		*/
+		function useElementWidth() {
+			const ref = (0, react.useRef)(null);
+			const [width, setWidth] = (0, react.useState)(0);
+			(0, react.useEffect)(() => {
+				const element = ref.current;
+				if (element === null || typeof ResizeObserver === "undefined") return;
+				const observer = new ResizeObserver(() => {
+					setWidth(element.clientWidth);
+				});
+				observer.observe(element);
+				setWidth(element.clientWidth);
+				return () => {
+					observer.disconnect();
+				};
+			}, []);
+			return [ref, width];
+		}
+		function QuickActionsSurface(props) {
+			const { layout, actions, session, t, onActivate, onConfirm, onCancelConfirm, onDismissFeedback, onManage } = props;
+			const [rowRef, width] = useElementWidth();
+			const [fitRef, fitWidth] = useElementWidth();
+			const density = densityFor(width);
+			const [panelOpen, setPanelOpen] = (0, react.useState)(false);
+			const panelTitleId = (0, react.useId)();
+			const widths = (0, react.useRef)(/* @__PURE__ */ new Map());
+			const [measured, setMeasured] = (0, react.useState)(0);
+			(0, react.useLayoutEffect)(() => {
+				if (layout !== "bar") return;
+				let changed = false;
+				for (const node of Array.from(fitRef.current?.querySelectorAll("[data-quick-action]") ?? [])) {
+					const key = node.dataset["quickAction"];
+					const value = node.offsetWidth;
+					if (key === void 0 || value <= 0 || widths.current.get(key) === value) continue;
+					widths.current.set(key, value);
+					changed = true;
+				}
+				if (changed) setMeasured((seen) => seen + 1);
+			});
+			const shown = (0, react.useMemo)(() => {
+				if (layout !== "bar") return actions.length;
+				const known = actions.map((action) => quickActionRefKey(action.ref)).map((key) => widths.current.get(key) ?? 0);
+				if (known.some((value) => value <= 0)) return actions.length;
+				return fitActionCount({
+					available: fitWidth,
+					widths: known,
+					reserved: 0,
+					gap: CONTROL_GAP
+				});
+			}, [
+				layout,
+				actions,
+				fitWidth,
+				measured
+			]);
+			const overflow = layout === "bar" ? actions.slice(shown) : actions;
+			/**
+			* Resolve one of this surface's own controls by its data marker.
+			*
+			* `Button` takes no ref, so the focus contract of spec 8.4 addresses controls
+			* the way the stylesheet does: through a marker attribute, queried from the
+			* row this surface already measures. The selector and the attribute that
+			* answers it live in this one file, so the coupling stays local.
+			*/
+			const control = (0, react.useCallback)((marker) => {
+				return rowRef.current?.querySelector(`[${marker}]`) ?? null;
+			}, [rowRef]);
+			const closePanel = (0, react.useCallback)(() => {
+				setPanelOpen(false);
+				control("data-quick-actions-entry")?.focus();
+			}, [control]);
+			const confirmOpener = (0, react.useRef)(null);
+			const confirming = session.confirming;
+			const activate = (0, react.useCallback)((action) => {
+				confirmOpener.current = document.activeElement;
+				onActivate(action);
+			}, [onActivate]);
+			(0, react.useEffect)(() => {
+				if (confirming !== void 0) return;
+				const opener = confirmOpener.current;
+				confirmOpener.current = null;
+				if (opener === null) return;
+				(opener.isConnected && !opener.disabled ? opener : control("data-quick-actions-manage"))?.focus();
+			}, [confirming, control]);
+			(0, react.useEffect)(() => {
+				if (overflow.length === 0) setPanelOpen(false);
+			}, [overflow.length]);
+			const manage = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+				variant: "toolbar",
+				size: "sm",
+				className: "dsh-cqa-entry",
+				"data-quick-actions-manage": "",
+				title: t("manage.tooltip"),
+				onClick: onManage,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					className: "dsh-cqa-label",
+					children: t("manage")
+				})
+			});
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: layout === "bar" ? "dsh-cqa-bar" : layout === "launcher" ? "dsh-cqa-launcher" : "dsh-cqa-ribbon",
+				"data-quick-actions-layout": layout,
+				"data-quick-actions-density": density,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					className: "dsh-cqa-row",
+					ref: rowRef,
+					"data-density": density,
+					children: [
+						layout === "ribbon" && density === "wide" ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: "dsh-cqa-title",
+							children: t("title")
+						}) : null,
+						layout === "ribbon" ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							className: "dsh-cqa-scroll",
+							children: [actions.length === 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								className: "dsh-cqa-title",
+								children: t("empty")
+							}) : null, actions.map((action) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ActionControl, {
+								action,
+								reason: unavailableReasonFor(action, session),
+								t,
+								onActivate: activate
+							}, quickActionRefKey(action.ref)))]
+						}) : null,
+						layout === "bar" ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							className: "dsh-cqa-fit",
+							ref: fitRef,
+							children: [actions.length === 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								className: "dsh-cqa-title",
+								children: t("empty")
+							}) : null, actions.slice(0, shown).map((action) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ActionControl, {
+								action,
+								reason: unavailableReasonFor(action, session),
+								t,
+								onActivate: activate
+							}, quickActionRefKey(action.ref)))]
+						}) : null,
+						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							className: "dsh-cqa-trailing",
+							children: [layout === "launcher" || layout === "bar" && overflow.length > 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+								className: "dsh-cqa-anchor",
+								children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+									variant: "toolbar",
+									size: "sm",
+									className: "dsh-cqa-entry",
+									"data-quick-actions-entry": layout,
+									"aria-expanded": panelOpen,
+									"aria-haspopup": "dialog",
+									disabled: layout === "launcher" && actions.length === 0,
+									onClick: () => {
+										setPanelOpen((open) => !open);
+									},
+									children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+										className: "dsh-cqa-label",
+										children: layout === "launcher" ? t("launcher", { count: actions.length }) : t("more", { count: overflow.length })
+									})
+								}), panelOpen ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ActionPanel, {
+									actions: overflow,
+									session,
+									t,
+									labelledBy: panelTitleId,
+									onActivate: activate,
+									onClose: closePanel
+								}) : null]
+							}) : null, /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+								className: "dsh-cqa-anchor",
+								children: [manage, session.confirming === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ConfirmPanel, {
+									pending: session.confirming,
+									t,
+									onConfirm,
+									onCancel: onCancelConfirm
+								})]
+							})]
+						})
+					]
+				}), session.feedback === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					className: "dsh-cqa-note",
+					role: "status",
+					"data-quick-actions-feedback": session.feedback.kind,
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+						className: "dsh-cqa-note-text",
+						children: session.feedback.kind === "failed" ? t("feedback.failed", { message: session.feedback.message }) : t(`feedback.${session.feedback.kind}`)
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+						type: "button",
+						className: "dsh-cqa-link",
+						onClick: onDismissFeedback,
+						children: t("feedback.dismiss")
+					})]
+				})]
+			});
+		}
+		//#endregion
+		//#region src/client/manager/press.ts
+		/**
+		* Gate one control. `blocked` is its own extra condition — an end of the list,
+		* the ceiling, the choice already made; the gate's own `busy` is folded in here
+		* so no caller has to remember it.
+		*/
+		function pressProps(gate, blocked, onPress) {
+			const refused = gate.readOnly || gate.busy || blocked;
+			return {
+				disabled: gate.readOnly,
+				"aria-disabled": gate.busy || blocked,
+				onClick: () => {
+					if (refused) return;
+					onPress();
+				}
+			};
+		}
+		//#endregion
+		//#region src/locales/index.ts
+		/** The locale namespace this package registers and every Slot entry binds. */
+		const QUICK_ACTIONS_LOCALE_NAMESPACE = "composer-quick-actions";
+		const zh = {
+			"title": "快捷动作",
+			"manage": "管理",
+			"manage.tooltip": "管理快捷动作",
+			"more": "更多 {count}",
+			"launcher": "快捷动作 {count}",
+			"empty": "暂无可用快捷动作",
+			"command.badge": "命令",
+			"unavailable.occupied-draft": "草稿中已有内容；发送动作不会覆盖或携带它",
+			"unavailable.composer-busy": "消息编辑器正在提交，请稍候",
+			"unavailable.composer-blocked": "当前会话的消息编辑器已被占用",
+			"unavailable.session-removed": "会话已被移除",
+			"unavailable.parent-offline": "父会话不可用",
+			"unavailable.sending": "正在发送",
+			"feedback.state-changed": "状态已变化，请重试",
+			"feedback.retained": "未发送，文本已保留",
+			"feedback.failed": "未能执行：{message}",
+			"feedback.dismiss": "知道了",
+			"catalog.loading": "正在读取快捷动作…",
+			"catalog.unreadable": "无法读取设置，快捷动作暂不可用",
+			"catalog.unavailable": "未找到预置目录",
+			"catalog.undecodable": "预置目录版本过新，无法读取",
+			"catalog.retry": "重试",
+			"crash.title": "快捷动作出错了",
+			"crash.retry": "重新加载",
+			"confirm.title": "确认发送",
+			"confirm.send": "发送",
+			"confirm.cancel": "取消",
+			"confirm.command": "这条文本会按命令进入 DSH 官方裁决路径。此处不会出现输入 / 时的原生候选菜单，你看到的就是最终提交内容。",
+			"panel.title": "选择快捷动作",
+			"panel.close": "关闭",
+			"panel.search": "搜索快捷动作",
+			"panel.search.empty": "没有匹配的快捷动作",
+			"manager.title": "管理快捷动作",
+			"manager.close": "关闭",
+			"manager.layout": "布局",
+			"manager.layout.ribbon": "上方动作带",
+			"manager.layout.bar": "下方操作栏",
+			"manager.layout.launcher": "单入口面板",
+			"manager.actions": "快捷动作",
+			"manager.count": "共 {total} / {limit} 项",
+			"manager.new": "新建快捷动作",
+			"manager.empty": "还没有任何快捷动作",
+			"manager.overflow": "动作总数为 {total} 项，已超过 {limit} 项上限。现有动作全部保留，但在恢复到上限以内之前无法新增或克隆。",
+			"manager.limit": "已达 {limit} 项上限，无法新增或克隆。",
+			"manager.command.notice": "标有「命令」的动作以 / 开头，会按命令进入 DSH 官方裁决路径。确认面板只展示最终提交的文本，不会出现原生 / 候选菜单；关闭确认后，命令将一键提交且没有任何预览。",
+			"manager.preset": "预置",
+			"manager.custom": "自定义",
+			"manager.clonedFrom": "克隆自预置",
+			"manager.hidden": "已隐藏",
+			"manager.disabled": "已停用",
+			"manager.hide": "隐藏",
+			"manager.restore": "恢复",
+			"manager.clone": "克隆",
+			"manager.edit": "编辑",
+			"manager.enable": "启用",
+			"manager.disable": "停用",
+			"manager.delete": "删除",
+			"manager.delete.confirm": "确认删除",
+			"manager.delete.cancel": "不删除",
+			"manager.moveUp": "上移",
+			"manager.moveDown": "下移",
+			"manager.readonly.storage": "设置存储当前不可用，管理界面为只读。",
+			"manager.readonly.offline": "连接已断开，管理界面为只读；连接恢复后可继续修改。",
+			"form.title.new": "新建快捷动作",
+			"form.title.edit": "编辑快捷动作",
+			"form.label": "标签",
+			"form.label.hint": "按钮上显示的名称，最长 {max} 个字符",
+			"form.text": "发送文本",
+			"form.text.hint": "原样提交的静态文本，保留换行，最长 {max} 个字符",
+			"form.icon": "图标（可选）",
+			"form.icon.hint": "1–{max} 个 emoji，仅作装饰",
+			"form.confirm": "发送前确认",
+			"form.save": "保存",
+			"form.cancel": "取消",
+			"form.command.warning": "这条文本以 / 开头，是命令发送动作：它会按命令进入 DSH 官方裁决路径；确认面板不会展示原生 / 候选菜单；关闭确认后，该命令将一键提交且没有任何预览。确认开关仍由你自行设置。",
+			"issue.invalid": "这个字段不符合要求",
+			"issue.label.blank": "请填写标签",
+			"issue.label.too-long": "标签超出长度上限",
+			"issue.text.blank": "发送文本至少要有一个非空白字符",
+			"issue.text.too-long": "发送文本超出长度上限",
+			"issue.text.reserved-placeholder": "发送文本包含 DSH 保留的引用占位符，无法作为静态文本提交",
+			"issue.icon.not-emoji": "图标只能由 emoji 组成",
+			"issue.icon.too-long": "图标的 emoji 数量超出上限",
+			"write.dismiss": "知道了",
+			"write.retry": "重试",
+			"write.not-ready": "设置尚未就绪，改动没有保存。",
+			"write.read-only": "当前无法写入设置，改动没有保存。",
+			"write.refused": "保存被拒绝，没有写入任何内容；请重试。",
+			"write.conflict": "设置已在别处被修改，已刷新到最新状态；请核对后重新确认这次修改。",
+			"write.failed": "保存失败：{message}；请重试。",
+			"write.invalid-fields": "有字段不符合要求，改动没有保存。",
+			"write.limit-reached": "已达动作数量上限，无法新增或克隆。",
+			"write.unknown-action": "这个动作已经不存在了，请核对当前列表后重试。",
+			"write.id-in-use": "生成的标识发生重复，请重试。",
+			"write.invalid-order": "顺序已经变化，请核对当前列表后重试。"
+		};
+		/** The dictionaries as `ctx.locale.register` takes them. */
+		const quickActionsDictionaries = {
+			zh,
+			en: {
+				"title": "Quick Actions",
+				"manage": "Manage",
+				"manage.tooltip": "Manage Quick Actions",
+				"more": "More {count}",
+				"launcher": "Quick Actions {count}",
+				"empty": "No Quick Actions available",
+				"command.badge": "Command",
+				"unavailable.occupied-draft": "The draft already has content; a send action never overwrites or carries it",
+				"unavailable.composer-busy": "The composer is submitting; try again in a moment",
+				"unavailable.composer-blocked": "Another feature owns this session’s composer",
+				"unavailable.session-removed": "This session was removed",
+				"unavailable.parent-offline": "The parent session is unavailable",
+				"unavailable.sending": "Sending",
+				"feedback.state-changed": "Something changed — try again",
+				"feedback.retained": "Not sent; the text was kept in the draft",
+				"feedback.failed": "Could not run: {message}",
+				"feedback.dismiss": "Dismiss",
+				"catalog.loading": "Loading Quick Actions…",
+				"catalog.unreadable": "Settings could not be read, so Quick Actions are unavailable",
+				"catalog.unavailable": "No Preset Catalog was published",
+				"catalog.undecodable": "The Preset Catalog is newer than this release can read",
+				"catalog.retry": "Retry",
+				"crash.title": "Quick Actions hit an error",
+				"crash.retry": "Reload",
+				"confirm.title": "Confirm send",
+				"confirm.send": "Send",
+				"confirm.cancel": "Cancel",
+				"confirm.command": "This text enters DSH’s own command adjudication path. The native “/” suggestion menu does not appear here, so what you see is exactly what is submitted.",
+				"panel.title": "Pick a Quick Action",
+				"panel.close": "Close",
+				"panel.search": "Search Quick Actions",
+				"panel.search.empty": "No Quick Action matches that",
+				"manager.title": "Manage Quick Actions",
+				"manager.close": "Close",
+				"manager.layout": "Layout",
+				"manager.layout.ribbon": "Action ribbon",
+				"manager.layout.bar": "Action bar",
+				"manager.layout.launcher": "Single launcher",
+				"manager.actions": "Quick Actions",
+				"manager.count": "{total} of {limit}",
+				"manager.new": "New Quick Action",
+				"manager.empty": "No Quick Actions yet",
+				"manager.overflow": "There are {total} actions, over the limit of {limit}. Everything you have is kept, but creating and cloning stay disabled until the total is back within the limit.",
+				"manager.limit": "The limit of {limit} actions is reached, so creating and cloning are disabled.",
+				"manager.command.notice": "Actions marked “Command” start with “/” and enter DSH’s own command adjudication path. The confirmation panel shows only the text that will be submitted — the native “/” suggestion menu does not appear — and with confirmation off the command is submitted in one click with no preview.",
+				"manager.preset": "Preset",
+				"manager.custom": "Custom",
+				"manager.clonedFrom": "Cloned from a preset",
+				"manager.hidden": "Hidden",
+				"manager.disabled": "Disabled",
+				"manager.hide": "Hide",
+				"manager.restore": "Restore",
+				"manager.clone": "Clone",
+				"manager.edit": "Edit",
+				"manager.enable": "Enable",
+				"manager.disable": "Disable",
+				"manager.delete": "Delete",
+				"manager.delete.confirm": "Confirm delete",
+				"manager.delete.cancel": "Keep it",
+				"manager.moveUp": "Move up",
+				"manager.moveDown": "Move down",
+				"manager.readonly.storage": "Settings storage is unavailable right now, so management is read-only.",
+				"manager.readonly.offline": "The connection is down, so management is read-only until it is back.",
+				"form.title.new": "New Quick Action",
+				"form.title.edit": "Edit Quick Action",
+				"form.label": "Label",
+				"form.label.hint": "The name on the button, up to {max} characters",
+				"form.text": "Text to send",
+				"form.text.hint": "Static text submitted as-is, line breaks kept, up to {max} characters",
+				"form.icon": "Icon (optional)",
+				"form.icon.hint": "1–{max} emoji, decoration only",
+				"form.confirm": "Confirm before sending",
+				"form.save": "Save",
+				"form.cancel": "Cancel",
+				"form.command.warning": "This text starts with “/”, which makes it a Command Send Action: it enters DSH’s own command adjudication path, the confirmation panel shows no native “/” suggestion menu, and with confirmation off the command is submitted in one click with no preview at all. The confirmation switch stays yours to set.",
+				"issue.invalid": "This field is not acceptable",
+				"issue.label.blank": "Enter a label",
+				"issue.label.too-long": "The label is over the length limit",
+				"issue.text.blank": "The text needs at least one non-whitespace character",
+				"issue.text.too-long": "The text is over the length limit",
+				"issue.text.reserved-placeholder": "The text holds a DSH-reserved reference placeholder and cannot be submitted as static text",
+				"issue.icon.not-emoji": "An icon may only be made of emoji",
+				"issue.icon.too-long": "The icon has too many emoji",
+				"write.dismiss": "Dismiss",
+				"write.retry": "Retry",
+				"write.not-ready": "Settings are not ready yet, so nothing was saved.",
+				"write.read-only": "Settings cannot be written right now, so nothing was saved.",
+				"write.refused": "The write was refused and nothing was saved; try again.",
+				"write.conflict": "Settings changed elsewhere and have been refreshed; check what is on screen and confirm your change again.",
+				"write.failed": "The write failed: {message}. Try again.",
+				"write.invalid-fields": "Some fields are not acceptable, so nothing was saved.",
+				"write.limit-reached": "The action limit is reached, so creating and cloning are disabled.",
+				"write.unknown-action": "That action no longer exists; check the current list and try again.",
+				"write.id-in-use": "The generated id collided; try again.",
+				"write.invalid-order": "The order has changed; check the current list and try again."
+			}
+		};
+		/**
+		* Every key this package ships, taken from the dictionary rather than restated,
+		* so a composed key is checked against what actually exists.
+		*/
+		const SHIPPED_KEYS = new Set(Object.keys(zh));
+		/**
+		* Narrow a composed key to one this package ships, falling back when it does
+		* not. Composed keys come from names the model and the controller own — a field
+		* issue, a mutation refusal, a write failure — so a case added upstream shows a
+		* general sentence instead of leaking `write.something-new` onto a surface.
+		*/
+		function quickActionsLocaleKey(candidate, fallback) {
+			return SHIPPED_KEYS.has(candidate) ? candidate : fallback;
+		}
+		/** The dictionary entry naming one field issue (spec 4.3). */
+		function quickActionIssueKey(issue) {
+			return quickActionsLocaleKey(`issue.${issue.field}.${issue.reason}`, "issue.invalid");
+		}
+		//#endregion
+		//#region src/client/manager/ActionForm.tsx
+		/**
+		* The Custom Quick Action form (spec 8.3).
+		*
+		* It edits exactly four things — label, static text, optional emoji and the send
+		* confirmation — and validates them through the shared model, so a draft this
+		* form accepts is a draft the Host will accept (spec 4.3).
+		*
+		* ## What this form deliberately does not have
+		*
+		* - **An action-type selector.** `kind` is not a configuration field: the first
+		*   release is always `'send'`, and no user path may change it (spec 4.1, 16.1).
+		* - **Any control the Command Send Action warning locks.** When the text becomes
+		*   a command the form warns and nothing else (spec 8.3, 16.1): the warning
+		*   states that the text enters DSH's own adjudication path, that the
+		*   confirmation panel shows no native `/` suggestion menu, and that with
+		*   confirmation off the command is submitted in one click with no preview. The
+		*   confirmation switch stays editable throughout.
+		* - **Any rewrite of `confirm` in response to the text.** The default is applied
+		*   once, when a draft is created or cloned (`newQuickActionDraft`, the clone
+		*   planner). Deriving it from the text here would silently undo the user's own
+		*   choice every time they edited the text — the same reason spec 4.3 forbids
+		*   normalization from touching it.
+		*
+		* The draft lives in the caller's state, which is what makes "a failed write
+		* keeps the form content" (spec 10) structural rather than incidental.
+		*
+		* ## The form as a nested editing context
+		*
+		* The management panel's Escape handler relies on this form stopping Escape
+		* before it arrives — but a handler on the form only sees keys typed *inside*
+		* the form. Until the form took focus of its own, the first Escape after "new"
+		* or "edit" was still aimed at the button that opened it, outside the form, and
+		* closed the whole panel (ticket 25). So the form has the two focus rules every
+		* other panel of spec 8.4 has: it opens with the caret in its first field, and
+		* it hands focus back to the control that opened it when it closes — which is
+		* what keeps a second Escape meaning "close the panel".
+		*/
+		/**
+		* The issues to render for one draft.
+		*
+		* Every rule comes from the shared model; the only presentation decision is that
+		* a blank field stays quiet until the user has tried to save it.
+		*/
+		function visibleQuickActionIssues(draft, attempted) {
+			const validated = validateQuickActionDraft(draft);
+			if (validated.ok) return [];
+			return attempted ? validated.issues : validated.issues.filter((issue) => issue.reason !== "blank");
+		}
+		/** One labelled field, with its hint and — when it has one — its issue. */
+		function Field(props) {
+			const { field, label, hint, issue, t, children } = props;
+			const id = (0, react.useId)();
+			const hintId = `${id}-hint`;
+			const errorId = `${id}-error`;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "dsh-cqa-field",
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", {
+						className: "dsh-cqa-field-label",
+						htmlFor: id,
+						children: label
+					}),
+					children({
+						id,
+						describedBy: issue === void 0 ? hintId : `${hintId} ${errorId}`,
+						invalid: issue !== void 0
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+						className: "dsh-cqa-field-hint",
+						id: hintId,
+						children: hint
+					}),
+					issue === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+						className: "dsh-cqa-field-error",
+						id: errorId,
+						"data-quick-actions-issue": field,
+						children: t(quickActionIssueKey(issue))
+					})
+				]
+			});
+		}
+		function ActionForm(props) {
+			const { mode, draft, attempted, gate, t, onChange, onSave, onCancel } = props;
+			const issues = visibleQuickActionIssues(draft, attempted);
+			const issueFor = (field) => issues.find((issue) => issue.field === field);
+			const command = isCommandSendActionText(draft.text);
+			const titleId = (0, react.useId)();
+			const formRef = (0, react.useRef)(null);
+			useFocusReturn(formRef);
+			useInitialFocusIn(formRef, "[data-quick-actions-form-label]");
+			/**
+			* Escape leaves the form, not the panel behind it.
+			*
+			* Without stopping it here, Escape typed in a field would reach the management
+			* panel's own handler and close the whole panel — a far larger action than the
+			* user asked for. The innermost editing context is what Escape means.
+			*/
+			const onKeyDown = (event) => {
+				if (event.key !== "Escape") return;
+				event.stopPropagation();
+				onCancel();
+			};
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "dsh-cqa-form",
+				ref: formRef,
+				role: "group",
+				"aria-labelledby": titleId,
+				"data-quick-actions-form": mode,
+				onKeyDown,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+						className: "dsh-cqa-section-title",
+						id: titleId,
+						children: t(mode === "new" ? "form.title.new" : "form.title.edit")
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Field, {
+						field: "label",
+						label: t("form.label"),
+						hint: t("form.label.hint", { max: 40 }),
+						issue: issueFor("label"),
+						t,
+						children: ({ id, describedBy, invalid }) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+							className: "dsh-cqa-input",
+							id,
+							"aria-describedby": describedBy,
+							"aria-invalid": invalid,
+							disabled: gate.readOnly,
+							"data-quick-actions-form-label": "",
+							value: draft.label,
+							onChange: (event) => {
+								onChange({
+									...draft,
+									label: event.target.value
+								});
+							}
+						})
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Field, {
+						field: "text",
+						label: t("form.text"),
+						hint: t("form.text.hint", { max: QUICK_ACTION_TEXT_MAX_CODE_POINTS }),
+						issue: issueFor("text"),
+						t,
+						children: ({ id, describedBy, invalid }) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("textarea", {
+							className: "dsh-cqa-textarea",
+							id,
+							rows: 4,
+							"aria-describedby": describedBy,
+							"aria-invalid": invalid,
+							disabled: gate.readOnly,
+							value: draft.text,
+							onChange: (event) => {
+								onChange({
+									...draft,
+									text: event.target.value
+								});
+							}
+						})
+					}),
+					command ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						className: "dsh-cqa-note",
+						role: "status",
+						"data-quick-actions-command-warning": "",
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: "dsh-cqa-note-text",
+							children: t("form.command.warning")
+						})
+					}) : null,
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(Field, {
+						field: "icon",
+						label: t("form.icon"),
+						hint: t("form.icon.hint", { max: 4 }),
+						issue: issueFor("icon"),
+						t,
+						children: ({ id, describedBy, invalid }) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+							className: "dsh-cqa-input",
+							id,
+							"aria-describedby": describedBy,
+							"aria-invalid": invalid,
+							disabled: gate.readOnly,
+							value: draft.icon,
+							onChange: (event) => {
+								onChange({
+									...draft,
+									icon: event.target.value
+								});
+							}
+						})
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", {
+						className: "dsh-cqa-switch",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+							type: "checkbox",
+							disabled: gate.readOnly,
+							checked: draft.confirm,
+							"data-quick-actions-confirm-switch": "",
+							onChange: (event) => {
+								onChange({
+									...draft,
+									confirm: event.target.checked
+								});
+							}
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: "dsh-cqa-field-label",
+							children: t("form.confirm")
+						})]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "dsh-cqa-form-actions",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+							variant: "toolbar",
+							size: "sm",
+							className: "dsh-cqa-entry",
+							onClick: onCancel,
+							children: t("form.cancel")
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+							variant: "toolbar",
+							size: "sm",
+							className: "dsh-cqa-entry",
+							...pressProps(gate, false, onSave),
+							children: t("form.save")
+						})]
+					})
+				]
+			});
+		}
+		//#endregion
+		//#region src/client/manager/ManagedRow.tsx
+		function ManagedRow({ action, index, total, gate, deleting, t, on }) {
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("li", {
+				className: "dsh-cqa-list-item",
+				"data-quick-action": quickActionRefKey(action.ref),
+				"data-quick-action-hidden": action.hidden ? "" : void 0,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+						className: "dsh-cqa-list-head",
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)(ActionFace, {
+								action,
+								t
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Pill, {
+								className: "dsh-cqa-tag",
+								children: t(action.editable ? "manager.custom" : "manager.preset")
+							}),
+							action.hidden ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Pill, {
+								active: true,
+								className: "dsh-cqa-tag",
+								children: t(action.editable ? "manager.disabled" : "manager.hidden")
+							}) : null,
+							action.clonedFromPresetId === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Pill, {
+								className: "dsh-cqa-tag",
+								children: t("manager.clonedFrom")
+							})
+						]
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+						className: "dsh-cqa-list-text",
+						children: action.text
+					}),
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+						className: "dsh-cqa-list-controls",
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+								variant: "toolbar",
+								size: "sm",
+								className: "dsh-cqa-entry",
+								"data-quick-actions-move": "up",
+								...pressProps(gate, index === 0, () => {
+									on.onMove(action.ref, index - 1);
+								}),
+								children: t("manager.moveUp")
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+								variant: "toolbar",
+								size: "sm",
+								className: "dsh-cqa-entry",
+								"data-quick-actions-move": "down",
+								...pressProps(gate, index === total - 1, () => {
+									on.onMove(action.ref, index + 1);
+								}),
+								children: t("manager.moveDown")
+							}),
+							action.editable ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+									variant: "toolbar",
+									size: "sm",
+									className: "dsh-cqa-entry",
+									...pressProps(gate, false, on.onEdit),
+									children: t("manager.edit")
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+									variant: "toolbar",
+									size: "sm",
+									className: "dsh-cqa-entry",
+									...pressProps(gate, false, on.onToggleEnabled),
+									children: t(action.hidden ? "manager.enable" : "manager.disable")
+								}),
+								deleting ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+									variant: "toolbar",
+									size: "sm",
+									className: "dsh-cqa-entry",
+									"data-quick-actions-delete": "confirm",
+									...pressProps(gate, false, on.onConfirmDelete),
+									children: t("manager.delete.confirm")
+								}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+									variant: "toolbar",
+									size: "sm",
+									className: "dsh-cqa-entry",
+									onClick: on.onCancelDelete,
+									children: t("manager.delete.cancel")
+								})] }) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+									variant: "toolbar",
+									size: "sm",
+									className: "dsh-cqa-entry",
+									"data-quick-actions-delete": "ask",
+									...pressProps(gate, false, on.onAskDelete),
+									children: t("manager.delete")
+								})
+							] }) : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+								variant: "toolbar",
+								size: "sm",
+								className: "dsh-cqa-entry",
+								...pressProps(gate, false, on.onToggleHidden),
+								children: t(action.hidden ? "manager.restore" : "manager.hide")
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+								variant: "toolbar",
+								size: "sm",
+								className: "dsh-cqa-entry",
+								"data-quick-actions-clone": "",
+								...pressProps(gate, !gate.canAdd, on.onClone),
+								children: t("manager.clone")
+							})] })
+						]
+					})
+				]
+			});
+		}
+		//#endregion
+		//#region src/client/manager/status.ts
+		/**
+		* How the management panel names the state it is in (spec 10).
+		*
+		* Both readings are pure functions over the snapshot the controller publishes,
+		* kept beside the panel rather than inside it — the same split the surfaces use
+		* for `layout.ts` and the action panel for `search.ts`.
+		*/
+		/**
+		* Report read-only state, and only read-only state.
+		*
+		* Spec 10 keeps two first-read failures apart: a catalog that could not be read
+		* shows a retryable catalog error, while a *readable* catalog whose user
+		* namespace failed shows "storage unavailable". Without the projection guard
+		* below, a loading or failed catalog also reads as read-only — the write gate
+		* refuses on `not-ready` — and the panel would print both notices at once,
+		* telling the user their storage is broken when it is the catalog that is
+		* missing. With no catalog there is nothing to be read-only *about*: the catalog
+		* notice is the whole story.
+		*/
+		function managerReadOnlyReason(client) {
+			if (client.projection === void 0) return void 0;
+			if (!client.readOnly) return void 0;
+			return client.stale ? "offline" : "storage";
+		}
+		/** One write failure as a sentence, with the recovery it implies (spec 10). */
+		function managerFailureMessage(failure, t) {
+			if (failure.kind === "failed") return t("write.failed", { message: failure.message });
+			return t(quickActionsLocaleKey(failure.kind === "rejected" ? `write.${failure.rejection.reason}` : `write.${failure.kind}`, "write.refused"));
+		}
+		//#endregion
+		//#region src/client/manager/ManagerPanel.tsx
+		/**
+		* The centralized management panel (spec 8.3).
+		*
+		* Everything a user can change about Quick Actions lives here and nowhere else:
+		* the shared order, a preset's hidden state and its clone, a custom action's
+		* whole life cycle, and the global layout. The Composer surfaces only read the
+		* projection and execute.
+		*
+		* ## Where the truth is
+		*
+		* The panel renders the authoritative snapshot the controller publishes and
+		* never a local copy of it. So a new UI state appears only once the Host has
+		* persisted it (spec 10) — including the order, which is why a failed reorder
+		* needs no "restore the old order" path: the old order was never left.
+		*
+		* ## Failure, and the one retry
+		*
+		* Every write goes through one funnel, which also remembers how to run it again.
+		* That is spec 10's 「提供明确重试」: the failure banner offers the retry, and
+		* pressing it *re-plans* rather than replaying — the controller builds each plan
+		* from the snapshot it holds at that moment, and a create mints a fresh Custom
+		* Action ID per attempt. Nothing ever retries on its own; a silent replay could
+		* submit a plan the user has already moved past.
+		*
+		* Each failure is named, because spec 10 asks for different handling per kind: a
+		* refusal or a transport failure keeps the form content and the panel open,
+		* while a revision conflict means the controller has already re-read the
+		* authoritative state, so the notice asks the user to confirm the change again
+		* against what is now on screen — this feature keeps no second offline truth.
+		*
+		* Nothing here reports success: the list is the feedback, and spec 9.5 forbids an
+		* extra success toast.
+		*/
+		/** The form's starting draft for an existing Custom Quick Action. */
+		function draftOf(action) {
+			return {
+				label: action.label,
+				text: action.text,
+				icon: action.icon ?? "",
+				confirm: action.confirm
+			};
+		}
+		function ManagerPanel({ client, controller, t }) {
+			const close = (0, react.useCallback)(() => {
+				controller.closeManager();
+			}, [controller]);
+			useFocusReturn();
+			const { panelRef, onKeyDown } = useModalKeys(close);
+			useInitialFocusIn(panelRef, "[data-quick-actions-manager-close]");
+			const titleId = (0, react.useId)();
+			const layoutTitleId = (0, react.useId)();
+			const listTitleId = (0, react.useId)();
+			const [form, setForm] = (0, react.useState)(void 0);
+			const [pendingDelete, setPendingDelete] = (0, react.useState)(void 0);
+			const [pending, setPending] = (0, react.useState)(void 0);
+			const projection = client.projection;
+			const managed = projection?.managed ?? [];
+			const counts = projection?.counts;
+			const readOnlyReason = managerReadOnlyReason(client);
+			const gate = {
+				readOnly: readOnlyReason !== void 0,
+				busy: client.writing,
+				canAdd: counts?.canAdd === true
+			};
+			const editingId = form?.target.kind === "edit" ? form.target.id : void 0;
+			const editingLives = editingId === void 0 || managed.some((action) => action.editable && action.ref.source === "custom" && action.ref.id === editingId);
+			(0, react.useEffect)(() => {
+				if (!editingLives) setForm(void 0);
+			}, [editingLives]);
+			/**
+			* The one funnel every write goes through: remember it, run it, and answer
+			* whether it landed.
+			*
+			* The `catch` is the belt. A controller write answers with an outcome rather
+			* than rejecting, so this arm should be unreachable — but an unhandled
+			* rejection must never reach the page from a click handler, and the failure
+			* the user sees comes from the snapshot the controller publishes either way.
+			*/
+			const write = (0, react.useCallback)(async (remember, run) => {
+				setPending(remember);
+				try {
+					const outcome = await run();
+					if (outcome.ok) setPending(void 0);
+					return outcome.ok;
+				} catch {
+					return false;
+				}
+			}, []);
+			/** Start a write from a click handler, with no outcome to react to. */
+			const fire = (0, react.useCallback)((run) => {
+				write({
+					kind: "write",
+					run
+				}, run);
+			}, [write]);
+			const save = (0, react.useCallback)(async () => {
+				if (form === void 0) return;
+				if (!validateQuickActionDraft(form.draft).ok) {
+					setForm({
+						...form,
+						attempted: true
+					});
+					return;
+				}
+				const { target, draft } = form;
+				if (await write({ kind: "form" }, () => target.kind === "new" ? controller.createCustomAction(draft) : controller.updateCustomAction(target.id, draft))) setForm(void 0);
+				else setForm({
+					...form,
+					attempted: true
+				});
+			}, [
+				controller,
+				form,
+				write
+			]);
+			const retry = (0, react.useCallback)(() => {
+				if (pending === void 0) return;
+				if (pending.kind === "form") {
+					save();
+					return;
+				}
+				write(pending, pending.run);
+			}, [
+				pending,
+				save,
+				write
+			]);
+			const remove = (0, react.useCallback)((id) => {
+				const run = () => controller.deleteCustomAction(id);
+				write({
+					kind: "write",
+					run
+				}, run).then((landed) => {
+					if (landed) setPendingDelete(void 0);
+				});
+			}, [controller, write]);
+			return (0, react_dom.createPortal)(/* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				className: "dsh-cqa-backdrop dsh-cqa-manager-backdrop",
+				"data-quick-actions-backdrop": "",
+				"aria-hidden": "true",
+				onClick: close
+			}), /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "dsh-cqa-manager",
+				ref: panelRef,
+				role: "dialog",
+				"aria-modal": "true",
+				"aria-labelledby": titleId,
+				"data-quick-actions-manager": "",
+				onKeyDown,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "dsh-cqa-manager-head",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h2", {
+							className: "dsh-cqa-manager-title",
+							id: titleId,
+							children: t("manager.title")
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+							variant: "toolbar",
+							size: "sm",
+							className: "dsh-cqa-entry",
+							"data-quick-actions-manager-close": "",
+							onClick: close,
+							children: t("manager.close")
+						})]
+					}),
+					projection === void 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "dsh-cqa-note",
+						role: "status",
+						"data-quick-actions-catalog-error": client.catalog.status === "error" ? client.catalog.reason : "loading",
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: "dsh-cqa-note-text",
+							children: t(client.catalog.status === "error" ? `catalog.${client.catalog.reason}` : "catalog.loading")
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							className: "dsh-cqa-link",
+							onClick: () => {
+								controller.refresh().catch(() => void 0);
+							},
+							children: t("catalog.retry")
+						})]
+					}) : null,
+					readOnlyReason === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						className: "dsh-cqa-note",
+						role: "status",
+						"data-quick-actions-readonly": readOnlyReason,
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: "dsh-cqa-note-text",
+							children: t(`manager.readonly.${readOnlyReason}`)
+						})
+					}),
+					client.failure === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: "dsh-cqa-note",
+						role: "alert",
+						"data-quick-actions-write-failure": client.failure.kind,
+						children: [
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								className: "dsh-cqa-note-text",
+								children: managerFailureMessage(client.failure, t)
+							}),
+							pending === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								className: "dsh-cqa-link",
+								"data-quick-actions-write-retry": "",
+								onClick: retry,
+								children: t("write.retry")
+							}),
+							/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								className: "dsh-cqa-link",
+								onClick: () => {
+									controller.dismissFailure();
+								},
+								children: t("write.dismiss")
+							})
+						]
+					}),
+					counts === void 0 || !counts.overflow && counts.canAdd ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+						className: "dsh-cqa-note",
+						role: "status",
+						"data-quick-actions-limit": counts.overflow ? "overflow" : "reached",
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: "dsh-cqa-note-text",
+							children: t(counts.overflow ? "manager.overflow" : "manager.limit", {
+								limit: counts.limit,
+								total: counts.total
+							})
+						})
+					}),
+					projection === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							className: "dsh-cqa-section",
+							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								className: "dsh-cqa-section-title",
+								id: layoutTitleId,
+								children: t("manager.layout")
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+								className: "dsh-cqa-group",
+								role: "group",
+								"aria-labelledby": layoutTitleId,
+								children: QUICK_ACTION_LAYOUTS.map((layout) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+									variant: "toolbar",
+									size: "sm",
+									className: "dsh-cqa-entry",
+									"data-quick-actions-layout-choice": layout,
+									"aria-pressed": projection.layout === layout,
+									...pressProps(gate, projection.layout === layout, () => {
+										fire(() => controller.setLayout(layout));
+									}),
+									children: t(`manager.layout.${layout}`)
+								}, layout))
+							})]
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+							className: "dsh-cqa-section",
+							children: [
+								/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+									className: "dsh-cqa-section-head",
+									children: [
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+											className: "dsh-cqa-section-title",
+											id: listTitleId,
+											children: t("manager.actions")
+										}),
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+											className: "dsh-cqa-field-hint",
+											"data-quick-actions-count": "",
+											children: t("manager.count", {
+												total: counts?.total ?? 0,
+												limit: counts?.limit ?? 0
+											})
+										}),
+										/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+											variant: "toolbar",
+											size: "sm",
+											className: "dsh-cqa-entry",
+											"data-quick-actions-new": "",
+											...pressProps(gate, !gate.canAdd || form?.target.kind === "new", () => {
+												setForm({
+													target: { kind: "new" },
+													draft: newQuickActionDraft(),
+													attempted: false
+												});
+											}),
+											children: t("manager.new")
+										})
+									]
+								}),
+								/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+									className: "dsh-cqa-note",
+									"data-quick-actions-command-notice": "",
+									children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+										className: "dsh-cqa-note-text",
+										children: t("manager.command.notice")
+									})
+								}),
+								managed.length === 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+									className: "dsh-cqa-field-hint",
+									children: t("manager.empty")
+								}) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("ul", {
+									className: "dsh-cqa-list",
+									"aria-labelledby": listTitleId,
+									children: managed.map((action, index) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ManagedRow, {
+										action,
+										index,
+										total: managed.length,
+										gate,
+										deleting: action.ref.source === "custom" && pendingDelete === action.ref.id,
+										t,
+										on: {
+											onMove: (ref, toIndex) => {
+												fire(() => controller.moveAction(ref, toIndex));
+											},
+											onEdit: () => {
+												setForm({
+													target: {
+														kind: "edit",
+														id: action.ref.id
+													},
+													draft: draftOf(action),
+													attempted: false
+												});
+											},
+											onClone: () => {
+												fire(() => controller.clonePreset(action.ref.id));
+											},
+											onToggleHidden: () => {
+												fire(() => controller.setPresetHidden(action.ref.id, !action.hidden));
+											},
+											onToggleEnabled: () => {
+												fire(() => controller.setCustomActionEnabled(action.ref.id, action.hidden));
+											},
+											onAskDelete: () => {
+												setPendingDelete(action.ref.id);
+											},
+											onCancelDelete: () => {
+												setPendingDelete(void 0);
+											},
+											onConfirmDelete: () => {
+												remove(action.ref.id);
+											}
+										}
+									}, quickActionRefKey(action.ref)))
+								})
+							]
+						}),
+						form === void 0 ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ActionForm, {
+							mode: form.target.kind,
+							draft: form.draft,
+							attempted: form.attempted,
+							gate,
+							t,
+							onChange: (draft) => {
+								setForm({
+									...form,
+									draft
+								});
+							},
+							onSave: () => {
+								save();
+							},
+							onCancel: () => {
+								setForm(void 0);
+							}
+						}, editingId === void 0 ? "new" : `edit:${editingId}`)
+					] })
+				]
+			})] }), document.body);
+		}
+		//#endregion
+		//#region src/client/surfaces/entries.tsx
+		/**
+		* The two dock Slot entries (spec 7.3, 8.1).
+		*
+		* Both are always registered; which one renders the layout is decided at render
+		* time from the authoritative Settings snapshot, and both render nothing at all
+		* unless the Resident Composer predicate holds for their Session:
+		*
+		* - `conversation.composer.dock` is the residency beacon. Its mount is DSH's own
+		*   statement that this Session's composer is in its resident variant, so it
+		*   marks the Session while mounted and additionally renders the `bar` layout.
+		* - `conversation.input.dock` renders `ribbon` or `launcher`, but only while the
+		*   beacon's mark stands — that Slot also mounts on the blank-session hero, and
+		*   the first release must never appear there.
+		*
+		* A third entry rides the same input dock: the centralized management overlay,
+		* which spec 8.1 requires to be registered independently of the layout entries.
+		* It is a separate Slot cell with its own id, order and error boundary, so a
+		* failure in the management panel cannot take a Composer layout down with it and
+		* vice versa (spec 7.3). Because the overlay is global state rendered from a
+		* session-scoped Slot, only the Session the residency registry elects primary
+		* draws it — two Resident Composers on screen must not stack two overlays.
+		*
+		* Each entry carries its own error boundary, so a failure replaces the Quick
+		* Action area alone.
+		*/
+		function useControllerState(controller) {
+			return (0, react.useSyncExternalStore)((0, react.useCallback)((listener) => controller.subscribe(listener), [controller]), () => controller.getSnapshot());
+		}
+		function useResident(residency, sessionId) {
+			return (0, react.useSyncExternalStore)((0, react.useCallback)((listener) => residency.subscribe(listener), [residency]), () => residency.isResident(sessionId));
+		}
+		/** Whether this Session is the one that draws anything global (see the registry). */
+		function usePrimaryResident(residency, sessionId) {
+			return (0, react.useSyncExternalStore)((0, react.useCallback)((listener) => residency.subscribe(listener), [residency]), () => residency.primarySessionId() === sessionId);
+		}
+		/**
+		* The Composer block for one Session, resolved on every read rather than cached.
+		*
+		* `conversation` is reached through `ctx.get` rather than `inject`, so nothing
+		* orders it before this component's first render. Caching the resolution would
+		* turn "the service was not there yet" into "this Session can never be blocked",
+		* and a Quick Action would then send into a Composer another feature has made
+		* inert. `storeFor` answers an identity-stable store, so re-resolving costs a
+		* map lookup and keeps `getSnapshot` referentially stable.
+		*/
+		function useComposerBlock(blocks, sessionId) {
+			return (0, react.useSyncExternalStore)((0, react.useCallback)((listener) => blocks()?.storeFor(sessionId)?.subscribe(listener) ?? (() => {}), [blocks, sessionId]), () => blocks()?.storeFor(sessionId)?.getSnapshot());
+		}
+		/**
+		* The body both entries render once residency and the layout agree.
+		*
+		* It owns the Session's execution engine for as long as it is mounted: every
+		* commit republishes the live `InputActions` and the live Composer projection
+		* into it, and unmounting cancels whatever has not reached the official state
+		* machine (spec 7.2).
+		*/
+		function SessionSurface(props) {
+			const { deps, layout, actions, sessionId, useInput, useSession, inputActions, t } = props;
+			const engine = (0, react.useMemo)(() => deps.sessions.engineFor(sessionId), [deps.sessions, sessionId]);
+			const input = useInput((state) => state);
+			const session = useSession((state) => state);
+			const block = useComposerBlock(deps.blocks, sessionId);
+			(0, react.useLayoutEffect)(() => {
+				engine.bind(inputActions, actions);
+				engine.observe(input, session, block);
+			});
+			(0, react.useEffect)(() => () => {
+				engine.cancelPending();
+			}, [engine]);
+			const state = (0, react.useSyncExternalStore)((0, react.useCallback)((listener) => engine.subscribe(listener), [engine]), () => engine.getSnapshot());
+			const onActivate = (0, react.useCallback)((action) => {
+				engine.activate(action);
+			}, [engine]);
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(QuickActionsSurface, {
+				layout,
+				actions,
+				session: state,
+				t,
+				onActivate,
+				onConfirm: () => {
+					engine.confirm();
+				},
+				onCancelConfirm: () => {
+					engine.cancel();
+				},
+				onDismissFeedback: () => {
+					engine.dismissFeedback();
+				},
+				onManage: () => {
+					deps.controller.openManager();
+				}
+			});
+		}
+		/** The catalog error and loading states of spec 10, rendered where the layout would be. */
+		function CatalogNotice(props) {
+			const { client, t, onRetry } = props;
+			if (client.catalog.status === "loading") return null;
+			if (client.catalog.status === "ready") return null;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: "dsh-cqa-note",
+				role: "status",
+				"data-quick-actions-catalog-error": client.catalog.reason,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					className: "dsh-cqa-note-text",
+					children: t(`catalog.${client.catalog.reason}`)
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+					type: "button",
+					className: "dsh-cqa-link",
+					onClick: onRetry,
+					children: t("catalog.retry")
+				})]
+			});
+		}
+		/** Build both Slot entry components over one set of fiber-owned dependencies. */
+		function createQuickActionDockEntries(deps) {
+			function Body(props) {
+				const { owns, ...slot } = props;
+				const client = useControllerState(deps.controller);
+				const projection = client.projection;
+				const onRetry = (0, react.useCallback)(() => {
+					deps.controller.refresh().catch(() => void 0);
+				}, []);
+				if (projection === void 0) return owns.includes("ribbon") ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CatalogNotice, {
+					client,
+					t: slot.t,
+					onRetry
+				}) : null;
+				if (!owns.includes(projection.layout)) return null;
+				return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SessionSurface, {
+					...slot,
+					deps,
+					layout: projection.layout,
+					actions: projection.composer
+				});
+			}
+			function InputDock(props) {
+				const resident = useResident(deps.residency, props.sessionId);
+				return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SurfaceErrorBoundary, {
+					t: props.t,
+					children: resident ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Body, {
+						...props,
+						owns: INPUT_DOCK_LAYOUTS
+					}) : null
+				});
+			}
+			function ComposerDock(props) {
+				const { sessionId } = props;
+				(0, react.useLayoutEffect)(() => deps.residency.mark(sessionId), [sessionId]);
+				return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SurfaceErrorBoundary, {
+					t: props.t,
+					children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Body, {
+						...props,
+						owns: COMPOSER_DOCK_LAYOUTS
+					})
+				});
+			}
+			/**
+			* The centralized management overlay (spec 8.1, 8.3).
+			*
+			* It renders only where a Resident Composer's own "manage" entry could have
+			* opened it, and only for the primary Session, so the global panel stays
+			* single however many composers are on screen.
+			*/
+			function ManagerDock(props) {
+				const primary = usePrimaryResident(deps.residency, props.sessionId);
+				const client = useControllerState(deps.controller);
+				return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SurfaceErrorBoundary, {
+					t: props.t,
+					children: primary && client.manager.open ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ManagerPanel, {
+						client,
+						controller: deps.controller,
+						t: props.t
+					}) : null
+				});
+			}
+			return {
+				InputDock,
+				ComposerDock,
+				ManagerDock
+			};
+		}
+		/** `ribbon` and `launcher` render above the composer card (spec 8.1). */
+		const INPUT_DOCK_LAYOUTS = ["ribbon", "launcher"];
+		/** `bar` renders below it. */
+		const COMPOSER_DOCK_LAYOUTS = ["bar"];
+		//#endregion
+		//#region src/styles/index.ts
+		/**
+		* The Composer Quick Action surfaces' stylesheet (spec 8.2, 8.4).
+		*
+		* It is shipped as one string installed into a `<style data-plugin-css>` tag,
+		* the same shape and idempotence the first-party DSH client bundles use, rather
+		* than as CSS Modules: the Client build adapter produces one browser CJS file
+		* with no CSS pipeline (spec 11.2), and adding one would change a contract the
+		* bundle's own tests pin. Class names carry the `dsh-cqa-` prefix instead of a
+		* generated hash, which gives the same collision safety by convention.
+		*
+		* Colours are DSH alias theme tokens only — nothing here defines a palette, and
+		* nothing overrides a global theme (spec 8.4).
+		*
+		* ## The width rule (spec 8.2)
+		*
+		* The two layouts sit in different boxes, so they reach the same outer edges by
+		* different arithmetic:
+		*
+		* - `.dsh-cqa-ribbon` renders in the composer stack, outside the InputBar, which
+		*   is the element that owns `--dsh-composer-side-clearance` as padding. It
+		*   therefore subtracts that clearance from both sides itself.
+		* - `.dsh-cqa-bar` renders as the InputBar's last child, inside that padding, so
+		*   it is simply `100%` wide.
+		*
+		* Both are then capped at `--dsh-composer-card-max-width` — the same cap the
+		* composer card uses — and centred, so their left and right edges coincide with
+		* the input box exactly rather than approximately.
+		*/
+		const TAG_ID = "dsh-quick-actions/surfaces.css";
+		const QUICK_ACTIONS_CSS = `
+.dsh-cqa-ribbon,
+.dsh-cqa-launcher {
+  box-sizing: border-box;
+  width: calc(100% - var(--dsh-composer-side-clearance) - var(--dsh-composer-side-clearance));
+  max-width: var(--dsh-composer-card-max-width);
+  margin: 0 auto;
+}
+.dsh-cqa-bar {
+  box-sizing: border-box;
+  width: 100%;
+  max-width: var(--dsh-composer-card-max-width);
+  margin: 0 auto;
+}
+
+.dsh-cqa-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-width: 0;
+  padding: 2px 0;
+}
+.dsh-cqa-row[data-density='narrow'] {
+  gap: 6px;
+}
+
+.dsh-cqa-title {
+  flex: none;
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 12px;
+  font-weight: 500;
+  line-height: 18px;
+  white-space: nowrap;
+}
+
+/* The ribbon overflows horizontally; the management entry never scrolls away. */
+.dsh-cqa-scroll {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex: 1 1 auto;
+  min-width: 0;
+  overflow-x: auto;
+  scrollbar-width: thin;
+}
+.dsh-cqa-fit {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex: 1 1 auto;
+  min-width: 0;
+  overflow: hidden;
+}
+.dsh-cqa-trailing {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex: none;
+  margin-left: auto;
+}
+
+/*
+ * The capsule itself — height, radius, padding, colours, hover and ":disabled"
+ * — belongs to the official "Button". What is left here is what a shared
+ * control cannot know (how it behaves inside these rows) plus what the
+ * primitive does not supply. Nothing below may restate a Button property,
+ * because the plugin class is applied after the primitive's and would win on
+ * equal specificity.
+ *
+ * The focus ring is one of the things it does not supply: "Button.module.css"
+ * and "Pill.module.css" carry no ":focus" rule at all — the library leaves the
+ * ring to each component that wants one ("Input.module.css" has
+ * ":focus-within", "HoverCard" and "JsonTree" their own). Spec 8.4 makes a
+ * clear focus ring a hard gate, so it stays here for every control this plugin
+ * renders.
+ */
+.dsh-cqa-action,
+.dsh-cqa-entry {
+  /* No global border-box reset exists in this stylesheet, and Button pads
+     itself, so the cap has to count that padding to mean 240px on screen. */
+  box-sizing: border-box;
+  flex: none;
+  /* Long labels truncate rather than pushing the row's other controls out. */
+  max-width: 240px;
+}
+.dsh-cqa-action:focus-visible,
+.dsh-cqa-entry:focus-visible {
+  outline: 2px solid var(--dsw-alias-state-business-primary);
+  outline-offset: 1px;
+}
+/* "aria-disabled" is not ":disabled": a control kept focusable while a write is
+   in flight still has to read as inert, and no primitive expresses that. */
+.dsh-cqa-entry[aria-disabled='true'] {
+  opacity: 0.5;
+  cursor: default;
+}
+/* The searchable panel's rows stay native — a full-width, left-aligned list row
+   is not a capsule — so they still need a focus ring of their own. */
+.dsh-cqa-panel-item:focus-visible,
+.dsh-cqa-link:focus-visible {
+  outline: 2px solid var(--dsw-alias-state-business-primary);
+  outline-offset: 1px;
+}
+.dsh-cqa-label {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.dsh-cqa-icon {
+  flex: none;
+}
+/* The chip look is "Pill"'s; only its behaviour in a flex row is ours. */
+.dsh-cqa-badge,
+.dsh-cqa-tag {
+  flex: none;
+}
+
+.dsh-cqa-note {
+  box-sizing: border-box;
+  width: 100%;
+  margin: 4px 0 0;
+  padding: 4px 8px;
+  border-radius: 8px;
+  background: var(--dsw-alias-interactive-bg-hover);
+  color: var(--dsw-alias-label-secondary);
+  font-size: 12px;
+  line-height: 18px;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.dsh-cqa-note-text {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+.dsh-cqa-link {
+  flex: none;
+  border: 0;
+  background: none;
+  padding: 0;
+  color: var(--dsw-alias-state-business-primary);
+  font: inherit;
+  font-size: 12px;
+  cursor: pointer;
+  text-decoration: underline;
+}
+
+/* Anchored surfaces: the popover list and the confirmation panel. */
+.dsh-cqa-anchor {
+  position: relative;
+}
+.dsh-cqa-backdrop {
+  position: fixed;
+  z-index: 19;
+  inset: 0;
+}
+.dsh-cqa-panel {
+  position: absolute;
+  z-index: 20;
+  bottom: calc(100% + 6px);
+  left: 0;
+  box-sizing: border-box;
+  max-width: min(100%, 360px);
+  min-width: 220px;
+  max-height: 260px;
+  overflow-y: auto;
+  padding: 6px;
+  border: 0.5px solid var(--dsw-alias-border-l1);
+  border-radius: 12px;
+  background: var(--dsw-specific-tip);
+  box-shadow: var(--dsw-elevation-soft);
+}
+.dsh-cqa-panel-head {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.dsh-cqa-panel-head .dsh-cqa-panel-title {
+  flex: 1 1 auto;
+  min-width: 0;
+}
+.dsh-cqa-panel-title {
+  padding: 4px 8px;
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 12px;
+  line-height: 18px;
+}
+.dsh-cqa-panel-item {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  width: 100%;
+  padding: 6px 8px;
+  border: 0;
+  border-radius: 8px;
+  background: none;
+  color: var(--dsw-alias-label-primary);
+  font: inherit;
+  font-size: 13px;
+  line-height: 20px;
+  text-align: left;
+  cursor: pointer;
+}
+.dsh-cqa-panel-item:hover:not(:disabled) {
+  background: var(--dsw-alias-interactive-bg-hover);
+}
+.dsh-cqa-panel-item:disabled {
+  opacity: 0.5;
+  cursor: default;
+}
+
+.dsh-cqa-confirm-text {
+  margin: 6px 0;
+  padding: 8px;
+  border-radius: 8px;
+  background: var(--dsw-alias-interactive-bg-hover);
+  color: var(--dsw-alias-label-primary);
+  font-family: var(--ds-font-family-code);
+  font-size: 12px;
+  line-height: 18px;
+  white-space: pre-wrap;
+  word-break: break-word;
+  max-height: 160px;
+  overflow-y: auto;
+}
+.dsh-cqa-confirm-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+}
+
+/* ------------------------------------------------------------------------- */
+/* Fields, shared by the search box and the Custom Quick Action form         */
+/* ------------------------------------------------------------------------- */
+
+.dsh-cqa-field {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  padding: 4px 0;
+}
+.dsh-cqa-field-label {
+  color: var(--dsw-alias-label-secondary);
+  font-size: 12px;
+  line-height: 18px;
+}
+.dsh-cqa-field-hint {
+  color: var(--dsw-alias-label-tertiary);
+  font-size: 11px;
+  line-height: 16px;
+}
+.dsh-cqa-field-error {
+  color: var(--dsw-alias-state-danger-primary, var(--dsw-alias-label-primary));
+  font-size: 11px;
+  line-height: 16px;
+  font-weight: 500;
+}
+
+.dsh-cqa-input,
+.dsh-cqa-textarea {
+  box-sizing: border-box;
+  width: 100%;
+  padding: 4px 8px;
+  border: 0.5px solid var(--dsw-alias-border-l1);
+  border-radius: 8px;
+  background: transparent;
+  color: var(--dsw-alias-label-primary);
+  font: inherit;
+  font-size: 13px;
+  line-height: 20px;
+}
+.dsh-cqa-textarea {
+  resize: vertical;
+  min-height: 72px;
+  font-family: var(--ds-font-family-code);
+  white-space: pre-wrap;
+}
+.dsh-cqa-input:focus-visible,
+.dsh-cqa-textarea:focus-visible {
+  outline: 2px solid var(--dsw-alias-state-business-primary);
+  outline-offset: 1px;
+}
+.dsh-cqa-input:disabled,
+.dsh-cqa-textarea:disabled {
+  opacity: 0.5;
+}
+
+.dsh-cqa-switch {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 4px 0;
+  cursor: pointer;
+}
+
+/* ------------------------------------------------------------------------- */
+/* The centralized management overlay                                        */
+/* ------------------------------------------------------------------------- */
+
+/*
+ * The overlay and its click-catching backdrop. Neither paints: only DSH alias
+ * theme tokens may be used here, and this release has no token to spend on a
+ * modal scrim (spec 8.4).
+ *
+ * These two numbers rank the overlay against its own backdrop, and nothing
+ * else. Since ticket 26 the overlay is portaled to the document body, so it and
+ * the anchored popovers (19 and 20, still rendered in the input dock) sit in
+ * different stacking contexts: which of them paints on top follows from where
+ * the dock's own ancestors land in the root context, not from comparing 31
+ * against 20. Raising these would not change that.
+ */
+.dsh-cqa-manager-backdrop {
+  z-index: 30;
+}
+.dsh-cqa-manager {
+  position: fixed;
+  z-index: 31;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  box-sizing: border-box;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  width: min(560px, calc(100vw - 24px));
+  max-height: min(80vh, 680px);
+  overflow-y: auto;
+  padding: 12px;
+  border: 0.5px solid var(--dsw-alias-border-l1);
+  border-radius: 12px;
+  background: var(--dsw-specific-tip);
+  color: var(--dsw-alias-label-primary);
+  box-shadow: var(--dsw-elevation-soft);
+}
+
+.dsh-cqa-manager-head {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.dsh-cqa-manager-title {
+  flex: 1 1 auto;
+  min-width: 0;
+  margin: 0;
+  color: var(--dsw-alias-label-primary);
+  font-size: 14px;
+  font-weight: 600;
+  line-height: 20px;
+}
+
+.dsh-cqa-section {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  padding: 6px 0;
+  border-top: 0.5px solid var(--dsw-alias-border-l1);
+}
+.dsh-cqa-section-head {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+.dsh-cqa-section-head .dsh-cqa-section-title {
+  flex: 1 1 auto;
+}
+.dsh-cqa-section-title {
+  color: var(--dsw-alias-label-secondary);
+  font-size: 12px;
+  font-weight: 500;
+  line-height: 18px;
+}
+.dsh-cqa-group {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  flex-wrap: wrap;
+}
+.dsh-cqa-entry[aria-pressed='true'] {
+  background: var(--dsw-alias-state-business-tertiary);
+  color: var(--dsw-alias-label-primary-bluish);
+  opacity: 1;
+}
+
+.dsh-cqa-list {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+.dsh-cqa-list-item {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  padding: 6px 8px;
+  border-radius: 8px;
+  background: var(--dsw-alias-interactive-bg-hover);
+}
+/* A hidden or disabled action stays legible: it is managed here, not removed. */
+.dsh-cqa-list-item[data-quick-action-hidden] .dsh-cqa-list-head,
+.dsh-cqa-list-item[data-quick-action-hidden] .dsh-cqa-list-text {
+  opacity: 0.6;
+}
+.dsh-cqa-list-head {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  flex-wrap: wrap;
+  min-width: 0;
+  font-size: 13px;
+  line-height: 20px;
+}
+.dsh-cqa-list-text {
+  min-width: 0;
+  overflow: hidden;
+  color: var(--dsw-alias-label-tertiary);
+  font-family: var(--ds-font-family-code);
+  font-size: 11px;
+  line-height: 16px;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+}
+.dsh-cqa-list-controls {
+  display: flex;
+  align-items: center;
+  gap: 4px;
+  flex-wrap: wrap;
+}
+
+.dsh-cqa-form {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  padding: 6px 0 0;
+  border-top: 0.5px solid var(--dsw-alias-border-l1);
+}
+.dsh-cqa-form-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+  padding-top: 6px;
+}
+`;
+		/**
+		* Install the stylesheet once per document and return its disposer, so the
+		* Client fiber owns it like every other registration (spec 7.3).
+		*
+		* The holder count lives on the tag rather than in this module, because a hot
+		* reload runs two bundle instances at once: the new fiber installs before the
+		* old one unloads, and each has its own module scope. Counting in the DOM is
+		* what keeps the surviving instance's styles from being removed underneath it.
+		*/
+		function installQuickActionStyles() {
+			if (typeof document === "undefined") return () => {};
+			const selector = `style[data-plugin-css=${JSON.stringify(TAG_ID)}]`;
+			const existing = document.querySelector(selector);
+			const tag = existing ?? document.createElement("style");
+			if (existing === null) {
+				tag.dataset["plugin"] = "dsh-quick-actions";
+				tag.dataset["pluginCss"] = TAG_ID;
+				tag.textContent = QUICK_ACTIONS_CSS;
+				document.head.appendChild(tag);
+			}
+			tag.dataset["pluginCssHolders"] = String(holdersOf(tag) + 1);
+			let released = false;
+			return () => {
+				if (released) return;
+				released = true;
+				const left = holdersOf(tag) - 1;
+				if (left > 0) {
+					tag.dataset["pluginCssHolders"] = String(left);
+					return;
+				}
+				tag.remove();
+			};
+		}
+		function holdersOf(tag) {
+			const held = Number(tag.dataset["pluginCssHolders"]);
+			return Number.isFinite(held) && held > 0 ? held : 0;
+		}
+		//#endregion
+		//#region src/client/index.tsx
+		const name = "composer-quick-actions";
+		/**
+		* The services this Client requires (spec 7.3). `conversation` is deliberately
+		* absent: its Composer-block registry is read through `ctx.get`, the documented
+		* read "without the inject requirement", because the service is guaranteed
+		* present wherever the two dock Slots it declares are rendered.
+		*/
+		const inject = [
+			"slots",
+			"settingsScope",
+			"connection",
+			"locale"
+		];
+		/** Ascending position among the shipped dock entries; late enough to sit last. */
+		const DOCK_ORDER = 100;
+		/** The management overlay's own cell, right after the layout's (spec 8.1). */
+		const MANAGER_ORDER = 101;
+		/**
+		* Start the feature and tie every piece of it to this fiber.
+		*
+		* Nothing is returned and no internal type is re-exported: the controller, the
+		* execution engine and the surfaces are internal to this package (spec 14).
+		*/
+		function apply(ctx) {
+			const controller = createQuickActionsController({
+				settingsScope: ctx.settingsScope,
+				connection: ctx.connection
+			});
+			const sessions = createQuickActionSessionRegistry();
+			const residency = createResidentComposerRegistry();
+			ctx.effect(() => () => {
+				sessions.dispose();
+				controller.dispose();
+			}, "composer-quick-actions: client controller");
+			ctx.effect(() => ctx.locale.register(QUICK_ACTIONS_LOCALE_NAMESPACE, quickActionsDictionaries), "composer-quick-actions: dictionaries");
+			ctx.effect(installQuickActionStyles, "composer-quick-actions: surface styles");
+			const { InputDock, ComposerDock, ManagerDock } = createQuickActionDockEntries({
+				controller,
+				sessions,
+				residency,
+				blocks: () => ctx.get("conversation")?.blocks
+			});
+			ctx.slots.inject("conversation.input.dock", () => [ctx.slots.register({
+				name: "conversation.input.dock",
+				id: "composer-quick-actions",
+				order: DOCK_ORDER,
+				locale: QUICK_ACTIONS_LOCALE_NAMESPACE
+			}, InputDock), ctx.slots.register({
+				name: "conversation.input.dock",
+				id: "composer-quick-actions-manager",
+				order: MANAGER_ORDER,
+				locale: QUICK_ACTIONS_LOCALE_NAMESPACE
+			}, ManagerDock)]);
+			ctx.slots.inject("conversation.composer.dock", () => ctx.slots.register({
+				name: "conversation.composer.dock",
+				id: "composer-quick-actions",
+				order: DOCK_ORDER,
+				locale: QUICK_ACTIONS_LOCALE_NAMESPACE
+			}, ComposerDock));
+		}
+		//#endregion
+		exports.apply = apply;
+		exports.inject = inject;
+		exports.name = name;
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.js.map