dsh-thinkbar 0.1.0

package/lib/client.cjs

@@ -0,0 +1,679 @@
+window.__ModuleLoader__.load({
+	id: "dsh-thinkbar",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let _deepseek_ai_cordis = require("@deepseek-ai/cordis");
+		let react_dom = require("react-dom");
+		let react = require("react");
+		let react_jsx_runtime = require("react/jsx-runtime");
+		//#region src/client/thermometer.ts
+		const FULL_SCALE_MS = 2e4;
+		const MIN_FILL = .08;
+		const DRAIN_MS = 240;
+		const IRON_STOPS = [
+			{
+				t: 0,
+				hex: "var(--dsw-alias-button-info-fill)"
+			},
+			{
+				t: 1 / 3,
+				hex: "#dc2626"
+			},
+			{
+				t: 2 / 3,
+				hex: "#e07020"
+			},
+			{
+				t: 1,
+				hex: "#ffcc00"
+			}
+		];
+		function reasoningWaitAppearance(projection, elapsed) {
+			if (projection?.active !== true) return { phase: "idle" };
+			const t = Math.min(1, Math.max(0, elapsed / FULL_SCALE_MS));
+			return {
+				phase: "thermometer",
+				t,
+				height: MIN_FILL + .92 * easeOutFill(t),
+				color: ironScale(t)
+			};
+		}
+		function extrapolateProjectionClock(projection, frameNow, anchor, identity) {
+			if (projection?.active !== true) return {
+				elapsed: 0,
+				anchor: null
+			};
+			const eventElapsed = Math.max(0, projection.streamTime - projection.waitOrigin);
+			const stamp = `${identity}:${projection.waitOrigin}:${projection.streamTime}`;
+			if (anchor?.stamp !== stamp) {
+				const elapsed = Math.max(anchor?.identity === identity ? anchor.renderedElapsed : 0, eventElapsed);
+				return {
+					elapsed,
+					anchor: {
+						stamp,
+						identity,
+						eventElapsed,
+						observedAt: frameNow,
+						renderedElapsed: elapsed
+					}
+				};
+			}
+			const elapsed = Math.max(anchor.renderedElapsed, anchor.eventElapsed + frameNow - anchor.observedAt);
+			return {
+				elapsed,
+				anchor: {
+					...anchor,
+					renderedElapsed: elapsed
+				}
+			};
+		}
+		function advanceReasoningWait(previous, input) {
+			const snapshot = reasoningWaitAppearance(input.projection, input.elapsed);
+			if (snapshot.phase === "thermometer") {
+				if (previous.phase === "thermometer" && previous.identity === input.identity && previous.t === snapshot.t && previous.height === snapshot.height && previous.color === snapshot.color) return previous;
+				return {
+					...snapshot,
+					identity: input.identity
+				};
+			}
+			if (input.reducedMotion) return previous.phase === "idle" ? previous : { phase: "idle" };
+			const sameIdentity = previous.phase !== "idle" && previous.identity === input.identity;
+			if (previous.phase === "thermometer" && sameIdentity) return {
+				phase: "drain",
+				identity: input.identity,
+				t: previous.t,
+				height: previous.height,
+				color: previous.color,
+				fromHeight: previous.height,
+				startedAt: input.frameNow
+			};
+			if (previous.phase === "drain" && sameIdentity) {
+				const elapsed = input.frameNow - previous.startedAt;
+				if (elapsed >= DRAIN_MS) return { phase: "idle" };
+				const height = previous.fromHeight * (1 - elapsed / DRAIN_MS);
+				if (height === previous.height) return previous;
+				return {
+					...previous,
+					height
+				};
+			}
+			return previous.phase === "idle" ? previous : { phase: "idle" };
+		}
+		function nearestStop(t) {
+			for (const stop of IRON_STOPS) if (Math.abs(t - stop.t) <= 1 / FULL_SCALE_MS) return stop.hex;
+		}
+		function ironScale(t) {
+			const snapped = nearestStop(t);
+			if (snapped !== void 0) return snapped;
+			if (t < IRON_STOPS[1].t) return mixOklch(IRON_STOPS[0].hex, IRON_STOPS[1].hex, t / (1 / 3));
+			if (t < IRON_STOPS[2].t) return mixOklch(IRON_STOPS[1].hex, IRON_STOPS[2].hex, (t - 1 / 3) / (1 / 3));
+			return mixOklch(IRON_STOPS[2].hex, IRON_STOPS[3].hex, (t - 2 / 3) / (1 / 3));
+		}
+		function mixOklch(fromHex, toHex, amount) {
+			return `color-mix(in oklch, ${fromHex}, ${toHex} ${amount * 100}%)`;
+		}
+		function easeOutFill(linearT) {
+			if (linearT <= 0) return 0;
+			if (linearT >= 1) return 1;
+			const xAt = (u) => 3 * (1 - u) * u * u * .58 + u ** 3;
+			const yAt = (u) => 3 * (1 - u) * u * u + u ** 3;
+			let low = 0;
+			let high = 1;
+			for (let i = 0; i < 24; i++) {
+				const mid = (low + high) / 2;
+				if (xAt(mid) < linearT) low = mid;
+				else high = mid;
+			}
+			return yAt((low + high) / 2);
+		}
+		//#endregion
+		//#region src/client/service.ts
+		/** Stateless reasoning-wait frame service. */
+		var ReasoningWaitService = class extends _deepseek_ai_cordis.Service {
+			static inject = [];
+			constructor(ctx) {
+				super(ctx, "reasoningWait");
+			}
+			clock(projection, frameNow, anchor, identity) {
+				return extrapolateProjectionClock(projection, frameNow, anchor, identity);
+			}
+			advance(previous, input) {
+				return advanceReasoningWait(previous, input);
+			}
+		};
+		//#endregion
+		//#region \0dsh-thinkbar-css:C:\Workspace\tower1229\dsh-thinkbar\src\client\ReasoningWaitIndicator.module.css.mjs
+		const css = ".lL-Mhq_anchor{display:none}[data-dsh-thinkbar-host]{isolation:isolate;position:relative;overflow:hidden}[data-dsh-thinkbar-host]>:not([data-dsh-thinkbar-layer]){z-index:1;position:relative}.lL-Mhq_root,.lL-Mhq_fill{border-radius:inherit;pointer-events:none;position:absolute;inset:0}.lL-Mhq_root{z-index:0;overflow:hidden}.lL-Mhq_fill{inset:0 auto 0 0;overflow:hidden}.lL-Mhq_particle{background:var(--dsw-static-neutral-bluish-00);opacity:var(--dsh-particle-opacity,.8);animation:lL-Mhq_reasoning-wait-particle-drift var(--dsh-particle-dur,3s) ease-in-out var(--dsh-particle-delay,0s) infinite;border-radius:50%;position:absolute}@keyframes lL-Mhq_reasoning-wait-particle-drift{0%,to{opacity:var(--dsh-particle-opacity,.8);transform:translate(0)}50%{transform:translate(var(--dsh-particle-dx,0px), var(--dsh-particle-dy,-2px));opacity:calc(var(--dsh-particle-opacity,.8) * .5)}}@media (prefers-reduced-motion:reduce){.lL-Mhq_particle{animation:none}}";
+		const tagId = "dsh-thinkbar/ReasoningWaitIndicator.module.css";
+		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId) + "]") === null) {
+			const tag = document.createElement("style");
+			tag.dataset.plugin = "dsh-thinkbar";
+			tag.dataset.pluginCss = tagId;
+			tag.textContent = css;
+			document.head.appendChild(tag);
+		}
+		var ReasoningWaitIndicator_module_css_default = {
+			"anchor": "lL-Mhq_anchor",
+			"fill": "lL-Mhq_fill",
+			"particle": "lL-Mhq_particle",
+			"reasoning-wait-particle-drift": "lL-Mhq_reasoning-wait-particle-drift",
+			"root": "lL-Mhq_root"
+		};
+		//#endregion
+		//#region src/client/ReasoningWaitIndicator.tsx
+		const FILL_PARTICLES = [
+			{
+				x: 10,
+				y: 15,
+				size: 2,
+				opacity: 1,
+				dur: 2.6,
+				delay: 0,
+				dx: 3,
+				dy: -2
+			},
+			{
+				x: 26,
+				y: 8,
+				size: 3,
+				opacity: .95,
+				dur: 3.4,
+				delay: -.8,
+				dx: -2,
+				dy: 3
+			},
+			{
+				x: 40,
+				y: 19,
+				size: 2,
+				opacity: 1,
+				dur: 2.2,
+				delay: -1.4,
+				dx: 3,
+				dy: -3
+			},
+			{
+				x: 56,
+				y: 12,
+				size: 2,
+				opacity: .9,
+				dur: 4.1,
+				delay: -.4,
+				dx: -3,
+				dy: 2
+			},
+			{
+				x: 72,
+				y: 21,
+				size: 3,
+				opacity: 1,
+				dur: 3,
+				delay: -2.1,
+				dx: 2,
+				dy: -2
+			},
+			{
+				x: 90,
+				y: 7,
+				size: 2,
+				opacity: .95,
+				dur: 2.8,
+				delay: -1.1,
+				dx: -2,
+				dy: 3
+			},
+			{
+				x: 106,
+				y: 16,
+				size: 2,
+				opacity: 1,
+				dur: 3.6,
+				delay: -.6,
+				dx: 3,
+				dy: -2
+			},
+			{
+				x: 124,
+				y: 10,
+				size: 3,
+				opacity: .9,
+				dur: 4.4,
+				delay: -2.8,
+				dx: -3,
+				dy: 2
+			},
+			{
+				x: 142,
+				y: 19,
+				size: 2,
+				opacity: 1,
+				dur: 2.4,
+				delay: -1.7,
+				dx: 2,
+				dy: -3
+			},
+			{
+				x: 160,
+				y: 13,
+				size: 2,
+				opacity: .95,
+				dur: 3.2,
+				delay: -.9,
+				dx: -2,
+				dy: 3
+			},
+			{
+				x: 180,
+				y: 8,
+				size: 3,
+				opacity: .95,
+				dur: 3.8,
+				delay: -2.4,
+				dx: 3,
+				dy: -2
+			},
+			{
+				x: 202,
+				y: 18,
+				size: 2,
+				opacity: 1,
+				dur: 2.7,
+				delay: -1.2,
+				dx: -3,
+				dy: 2
+			},
+			{
+				x: 226,
+				y: 12,
+				size: 2,
+				opacity: .9,
+				dur: 4.3,
+				delay: -.3,
+				dx: 2,
+				dy: -3
+			},
+			{
+				x: 250,
+				y: 17,
+				size: 3,
+				opacity: 1,
+				dur: 3.1,
+				delay: -1.9,
+				dx: -2,
+				dy: 2
+			},
+			{
+				x: 278,
+				y: 9,
+				size: 2,
+				opacity: .95,
+				dur: 2.9,
+				delay: -.7,
+				dx: 3,
+				dy: -2
+			},
+			{
+				x: 306,
+				y: 14,
+				size: 2,
+				opacity: .9,
+				dur: 3.7,
+				delay: -2.6,
+				dx: -2,
+				dy: 3
+			}
+		];
+		function particleStyle(particle) {
+			return {
+				left: `${particle.x}px`,
+				top: `${particle.y}px`,
+				width: `${particle.size}px`,
+				height: `${particle.size}px`,
+				"--dsh-particle-opacity": String(particle.opacity),
+				"--dsh-particle-dx": `${particle.dx}px`,
+				"--dsh-particle-dy": `${particle.dy}px`,
+				"--dsh-particle-dur": `${particle.dur}s`,
+				"--dsh-particle-delay": `${particle.delay}s`
+			};
+		}
+		function ReasoningWaitIndicator({ identity, projection, clock, advance }) {
+			const [waitState, setWaitState] = (0, react.useState)({ phase: "idle" });
+			const clockAnchorRef = (0, react.useRef)(null);
+			const reducedMotion = window.matchMedia?.("(prefers-reduced-motion: reduce)")?.matches ?? false;
+			const frameNow = useFrameNow(projection?.active === true || waitState.phase !== "idle");
+			const clockRead = clock(projection, frameNow, clockAnchorRef.current, identity);
+			clockAnchorRef.current = clockRead.anchor;
+			const input = {
+				projection,
+				elapsed: clockRead.elapsed,
+				frameNow,
+				reducedMotion,
+				identity
+			};
+			const view = advance(waitState, input);
+			(0, react.useLayoutEffect)(() => {
+				setWaitState((previous) => advance(previous, input));
+			}, [
+				projection,
+				clockRead.elapsed,
+				frameNow,
+				reducedMotion,
+				identity,
+				advance
+			]);
+			if (view.phase === "idle") return null;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+				className: ReasoningWaitIndicator_module_css_default.root,
+				"data-reasoning-wait": view.phase,
+				"aria-hidden": "true",
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					className: ReasoningWaitIndicator_module_css_default.fill,
+					"data-reasoning-wait-fill": "",
+					style: {
+						width: `${view.height * 100}%`,
+						backgroundColor: view.color
+					},
+					children: FILL_PARTICLES.map((particle, index) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+						className: ReasoningWaitIndicator_module_css_default.particle,
+						"data-reasoning-wait-particle": "",
+						style: particleStyle(particle)
+					}, index))
+				})
+			});
+		}
+		function useFrameNow(active) {
+			const [, setTick] = (0, react.useState)(0);
+			(0, react.useEffect)(() => {
+				if (!active) return;
+				let frame = 0;
+				const tick = () => {
+					setTick((value) => value + 1);
+					frame = requestAnimationFrame(tick);
+				};
+				frame = requestAnimationFrame(tick);
+				return () => cancelAnimationFrame(frame);
+			}, [active]);
+			return performance.now();
+		}
+		//#endregion
+		//#region src/client/model-trigger-adapter.ts
+		const COMPOSER_SELECTOR = "[data-composer-card]";
+		const MODEL_TRIGGER_SELECTOR = "button[aria-haspopup=\"menu\"]";
+		const HOST_ATTRIBUTE = "data-dsh-thinkbar-host";
+		const LAYER_ATTRIBUTE = "data-dsh-thinkbar-layer";
+		let compatibilityWarningShown = false;
+		/** Resolve the only semantic menu trigger following the public Slot anchor. */
+		function resolveModelTrigger(anchor) {
+			const composer = anchor.closest(COMPOSER_SELECTOR);
+			if (composer === null) return null;
+			const candidates = [...composer.querySelectorAll(MODEL_TRIGGER_SELECTOR)].filter((candidate) => Boolean(anchor.compareDocumentPosition(candidate) & Node.DOCUMENT_POSITION_FOLLOWING));
+			return candidates.length === 1 ? candidates[0] ?? null : null;
+		}
+		function warnCompatibility() {
+			if (compatibilityWarningShown) return;
+			compatibilityWarningShown = true;
+			console.warn("[dsh-thinkbar] Could not uniquely identify the DeepSeek Harness model selector; the indicator is disabled.");
+		}
+		function existingLayer(target) {
+			return [...target.children].find((child) => child instanceof HTMLSpanElement && child.hasAttribute(LAYER_ATTRIBUTE)) ?? null;
+		}
+		/** Attach one plugin-owned Portal layer without moving or rewriting host children. */
+		function mountModelTrigger(anchor) {
+			const target = resolveModelTrigger(anchor);
+			if (target === null) {
+				warnCompatibility();
+				return null;
+			}
+			const layer = existingLayer(target) ?? document.createElement("span");
+			layer.setAttribute(LAYER_ATTRIBUTE, "");
+			if (!layer.isConnected) target.prepend(layer);
+			target.setAttribute(HOST_ATTRIBUTE, "");
+			let disposed = false;
+			return {
+				layer,
+				dispose: () => {
+					if (disposed) return;
+					disposed = true;
+					layer.remove();
+					if (existingLayer(target) === null) target.removeAttribute(HOST_ATTRIBUTE);
+				}
+			};
+		}
+		//#endregion
+		//#region src/client/use-model-trigger.ts
+		/** Keep a Portal layer attached across ModelSelect and composer reconstruction. */
+		function useModelTrigger(anchorRef) {
+			const [layer, setLayer] = (0, react.useState)(null);
+			(0, react.useLayoutEffect)(() => {
+				const anchor = anchorRef.current;
+				if (anchor === null) return;
+				const composer = anchor.closest("[data-composer-card]");
+				if (composer === null) return;
+				let mount = null;
+				const refresh = () => {
+					const target = resolveModelTrigger(anchor);
+					if (mount?.layer.isConnected === true && mount.layer.parentElement === target) return;
+					mount?.dispose();
+					mount = mountModelTrigger(anchor);
+					setLayer(mount?.layer ?? null);
+				};
+				refresh();
+				const observer = new MutationObserver(refresh);
+				observer.observe(composer, {
+					childList: true,
+					subtree: true
+				});
+				return () => {
+					observer.disconnect();
+					mount?.dispose();
+				};
+			}, [anchorRef]);
+			return layer;
+		}
+		//#endregion
+		//#region src/client/ModelTriggerBridge.tsx
+		/** Public-Slot lifecycle bridge that portals the indicator into the model trigger. */
+		function ModelTriggerBridge({ useSession, sessionId, clock, advance }) {
+			const anchorRef = (0, react.useRef)(null);
+			const layer = useModelTrigger(anchorRef);
+			const projection = useSession((snapshot) => snapshot.views.get("dsh-thinkbar"));
+			const identity = projection === null || projection === void 0 ? String(sessionId) : `${String(sessionId)}:${projection.turn}:${projection.step}`;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+				ref: anchorRef,
+				className: ReasoningWaitIndicator_module_css_default.anchor,
+				"data-dsh-thinkbar-anchor": "",
+				"aria-hidden": "true",
+				children: layer === null ? null : (0, react_dom.createPortal)(/* @__PURE__ */ (0, react_jsx_runtime.jsx)(ReasoningWaitIndicator, {
+					identity,
+					projection,
+					clock,
+					advance
+				}), layer)
+			});
+		}
+		//#endregion
+		//#region src/client/reasoning-wait-projection.ts
+		function isCompactChunkEvent(event) {
+			const type = String(event.type);
+			return type === "chunkrow/text-chunks" || type === "chunkrow/reasoning-chunks" || type === "chunkrow/tool-call-chunks";
+		}
+		function projectionOf(state) {
+			const { retryPending: _retryPending, ...projection } = state;
+			return projection;
+		}
+		function eventIdentity(event) {
+			if (isCompactChunkEvent(event)) return `${event.data.turn}:${event.data.step}`;
+			if (event.type === "step/start" || event.type === "step/end" || event.type === "assistant/chunk" || event.type === "assistant/message" || event.type === "llm/retry" || event.type === "llm/retry-started") return `${event.data.turn}:${event.data.step}`;
+			return null;
+		}
+		function transition(state, time, tailKind, active, originTime = time) {
+			return {
+				...state,
+				waitOrigin: state.retryPending && tailKind === "reasoning" ? originTime : state.waitOrigin,
+				streamTime: time,
+				active,
+				tailKind,
+				retryPending: state.retryPending && tailKind === "empty"
+			};
+		}
+		function chunkTransition(state, match) {
+			if (match.event.type !== "assistant/chunk") return state;
+			const { chunk } = match.event.data;
+			switch (chunk.type) {
+				case "block-start":
+					if (chunk.blockType === "reasoning") return transition(state, match.event.time, "reasoning", true);
+					if (chunk.blockType === "text") return transition(state, match.event.time, "text", false);
+					if (chunk.blockType === "tool-call") return transition(state, match.event.time, "tool", false);
+					return transition(state, match.event.time, "other", false);
+				case "reasoning-delta": return transition(state, match.event.time, "reasoning", true);
+				case "text-delta": return transition(state, match.event.time, "text", false);
+				case "tool-call-delta": return transition(state, match.event.time, "tool", false);
+				case "block-end":
+					if (chunk.block.type === "reasoning") return transition(state, match.event.time, "reasoning", true);
+					if (chunk.block.type === "text") return transition(state, match.event.time, "text", false);
+					if (chunk.block.type === "tool-call") return transition(state, match.event.time, "tool", false);
+					return transition(state, match.event.time, "other", false);
+				default: return state;
+			}
+		}
+		function compactEndTime(event) {
+			return event.data.dt.reduce((time, gap) => time + gap, event.time);
+		}
+		function compactFirstEvidenceTime(event) {
+			let time = event.time;
+			for (let index = 0; index < (event.data.texts?.length ?? 0); index++) {
+				if (event.data.texts?.[index] !== "") return time;
+				time += event.data.dt[index] ?? 0;
+			}
+			return null;
+		}
+		function compactTransition(state, event) {
+			const streamTime = compactEndTime(event);
+			if (event.type === "chunkrow/reasoning-chunks") {
+				const firstEvidenceTime = compactFirstEvidenceTime(event);
+				return firstEvidenceTime === null ? state : transition(state, streamTime, "reasoning", true, firstEvidenceTime);
+			}
+			if (event.type === "chunkrow/text-chunks") return transition(state, streamTime, "text", false);
+			return transition(state, streamTime, "tool", false);
+		}
+		function updateState(state, match) {
+			const event = match.event;
+			if (isCompactChunkEvent(event)) return compactTransition(state, event);
+			if (event.type === "assistant/chunk") return chunkTransition(state, match);
+			if (event.type === "llm/retry" || event.type === "llm/retry-started") return {
+				...state,
+				streamTime: event.time,
+				active: false,
+				tailKind: "empty",
+				retryPending: true
+			};
+			if (event.type === "assistant/message" || event.type === "step/end") return {
+				...state,
+				streamTime: event.time,
+				active: false,
+				retryPending: false
+			};
+			return state;
+		}
+		/** Per-Step event state machine for the reasoning indicator. */
+		const reasoningWaitDefinition = {
+			kind: "dsh-thinkbar/reasoning-wait",
+			target: "dsh-thinkbar",
+			match: (event) => {
+				const id = eventIdentity(event);
+				if (id === null) return null;
+				return {
+					id,
+					role: event.type === "step/start" ? "start" : "update"
+				};
+			},
+			start: (_context, match) => {
+				if (match.event.type !== "step/start") throw new Error("reasoning-wait start requires step/start");
+				return {
+					turn: match.event.data.turn,
+					step: match.event.data.step,
+					waitOrigin: match.event.time,
+					streamTime: match.event.time,
+					active: false,
+					tailKind: "empty",
+					retryPending: false
+				};
+			},
+			update: (context, match) => updateState(context.state, match),
+			publication: (match) => match.event.type === "assistant/chunk" || isCompactChunkEvent(match.event) ? "animation-frame" : "immediate",
+			buildViewNode: (context) => {
+				if (context.state === void 0) return null;
+				return {
+					key: context.key,
+					kind: context.kind,
+					id: context.id,
+					target: "dsh-thinkbar",
+					anchorSeq: context.matches.at(-1)?.event.seq ?? context.start?.event.seq ?? 0,
+					data: projectionOf(context.state)
+				};
+			}
+		};
+		function latestProjection(nodes) {
+			let latest;
+			for (const node of nodes) if (latest === void 0 || node.anchorSeq > latest.anchorSeq) latest = node;
+			return latest?.data ?? null;
+		}
+		/** Session-owned reducer selecting the latest Step projection. */
+		const reasoningWaitView = {
+			target: "dsh-thinkbar",
+			create: () => {
+				const nodes = /* @__PURE__ */ new Map();
+				return {
+					empty: null,
+					replace: (input) => {
+						nodes.clear();
+						for (const node of input.nodes) nodes.set(node.key, node);
+						return latestProjection(nodes.values());
+					},
+					apply: (input) => {
+						for (const node of input.upserts) nodes.set(node.key, node);
+						return latestProjection(nodes.values());
+					}
+				};
+			}
+		};
+		//#endregion
+		//#region src/client/index.ts
+		/** Required public rc.2 registries. */
+		const inject = [
+			"slots",
+			"conversationEvents",
+			"conversationViews"
+		];
+		/** Mount the projection, frame service, and public-Slot DOM bridge. */
+		function apply(ctx) {
+			ctx.conversationEvents.register(reasoningWaitDefinition);
+			ctx.conversationViews.register(reasoningWaitView);
+			ctx.plugin(ReasoningWaitService);
+			ctx.slots.inject("conversation.input.right", () => ctx.slots.register({
+				name: "conversation.input.right",
+				id: "dsh-thinkbar",
+				order: 20,
+				inject: () => {
+					const reasoningWait = () => ctx.get("reasoningWait");
+					return {
+						clock: (projection, frameNow, anchor, identity) => reasoningWait()?.clock(projection, frameNow, anchor, identity) ?? {
+							elapsed: 0,
+							anchor: null
+						},
+						advance: (previous, input) => reasoningWait()?.advance(previous, input) ?? { phase: "idle" }
+					};
+				}
+			}, ModelTriggerBridge));
+		}
+		//#endregion
+		exports.ReasoningWaitService = ReasoningWaitService;
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.cjs.map