@dungle-scrubs/admin-ui-soft 0.0.0-stage → 0.0.0

package/dist/components/assistant-ui/elements/voice.js

@@ -0,0 +1,400 @@
+"use client";
+import { __exportAll } from "../../../_virtual/_rolldown/runtime.js";
+import { cn } from "../../../lib/utils.js";
+import { memo, useCallback, useEffect, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/assistant-ui/elements/voice.tsx
+var voice_exports = /* @__PURE__ */ __exportAll({ VoiceOrb: () => VoiceOrb });
+const VARIANT_COLORS = {
+	default: [
+		[
+			.55,
+			.55,
+			.6
+		],
+		[
+			.7,
+			.7,
+			.75
+		],
+		[
+			.4,
+			.4,
+			.45
+		]
+	],
+	blue: [
+		[
+			.2,
+			.5,
+			1
+		],
+		[
+			.4,
+			.7,
+			1
+		],
+		[
+			.1,
+			.3,
+			.8
+		]
+	],
+	violet: [
+		[
+			.6,
+			.3,
+			1
+		],
+		[
+			.8,
+			.5,
+			1
+		],
+		[
+			.4,
+			.15,
+			.8
+		]
+	],
+	emerald: [
+		[
+			.15,
+			.75,
+			.55
+		],
+		[
+			.3,
+			.9,
+			.7
+		],
+		[
+			.1,
+			.55,
+			.4
+		]
+	]
+};
+const STATE_PARAMS = {
+	idle: {
+		speed: .15,
+		amplitude: .04,
+		glow: .15,
+		brightness: .55,
+		pulse: 0,
+		saturation: .7
+	},
+	connecting: {
+		speed: .5,
+		amplitude: .1,
+		glow: .45,
+		brightness: .75,
+		pulse: 1,
+		saturation: .9
+	},
+	listening: {
+		speed: .4,
+		amplitude: .14,
+		glow: .5,
+		brightness: .85,
+		pulse: 0,
+		saturation: 1
+	},
+	speaking: {
+		speed: 1.4,
+		amplitude: .35,
+		glow: .9,
+		brightness: 1,
+		pulse: 0,
+		saturation: 1
+	},
+	muted: {
+		speed: .06,
+		amplitude: .015,
+		glow: .08,
+		brightness: .35,
+		pulse: 0,
+		saturation: .2
+	}
+};
+const VERT_SRC = `#version 300 es
+in vec2 a_position;
+out vec2 v_uv;
+void main() {
+  v_uv = a_position * 0.5 + 0.5;
+  gl_Position = vec4(a_position, 0.0, 1.0);
+}`;
+const FRAG_SRC = `#version 300 es
+precision highp float;
+
+in vec2 v_uv;
+out vec4 fragColor;
+
+uniform float u_time;
+uniform float u_speed;
+uniform float u_amplitude;
+uniform float u_glow;
+uniform float u_brightness;
+uniform float u_pulse;
+uniform float u_saturation;
+uniform vec3 u_color0;
+uniform vec3 u_color1;
+uniform vec3 u_color2;
+uniform float u_dpr;
+
+// Simplex-like noise (3D)
+vec3 mod289(vec3 x) { return x - floor(x / 289.0) * 289.0; }
+vec4 mod289(vec4 x) { return x - floor(x / 289.0) * 289.0; }
+vec4 permute(vec4 x) { return mod289((x * 34.0 + 1.0) * x); }
+vec4 taylorInvSqrt(vec4 r) { return 1.79284291400159 - 0.85373472095314 * r; }
+
+float snoise(vec3 v) {
+  const vec2 C = vec2(1.0 / 6.0, 1.0 / 3.0);
+  vec3 i = floor(v + dot(v, vec3(C.y)));
+  vec3 x0 = v - i + dot(i, vec3(C.x));
+  vec3 g = step(x0.yzx, x0.xyz);
+  vec3 l = 1.0 - g;
+  vec3 i1 = min(g, l.zxy);
+  vec3 i2 = max(g, l.zxy);
+  vec3 x1 = x0 - i1 + C.x;
+  vec3 x2 = x0 - i2 + C.y;
+  vec3 x3 = x0 - 0.5;
+  i = mod289(i);
+  vec4 p = permute(permute(permute(
+    i.z + vec4(0.0, i1.z, i2.z, 1.0))
+    + i.y + vec4(0.0, i1.y, i2.y, 1.0))
+    + i.x + vec4(0.0, i1.x, i2.x, 1.0));
+  vec4 j = p - 49.0 * floor(p / 49.0);
+  vec4 x_ = floor(j / 7.0);
+  vec4 y_ = floor(j - 7.0 * x_);
+  vec4 x = (x_ * 2.0 + 0.5) / 7.0 - 1.0;
+  vec4 y = (y_ * 2.0 + 0.5) / 7.0 - 1.0;
+  vec4 h = 1.0 - abs(x) - abs(y);
+  vec4 b0 = vec4(x.xy, y.xy);
+  vec4 b1 = vec4(x.zw, y.zw);
+  vec4 s0 = floor(b0) * 2.0 + 1.0;
+  vec4 s1 = floor(b1) * 2.0 + 1.0;
+  vec4 sh = -step(h, vec4(0.0));
+  vec4 a0 = b0.xzyw + s0.xzyw * sh.xxyy;
+  vec4 a1 = b1.xzyw + s1.xzyw * sh.zzww;
+  vec3 g0 = vec3(a0.xy, h.x);
+  vec3 g1 = vec3(a0.zw, h.y);
+  vec3 g2 = vec3(a1.xy, h.z);
+  vec3 g3 = vec3(a1.zw, h.w);
+  vec4 norm = taylorInvSqrt(vec4(dot(g0,g0), dot(g1,g1), dot(g2,g2), dot(g3,g3)));
+  g0 *= norm.x; g1 *= norm.y; g2 *= norm.z; g3 *= norm.w;
+  vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
+  m = m * m;
+  return 42.0 * dot(m * m, vec4(dot(g0,x0), dot(g1,x1), dot(g2,x2), dot(g3,x3)));
+}
+
+void main() {
+  vec2 uv = v_uv * 2.0 - 1.0;
+  float dist = length(uv);
+  float t = u_time * u_speed;
+
+  // Perfect circle — hard boundary, soft anti-aliased edge
+  float radius = 0.44;
+  float circle = 1.0 - smoothstep(radius - 0.008, radius + 0.008, dist);
+
+  if (circle < 0.001) {
+    // Outer glow only
+    float glowDist = dist - radius;
+    float glow = exp(-glowDist * 12.0) * u_glow * 0.4;
+    vec3 glowColor = mix(u_color0, u_color1, 0.5);
+    fragColor = vec4(glowColor * glow, glow);
+    return;
+  }
+
+  float n1 = snoise(vec3(uv * 2.0, t * 0.6)) * 0.5 + 0.5;
+  float n2 = snoise(vec3(uv * 3.5 + 7.0, t * 0.9)) * 0.5 + 0.5;
+  float n3 = snoise(vec3(uv * 1.5 - 3.0, t * 0.4 + 10.0)) * 0.5 + 0.5;
+
+  vec2 distort = vec2(
+    snoise(vec3(uv * 2.0 + 5.0, t * 0.7)),
+    snoise(vec3(uv * 2.0 + 15.0, t * 0.7))
+  ) * u_amplitude * 2.0;
+  float n4 = snoise(vec3((uv + distort) * 3.0, t * 0.5)) * 0.5 + 0.5;
+
+  vec3 col = mix(u_color0, u_color1, n1);
+  col = mix(col, u_color2, n2 * 0.5);
+  col = mix(col, u_color1 * 1.3, n4 * 0.4);
+
+  float vein = pow(n3, 3.0) * u_amplitude * 6.0;
+  col += vein * mix(u_color1, vec3(1.0), 0.3);
+
+  float centerDist = dist / radius;
+  float depthShade = 1.0 - centerDist * centerDist * 0.4;
+  col *= depthShade;
+
+  float rim = pow(centerDist, 4.0) * 0.6;
+  col += rim * mix(u_color0, vec3(1.0), 0.5);
+
+  vec2 lightPos = vec2(-0.15, -0.18);
+  float specDist = length(uv - lightPos);
+  float spec = exp(-specDist * specDist * 30.0) * 0.7;
+  col += spec * vec3(1.0);
+
+  vec2 lightPos2 = vec2(0.2, 0.25);
+  float spec2 = exp(-length(uv - lightPos2) * 8.0) * 0.15;
+  col += spec2 * u_color1;
+
+  float pulseFactor = 1.0 + u_pulse * sin(u_time * 3.5) * 0.35;
+
+  float lum = dot(col, vec3(0.299, 0.587, 0.114));
+  col = mix(vec3(lum), col, u_saturation);
+
+  col *= u_brightness * pulseFactor;
+
+  fragColor = vec4(col, circle);
+}`;
+function createShader(gl, type, source) {
+	const shader = gl.createShader(type);
+	if (!shader) return null;
+	gl.shaderSource(shader, source);
+	gl.compileShader(shader);
+	if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+		gl.deleteShader(shader);
+		return null;
+	}
+	return shader;
+}
+function initWebGL(canvas) {
+	const gl = canvas.getContext("webgl2", {
+		alpha: true,
+		premultipliedAlpha: false,
+		antialias: true
+	});
+	if (!gl) return null;
+	const vs = createShader(gl, gl.VERTEX_SHADER, VERT_SRC);
+	const fs = createShader(gl, gl.FRAGMENT_SHADER, FRAG_SRC);
+	if (!vs || !fs) return null;
+	const program = gl.createProgram();
+	gl.attachShader(program, vs);
+	gl.attachShader(program, fs);
+	gl.linkProgram(program);
+	if (!gl.getProgramParameter(program, gl.LINK_STATUS)) return null;
+	gl.useProgram(program);
+	const buf = gl.createBuffer();
+	gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+	gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([
+		-1,
+		-1,
+		1,
+		-1,
+		-1,
+		1,
+		1,
+		1
+	]), gl.STATIC_DRAW);
+	const loc = gl.getAttribLocation(program, "a_position");
+	gl.enableVertexAttribArray(loc);
+	gl.vertexAttribPointer(loc, 2, gl.FLOAT, false, 0, 0);
+	gl.enable(gl.BLEND);
+	gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
+	return {
+		gl,
+		uniforms: {
+			u_time: gl.getUniformLocation(program, "u_time"),
+			u_speed: gl.getUniformLocation(program, "u_speed"),
+			u_amplitude: gl.getUniformLocation(program, "u_amplitude"),
+			u_glow: gl.getUniformLocation(program, "u_glow"),
+			u_brightness: gl.getUniformLocation(program, "u_brightness"),
+			u_pulse: gl.getUniformLocation(program, "u_pulse"),
+			u_saturation: gl.getUniformLocation(program, "u_saturation"),
+			u_color0: gl.getUniformLocation(program, "u_color0"),
+			u_color1: gl.getUniformLocation(program, "u_color1"),
+			u_color2: gl.getUniformLocation(program, "u_color2"),
+			u_dpr: gl.getUniformLocation(program, "u_dpr")
+		}
+	};
+}
+function lerp(a, b, t) {
+	return a + (b - a) * t;
+}
+const VoiceOrb = memo(({ state = "idle", volume = 0, variant = "default", className }) => {
+	const volumeRef = useRef(0);
+	volumeRef.current = volume;
+	const canvasRef = useRef(null);
+	const glRef = useRef(null);
+	const animRef = useRef(0);
+	const startTime = useRef(performance.now());
+	const currentParams = useRef({ ...STATE_PARAMS.idle });
+	const targetParams = useRef({ ...STATE_PARAMS.idle });
+	useEffect(() => {
+		targetParams.current = { ...STATE_PARAMS[state] };
+	}, [state]);
+	const colors = VARIANT_COLORS[variant];
+	const [ready, setReady] = useState(false);
+	useEffect(() => {
+		const id = requestAnimationFrame(() => setReady(true));
+		return () => {
+			cancelAnimationFrame(id);
+			setReady(false);
+		};
+	}, []);
+	const render = useCallback(() => {
+		const ctx = glRef.current;
+		if (!ctx) return;
+		const { gl, uniforms } = ctx;
+		const canvas = canvasRef.current;
+		if (!canvas) return;
+		const p = currentParams.current;
+		const tp = targetParams.current;
+		const s = .045;
+		p.speed = lerp(p.speed, tp.speed, s);
+		p.amplitude = lerp(p.amplitude, tp.amplitude, s);
+		p.glow = lerp(p.glow, tp.glow, s);
+		p.brightness = lerp(p.brightness, tp.brightness, s);
+		p.pulse = lerp(p.pulse, tp.pulse, s);
+		p.saturation = lerp(p.saturation, tp.saturation, s);
+		const elapsed = (performance.now() - startTime.current) / 1e3;
+		const dpr = window.devicePixelRatio || 1;
+		const rect = canvas.getBoundingClientRect();
+		const w = Math.round(rect.width * dpr);
+		const h = Math.round(rect.height * dpr);
+		if (canvas.width !== w || canvas.height !== h) {
+			canvas.width = w;
+			canvas.height = h;
+		}
+		gl.viewport(0, 0, w, h);
+		gl.clearColor(0, 0, 0, 0);
+		gl.clear(gl.COLOR_BUFFER_BIT);
+		const vol = volumeRef.current;
+		gl.uniform1f(uniforms.u_time, elapsed);
+		gl.uniform1f(uniforms.u_speed, p.speed + vol * .4);
+		gl.uniform1f(uniforms.u_amplitude, p.amplitude + vol * .12);
+		gl.uniform1f(uniforms.u_glow, p.glow + vol * .2);
+		gl.uniform1f(uniforms.u_brightness, p.brightness);
+		gl.uniform1f(uniforms.u_pulse, p.pulse);
+		gl.uniform1f(uniforms.u_saturation, p.saturation);
+		gl.uniform3fv(uniforms.u_color0, colors[0]);
+		gl.uniform3fv(uniforms.u_color1, colors[1]);
+		gl.uniform3fv(uniforms.u_color2, colors[2]);
+		gl.uniform1f(uniforms.u_dpr, dpr);
+		gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+		animRef.current = requestAnimationFrame(render);
+	}, [colors]);
+	useEffect(() => {
+		if (!ready) return;
+		const canvas = canvasRef.current;
+		if (!canvas) return;
+		glRef.current = initWebGL(canvas);
+		if (!glRef.current) return;
+		animRef.current = requestAnimationFrame(render);
+		return () => {
+			cancelAnimationFrame(animRef.current);
+			const ctx = glRef.current;
+			if (ctx) ctx.gl.getExtension("WEBGL_lose_context")?.loseContext();
+			glRef.current = null;
+		};
+	}, [ready, render]);
+	return /* @__PURE__ */ jsx("canvas", {
+		ref: canvasRef,
+		className: cn("aui-voice-orb size-16 shrink-0", className),
+		"data-state": state
+	});
+});
+VoiceOrb.displayName = "VoiceOrb";
+//#endregion
+export { VoiceOrb, voice_exports };

package/dist/components/assistant-ui/elements/web-preview.d.ts

@@ -0,0 +1,18 @@
+import { ComponentProps } from "react";
+declare namespace web_preview_d_exports {
+  export { WebPreview };
+}
+/**
+ * Chrome around a preview: a URL bar, reload, and open-in-new. It renders
+ * `children` as given and enforces no isolation of its own, so the caller is
+ * responsible for passing an already-sandboxed frame.
+ */
+export declare function WebPreview({ origin, loading, children, onReload, onOpenExternal, className, ...props }: Omit<ComponentProps<"div">, "origin" | "loading" | "children" | "onReload" | "onOpenExternal"> & {
+  origin: string;
+  loading: boolean;
+  children: React.ReactNode;
+  onReload?: () => void;
+  onOpenExternal?: () => void;
+}): import("react").JSX.Element;
+//#endregion
+export { web_preview_d_exports };

package/dist/components/assistant-ui/elements/web-preview.js

@@ -0,0 +1,61 @@
+"use client";
+import { __exportAll } from "../../../_virtual/_rolldown/runtime.js";
+import { cn } from "../../../lib/utils.js";
+import { ShimmerLabel, field, ghostButton, mono, paper } from "./surfaces.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { ExternalLinkIcon, RotateCwIcon } from "lucide-react";
+//#region src/components/assistant-ui/elements/web-preview.tsx
+var web_preview_exports = /* @__PURE__ */ __exportAll({ WebPreview: () => WebPreview });
+/**
+* Chrome around a preview: a URL bar, reload, and open-in-new. It renders
+* `children` as given and enforces no isolation of its own, so the caller is
+* responsible for passing an already-sandboxed frame.
+*/
+function WebPreview({ origin, loading, children, onReload, onOpenExternal, className, ...props }) {
+	return /* @__PURE__ */ jsxs("div", {
+		"data-slot": "web-preview",
+		className: cn(paper, "flex w-full max-w-md flex-col overflow-hidden rounded-2xl", className),
+		...props,
+		children: [/* @__PURE__ */ jsxs("div", {
+			className: "flex items-center gap-1.5 px-2.5 py-2",
+			children: [
+				/* @__PURE__ */ jsx("button", {
+					type: "button",
+					"aria-label": "Reload the preview",
+					onClick: onReload,
+					className: cn(ghostButton, "size-7 shrink-0"),
+					children: /* @__PURE__ */ jsx(RotateCwIcon, { className: cn("size-3.5", loading && "animate-spin motion-reduce:animate-none") })
+				}),
+				/* @__PURE__ */ jsx("span", {
+					className: cn(field, "flex min-w-0 flex-1 items-center gap-1.5 rounded-full px-2.5 py-1"),
+					children: /* @__PURE__ */ jsx("span", {
+						className: cn(mono, "text-muted-foreground min-w-0 truncate"),
+						children: origin
+					})
+				}),
+				/* @__PURE__ */ jsx("button", {
+					type: "button",
+					"aria-label": "Open the preview in a new tab",
+					onClick: onOpenExternal,
+					className: cn(ghostButton, "size-7 shrink-0"),
+					children: /* @__PURE__ */ jsx(ExternalLinkIcon, { className: "size-3.5" })
+				})
+			]
+		}), /* @__PURE__ */ jsxs("div", {
+			className: "border-foreground/[0.07] relative min-h-[9rem] border-t",
+			children: [/* @__PURE__ */ jsx("div", {
+				"aria-hidden": loading,
+				className: cn("transition-opacity duration-300 motion-reduce:transition-none", loading && "invisible opacity-0"),
+				children
+			}), loading && /* @__PURE__ */ jsx("div", {
+				className: "absolute inset-0 flex items-center justify-center",
+				children: /* @__PURE__ */ jsx(ShimmerLabel, {
+					className: "text-muted-foreground relative inline-block text-xs leading-none",
+					children: "Loading preview"
+				})
+			})]
+		})]
+	});
+}
+//#endregion
+export { WebPreview, web_preview_exports };

package/dist/components/assistant-ui/elements/web-search.d.ts

@@ -0,0 +1,17 @@
+import { ComponentProps } from "react";
+declare namespace web_search_d_exports {
+  export { WebSearch, WebSearchResult };
+}
+export interface WebSearchResult {
+  title: string;
+  domain: string;
+}
+export declare function WebSearch({ query, results, visibleResults, searching, cycle, className, ...props }: Omit<ComponentProps<"div">, "children" | "query" | "results" | "visibleResults" | "searching" | "cycle"> & {
+  query: string;
+  results: readonly WebSearchResult[];
+  visibleResults: number;
+  searching: boolean;
+  cycle: number;
+}): import("react").JSX.Element;
+//#endregion
+export { web_search_d_exports };

package/dist/components/assistant-ui/elements/web-search.js

@@ -0,0 +1,54 @@
+"use client";
+import { __exportAll } from "../../../_virtual/_rolldown/runtime.js";
+import { cn } from "../../../lib/utils.js";
+import { ShimmerLabel, field, mono } from "./surfaces.js";
+import { take } from "../utils/range.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { SearchIcon } from "lucide-react";
+//#region src/components/assistant-ui/elements/web-search.tsx
+var web_search_exports = /* @__PURE__ */ __exportAll({ WebSearch: () => WebSearch });
+function WebSearch({ query, results, visibleResults, searching, cycle, className, ...props }) {
+	return /* @__PURE__ */ jsxs("div", {
+		"data-slot": "web-search",
+		className: cn("flex w-full max-w-sm flex-col gap-2.5", className),
+		...props,
+		children: [
+			/* @__PURE__ */ jsxs("span", {
+				className: cn(field, "text-muted-foreground inline-flex w-fit items-center gap-1.5 rounded-full px-3.5 py-2 text-xs"),
+				children: [/* @__PURE__ */ jsx(SearchIcon, { className: "text-muted-foreground size-3" }), query]
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: "text-muted-foreground text-xs",
+				children: searching ? /* @__PURE__ */ jsx(ShimmerLabel, {
+					className: "relative inline-block leading-none",
+					children: "Searching"
+				}) : /* @__PURE__ */ jsx("span", {
+					className: "fade-in animate-in duration-300",
+					children: "Read 3 sources"
+				})
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: "flex min-h-[5.75rem] flex-col",
+				children: take(results, visibleResults).map((result) => /* @__PURE__ */ jsxs("div", {
+					className: "fade-in slide-in-from-bottom-1 animate-in fill-mode-both hover:bg-foreground/[0.03] -mx-2.5 flex items-center gap-2.5 rounded-xl px-2.5 py-1.5 transition-colors duration-300",
+					children: [
+						/* @__PURE__ */ jsx("span", {
+							className: "bg-foreground/[0.06] text-muted-foreground flex size-4 shrink-0 items-center justify-center rounded text-[9px] font-medium",
+							children: result.domain.charAt(0).toUpperCase()
+						}),
+						/* @__PURE__ */ jsx("span", {
+							className: "text-foreground/90 min-w-0 flex-1 truncate text-[13.5px]",
+							children: result.title
+						}),
+						/* @__PURE__ */ jsx("span", {
+							className: cn(mono, "text-muted-foreground shrink-0"),
+							children: result.domain
+						})
+					]
+				}, `${cycle}-${result.domain}`))
+			})
+		]
+	});
+}
+//#endregion
+export { WebSearch, web_search_exports };

package/dist/components/assistant-ui/utils/href.d.ts

@@ -0,0 +1,13 @@
+declare namespace href_d_exports {
+  export { hostOf, safeHref };
+}
+/**
+ * `url` when a browser following it runs no script: an `http:`, `https:`, or
+ * `mailto:` URL, or one relative to the page. Anything else, including a
+ * string that is not a URL at all, is `undefined`.
+ */
+export declare function safeHref(url: string | undefined): string | undefined;
+/** The host `url` points at, without a leading `www.`, or `undefined`. */
+export declare function hostOf(url: string | undefined): string | undefined;
+//#endregion
+export { href_d_exports };

package/dist/components/assistant-ui/utils/href.js

@@ -0,0 +1,39 @@
+import { __exportAll } from "../../../_virtual/_rolldown/runtime.js";
+//#region src/components/assistant-ui/utils/href.ts
+var href_exports = /* @__PURE__ */ __exportAll({
+	hostOf: () => hostOf,
+	safeHref: () => safeHref
+});
+const RELATIVE = /^(?:[/?#]|\.{1,2}\/)/;
+const ALLOWED_PROTOCOLS = /* @__PURE__ */ new Set([
+	"http:",
+	"https:",
+	"mailto:"
+]);
+const parse = (url) => {
+	try {
+		return new URL(url);
+	} catch {
+		return;
+	}
+};
+/**
+* `url` when a browser following it runs no script: an `http:`, `https:`, or
+* `mailto:` URL, or one relative to the page. Anything else, including a
+* string that is not a URL at all, is `undefined`.
+*/
+function safeHref(url) {
+	if (typeof url !== "string") return void 0;
+	const trimmed = url.trim();
+	if (trimmed === "") return void 0;
+	const parsed = parse(trimmed);
+	if (parsed) return ALLOWED_PROTOCOLS.has(parsed.protocol) ? trimmed : void 0;
+	return RELATIVE.test(trimmed) ? trimmed : void 0;
+}
+/** The host `url` points at, without a leading `www.`, or `undefined`. */
+function hostOf(url) {
+	const href = safeHref(url);
+	return (href === void 0 ? "" : parse(href)?.hostname ?? "").replace(/^www\./, "") || void 0;
+}
+//#endregion
+export { hostOf, href_exports, safeHref };

package/dist/components/assistant-ui/utils/range.d.ts

@@ -0,0 +1,22 @@
+declare namespace range_d_exports {
+  export { announced, at, clamp, indexIn, pct, progressOf, take };
+}
+export declare function clamp(value: number, min: number, max: number): number;
+/** The first `count` items, for a `count` that may be out of range. */
+export declare function take<T>(items: readonly T[], count: number): T[];
+/** The position `index` names in `items`, for an `index` out of range. */
+export declare function indexIn<T>(items: readonly T[], index: number): number;
+/** The item at `index`, for an `index` that may be out of range. */
+export declare function at<T>(items: readonly T[], index: number): T | undefined;
+/** `value` as a share of `total`, as a percentage in `0…100`. */
+export declare function pct(value: number, total: number): number;
+/**
+ * A `0…100` share as it should be announced. `pct` divides, so a share that
+ * reads as a whole number on screen can still reach `aria-valuenow` carrying
+ * float error, which a screen reader reads out in full.
+ */
+export declare function announced(share: number): number;
+/** A count of completed items out of `total`, in `0…total`. */
+export declare function progressOf(index: number, total: number): number;
+//#endregion
+export { range_d_exports };

package/dist/components/assistant-ui/utils/range.js

@@ -0,0 +1,48 @@
+import { __exportAll } from "../../../_virtual/_rolldown/runtime.js";
+//#region src/components/assistant-ui/utils/range.ts
+var range_exports = /* @__PURE__ */ __exportAll({
+	announced: () => announced,
+	at: () => at,
+	clamp: () => clamp,
+	indexIn: () => indexIn,
+	pct: () => pct,
+	progressOf: () => progressOf,
+	take: () => take
+});
+function clamp(value, min, max) {
+	if (Number.isNaN(value)) return min;
+	return Math.min(max, Math.max(min, value));
+}
+/** The first `count` items, for a `count` that may be out of range. */
+function take(items, count) {
+	return items.slice(0, Math.floor(clamp(count, 0, items.length)));
+}
+/** The position `index` names in `items`, for an `index` out of range. */
+function indexIn(items, index) {
+	return Math.floor(clamp(index, 0, Math.max(0, items.length - 1)));
+}
+/** The item at `index`, for an `index` that may be out of range. */
+function at(items, index) {
+	if (items.length === 0) return void 0;
+	return items[indexIn(items, index)];
+}
+/** `value` as a share of `total`, as a percentage in `0…100`. */
+function pct(value, total) {
+	if (!(total > 0)) return 0;
+	return clamp(value / total * 100, 0, 100);
+}
+/**
+* A `0…100` share as it should be announced. `pct` divides, so a share that
+* reads as a whole number on screen can still reach `aria-valuenow` carrying
+* float error, which a screen reader reads out in full.
+*/
+function announced(share) {
+	return Math.round(share * 10) / 10;
+}
+/** A count of completed items out of `total`, in `0…total`. */
+function progressOf(index, total) {
+	if (!(total > 0)) return 0;
+	return Math.floor(clamp(index, 0, total));
+}
+//#endregion
+export { announced, at, clamp, indexIn, pct, progressOf, range_exports, take };

package/dist/components/assistant-ui/utils/task.d.ts

@@ -0,0 +1,14 @@
+import { ToolCallMessagePart, ToolCallMessagePartStatus } from "@assistant-ui/react";
+declare namespace task_d_exports {
+  export { TASK_PAGE_SIZE, TaskTiming, TaskViewState, formatElapsed, taskLabel, taskMeta, taskStateOf, useTaskElapsed };
+}
+export type TaskViewState = "working" | "waiting" | "done" | "failed" | "cancelled";
+export type TaskTiming = NonNullable<ToolCallMessagePart["timing"]>;
+export declare const TASK_PAGE_SIZE = 4;
+export declare function taskStateOf(status: ToolCallMessagePartStatus, isError?: boolean): TaskViewState;
+export declare function taskLabel(toolName: string, args: unknown): string;
+export declare function taskMeta(args: unknown): string | undefined;
+export declare function formatElapsed(ms: number): string;
+export declare function useTaskElapsed(timing: TaskTiming | undefined, running: boolean): number | undefined;
+//#endregion
+export { task_d_exports };