@mastra/playground-ui 68.0.0-alpha.3 → 69.0.0-alpha.0

package/dist/AgentIndicator-Dnv_1hvF.js

@@ -0,0 +1,1995 @@
+import { t as cn } from "./utils-DQx8TpNT.js";
+import { forwardRef, useId, useLayoutEffect, useRef } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+import './AgentIndicator.css';// src/ds/components/AgentIndicator/shapes.ts
+var TAU = Math.PI * 2;
+var clamp01 = (x) => x < 0 ? 0 : x > 1 ? 1 : x;
+var range = (n) => Array.from({ length: n }, (_, i) => i);
+var RAY_DIRECTIONS = range(64).map((i) => [Math.cos(TAU * i / 64), Math.sin(TAU * i / 64)]);
+function once(make) {
+	let value;
+	return () => value ??= make();
+}
+var lerpFrame = (a, b, w) => a.map((v, i) => v + ((b[i] ?? v) - v) * w);
+function sstep(a, b, x) {
+	const k = clamp01((x - a) / (b - a));
+	return k * k * (3 - 2 * k);
+}
+function loopPulse(clock, periodSeconds) {
+	const phase = clock / periodSeconds % 1;
+	return sstep(.08, .28, phase) * (1 - sstep(.52, .78, phase));
+}
+function cubicBezier(x1, y1, x2, y2) {
+	const cx = 3 * x1;
+	const bx = 3 * (x2 - x1) - cx;
+	const ax = 1 - cx - bx;
+	const cy = 3 * y1;
+	const by = 3 * (y2 - y1) - cy;
+	const ay = 1 - cy - by;
+	const at = (t) => ((ax * t + bx) * t + cx) * t;
+	return (x) => {
+		if (x <= 0) return 0;
+		if (x >= 1) return 1;
+		let lo = 0;
+		let hi = 1;
+		let t = x;
+		for (let i = 0; i < 24 && Math.abs(at(t) - x) >= 1e-5; i++) {
+			if (at(t) < x) lo = t;
+			else hi = t;
+			t = (lo + hi) / 2;
+		}
+		return ((ay * t + by) * t + cy) * t;
+	};
+}
+function segDist([px, py], [ax, ay], [bx, by]) {
+	const vx = bx - ax;
+	const vy = by - ay;
+	const k = clamp01(((px - ax) * vx + (py - ay) * vy) / (vx * vx + vy * vy));
+	return Math.hypot(px - ax - vx * k, py - ay - vy * k);
+}
+var inCirc = (cx, cy, r) => ([x, y]) => (x - cx) ** 2 + (y - cy) ** 2 < r * r;
+var inCap = (a, b, r) => (p) => segDist(p, a, b) < r;
+var inShape = (poly) => ([x, y]) => {
+	let inside = false;
+	let previous = poly.at(-1);
+	for (const point of poly) {
+		if (!previous) break;
+		const [xi, yi] = point;
+		const [xj, yj] = previous;
+		if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) inside = !inside;
+		previous = point;
+	}
+	return inside;
+};
+var inRoundRect = (cx, cy, hx, hy, r) => ([x, y]) => Math.hypot(Math.max(0, Math.abs(x - cx) - hx + r), Math.max(0, Math.abs(y - cy) - hy + r)) < r;
+var inOval = (cx, cy, rx, ry, b = 0, n = 11) => ([x, y]) => ((x - cx) / rx) ** 2 + ((y - cy) / ry) ** 2 < (1 + b * Math.cos(n * Math.atan2(y - cy, x - cx))) ** 2;
+var anyOf = (...shapes) => (p) => shapes.some((inside) => inside(p));
+var allOf = (...shapes) => (p) => shapes.every((inside) => inside(p));
+var nothing = () => false;
+var placed = (inside, a, [tx, ty] = [0, 0]) => ([x, y]) => {
+	const c = Math.cos(a);
+	const s = Math.sin(a);
+	const dx = x - tx;
+	const dy = y - ty;
+	return inside([dx * c + dy * s, -dx * s + dy * c]);
+};
+var around = ([cx, cy], a, r) => [cx + r * Math.cos(a), cy + r * Math.sin(a)];
+var dot = (p, d) => [[
+	...p,
+	d,
+	0
+], [
+	...p,
+	0,
+	0
+]];
+function radial(inside, [cx, cy]) {
+	const r = RAY_DIRECTIONS.map(([dx, dy]) => {
+		const at = (d) => inside([cx + dx * d, cy + dy * d]);
+		let d = 0;
+		while (d < 12 && at(d)) d += .3;
+		let lo = Math.max(0, d - .3);
+		let hi = d;
+		for (let k = 0; k < 6; k++) {
+			const m = (lo + hi) / 2;
+			if (at(m)) lo = m;
+			else hi = m;
+		}
+		return lo;
+	});
+	const ring = (i) => r[(i + 64) % 64] ?? 0;
+	return range(64).map((i) => (ring(i - 1) + 2 * ring(i) + ring(i + 1)) / 4);
+}
+var NO_HOLE = range(64).map(() => 0);
+function kit(outer, c, { hole, holeCenter = c, balls = [], cuts = [], inks = [], rings = [] } = {}) {
+	return [
+		...c,
+		...radial(outer, c),
+		...holeCenter,
+		...hole ? radial(hole, holeCenter) : NO_HOLE,
+		...range(2).flatMap((i) => balls[i] ?? [...c, 0]),
+		...range(2).flatMap((i) => cuts[i] ?? [
+			...c,
+			...c,
+			0
+		]),
+		...range(2).flatMap((i) => inks[i] ?? [
+			...c,
+			...c,
+			0
+		]),
+		...range(1).flatMap((i) => rings[i] ?? [
+			...c,
+			0,
+			0
+		])
+	];
+}
+function withTrail(kitFrame, points = []) {
+	const [x = 0, y = 0] = points.at(-1) ?? kitFrame;
+	return [...kitFrame, ...range(64).flatMap((i) => points[i] ?? [
+		x,
+		y,
+		0,
+		0
+	])];
+}
+var polyline = (points, ink, cut) => points.map((p, i) => i < points.length - 1 ? [
+	...p,
+	ink,
+	cut
+] : [
+	...p,
+	0,
+	0
+]);
+// src/ds/components/AgentIndicator/paint.ts
+var xy = (x, y) => `${x.toFixed(2)} ${y.toFixed(2)}`;
+function outline(cx, cy, radii) {
+	const points = radii.map((radius, i) => [cx + radius * Math.cos(TAU * i / 64), cy + radius * Math.sin(TAU * i / 64)]);
+	const mid = ([ax, ay], [bx, by] = [ax, ay]) => xy((ax + bx) / 2, (ay + by) / 2);
+	const curves = points.map((p, i) => `Q${xy(...p)} ${mid(p, points[(i + 1) % 64])}`).join("");
+	const [first = [cx, cy]] = points;
+	return `M${mid(first, points.at(-1))}${curves}Z`;
+}
+function segment$1(x1, y1, x2, y2, width) {
+	if (width <= 0) return { width: "0.000" };
+	const strokeWidth = width.toFixed(3);
+	if (Number(strokeWidth) === 0) return { width: strokeWidth };
+	return {
+		width: strokeWidth,
+		d: `M${x1.toFixed(3)} ${y1.toFixed(3)}L${(x2 + .001).toFixed(3)} ${y2.toFixed(3)}`
+	};
+}
+var HOLE_AT = 66;
+var LINES_AT = 138;
+var RINGS_AT = LINES_AT + 20;
+function describeFrame(f, bodyOutline, holeOutline) {
+	const at = (i) => f[i] ?? 0;
+	const hole = f.slice(HOLE_AT + 2, HOLE_AT + 2 + 64);
+	const holePath = hole.some((r) => r > .05) ? holeOutline(at(HOLE_AT), at(HOLE_AT + 1), hole) : "";
+	const line = (k) => segment$1(at(k), at(k + 1), at(k + 2), at(k + 3), at(k + 4));
+	const trail = (k, widthAt) => segment$1(at(k), at(k + 1), at(k + 4), at(k + 5), at(k + widthAt));
+	return {
+		body: bodyOutline(at(0), at(1), f.slice(2, HOLE_AT)) + holePath,
+		balls: range(2).map((i) => {
+			const k = 132 + 3 * i;
+			return {
+				cx: at(k).toFixed(2),
+				cy: at(k + 1).toFixed(2),
+				r: Math.max(0, at(k + 2)).toFixed(2)
+			};
+		}),
+		rings: range(1).map((i) => {
+			const k = RINGS_AT + 4 * i;
+			return {
+				cx: at(k).toFixed(2),
+				cy: at(k + 1).toFixed(2),
+				r: Math.max(0, at(k + 2)).toFixed(2),
+				width: Math.max(0, at(k + 3)).toFixed(3)
+			};
+		}),
+		cuts: range(2).map((i) => line(LINES_AT + 5 * i)),
+		inks: range(2).map((i) => line(LINES_AT + 5 * (2 + i))),
+		trailCuts: range(63).map((i) => trail(162 + 4 * i, 3)),
+		trailInks: range(63).map((i) => trail(162 + 4 * i, 2))
+	};
+}
+function frameParts(frame) {
+	return describeFrame(frame, outline, outline);
+}
+function cachedOutline() {
+	let previousX;
+	let previousY;
+	let previousRadii = [];
+	let path = "";
+	return (cx, cy, radii) => {
+		if (cx === previousX && cy === previousY && radii.every((radius, i) => radius === previousRadii[i])) return path;
+		previousX = cx;
+		previousY = cy;
+		previousRadii = radii;
+		path = outline(cx, cy, radii);
+		return path;
+	};
+}
+function attributeWriter(element, name) {
+	let previous;
+	return (value) => {
+		if (value === previous) return;
+		element.setAttribute(name, value);
+		previous = value;
+	};
+}
+function strokePainter(path) {
+	const width = attributeWriter(path, "stroke-width");
+	const drawing = attributeWriter(path, "d");
+	return (stroke) => {
+		width(stroke.width);
+		if (stroke.d) drawing(stroke.d);
+	};
+}
+function circlePainter(circle) {
+	const x = attributeWriter(circle, "cx");
+	const y = attributeWriter(circle, "cy");
+	const radius = attributeWriter(circle, "r");
+	return ({ cx, cy, r }) => {
+		x(cx);
+		y(cy);
+		radius(r);
+	};
+}
+function ringPainter(circle) {
+	const paintCircle = circlePainter(circle);
+	const width = attributeWriter(circle, "stroke-width");
+	return (ring) => {
+		paintCircle(ring);
+		width(ring.width);
+	};
+}
+function painter(svg) {
+	const parts = (name) => [...svg.querySelectorAll(`[data-part="${name}"]`)];
+	const [body] = parts("body");
+	if (!body) throw new Error("AgentIndicator is missing its body path");
+	const paintBody = attributeWriter(body, "d");
+	const bodyOutline = cachedOutline();
+	const holeOutline = cachedOutline();
+	const balls = parts("ball").map(circlePainter);
+	const rings = parts("ring").map(ringPainter);
+	const strokes = {
+		cuts: parts("cut").map(strokePainter),
+		inks: parts("ink").map(strokePainter),
+		trailCuts: parts("trail-cut").map(strokePainter),
+		trailInks: parts("trail-ink").map(strokePainter)
+	};
+	return (frame) => {
+		const drawn = describeFrame(frame, bodyOutline, holeOutline);
+		paintBody(drawn.body);
+		drawn.balls.forEach((ball, i) => balls[i]?.(ball));
+		drawn.rings.forEach((ring, i) => rings[i]?.(ring));
+		for (const name of [
+			"cuts",
+			"inks",
+			"trailCuts",
+			"trailInks"
+		]) drawn[name].forEach((stroke, i) => strokes[name][i]?.(stroke));
+	};
+}
+// src/ds/components/AgentIndicator/poses/coordination.ts
+var delegationFrames = once(() => {
+	const handoff = (received) => withTrail(kit(inRoundRect(-3, 3.5, 3.8, 3, 2.5), [-3, 3.5], {
+		balls: [[
+			-3,
+			-3.8,
+			2.5
+		], [
+			4.6,
+			-1.6 - .7 * received,
+			2.2 + .25 * received
+		]],
+		inks: [[
+			0,
+			3,
+			3,
+			3.5,
+			1.6 * received
+		]]
+	}), polyline([[3, 5 - .4 * received], [6.6, 5 - .4 * received]], 3.4 + .3 * received, 0));
+	return {
+		ready: handoff(0),
+		received: handoff(1)
+	};
+});
+var delegating = (t) => {
+	const { ready, received } = delegationFrames();
+	return lerpFrame(ready, received, loopPulse(t, 3.1));
+};
+var workflowFrames = once(() => {
+	const flow = (progress, radius) => withTrail(kit(inRoundRect(0, -5, 2.9, 2.3, 1.2), [0, -5], {
+		balls: [[
+			-4.8 * progress,
+			-2.8 + 7.6 * progress,
+			radius
+		], [
+			4.8 * progress,
+			-2.8 + 7.6 * progress,
+			radius
+		]],
+		inks: [[
+			0,
+			-2.8,
+			-4.8,
+			4.8,
+			1.7
+		], [
+			0,
+			-2.8,
+			4.8,
+			4.8,
+			1.7
+		]]
+	}), [...polyline([[-5.3, 4.8], [-4.3, 4.8]], 4.8, 0), ...polyline([[4.3, 4.8], [5.3, 4.8]], 4.8, 0)]);
+	return {
+		resting: flow(0, 0),
+		leaving: flow(0, 1.5),
+		arriving: flow(1, 1.5),
+		arrived: flow(1, 0)
+	};
+});
+var workflow = (t) => {
+	const { resting, leaving, arriving, arrived } = workflowFrames();
+	const phase = t / 3.2 % 1;
+	const progress = sstep(.12, .58, phase) * (1 - sstep(.76, .94, phase));
+	const visible = sstep(.03, .12, phase) * (1 - sstep(.6, .74, phase));
+	return lerpFrame(lerpFrame(resting, arrived, progress), lerpFrame(leaving, arriving, progress), visible);
+};
+var connectionFrames = once(() => {
+	const plug = (lift) => withTrail(kit(inRoundRect(0, -1.2 - lift, 4.5, 3.3, 2), [0, -1.2 - lift], { inks: [[
+		-2.2,
+		-7.2 - lift,
+		-2.2,
+		-3.5 - lift,
+		2.1
+	], [
+		2.2,
+		-7.2 - lift,
+		2.2,
+		-3.5 - lift,
+		2.1
+	]] }), polyline([
+		[0, 2 - lift],
+		[0, 4.8],
+		[.5, 6],
+		[1.5, 6.6],
+		[4.5, 6.6]
+	], 2.1, 0));
+	return {
+		ready: plug(0),
+		inserted: plug(.8)
+	};
+});
+var connecting = (t) => {
+	const { ready, inserted } = connectionFrames();
+	return lerpFrame(ready, inserted, loopPulse(t, 3.3));
+};
+var planningFrames = once(() => {
+	const checklist = (checked) => withTrail(kit(anyOf(inRoundRect(0, 1, 6.2, 6.6, 1.8), inRoundRect(0, -5.6, 3, 1.8, 1)), [0, 0], { cuts: [[
+		0,
+		-.1,
+		3.5,
+		-.1,
+		1.8
+	], [
+		-.8,
+		3.6,
+		3.5,
+		3.6,
+		1.8
+	]] }), [
+		...polyline([[-3.5 - checked, -.1], [-3.5, -.1 + checked]], 0, 1.8),
+		...polyline([[-3.5, -.1 + checked], [-3.5 + 1.8 * checked, -.1 - 1.5 * checked]], 0, 1.8 * checked),
+		...polyline([[-3.5, 3.6], [-3.5, 3.6]], 0, 1.8),
+		...polyline([[-2, -4.3], [2, -4.3]], 0, 1.5)
+	]);
+	return {
+		pending: checklist(0),
+		checked: checklist(1)
+	};
+});
+var planning = (t) => {
+	const { pending, checked } = planningFrames();
+	return lerpFrame(pending, checked, loopPulse(t, 3.4));
+};
+var messageFrames = once(() => {
+	const bubble = (liftedDot) => withTrail(kit(anyOf(inRoundRect(0, -1.2, 7, 5.2, 2.8), inShape([
+		[-4.8, 2],
+		[-5.5, 7],
+		[0, 3.8]
+	])), [0, -.5]), [
+		-3.4,
+		0,
+		3.4
+	].flatMap((x, index) => {
+		const y = index === liftedDot ? -2.5 : -1.2;
+		return polyline([[x, y], [x, y]], 0, 2);
+	}));
+	return {
+		resting: bubble(-1),
+		first: bubble(0),
+		second: bubble(1),
+		third: bubble(2)
+	};
+});
+var messaging = (t) => {
+	const { resting, first, second, third } = messageFrames();
+	const phase = t / 3.6 % 1;
+	const beat = (start) => sstep(start, start + .09, phase) * (1 - sstep(start + .2, start + .29, phase));
+	return lerpFrame(lerpFrame(lerpFrame(resting, first, beat(.05)), second, beat(.22)), third, beat(.39));
+};
+var branchFrames = once(() => {
+	const branch = (extension) => withTrail(kit(inCirc(-4, 5.5, 2.5), [-4, 5.5], {
+		balls: [[
+			-4,
+			-5.5,
+			2.5
+		], [
+			5 + extension,
+			-4 - extension,
+			2.5 + .3 * extension
+		]],
+		inks: [[
+			-4,
+			4,
+			-4,
+			-4,
+			1.8
+		]]
+	}), polyline([
+		[-4, 2.5],
+		[-1.8, 2.3],
+		[.5, 1.4],
+		[2.6, -.3],
+		[4.2 + extension, -2.3 - extension],
+		[5 + extension, -4 - extension]
+	], 1.8, 0));
+	return {
+		ready: branch(0),
+		extended: branch(.7)
+	};
+});
+var branching = (t) => {
+	const { ready, extended } = branchFrames();
+	return lerpFrame(ready, extended, loopPulse(t, 3.5));
+};
+// src/ds/components/AgentIndicator/poses/documents.ts
+var writingFrames = once(() => {
+	const page = (end) => withTrail(kit(inRoundRect(0, 0, 6, 7.5, 2), [0, 0], { cuts: [[
+		-2.8,
+		-1.8,
+		2.8,
+		-1.8,
+		1.8
+	], [
+		-2.8,
+		2,
+		end,
+		2,
+		1.8
+	]] }));
+	return {
+		start: page(-1),
+		end: page(2.8)
+	};
+});
+var writing = (t) => {
+	const phase = (t / 2.6 + .55) % 1;
+	const written = sstep(.08, .5, phase) * (1 - sstep(.82, 1, phase));
+	const { start, end } = writingFrames();
+	return lerpFrame(start, end, written);
+};
+// src/ds/components/AgentIndicator/poses/files.ts
+var FOLDER = anyOf(inRoundRect(0, .8, 7.6, 5, 1.8), inRoundRect(-4, -4.4, 3.6, 1.4, 1.2));
+var findingFrames = once(() => {
+	const folder = (lens) => withTrail(kit(FOLDER, [0, .4], {
+		hole: inCirc(...lens, 2.9),
+		holeCenter: lens,
+		balls: [[...lens, 1.7]],
+		cuts: [[
+			lens[0] + 2.1,
+			lens[1] + 2.1,
+			lens[0] + 3.2,
+			lens[1] + 3.2,
+			1.5
+		]]
+	}));
+	return {
+		topLeft: folder([-1.9, .35]),
+		topRight: folder([.7, .35]),
+		bottomLeft: folder([-1.9, .85]),
+		bottomRight: folder([.7, .85])
+	};
+});
+var finding = (t) => {
+	const w = TAU * t / 2.8;
+	const horizontal = .5 + .5 * Math.sin(w);
+	const vertical = .5 + .5 * Math.sin(2 * w);
+	const { topLeft, topRight, bottomLeft, bottomRight } = findingFrames();
+	return lerpFrame(lerpFrame(topLeft, topRight, horizontal), lerpFrame(bottomLeft, bottomRight, horizontal), vertical);
+};
+var creatingFrames = once(() => {
+	const folder = (arm) => withTrail(kit(FOLDER, [0, .4], { cuts: [[
+		-arm,
+		1,
+		arm,
+		1,
+		1.7
+	], [
+		0,
+		1 - arm,
+		0,
+		1 + arm,
+		1.7
+	]] }));
+	return {
+		small: folder(2.21),
+		large: folder(2.6 * 1.15)
+	};
+});
+var creating = (t) => {
+	const { small, large } = creatingFrames();
+	return lerpFrame(small, large, .5 + .5 * Math.sin(TAU * t / 1.6));
+};
+var listingFrames = once(() => {
+	const folder = (end) => withTrail(kit(FOLDER, [0, .4], { cuts: [[
+		-.8,
+		-1.2,
+		4.2,
+		-1.2,
+		1.6
+	], [
+		-.8,
+		2,
+		end,
+		2,
+		1.6
+	]] }), [
+		[
+			-3.7,
+			-1.2,
+			0,
+			1.8
+		],
+		[
+			-3.7,
+			-1.2,
+			0,
+			0
+		],
+		[
+			-3.7,
+			2,
+			0,
+			1.8
+		],
+		[
+			-3.7,
+			2,
+			0,
+			0
+		]
+	]);
+	return {
+		short: folder(1.5),
+		long: folder(4.2)
+	};
+});
+var listing = (t) => {
+	const phase = (t / 3 + .5) % 1;
+	const reveal = sstep(.1, .4, phase) * (1 - sstep(.8, 1, phase));
+	const { short, long } = listingFrames();
+	return lerpFrame(short, long, reveal);
+};
+var inspectingFrames = once(() => {
+	const brackets = (x) => withTrail(kit(nothing, [0, 0], { inks: [[
+		x,
+		-2.8,
+		x,
+		2.8,
+		1.8
+	]] }), [
+		[
+			-3.2,
+			-4.4,
+			2.3,
+			0
+		],
+		[
+			-7.3,
+			0,
+			2.3,
+			0
+		],
+		[
+			-3.2,
+			4.4,
+			0,
+			0
+		],
+		[
+			3.2,
+			-4.4,
+			2.3,
+			0
+		],
+		[
+			7.3,
+			0,
+			2.3,
+			0
+		],
+		[
+			3.2,
+			4.4,
+			0,
+			0
+		]
+	]);
+	return {
+		left: brackets(-.8),
+		right: brackets(.8)
+	};
+});
+var inspecting = (t) => {
+	const scan = .5 + .5 * Math.sin(TAU * t / 2.8);
+	const { left, right } = inspectingFrames();
+	return lerpFrame(left, right, scan);
+};
+// src/ds/components/AgentIndicator/poses/interface.ts
+var pulse = (phase, start, end) => sstep(start, start + .07, phase) * (1 - sstep(end, end + .12, phase));
+var fetchingFrames = once(() => {
+	const browser = (firstWidth, secondWidth) => withTrail(kit(inRoundRect(0, 0, 7.6, 7.2, 2), [0, 0], { cuts: [[
+		-5.8,
+		-3.2,
+		5.8,
+		-3.2,
+		1.4
+	], [
+		-4.3,
+		0,
+		4.3,
+		0,
+		firstWidth
+	]] }), [
+		[
+			-4.3,
+			3.2,
+			0,
+			secondWidth
+		],
+		[
+			1.7,
+			3.2,
+			0,
+			0
+		],
+		[
+			-4.3,
+			-5.1,
+			0,
+			1.1
+		],
+		[
+			-4.3,
+			-5.1,
+			0,
+			0
+		],
+		[
+			-1.9,
+			-5.1,
+			0,
+			1.1
+		],
+		[
+			-1.9,
+			-5.1,
+			0,
+			0
+		]
+	]);
+	return {
+		rest: browser(1.7, 1.7),
+		first: browser(2.4, 1.3),
+		second: browser(1.3, 2.4)
+	};
+});
+var fetching = (t) => {
+	const phase = t / 3.2 % 1;
+	const { rest, first, second } = fetchingFrames();
+	return lerpFrame(lerpFrame(rest, first, pulse(phase, .08, .35)), second, pulse(phase, .5, .8));
+};
+var clickingFrames = once(() => {
+	const rest = withTrail(kit(inShape([
+		[-5.6, -7.2],
+		[-5.6, 5.4],
+		[5.6, .2]
+	]), [-2, 0], { inks: [[
+		-2,
+		0,
+		2.1,
+		7.1,
+		3.3
+	]] }));
+	return {
+		rest,
+		pressed: rest.map((value) => value * .88)
+	};
+});
+var clicking = (t) => {
+	const { rest, pressed } = clickingFrames();
+	return lerpFrame(rest, pressed, pulse(t / 2.6 % 1, .2, .32));
+};
+var typingFrames = once(() => {
+	const keyboard = (active) => withTrail(kit(inRoundRect(0, 0, 8, 5.6, 1.8), [0, 0], { cuts: [[
+		-3.4,
+		3.4,
+		3.4,
+		3.4,
+		active === 6 ? 2.1 : 1.5
+	]] }), [-3.1, .1].flatMap((y, row) => [
+		-4.6,
+		0,
+		4.6
+	].flatMap((x, column) => [[
+		x,
+		y,
+		0,
+		active === row * 3 + column ? 2.4 : 1.6
+	], [
+		x,
+		y,
+		0,
+		0
+	]])));
+	return {
+		rest: keyboard(-1),
+		left: keyboard(0),
+		right: keyboard(5),
+		space: keyboard(6)
+	};
+});
+var typing = (t) => {
+	const phase = t / 2 % 1;
+	const { rest, left, right, space } = typingFrames();
+	return lerpFrame(lerpFrame(lerpFrame(rest, left, pulse(phase, .06, .16)), right, pulse(phase, .36, .46)), space, pulse(phase, .66, .78));
+};
+var screenshotFrames = once(() => {
+	const camera = (lens, pupil) => withTrail(kit(anyOf(inRoundRect(0, 1, 8, 5.4, 1.8), inRoundRect(-.5, -4.2, 3.4, 1.9, 1.1)), [0, .6], {
+		hole: inCirc(0, 1, lens),
+		holeCenter: [0, 1],
+		balls: [[
+			0,
+			1,
+			pupil
+		]]
+	}));
+	return {
+		open: camera(3.3, 1.7),
+		shuttered: camera(2.8, 1.3)
+	};
+});
+var screenshot = (t) => {
+	const { open, shuttered } = screenshotFrames();
+	return lerpFrame(open, shuttered, pulse(t / 3.4 % 1, .2, .29));
+};
+var cubicPoint = ([start, first, last, end], u) => {
+	const v = 1 - u;
+	return [v ** 3 * start[0] + 3 * v ** 2 * u * first[0] + 3 * v * u ** 2 * last[0] + u ** 3 * end[0], v ** 3 * start[1] + 3 * v ** 2 * u * first[1] + 3 * v * u ** 2 * last[1] + u ** 3 * end[1]];
+};
+var askingFrames = once(() => {
+	const question = [[
+		[-2.2, -2.9],
+		[-2.1, -5.1],
+		[2.3, -5.2],
+		[2.3, -2.9]
+	], [
+		[2.3, -2.9],
+		[2.3, -1.3],
+		[.1, -1.2],
+		[.1, .4]
+	]];
+	const bubble = (lift, dot) => withTrail(kit(anyOf(inRoundRect(0, -1, 7.8, 5.8, 2.5), inShape([
+		[-5.8, 2],
+		[-1.8, 3],
+		[-5.8, 7.6]
+	])), [0, -1]), [
+		...question.flatMap((curve, index) => range(index === question.length - 1 ? 17 : 16).map((i) => {
+			const [x, y] = cubicPoint(curve, i / 16);
+			return [
+				x,
+				y - lift,
+				0,
+				i === 16 ? 0 : 1.8
+			];
+		})),
+		[
+			.1,
+			3.1,
+			0,
+			dot
+		],
+		[
+			.1,
+			3.1,
+			0,
+			0
+		]
+	]);
+	return {
+		rest: bubble(0, 1.8),
+		questioning: bubble(.45, 2.3)
+	};
+});
+var asking = (t) => {
+	const { rest, questioning } = askingFrames();
+	return lerpFrame(rest, questioning, pulse(t / 3.8 % 1, .16, .48));
+};
+var inboxFrames = once(() => {
+	const tray = (drop) => withTrail(kit(inShape([
+		[0, .6 + drop],
+		[-3.1, -2.4 + drop],
+		[3.1, -2.4 + drop]
+	]), [0, -1.2 + drop], { inks: [[
+		0,
+		-6.6 + drop,
+		0,
+		-2.2 + drop,
+		2.2
+	]] }), [
+		[
+			-7.4,
+			-1.4,
+			2.8,
+			0
+		],
+		[
+			-7.4,
+			6.4,
+			2.8,
+			0
+		],
+		[
+			7.4,
+			6.4,
+			2.8,
+			0
+		],
+		[
+			7.4,
+			-1.4,
+			0,
+			0
+		]
+	]);
+	return {
+		waiting: tray(0),
+		receiving: tray(2.5)
+	};
+});
+var inbox = (t) => {
+	const { waiting, receiving } = inboxFrames();
+	return lerpFrame(waiting, receiving, pulse(t / 3 % 1, .14, .52));
+};
+var schedulingFrames = once(() => {
+	const calendar = (active) => withTrail(kit(inRoundRect(0, .8, 7.2, 6.8, 1.8), [0, .8], {
+		cuts: [[
+			-5.7,
+			-2.2,
+			5.7,
+			-2.2,
+			1.5
+		]],
+		inks: [[
+			-3.4,
+			-7.6,
+			-3.4,
+			-4.8,
+			2.4
+		], [
+			3.4,
+			-7.6,
+			3.4,
+			-4.8,
+			2.4
+		]]
+	}), [.7, 4].flatMap((y, row) => [-2.5, 2.5].flatMap((x, column) => [[
+		x,
+		y,
+		0,
+		active === row * 2 + column ? 3.2 : 2.2
+	], [
+		x,
+		y,
+		0,
+		0
+	]])));
+	return {
+		rest: calendar(-1),
+		first: calendar(0),
+		next: calendar(3)
+	};
+});
+var scheduling = (t) => {
+	const phase = t / 3.4 % 1;
+	const { rest, first, next } = schedulingFrames();
+	return lerpFrame(lerpFrame(rest, first, pulse(phase, .1, .3)), next, pulse(phase, .52, .74));
+};
+// src/ds/components/AgentIndicator/poses/knowledge.ts
+var networkFrames = once(() => {
+	const origin = [-.2, -4.6];
+	const added = [6.5, -4.7];
+	const network = (node, radius, linkEnd) => withTrail(kit(inCirc(-4.4, 3.2, 2.7), [-4.4, 3.2], {
+		balls: [[...origin, 2.3], [
+			5,
+			3.2,
+			2.5
+		]],
+		inks: [[
+			-4.4,
+			3.2,
+			...origin,
+			1.7
+		], [
+			-4.4,
+			3.2,
+			5,
+			3.2,
+			1.7
+		]]
+	}), [
+		[
+			...origin,
+			1.7,
+			0
+		],
+		[
+			5,
+			3.2,
+			0,
+			0
+		],
+		[
+			...origin,
+			1.5,
+			0
+		],
+		[
+			...linkEnd,
+			0,
+			0
+		],
+		...dot(node, radius * 2)
+	]);
+	return {
+		rest: network(origin, 0, origin),
+		added: network(added, 1.8, origin),
+		linked: network(added, 1.8, added)
+	};
+});
+var knowledge = (clock, sinceEntered) => {
+	const phase = Math.min(clock, sinceEntered) % 4;
+	const node = sstep(.65, 1.1, phase) * (1 - sstep(3.05, 3.5, phase));
+	const link = sstep(1.1, 1.65, phase) * (1 - sstep(2.6, 3, phase));
+	const { rest, added, linked } = networkFrames();
+	if (node === 0) return rest;
+	return lerpFrame(lerpFrame(rest, added, node), linked, link);
+};
+// src/ds/components/AgentIndicator/poses/knowledge-actions.ts
+var noteFrames = once(() => {
+	const note = (written) => withTrail(kit(inShape([
+		[-6, -7],
+		[6, -7],
+		[6, 2.5],
+		[1.5, 7],
+		[-6, 7]
+	]), [0, 0], { cuts: [[
+		-3,
+		-2.8,
+		3,
+		-2.8,
+		1.8
+	], [
+		-3,
+		-.1,
+		.5 + 2.5 * written,
+		-.1,
+		1.8
+	]] }), polyline([
+		[1.5, 6.4],
+		[1.5, 2.5],
+		[5.4, 2.5]
+	], 0, 1.5));
+	return {
+		ready: note(0),
+		written: note(1)
+	};
+});
+var noting = (t) => {
+	const { ready, written } = noteFrames();
+	return lerpFrame(ready, written, loopPulse(t, 2.8));
+};
+var pinShape = (pressed) => inShape([
+	[-3.2, -6 + pressed],
+	[3.2, -6 + pressed],
+	[2.5, -1 + pressed],
+	[4.7, 2 + pressed],
+	[.8, 2 + pressed],
+	[0, 7.5],
+	[-.8, 2 + pressed],
+	[-4.7, 2 + pressed],
+	[-2.5, -1 + pressed]
+]);
+var PIN = pinShape(0);
+var pinFrames = once(() => ({
+	ready: withTrail(kit(PIN, [0, 0])),
+	pressed: withTrail(kit(pinShape(1), [0, 0]))
+}));
+var pinning = (t) => {
+	const { ready, pressed } = pinFrames();
+	return lerpFrame(ready, pressed, loopPulse(t, 3.1));
+};
+var unpinFrames = once(() => {
+	const lifted = (lift) => withTrail(kit(placed(PIN, 0, [0, -lift]), [0, -lift], { cuts: [[
+		-5.4,
+		-5.8,
+		5.4,
+		5.8,
+		2.6
+	]] }), polyline([[-5.4, -5.8], [5.4, 5.8]], 1.6, 0));
+	return {
+		ready: lifted(0),
+		lifted: lifted(.9)
+	};
+});
+var unpinning = (t) => {
+	const { ready, lifted } = unpinFrames();
+	return lerpFrame(ready, lifted, loopPulse(t, 3.1));
+};
+var moveFrames = once(() => {
+	const arrow = (advance) => withTrail(kit(nothing, [advance, 0], { inks: [[
+		-7.2 + advance,
+		0,
+		6.8 + advance,
+		0,
+		2.5
+	]] }), polyline([
+		[1 + advance, -5.5],
+		[6.8 + advance, 0],
+		[1 + advance, 5.5]
+	], 2.5, 0));
+	return {
+		ready: arrow(0),
+		advanced: arrow(.9)
+	};
+});
+var moving = (t) => {
+	const { ready, advanced } = moveFrames();
+	return lerpFrame(ready, advanced, loopPulse(t, 2.7));
+};
+var mergeFrames = once(() => {
+	const merge = (approach) => withTrail(kit(inShape([
+		[0, -7.8],
+		[3.2, -3.8],
+		[1, -3.8],
+		[1, -1],
+		[-1, -1],
+		[-1, -3.8],
+		[-3.2, -3.8]
+	]), [0, -4], {
+		balls: [[
+			-5 + 1.2 * approach,
+			5 - 1.4 * approach,
+			2.5
+		], [
+			5 - 1.2 * approach,
+			5 - 1.4 * approach,
+			2.5
+		]],
+		inks: [[
+			-5 + 1.2 * approach,
+			5 - 1.4 * approach,
+			0,
+			-1.5,
+			1.8
+		], [
+			5 - 1.2 * approach,
+			5 - 1.4 * approach,
+			0,
+			-1.5,
+			1.8
+		]]
+	}));
+	return {
+		separate: merge(0),
+		converging: merge(1)
+	};
+});
+var merging = (t) => {
+	const { separate, converging } = mergeFrames();
+	return lerpFrame(separate, converging, loopPulse(t, 3.2));
+};
+// src/ds/components/AgentIndicator/poses/skills.ts
+var page = (side, lift) => inShape([
+	[-.1, -3.6],
+	[3, -5.2 - lift],
+	[7.6, -5 - lift],
+	[7.6, 4.6],
+	[3, 4.8],
+	[-.1, 6.2]
+].map(([x, y]) => [side * x, y]));
+var openBook = (lift) => anyOf(page(1, lift), page(-1, -lift));
+var invocationFrames = once(() => {
+	const book = (lift) => withTrail(kit(openBook(lift), [0, .4], { cuts: [[
+		0,
+		-6,
+		0,
+		7.2,
+		1.1
+	]] }));
+	return {
+		rest: book(0),
+		left: book(-.5),
+		right: book(.5)
+	};
+});
+var skill = (t) => {
+	const lift = Math.sin(TAU * t / 2.2);
+	const { rest, left, right } = invocationFrames();
+	return lerpFrame(rest, lift < 0 ? left : right, Math.abs(lift));
+};
+var searchFrames = once(() => {
+	const book = (x) => withTrail(kit(openBook(0), [0, .4], {
+		cuts: [[
+			0,
+			-6,
+			0,
+			7.2,
+			1.1
+		]],
+		rings: [[
+			x,
+			3.2,
+			2.7,
+			1.65
+		]]
+	}), [
+		[
+			x,
+			3.2,
+			0,
+			8.45
+		],
+		[
+			x,
+			3.2,
+			0,
+			0
+		],
+		[
+			x + 2.35,
+			5.55,
+			1.8,
+			0
+		],
+		[
+			x + 4,
+			7.2,
+			0,
+			0
+		]
+	]);
+	return {
+		right: book(4.5),
+		left: book(1.5)
+	};
+});
+var skillSearching = (t) => {
+	const { right, left } = searchFrames();
+	return lerpFrame(right, left, loopPulse(t, 3.6));
+};
+var readingFrames = once(() => {
+	const book = (upper, lower) => withTrail(kit(inRoundRect(0, 0, 6.3, 7.3, 1.8), [0, 0], { cuts: [[
+		-3.2,
+		-8,
+		-3.2,
+		8,
+		1.05
+	], [
+		-.7,
+		-1.8,
+		3.6,
+		-1.8,
+		upper
+	]] }), [[
+		-.7,
+		1.6,
+		0,
+		lower
+	], [
+		2.4,
+		1.6,
+		0,
+		0
+	]]);
+	return {
+		rest: book(1.55, 1.55),
+		reading: book(2.1, 1.25)
+	};
+});
+var skillReading = (t) => {
+	const { rest, reading } = readingFrames();
+	return lerpFrame(rest, reading, loopPulse(t, 3.2));
+};
+// src/ds/components/AgentIndicator/poses/terminal.ts
+var SCREEN = inRoundRect(0, 0, 7.6, 6.2, 2);
+var runningFrames = once(() => {
+	const screen = (cursor) => withTrail(kit(SCREEN, [0, 0], { cuts: [[
+		.6,
+		2.8,
+		4.2,
+		2.8,
+		cursor
+	]] }), [
+		[
+			-4,
+			-2.4,
+			0,
+			1.8
+		],
+		[
+			-1.2,
+			.2,
+			0,
+			1.8
+		],
+		[
+			-4,
+			2.8,
+			0,
+			0
+		]
+	]);
+	return {
+		hidden: screen(0),
+		visible: screen(1.8)
+	};
+});
+var running = (t) => {
+	const p = t / 1.1 % 1;
+	const cursor = 1 - sstep(.45, .55, p) + sstep(.9, 1, p);
+	const { hidden, visible } = runningFrames();
+	return lerpFrame(hidden, visible, cursor);
+};
+var stoppingFrames = once(() => {
+	const screen = (half) => withTrail(kit(SCREEN, [0, 0], { hole: inRoundRect(0, 0, half, half, 1) }));
+	return {
+		expanded: screen(2.8),
+		contracted: screen(2.3)
+	};
+});
+var stopping = (t) => {
+	const p = t / 1.4 % 1;
+	const press = sstep(0, .12, p) * (1 - sstep(.24, .6, p));
+	const { expanded, contracted } = stoppingFrames();
+	return lerpFrame(expanded, contracted, press);
+};
+var outputFrames = once(() => {
+	const screen = (end) => withTrail(kit(SCREEN, [0, 0], { cuts: [[
+		-4.1,
+		-1.8,
+		4.1,
+		-1.8,
+		1.8
+	], [
+		-4.1,
+		1.8,
+		end,
+		1.8,
+		1.8
+	]] }));
+	return {
+		short: screen(.6),
+		long: screen(3.2)
+	};
+});
+var output = (t) => {
+	const phase = (t / 2.8 + .6) % 1;
+	const reveal = sstep(.08, .38, phase) * (1 - sstep(.82, 1, phase));
+	const { short, long } = outputFrames();
+	return lerpFrame(short, long, reveal);
+};
+// src/ds/components/AgentIndicator/poses/thinking.ts
+var sulcus = ([a, b, amp, waves]) => (u) => {
+	const dx = b[0] - a[0];
+	const dy = b[1] - a[1];
+	const length = Math.hypot(dx, dy);
+	const s = amp * Math.sin(Math.PI * waves * u);
+	return [a[0] + dx * u - dy / length * s, a[1] + dy * u + dx / length * s];
+};
+var PROFILE = anyOf(inOval(-.3, -1.3, 7.9, 5.3, .035), inOval(-1.6, 2.2, 4.6, 2.6), inOval(5, 3.4, 2.8, 2), inCap([1.4, 2.6], [2.1, 6.8], 1.2));
+var SULCI = [
+	[
+		[-5.8, 1.4],
+		[3, -1.6],
+		.5,
+		2
+	],
+	[
+		[.9, -7],
+		[-.6, -2.6],
+		.45,
+		3
+	],
+	[
+		[-7.6, -2.2],
+		[-3.4, -3.4],
+		.55,
+		2
+	],
+	[
+		[4.6, -6],
+		[5.6, -1.6],
+		.5,
+		2
+	],
+	[
+		[2.4, 2.4],
+		[8.2, 1.8],
+		0,
+		1
+	]
+].map(sulcus);
+var brainKit = once(() => kit(PROFILE, [.4, .4], { cuts: [[
+	2.9,
+	3,
+	3.4,
+	6.2,
+	1.2
+]] }));
+var brain = (t) => withTrail(brainKit(), SULCI.flatMap((fold, j) => range(9).map((i) => {
+	const pulse = .7 * Math.max(0, Math.cos(2.2 * t - 1.3 * j - 3 * i / 8)) ** 6;
+	return [
+		...fold(i / 8),
+		0,
+		i < 8 ? (j ? 1.6 : 1.9) + pulse : 0
+	];
+})));
+var BULB = anyOf(inCirc(0, -1.2, 4.6), inShape([
+	[-3.1, 1.9],
+	[3.1, 1.9],
+	[2.1, 4.4],
+	[-2.1, 4.4]
+]), inRoundRect(0, 5.5, 2.1, 1.4, .8));
+var BULB_RAYS = [
+	-132,
+	-48,
+	-174,
+	-6,
+	-90
+].map((d) => d * Math.PI / 180);
+var bulbKit = once(() => kit(BULB, [0, 0], { cuts: [[
+	0,
+	-2,
+	0,
+	-2,
+	0
+], [
+	-2.6,
+	5.4,
+	2.6,
+	5.4,
+	.8
+]] }));
+var bulb = (light) => withTrail(bulbKit(), BULB_RAYS.flatMap((a, j) => {
+	const n = j < 4 ? 15 : 2;
+	return range(n).map((i) => [
+		...around([0, -1.2], a, 5.9 + 1.5 * light * i / (n - 1)),
+		i < n - 1 ? 1.8 * light : 0,
+		0
+	]);
+}));
+var thinking = (t) => {
+	const p = t / 5 % 1;
+	const lit = sstep(.28, .4, p) * (1 - sstep(.76, .88, p));
+	const glow = sstep(.4, .5, p) * (1 - sstep(.68, .76, p));
+	return lerpFrame(brain(t), bulb(glow * (1 + .06 * Math.sin(8 * t))), lit);
+};
+// src/ds/components/AgentIndicator/poses.ts
+var agentIndicatorStates = [
+	"idle",
+	"memory",
+	"thinking",
+	"reading",
+	"searching",
+	"finding",
+	"browsing",
+	"editing",
+	"writing",
+	"creating",
+	"knowledge",
+	"listing",
+	"inspecting",
+	"stopping",
+	"output",
+	"fetching",
+	"clicking",
+	"typing",
+	"screenshot",
+	"asking",
+	"inbox",
+	"scheduling",
+	"noting",
+	"pinning",
+	"unpinning",
+	"moving",
+	"merging",
+	"delegating",
+	"workflow",
+	"connecting",
+	"planning",
+	"messaging",
+	"branching",
+	"running",
+	"deleting",
+	"skill",
+	"skill-searching",
+	"skill-reading",
+	"tool",
+	"waiting",
+	"done",
+	"error",
+	"context",
+	"notice"
+];
+var MORPH_SECONDS = .52;
+var GROW = 1.2;
+var settle = (sinceEntered) => Math.max(0, sinceEntered - MORPH_SECONDS);
+var AGENT_HEAD = [0, -5.5];
+var AGENT_LIMBS = [
+	[-5.778, -1.293],
+	[5.778, -1.293],
+	[3.57, 5.5],
+	[-3.57, 5.5]
+];
+var AGENT_WEB = [
+	AGENT_LIMBS[0],
+	[-4.029, -2.566],
+	[4.029, -2.566],
+	...AGENT_LIMBS.slice(1)
+];
+var AGENT_NOTCHES = [
+	[-4.674, 2.104],
+	[4.674, 2.104],
+	[0, 5.5]
+];
+var AGENT_DOT = 4.326;
+var agent = once(() => withTrail(kit(inShape(AGENT_WEB), [0, 1.8]), [
+	...dot(AGENT_HEAD, AGENT_DOT),
+	[
+		...AGENT_HEAD,
+		0,
+		9.968
+	],
+	[
+		...AGENT_HEAD,
+		0,
+		0
+	],
+	...AGENT_LIMBS.flatMap((limb) => dot(limb, AGENT_DOT)),
+	...AGENT_NOTCHES.flatMap((notch) => [[
+		...notch,
+		0,
+		2.818
+	], [
+		...notch,
+		0,
+		0
+	]])
+]));
+var memory = (t) => {
+	const c = t / 2.4;
+	const turn = Math.floor(c) + sstep(0, .6, c - Math.floor(c));
+	const minute = -Math.PI / 2 - TAU * turn;
+	const hour = -2.6 - TAU / 12 * turn;
+	return withTrail(kit(inCirc(0, 0, 7.8), [0, 0], { cuts: [[
+		0,
+		0,
+		4.6 * Math.cos(minute),
+		4.6 * Math.sin(minute),
+		2.2
+	], [
+		0,
+		0,
+		3 * Math.cos(hour),
+		3 * Math.sin(hour),
+		2.2
+	]] }));
+};
+var TELESCOPE = anyOf(inShape([
+	[-6.8, -1.3],
+	[5.4, -2.6],
+	[5.4, 2.6],
+	[-6.8, 1.3]
+]), inCap([-6.8, 0], [-8, 0], 1.6), inCirc(0, 1.6, 1.8));
+var MOUNT = [-.4, 1];
+var browsing = (t) => {
+	return withTrail(kit(placed(TELESCOPE, -.5 + .2 * Math.sin(.9 * t) + .06 * Math.sin(2.3 * t), MOUNT), MOUNT, { inks: [[
+		MOUNT[0],
+		MOUNT[1] + 1.4,
+		-4.2,
+		8,
+		1.8
+	], [
+		MOUNT[0],
+		MOUNT[1] + 1.4,
+		3.4,
+		8,
+		1.8
+	]] }));
+};
+var NUT = ([x, y]) => {
+	const side = Math.PI / 3;
+	const a = (Math.atan2(y, x) % side + side) % side;
+	return Math.hypot(x, y) < 7.4 * Math.cos(side / 2) / Math.cos(a - side / 2);
+};
+var nut = (turn) => withTrail(kit(placed(NUT, Math.PI / 3 * turn), [0, 0], { hole: inCirc(0, 0, 2.8) }));
+var restingNut = once(() => nut(0));
+var tool = (t) => {
+	const c = t / 1.1;
+	const turn = sstep(.55, .85, c - Math.floor(c));
+	return Number.isInteger(turn) ? restingNut() : nut(turn);
+};
+var turned = ([x, y], a) => [x * Math.cos(a) - y * Math.sin(a), x * Math.sin(a) + y * Math.cos(a)];
+var shifted = ([x, y], [dx, dy]) => [x + dx, y + dy];
+var segment = (a, b, width) => [
+	...a,
+	...b,
+	width
+];
+var dotCut = (p, d) => [[
+	...p,
+	0,
+	d
+], [
+	...p,
+	0,
+	0
+]];
+var ALMOND = allOf(inCirc(0, 4.6, 8.8), inCirc(0, -4.6, 8.8));
+var reading = (t) => {
+	const iris = [1.5 * Math.sin(TAU * t / 2.6), 0];
+	return withTrail(kit(ALMOND, [0, 0], {
+		hole: inCirc(...iris, 3.1),
+		holeCenter: iris,
+		balls: [[...iris, 1.7]]
+	}));
+};
+var LENS = [-1.6, -1.6];
+var searching = (t) => {
+	const w = TAU * t / 2.4;
+	const at = [.9 * Math.sin(w), .5 * Math.sin(2 * w)];
+	const lens = shifted(LENS, at);
+	return withTrail(kit(nothing, lens, { rings: [[
+		...lens,
+		4.05,
+		1.9
+	]] }), polyline([shifted([1.8, 1.8], at), shifted([5.4, 5.4], at)], 3.1, 0));
+};
+var PEN = anyOf(inCap([-2.6, 2.6], [5, -5], 2.3), inShape([
+	[-4.23, .97],
+	[-.97, 4.23],
+	[-5.9, 5.9]
+]));
+var PEN_BANDS = [[[-3.4, .6], [-.6, 3.4]], [[1.4, -4.2], [4.2, -1.4]]];
+var editing = (t) => {
+	const w = TAU * t / .9;
+	const at = [.45 * Math.sin(w), .3 * Math.sin(2 * w)];
+	return withTrail(kit(placed(PEN, 0, at), at, { cuts: PEN_BANDS.map(([a, b]) => segment(shifted(a, at), shifted(b, at), 1)) }));
+};
+var CAN = anyOf(inRoundRect(0, 1.6, 5.4, 5.2, 1.4), inRoundRect(0, -4.4, 7.2, 1, 1), inRoundRect(0, -6, 2.4, 1, .8));
+var CAN_CUTS = [[[-1.9, -.8], [-1.9, 4.4]], [[1.9, -.8], [1.9, 4.4]]];
+var LID_SEAM = [[-5.6, -3.2], [5.6, -3.2]];
+var deleting = (t) => {
+	const a = .08 * Math.sin(TAU * t / 1.2);
+	return withTrail(kit(placed(CAN, a), [0, 0], { cuts: CAN_CUTS.map(([p, q]) => segment(turned(p, a), turned(q, a), 1.3)) }), polyline(LID_SEAM.map((p) => turned(p, a)), 0, .9));
+};
+var LAYER_TIERS = [
+	-3.2,
+	0,
+	3.2
+];
+var diamond = (cy) => [
+	[0, cy - 3.6],
+	[7.4, cy],
+	[0, cy + 3.6],
+	[-7.4, cy]
+];
+var contextFrames = once(() => {
+	const layers = (spacing) => withTrail(kit(anyOf(...LAYER_TIERS.map((cy) => inShape(diamond(cy * spacing)))), [0, 0]), LAYER_TIERS.slice(0, -1).flatMap((cy) => {
+		const [, right, bottom, left] = diamond(cy * spacing);
+		return polyline([
+			left,
+			bottom,
+			right
+		], 0, 1);
+	}));
+	return {
+		closed: layers(1),
+		open: layers(1.16)
+	};
+});
+var context = (clock) => {
+	const { closed, open } = contextFrames();
+	return lerpFrame(closed, open, loopPulse(clock, 3.6));
+};
+var noticeFrames = once(() => {
+	const information = (dotSize) => withTrail(kit(inCirc(0, 0, 7.4), [0, 0], { cuts: [segment([0, -.4], [0, 3.8], 1.9)] }), dotCut([0, -3.6], dotSize));
+	return {
+		rest: information(2.3),
+		emphasis: information(3.1)
+	};
+});
+var notice = (clock) => {
+	const { rest, emphasis } = noticeFrames();
+	return lerpFrame(rest, emphasis, loopPulse(clock, 2.8));
+};
+var blank = once(() => kit(nothing, [0, 0]));
+var line = (a, b) => (u) => [a[0] + (b[0] - a[0]) * u, a[1] + (b[1] - a[1]) * u];
+var twoStrokes = (first, second, width) => withTrail(blank(), [first, second].flatMap((stroke) => range(32).map((i) => [
+	...stroke(i / 31),
+	i < 31 ? width : 0,
+	0
+])));
+var waiting = once(() => twoStrokes(line([-2.7, -3.4], [-2.7, 3.4]), line([2.7, -3.4], [2.7, 3.4]), 2.2));
+var OUTCOME_STROKE_WIDTH = 2.1;
+var CHECK = [
+	[-6.2, .4],
+	[-2.2, 4.4],
+	[6.4, -4.8]
+];
+var done = (_, s) => {
+	const q = settle(s);
+	const k = 1 + .08 * Math.exp(-q * 7) * Math.sin(q * 15);
+	const at = ([x, y]) => [x * k, y * k];
+	const [a, b, c] = CHECK;
+	return twoStrokes(line(at(a), at(b)), line(at(b), at(c)), OUTCOME_STROKE_WIDTH);
+};
+var CROSS = 4.6;
+var error = (_, s) => {
+	const q = settle(s);
+	const shake = 1.4 * Math.exp(-q * 5) * Math.sin(q * 36);
+	return twoStrokes(line([-4.6 + shake, -4.6], [CROSS + shake, CROSS]), line([CROSS + shake, -4.6], [-4.6 + shake, CROSS]), OUTCOME_STROKE_WIDTH);
+};
+var grown = (pose) => (t, s) => pose(t, s).map((v) => v * GROW);
+var RINGING_SECONDS = 2.52;
+var restsAfterSeconds = {
+	idle: 0,
+	waiting: 0,
+	done: RINGING_SECONDS,
+	error: RINGING_SECONDS
+};
+var poses = {
+	idle: grown(agent),
+	memory: grown(memory),
+	thinking: grown(thinking),
+	reading: grown(reading),
+	searching: grown(searching),
+	finding: grown(finding),
+	browsing: grown(browsing),
+	editing: grown(editing),
+	writing: grown(writing),
+	creating: grown(creating),
+	knowledge: grown(knowledge),
+	listing: grown(listing),
+	inspecting: grown(inspecting),
+	stopping: grown(stopping),
+	output: grown(output),
+	fetching: grown(fetching),
+	clicking: grown(clicking),
+	typing: grown(typing),
+	screenshot: grown(screenshot),
+	asking: grown(asking),
+	inbox: grown(inbox),
+	scheduling: grown(scheduling),
+	noting: grown(noting),
+	pinning: grown(pinning),
+	unpinning: grown(unpinning),
+	moving: grown(moving),
+	merging: grown(merging),
+	delegating: grown(delegating),
+	workflow: grown(workflow),
+	connecting: grown(connecting),
+	planning: grown(planning),
+	messaging: grown(messaging),
+	branching: grown(branching),
+	running: grown(running),
+	deleting: grown(deleting),
+	skill: grown(skill),
+	"skill-searching": grown(skillSearching),
+	"skill-reading": grown(skillReading),
+	tool: grown(tool),
+	waiting: grown(waiting),
+	done: grown(done),
+	error: grown(error),
+	context: grown(context),
+	notice: grown(notice)
+};
+// src/ds/components/AgentIndicator/animate.ts
+var ease = cubicBezier(.65, 0, .35, 1);
+var MAX_STEP_SECONDS = .05;
+var prefersReducedMotion = () => window.matchMedia?.("(prefers-reduced-motion: reduce)").matches ?? false;
+function animate(svg) {
+	const paint = painter(svg);
+	const reduced = prefersReducedMotion();
+	let clock = 0;
+	let state;
+	let enteredAt = 0;
+	let leaving;
+	let shown;
+	let onScreen = true;
+	let frame = 0;
+	let last = 0;
+	const draw = () => {
+		if (!state) return;
+		let f = poses[state](clock, clock - enteredAt);
+		const morph = clamp01((clock - enteredAt) / MORPH_SECONDS);
+		if (morph >= 1) leaving = void 0;
+		if (leaving) f = lerpFrame(leaving(clock), f, ease(morph));
+		shown = f;
+		paint(f);
+	};
+	const resting = () => !leaving && state !== void 0 && clock - enteredAt >= (restsAfterSeconds[state] ?? Infinity);
+	const tick = (now) => {
+		clock += Math.min(MAX_STEP_SECONDS, (now - last) / 1e3);
+		last = now;
+		draw();
+		frame = resting() ? 0 : requestAnimationFrame(tick);
+	};
+	const wake = () => {
+		const running = onScreen && !reduced && !resting();
+		if (running && !frame) {
+			last = performance.now();
+			frame = requestAnimationFrame(tick);
+		}
+		if (!running && frame) {
+			cancelAnimationFrame(frame);
+			frame = 0;
+		}
+	};
+	const viewport = new IntersectionObserver((entries) => {
+		onScreen = entries.at(-1)?.isIntersecting ?? onScreen;
+		wake();
+	});
+	viewport.observe(svg);
+	return {
+		show(next) {
+			if (next === state) return;
+			if (state && !reduced) {
+				const outgoing = poses[state];
+				const outgoingAt = enteredAt;
+				const frozen = shown;
+				leaving = leaving && frozen ? () => frozen : (t) => outgoing(t, t - outgoingAt);
+			}
+			state = next;
+			enteredAt = clock;
+			draw();
+			wake();
+		},
+		stop() {
+			cancelAnimationFrame(frame);
+			viewport.disconnect();
+		}
+	};
+}
+// src/ds/components/AgentIndicator/agent-indicator.tsx
+var MORPH = { "--agent-indicator-morph": `${MORPH_SECONDS}s` };
+function Strokes({ part, count }) {
+	return range(count).map((i) => /* @__PURE__ */ jsx("path", { "data-part": part }, i));
+}
+var CUTS = /* @__PURE__ */ jsxs("g", {
+	fill: "none",
+	stroke: "black",
+	strokeLinecap: "round",
+	children: [/* @__PURE__ */ jsx(Strokes, {
+		part: "cut",
+		count: 2
+	}), /* @__PURE__ */ jsx(Strokes, {
+		part: "trail-cut",
+		count: 63
+	})]
+});
+var SHAPE = /* @__PURE__ */ jsxs(Fragment$1, { children: [
+	/* @__PURE__ */ jsx("path", {
+		"data-part": "body",
+		fillRule: "evenodd"
+	}),
+	range(2).map((i) => /* @__PURE__ */ jsx("circle", { "data-part": "ball" }, i)),
+	/* @__PURE__ */ jsx("g", {
+		fill: "none",
+		stroke: "currentColor",
+		strokeLinecap: "round",
+		children: /* @__PURE__ */ jsx(Strokes, {
+			part: "ink",
+			count: 2
+		})
+	})
+] });
+var TRAIL_INKS = /* @__PURE__ */ jsx("g", {
+	fill: "none",
+	stroke: "currentColor",
+	strokeLinecap: "round",
+	children: /* @__PURE__ */ jsx(Strokes, {
+		part: "trail-ink",
+		count: 63
+	})
+});
+function AgentIndicator({ state, still, className }) {
+	const maskId = `agent-indicator-${useId().replace(/[^a-zA-Z0-9_-]/g, "")}`;
+	const svgRef = useRef(null);
+	const animation = useRef(void 0);
+	useLayoutEffect(() => {
+		if (!svgRef.current) return;
+		const running = animate(svgRef.current);
+		animation.current = running;
+		return () => {
+			running.stop();
+			animation.current = void 0;
+		};
+	}, []);
+	useLayoutEffect(() => {
+		animation.current?.show(state);
+	}, [state]);
+	return /* @__PURE__ */ jsx("span", {
+		"aria-hidden": true,
+		"data-state": state,
+		"data-still": still || void 0,
+		className: cn("agent-indicator inline-flex size-4 shrink-0", className),
+		style: MORPH,
+		children: /* @__PURE__ */ jsxs("svg", {
+			ref: svgRef,
+			viewBox: "-12 -12 24 24",
+			className: "size-full",
+			children: [
+				/* @__PURE__ */ jsx("defs", { children: /* @__PURE__ */ jsxs("mask", {
+					id: maskId,
+					maskUnits: "userSpaceOnUse",
+					x: -12,
+					y: -12,
+					width: 24,
+					height: 24,
+					children: [/* @__PURE__ */ jsx("rect", {
+						x: -12,
+						y: -12,
+						width: 24,
+						height: 24,
+						fill: "white"
+					}), CUTS]
+				}) }),
+				/* @__PURE__ */ jsx("g", {
+					fill: "currentColor",
+					mask: `url(#${maskId})`,
+					children: SHAPE
+				}),
+				TRAIL_INKS,
+				/* @__PURE__ */ jsx("g", {
+					fill: "none",
+					stroke: "currentColor",
+					children: range(1).map((i) => /* @__PURE__ */ jsx("circle", { "data-part": "ring" }, i))
+				})
+			]
+		})
+	});
+}
+// src/ds/components/AgentIndicator/agent-glyph.tsx
+var SETTLED_SECONDS = 60;
+var drawn = (strokes) => strokes.filter((stroke) => stroke.d);
+function glyph(state) {
+	const parts = once(() => frameParts(poses[state](0, SETTLED_SECONDS)));
+	const Glyph = forwardRef(({ size = 24, color = "currentColor", absoluteStrokeWidth: _, ...props }, ref) => {
+		const maskId = `agent-glyph-${useId().replace(/[^a-zA-Z0-9_-]/g, "")}`;
+		const { body, balls, rings, cuts, inks, trailCuts, trailInks } = parts();
+		const cutting = drawn([...cuts, ...trailCuts]);
+		const named = Object.keys(props).some((prop) => prop.startsWith("aria-") || prop === "role" || prop === "title");
+		return /* @__PURE__ */ jsxs("svg", {
+			ref,
+			viewBox: "-12 -12 24 24",
+			width: size,
+			height: size,
+			fill: color,
+			"aria-hidden": named ? void 0 : true,
+			...props,
+			children: [
+				cutting.length > 0 && /* @__PURE__ */ jsxs("mask", {
+					id: maskId,
+					maskUnits: "userSpaceOnUse",
+					x: -12,
+					y: -12,
+					width: 24,
+					height: 24,
+					children: [/* @__PURE__ */ jsx("rect", {
+						x: -12,
+						y: -12,
+						width: 24,
+						height: 24,
+						fill: "white"
+					}), /* @__PURE__ */ jsx("g", {
+						fill: "none",
+						stroke: "black",
+						strokeLinecap: "round",
+						children: cutting.map(({ d, width }) => /* @__PURE__ */ jsx("path", {
+							"data-part": "cut",
+							d,
+							strokeWidth: width
+						}, d))
+					})]
+				}),
+				/* @__PURE__ */ jsxs("g", {
+					mask: cutting.length > 0 ? `url(#${maskId})` : void 0,
+					children: [
+						/* @__PURE__ */ jsx("path", {
+							"data-part": "body",
+							d: body,
+							fillRule: "evenodd"
+						}),
+						balls.filter((ball) => Number(ball.r) > 0).map((ball) => /* @__PURE__ */ jsx("circle", {
+							"data-part": "ball",
+							...ball
+						}, `${ball.cx} ${ball.cy}`)),
+						/* @__PURE__ */ jsx("g", {
+							fill: "none",
+							stroke: color,
+							strokeLinecap: "round",
+							children: drawn(inks).map(({ d, width }) => /* @__PURE__ */ jsx("path", {
+								"data-part": "ink",
+								d,
+								strokeWidth: width
+							}, d))
+						})
+					]
+				}),
+				/* @__PURE__ */ jsx("g", {
+					fill: "none",
+					stroke: color,
+					strokeLinecap: "round",
+					children: drawn(trailInks).map(({ d, width }) => /* @__PURE__ */ jsx("path", {
+						"data-part": "ink",
+						d,
+						strokeWidth: width
+					}, d))
+				}),
+				/* @__PURE__ */ jsx("g", {
+					fill: "none",
+					stroke: color,
+					children: rings.filter((ring) => Number(ring.r) > 0 && Number(ring.width) > 0).map(({ width, ...ring }) => /* @__PURE__ */ jsx("circle", {
+						"data-part": "ring",
+						...ring,
+						strokeWidth: width
+					}, `${ring.cx} ${ring.cy}`))
+				})
+			]
+		});
+	});
+	Glyph.displayName = `AgentGlyph(${state})`;
+	return Glyph;
+}
+var glyphs = /* @__PURE__ */ new Map();
+/** An indicator pose as a still icon: what a row shows for the work the indicator morphs into. */
+function agentGlyph(state) {
+	const known = glyphs.get(state);
+	if (known) return known;
+	const made = glyph(state);
+	glyphs.set(state, made);
+	return made;
+}
+export { AgentIndicator as n, agentIndicatorStates as r, agentGlyph as t };
+
+//# sourceMappingURL=AgentIndicator-Dnv_1hvF.js.map