@harperfast/harper 5.3.0-beta.3 → 5.3.0-beta.4

package/server/threads/windowsProcessTree.ts

@@ -0,0 +1,409 @@
+import { spawn } from 'node:child_process';
+import { setTimeout as delay } from 'node:timers/promises';
+import * as harperLogger from '../../utility/logging/harper_logger.ts';
+
+/**
+ * Confirms that a spawned Windows process tree is gone, identifying its members by lifetime
+ * rather than by PID alone.
+ *
+ * Windows recycles a freed PID almost immediately, and a process keeps its ParentProcessId after
+ * that parent exits. So once the direct child (the tree root) has exited, `ProcessId == rootPid`
+ * can be any newer process, and `ParentProcessId == rootPid` can be that newer process's children
+ * — a scan keyed on the PID alone reports the tree alive for as long as the recycled PID stays in
+ * use, and `taskkill /T` on that PID kills whatever now owns it (harper#2273). A real member's
+ * creation time is bounded by its parent's lifetime, which is what `selectWindowsProcessTree`
+ * checks: the root is only a member while it is the process we spawned, and a child of `X` was
+ * created after `X` was and before `X` exited.
+ */
+
+export interface WindowsProcessRecord {
+	pid: number;
+	ppid: number;
+	/** Win32_Process.CreationDate as epoch ms; null when Windows reports none (system processes). */
+	created: number | null;
+	name?: string;
+}
+
+export interface WindowsProcessTreeIdentity {
+	rootPid: number;
+	/** Epoch ms at which the root was already running: after spawn returned, or at group registration. */
+	rootKnownAt: number;
+	/**
+	 * How long before `rootKnownAt` the root may have started: the interval measured around the
+	 * `spawn` call, or `ROOT_SPAWN_ALLOWANCE_MS` when that was not measured. Bounds the children of
+	 * a root whose own creation time was never observed.
+	 */
+	rootStartedWithinMs?: number;
+	/** The root's own creation time, once a scan has seen it running as ours; the exact child bound. */
+	rootCreatedAt?: number;
+	/**
+	 * Epoch ms after which the root was no longer running — Node observed its exit, a forced kill
+	 * was confirmed, or a scan found its PID gone or recycled. Bounds its children's creation. Left
+	 * undefined while it runs; `confirmWindowsProcessTreeGone` latches it from its own scans.
+	 */
+	rootExitedAt?: number;
+	/**
+	 * Every member below the root that a scan has found, by PID with its creation time, and the
+	 * moment a later scan first found it gone. Kept so a member stays one after the parent that
+	 * linked it to the root has exited, and so its own children stay bounded by its lifetime.
+	 * `confirmWindowsProcessTreeGone` maintains it.
+	 */
+	descendants?: Map<number, WindowsTreeMemberRecord>;
+}
+
+export interface WindowsTreeMemberRecord {
+	created: number;
+	exitedAt?: number;
+}
+
+export interface WindowsProcessTreeWaitOptions {
+	scan?: () => Promise<WindowsProcessRecord[] | null>;
+	kill?: (members: WindowsProcessRecord[], rootPid: number) => Promise<void>;
+	now?: () => number;
+	warn?: (message: string) => void;
+	pollMs?: number;
+	maxPollMs?: number;
+	/** Names the tree in the unconfirmed-termination warning. */
+	label?: string;
+}
+
+// Date.now() and Win32_Process.CreationDate read the same system clock; this covers its resolution.
+const CLOCK_SKEW_MS = 50;
+// The root is created inside the `spawn` call, so the interval measured around that call is the
+// exact bound on how much earlier than `rootKnownAt` it may have started. This is the fallback for a
+// registration that carried no such interval: a stall between the two — an event loop pause, never
+// a network hop.
+export const ROOT_SPAWN_ALLOWANCE_MS = 1_000;
+export const WINDOWS_TREE_POLL_MS = 25;
+const WINDOWS_TREE_POLL_MAX_MS = 5_000;
+const WINDOWS_TREE_WARNING_MS = 5_000;
+const WINDOWS_TREE_WARNING_INTERVAL_MS = 60_000;
+// Neither helper below is allowed to suspend the confirmation loop indefinitely. The loop itself is
+// deliberately deadline-free (harper#2076: the preparation lock is never released on an unconfirmed
+// tree), but that policy is about the DECISION, not about a single syscall: a `Get-CimInstance` or
+// `taskkill` that never returns parks the loop before it can warn, so an operator sees a silent
+// wedge instead of the 60 s "could not be queried" message the unknown state already produces.
+// Bounding each invocation converts a hung helper into that same unknown, which keeps waiting.
+const WINDOWS_TREE_HELPER_TIMEOUT_MS = 30_000;
+
+// Exit 0 means the query ran and produced a table (possibly empty — an empty table is still a
+// positive result, not "unknown"); exit 2 means the query itself failed (e.g. Get-CimInstance
+// denied or WMI unavailable), which ErrorActionPreference=Stop plus the wrapping try/catch turns
+// into that distinct code instead of a false-empty result, and `queryWindowsProcessTable` reads
+// anything but 0 as "could not read the table" (null), never as "positively found nothing".
+const PROCESS_TABLE_SCRIPT =
+	"$ErrorActionPreference = 'Stop'; try { " +
+	'$rows = @(Get-CimInstance Win32_Process | ForEach-Object { [pscustomobject]@{ ' +
+	'pid = [int]$_.ProcessId; ppid = [int]$_.ParentProcessId; name = [string]$_.Name; ' +
+	'created = if ($_.CreationDate) { [DateTimeOffset]::new($_.CreationDate).ToUnixTimeMilliseconds() } else { $null } } }); ' +
+	'[Console]::Out.Write((ConvertTo-Json -Compress -InputObject $rows)); exit 0 ' +
+	'} catch { exit 2 }';
+
+export function queryWindowsProcessTable(
+	timeoutMs: number = WINDOWS_TREE_HELPER_TIMEOUT_MS
+): Promise<WindowsProcessRecord[] | null> {
+	return new Promise((resolve) => {
+		const query = spawn(
+			'powershell.exe',
+			['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', PROCESS_TABLE_SCRIPT],
+			{
+				stdio: ['ignore', 'pipe', 'ignore'],
+				windowsHide: true,
+			}
+		);
+		let output = '';
+		// utf8 so the decoder buffers a multi-byte character split across a chunk boundary — a
+		// process name has arbitrary Unicode — instead of coercing each half's raw bytes separately
+		query.stdout.setEncoding('utf8');
+		query.stdout.on('data', (chunk) => {
+			output += chunk;
+		});
+		const abandon = setTimeout(() => {
+			query.kill();
+			resolve(null); // unknown, exactly as an unreadable table: the caller keeps waiting
+		}, timeoutMs);
+		abandon.unref?.();
+		const settle = (value: WindowsProcessRecord[] | null) => {
+			clearTimeout(abandon);
+			resolve(value);
+		};
+		query.once('close', (code) => settle(code === 0 ? parseProcessTable(output) : null));
+		query.once('error', () => settle(null));
+	});
+}
+
+export function parseProcessTable(json: string): WindowsProcessRecord[] | null {
+	let rows: unknown;
+	try {
+		rows = JSON.parse(json.replace(/^\uFEFF/, ''));
+	} catch {
+		return null;
+	}
+	if (rows === null || typeof rows !== 'object') return null;
+	const table: WindowsProcessRecord[] = [];
+	for (const row of Array.isArray(rows) ? rows : [rows]) {
+		const { pid, ppid, created, name } = (row ?? {}) as Record<string, unknown>;
+		if (!Number.isInteger(pid) || !Number.isInteger(ppid)) return null;
+		table.push({
+			pid: pid as number,
+			ppid: ppid as number,
+			created: Number.isFinite(created) ? (created as number) : null,
+			name: typeof name === 'string' ? name : undefined,
+		});
+	}
+	return table;
+}
+
+export function findWindowsTreeRoot(
+	table: WindowsProcessRecord[],
+	identity: WindowsProcessTreeIdentity
+): WindowsProcessRecord | undefined {
+	if (identity.rootExitedAt !== undefined) return undefined;
+	const root = table.find((process) => process.pid === identity.rootPid);
+	if (!root || root.created === null) return undefined;
+	// Once a scan has pinned the root's exact creation time, a later row at the same PID is ours only
+	// if it matches exactly — same as a remembered descendant (line ~223). Without that pin, a
+	// replacement created within the clock-skew window of `rootKnownAt` would otherwise pass the loose
+	// upper-bound check below, which only rules out a replacement created too late to be ours, not one
+	// created too early (the original having already exited and been recycled inside that window).
+	if (identity.rootCreatedAt !== undefined) return root.created === identity.rootCreatedAt ? root : undefined;
+	if (root.created <= identity.rootKnownAt + CLOCK_SKEW_MS) return root;
+	return undefined;
+}
+
+/**
+ * The processes in `table` that belong to the tree rooted at `identity.rootPid`. The root counts
+ * only while it still runs and is the process we spawned (created no later than we first knew
+ * it); a child counts only if it was created while its parent lived — after the root's own
+ * creation where that was observed, and before its exit — so nothing that merely inherited a
+ * recycled PID or ParentProcessId is included.
+ */
+export function selectWindowsProcessTree(
+	table: WindowsProcessRecord[],
+	identity: WindowsProcessTreeIdentity,
+	now: number = Date.now()
+): WindowsProcessRecord[] {
+	const members: WindowsProcessRecord[] = [];
+	const seen = new Set<number>();
+	const root = findWindowsTreeRoot(table, identity);
+	// Only reserve the root's PID once it is verified as ours — once the root has exited, a live
+	// descendant that Windows hands that freed PID is a legitimate child of some other frontier
+	// member, and must still be reachable through the frontier walk below.
+	if (root) {
+		seen.add(identity.rootPid);
+		members.push(root);
+	}
+	const rootCreatedAt = root?.created ?? identity.rootCreatedAt;
+	// A row now holding `pid` that could not possibly be the member we are bounding — created after
+	// the latest moment a genuine one could have been — proves the PID was already recycled by then,
+	// tighter than a "gone" conclusion that only arrives once a scan stops observing the member at
+	// all (for a remembered descendant that can be a whole backed-off poll late; for the root, the
+	// scan that first fails to find it still uses this frontier before its exit is stamped —
+	// `confirmWindowsProcessTreeGone` below only latches `rootExitedAt` after this call returns).
+	// `oursNoLaterThan` for a descendant is its exact known creation time; for the root it is the
+	// latest creation `findWindowsTreeRoot` would still have accepted as ours, so a row this cannot
+	// exonerate is never treated as a false impostor of a root we simply haven't re-confirmed yet.
+	const impostorCreatedAt = (pid: number, oursNoLaterThan: number): number | undefined => {
+		const impostor = table.find(
+			(process) => process.pid === pid && process.created !== null && process.created > oursNoLaterThan
+		);
+		return impostor?.created;
+	};
+	let frontier = [
+		{
+			pid: identity.rootPid,
+			notBefore:
+				rootCreatedAt === undefined || rootCreatedAt === null
+					? // our own clock against WMI's, so it carries the skew allowance
+						identity.rootKnownAt - (identity.rootStartedWithinMs ?? ROOT_SPAWN_ALLOWANCE_MS) - CLOCK_SKEW_MS
+					: // WMI's clock against itself: a process created before the one whose PID it names as its
+						// parent was created by an earlier holder of that PID, so it is never ours
+						rootCreatedAt,
+			notAfter: Math.min(
+				// this bound is our own clock against WMI's, so it carries the skew allowance
+				(identity.rootExitedAt ?? now) + CLOCK_SKEW_MS,
+				// this one is WMI's clock against itself: the replacement's creation time is exactly when
+				// the PID stopped being ours, so anything it went on to create is a stranger's, not ours
+				(impostorCreatedAt(identity.rootPid, rootCreatedAt ?? identity.rootKnownAt + CLOCK_SKEW_MS) ?? Infinity) - 1
+			),
+		},
+	];
+	// A member an earlier scan found is still one — by PID and creation time — after the parent
+	// that linked it to the root has exited and left no row to walk through; its children are
+	// bounded by its lifetime like any other member's, latched from the scan that first lost it.
+	for (const [pid, known] of identity.descendants ?? []) {
+		if (seen.has(pid)) continue;
+		const live = table.find((process) => process.pid === pid && process.created === known.created);
+		if (live) {
+			seen.add(pid);
+			members.push(live);
+			frontier.push({ pid, notBefore: known.created, notAfter: Infinity });
+		} else {
+			frontier.push({
+				pid,
+				notBefore: known.created,
+				notAfter: Math.min(
+					(known.exitedAt ?? now) + CLOCK_SKEW_MS,
+					(impostorCreatedAt(pid, known.created) ?? Infinity) - 1
+				),
+			});
+		}
+	}
+	while (frontier.length > 0) {
+		const next: typeof frontier = [];
+		for (const parent of frontier) {
+			for (const process of table) {
+				if (process.ppid !== parent.pid || seen.has(process.pid) || process.created === null) continue;
+				if (process.created < parent.notBefore || process.created > parent.notAfter) continue;
+				seen.add(process.pid);
+				members.push(process);
+				next.push({ pid: process.pid, notBefore: process.created, notAfter: Infinity });
+			}
+		}
+		frontier = next;
+	}
+	return members;
+}
+
+// `CreateProcess` rejects a command line over 8191 characters, and the rejection surfaces as a
+// spawn error this module deliberately absorbs — so a tree with enough orphans would be "killed"
+// by a command that never ran, and the wait would never end. At ~11 characters per `/pid NNNNN`
+// this is an order of magnitude inside the limit.
+const TASKKILL_PIDS_PER_INVOCATION = 200;
+
+/**
+ * The taskkill argument lists that terminate `members`: the whole tree through the root while the
+ * root itself is still ours — never also by descendant PID in the same round, since `/T` frees
+ * those PIDs before a second invocation could run — and otherwise every member by its own PID,
+ * which is safe only because the root's PID is then no longer ours to `/T`. Per-PID kills are
+ * batched, since one command line cannot name an unbounded number of them.
+ */
+export function taskkillInvocation(members: WindowsProcessRecord[], rootPid: number): string[][] | null {
+	if (members.length === 0) return null;
+	if (members.some((member) => member.pid === rootPid)) return [['/pid', String(rootPid), '/T', '/F']];
+	const invocations: string[][] = [];
+	for (let i = 0; i < members.length; i += TASKKILL_PIDS_PER_INVOCATION) {
+		const batch = members.slice(i, i + TASKKILL_PIDS_PER_INVOCATION);
+		invocations.push(['/F', ...batch.flatMap((member) => ['/pid', String(member.pid)])]);
+	}
+	return invocations;
+}
+
+export function runTaskkill(args: string[], timeoutMs: number = WINDOWS_TREE_HELPER_TIMEOUT_MS): Promise<void> {
+	return new Promise((resolve) => {
+		const taskkill = spawn('taskkill', args, { stdio: 'ignore', windowsHide: true });
+		const abandon = setTimeout(() => {
+			taskkill.kill();
+			resolve(); // the next round reissues it; nothing here reads a kill as proof of anything
+		}, timeoutMs);
+		abandon.unref?.();
+		const settle = () => {
+			clearTimeout(abandon);
+			resolve();
+		};
+		taskkill.once('close', settle);
+		taskkill.once('error', settle);
+	});
+}
+
+async function killWindowsProcesses(members: WindowsProcessRecord[], rootPid: number): Promise<void> {
+	for (const args of taskkillInvocation(members, rootPid) ?? []) await runTaskkill(args);
+}
+
+function rememberDescendants(
+	identity: WindowsProcessTreeIdentity,
+	members: WindowsProcessRecord[],
+	scannedAt: number,
+	root: WindowsProcessRecord | undefined
+) {
+	const descendants = (identity.descendants ??= new Map());
+	for (const member of members) {
+		// Skip only the verified root row itself (its lifetime is tracked separately via
+		// rootCreatedAt/rootExitedAt) — not every member sharing its PID number. Once the root has
+		// exited, a live descendant that Windows hands that freed PID is a distinct incarnation,
+		// identified by its own (pid, created) pair, and must be remembered like any other descendant
+		// so a later scan can still find it and its own children.
+		if (member === root || member.created === null) continue;
+		if (descendants.get(member.pid)?.created !== member.created)
+			descendants.set(member.pid, { created: member.created });
+	}
+	for (const [pid, known] of descendants) {
+		if (known.exitedAt !== undefined) continue;
+		if (!members.some((member) => member.pid === pid && member.created === known.created)) known.exitedAt = scannedAt;
+	}
+}
+
+function describeMembers(members: WindowsProcessRecord[]): string {
+	return members
+		.map(
+			(member) =>
+				`${member.pid}${member.name ? ` (${member.name})` : ''} created ${member.created === null ? 'unknown' : new Date(member.created).toISOString()}`
+		)
+		.join(', ');
+}
+
+/**
+ * Terminate every remaining member of the tree and resolve once a scan positively finds none.
+ * There is deliberately no deadline: releasing a component's preparation lock while a descendant
+ * can still mutate its directory is less safe than keeping that deployment wedged for operator
+ * intervention — but the wait is logged, so a wedge names the process holding it, and the poll
+ * backs off so a wedge does not spin the process table query. A scan that cannot read the table
+ * (null) is unknown, not gone, and keeps the wait going.
+ */
+export async function confirmWindowsProcessTreeGone(
+	identity: WindowsProcessTreeIdentity,
+	options: WindowsProcessTreeWaitOptions = {}
+): Promise<void> {
+	const scan = options.scan ?? queryWindowsProcessTable;
+	const kill = options.kill ?? killWindowsProcesses;
+	const now = options.now ?? Date.now;
+	const warn = options.warn ?? ((message: string) => harperLogger.warn(message));
+	const maxPollMs = options.maxPollMs ?? WINDOWS_TREE_POLL_MAX_MS;
+	let pollMs = options.pollMs ?? WINDOWS_TREE_POLL_MS;
+	const label = options.label ?? `pid ${identity.rootPid}`;
+	const startedAt = now();
+	let nextWarningAt = startedAt + WINDOWS_TREE_WARNING_MS;
+	for (;;) {
+		const table = await scan();
+		let members: WindowsProcessRecord[] | null = null;
+		let rootIdentityUnknown: WindowsProcessRecord | undefined;
+		if (table !== null) {
+			const scannedAt = now();
+			const root = findWindowsTreeRoot(table, identity);
+			rootIdentityUnknown =
+				identity.rootExitedAt === undefined
+					? table.find((process) => process.pid === identity.rootPid && process.created === null)
+					: undefined;
+			if (rootIdentityUnknown) {
+				members = selectWindowsProcessTree(table, identity, scannedAt).filter(
+					(member) => identity.descendants?.get(member.pid)?.created === member.created
+				);
+			} else {
+				if (root && identity.rootCreatedAt === undefined) identity.rootCreatedAt = root.created;
+				members = selectWindowsProcessTree(table, identity, scannedAt);
+				// The root's PID is reusable the moment it exits, so from the first scan that no longer finds
+				// it running as ours, nothing created later can be its child. Stamped after the scan: the
+				// snapshot may predate the stamp, and a bound that is late keeps waiting, which is the safe
+				// direction. The same goes for every other member.
+				if (!root && identity.rootExitedAt === undefined) identity.rootExitedAt = scannedAt;
+				rememberDescendants(identity, members, scannedAt, root);
+			}
+		}
+		if (!rootIdentityUnknown && members?.length === 0) return;
+		if (members?.length) await kill(members, identity.rootPid);
+		const time = now();
+		if (time >= nextWarningAt) {
+			warn(
+				`Termination of the process tree of ${label} remains unconfirmed after ${Math.round(time - startedAt)}ms: ` +
+					(rootIdentityUnknown
+						? `root pid ${identity.rootPid} is held by ${rootIdentityUnknown.name ?? 'an unnamed process'} without a creation time`
+						: members
+							? `live members ${describeMembers(members)}`
+							: 'the Windows process table could not be queried')
+			);
+			nextWarningAt = time + WINDOWS_TREE_WARNING_INTERVAL_MS;
+		}
+		await delay(pollMs);
+		pollMs = Math.min(pollMs * 2, maxPollMs);
+	}
+}

package/server/throttle.ts

@@ -5,6 +5,7 @@ const DEFAULT_MAX_QUEUE_TIME = 20_000; // 20 seconds
 let lastWarning = 0;
 const WARNING_INTERVAL = 30000;
 const EVENT_QUEUE_MONITORING_INTERVAL = 3000;
+const LIMIT_EXCEEDED_LOG_INTERVAL = 5000;
 let lastEventQueueCheck = performance.now() + EVENT_QUEUE_MONITORING_INTERVAL;
 let averageEventCycleTime = 0;
 /**
@@ -16,13 +17,22 @@ let averageEventCycleTime = 0;
 export function throttle(
 	fn: (...args: any) => any,
 	onLimitExceeded?: (...args: any) => any,
-	maxQueueTimeLimit = DEFAULT_MAX_QUEUE_TIME
+	maxQueueTimeLimit = DEFAULT_MAX_QUEUE_TIME,
+	name?: string
 ) {
 	let queuedCalls: any[];
+	let lastLimitExceededLog = -Infinity;
 	return function (...args: any[]) {
 		if (queuedCalls) {
 			// this is an estimate of the time an event will take to process, based on the average event cycle time and the queue depth
 			if (queuedCalls.length * averageEventCycleTime > maxQueueTimeLimit) {
+				const now = performance.now();
+				if (now - lastLimitExceededLog > LIMIT_EXCEEDED_LOG_INTERVAL) {
+					lastLimitExceededLog = now;
+					logger.warn?.(
+						`Rejecting queued calls${name ? ` (${name})` : ''}: ${queuedCalls.length} already queued at ~${Math.round(averageEventCycleTime)}ms per event cycle, an estimated wait past the ${maxQueueTimeLimit}ms limit`
+					);
+				}
 				return onLimitExceeded(...args);
 			}
 			return new Promise((resolve, reject) => {

package/studio/web/assets/{Chat-CveGbxe6.js → Chat-Bq60AO-g.js}

@@ -1,4 +1,4 @@
-import{i as e,t}from"./rolldown-runtime-Dd_uD5pT.js";import{S as n,_ as r,a as i,b as a,c as o,d as s,f as c,g as l,h as u,l as d,m as f,n as p,o as m,p as h,r as g,s as _,t as v,v as y,x as b,y as x}from"./vendor-core-BdkdbUek.js";import{i as S,t as C}from"./button-MFP9n8Ck.js";import{a as ee}from"./vendor-datadog-fCQhBHGk.js";import{r as te}from"./vendor-react-izWchTRL.js";import{J as ne,L as re,k as ie,z as ae}from"./vendor-tanstack-CQ1aRjVa.js";import{n as oe}from"./setSessionStorage-B0bf71m4.js";import{It as se}from"./vendor-ui-aE1tHcW7.js";import{t as w}from"./createLucideIcon-bziYxJli.js";import{n as ce,r as le,t as ue}from"./chevron-up-CFe8x5Bp.js";import{c as de,f as fe,h as pe,i as me,l as he,m as ge,p as _e,r as ve,t as ye,u as be}from"./setComponentFile-VnJ80SSJ.js";import{t as xe}from"./x-vYntCxm4.js";import{n as Se}from"./setLocalStorage-D_kflv4U.js";import{t as Ce}from"./useLocalStorage-BYoZF60G.js";import{Ar as we,Dr as Te,H as Ee,It as De,Mn as Oe,Mt as ke,Nt as Ae,On as je,Pr as Me,Pt as Ne,Sr as Pe,V as Fe,Z as Ie,_n as Le,_r as Re,c as ze,cr as Be,d as Ve,f as He,fr as Ue,ft as We,in as Ge,kr as Ke,m as qe,mr as Je,ur as Ye,ut as Xe,xr as Ze,yt as Qe}from"./index-B4g2Fu_2.js";import{t as $e}from"./useEntityRestURL-BUdnVSVv.js";import{n as et,t as tt}from"./FloatingChat-IpCFgYWL.js";import{n as nt}from"./getAnalytics-CjthMQqF.js";var rt={name:`between-horizontal-start`,size:24,node:[[`rect`,{width:`13`,height:`7`,x:`8`,y:`3`,rx:`1`,key:`pkso9a`}],[`path`,{d:`m2 9 3 3-3 3`,key:`1agib5`}],[`rect`,{width:`13`,height:`7`,x:`8`,y:`14`,rx:`1`,key:`1q5fc1`}]],aliases:[`between-horizonal-start`]};rt.node;var it=w(rt),at={name:`book`,size:24,node:[[`path`,{d:`M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20`,key:`k3hazp`}]]};at.node;var ot=w(at),st={name:`chart-area`,size:24,node:[[`path`,{d:`M3 3v16a2 2 0 0 0 2 2h16`,key:`c24i48`}],[`path`,{d:`M7 11.207a.5.5 0 0 1 .146-.353l2-2a.5.5 0 0 1 .708 0l3.292 3.292a.5.5 0 0 0 .708 0l4.292-4.292a.5.5 0 0 1 .854.353V16a1 1 0 0 1-1 1H8a1 1 0 0 1-1-1z`,key:`q0gr47`}]],aliases:[`area-chart`]};st.node;var ct=w(st),lt={name:`circle-x`,size:24,node:[[`circle`,{cx:`12`,cy:`12`,r:`10`,key:`1mglay`}],[`path`,{d:`m15 9-6 6`,key:`1uzhvr`}],[`path`,{d:`m9 9 6 6`,key:`z0biqf`}]],aliases:[`x-circle`]};lt.node;var ut=w(lt),dt={name:`file-pen`,size:24,node:[[`path`,{d:`M12.659 22H18a2 2 0 0 0 2-2V8a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 14 2H6a2 2 0 0 0-2 2v9.34`,key:`o6klzx`}],[`path`,{d:`M14 2v5a1 1 0 0 0 1 1h5`,key:`wfsgrz`}],[`path`,{d:`M10.378 12.622a1 1 0 0 1 3 3.003L8.36 20.637a2 2 0 0 1-.854.506l-2.867.837a.5.5 0 0 1-.62-.62l.836-2.869a2 2 0 0 1 .506-.853z`,key:`zhnas1`}]],aliases:[`file-edit`]};dt.node;var ft=w(dt),pt={name:`logs`,size:24,node:[[`path`,{d:`M3 5h1`,key:`1mv5vm`}],[`path`,{d:`M3 12h1`,key:`lp3yf2`}],[`path`,{d:`M3 19h1`,key:`w6f3n9`}],[`path`,{d:`M8 5h1`,key:`1nxr5w`}],[`path`,{d:`M8 12h1`,key:`1con00`}],[`path`,{d:`M8 19h1`,key:`k7p10e`}],[`path`,{d:`M13 5h8`,key:`a7qcls`}],[`path`,{d:`M13 12h8`,key:`h98zly`}],[`path`,{d:`M13 19h8`,key:`c3s6r1`}]]};pt.node;var mt=w(pt),ht={name:`message-square-heart`,size:24,node:[[`path`,{d:`M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z`,key:`18887p`}],[`path`,{d:`M7.5 9.5c0 .687.265 1.383.697 1.844l3.009 3.264a1.14 1.14 0 0 0 .407.314 1 1 0 0 0 .783-.004 1.14 1.14 0 0 0 .398-.31l3.008-3.264A2.77 2.77 0 0 0 16.5 9.5 2.5 2.5 0 0 0 12 8a2.5 2.5 0 0 0-4.5 1.5`,key:`1faxuh`}]]};ht.node;var gt=w(ht),_t={name:`send`,size:24,node:[[`path`,{d:`M14.536 21.686a.5.5 0 0 0 .937-.024l6.5-19a.496.496 0 0 0-.635-.635l-19 6.5a.5.5 0 0 0-.024.937l7.93 3.18a2 2 0 0 1 1.112 1.11z`,key:`1ffxy3`}],[`path`,{d:`m21.854 2.147-10.94 10.939`,key:`12cjpa`}]]};_t.node;var vt=w(_t),yt={name:`wrench`,size:24,node:[[`path`,{d:`M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.106-3.105c.32-.322.863-.22.983.218a6 6 0 0 1-8.259 7.057l-7.91 7.91a1 1 0 0 1-2.999-3l7.91-7.91a6 6 0 0 1 7.057-8.259c.438.12.54.662.219.984z`,key:`1ngwbx`}]]};yt.node;var bt=w(yt);async function xt(){await S.delete(`/Chat/Messages/`)}var T=e(ee(),1),E=te();function St({setMessages:e}){let[t,n]=(0,T.useState)(!1),r=(0,T.useCallback)(async()=>{if(!t){n(!0);try{await xt(),e([])}catch(e){console.error(`Failed to clear chat:`,e)}finally{n(!1)}}},[t,e]);return(0,E.jsxs)(`button`,{type:`button`,className:`clear-chat-button gap-1`,onClick:r,disabled:t,title:`Clear chat`,children:[t?(0,E.jsx)(Ze,{className:`animate-spin`,size:18}):(0,E.jsx)(Ue,{size:18}),`Clear`]})}async function Ct(){let{data:e}=await S.get(`/Chat/Messages/`);return e}var wt=`vercel.ai.error`,Tt=Symbol.for(wt),Et,Dt,D=class e extends (Dt=Error,Et=Tt,Dt){constructor({name:e,message:t,cause:n}){super(t),this[Et]=!0,this.name=e,this.cause=n}static isInstance(t){return e.hasMarker(t,wt)}static hasMarker(e,t){let n=Symbol.for(t);return typeof e==`object`&&!!e&&n in e&&typeof e[n]==`boolean`&&e[n]===!0}},Ot=`AI_APICallError`,kt=`vercel.ai.error.${Ot}`,At=Symbol.for(kt),jt,Mt,Nt=class extends (Mt=D,jt=At,Mt){constructor({message:e,url:t,requestBodyValues:n,statusCode:r,responseHeaders:i,responseBody:a,cause:o,isRetryable:s=r!=null&&(r===408||r===409||r===429||r>=500),data:c}){super({name:Ot,message:e,cause:o}),this[jt]=!0,this.url=t,this.requestBodyValues=n,this.statusCode=r,this.responseHeaders=i,this.responseBody=a,this.isRetryable=s,this.data=c}static isInstance(e){return D.hasMarker(e,kt)}},Pt=`AI_EmptyResponseBodyError`,Ft=`vercel.ai.error.${Pt}`,It=Symbol.for(Ft),Lt,Rt,zt=class extends (Rt=D,Lt=It,Rt){constructor({message:e=`Empty response body`}={}){super({name:Pt,message:e}),this[Lt]=!0}static isInstance(e){return D.hasMarker(e,Ft)}};function Bt(e){return e==null?`unknown error`:typeof e==`string`?e:e instanceof Error?e.toString():JSON.stringify(e)}var Vt=`AI_InvalidArgumentError`,Ht=`vercel.ai.error.${Vt}`,Ut=Symbol.for(Ht),Wt,Gt,Kt=class extends (Gt=D,Wt=Ut,Gt){constructor({message:e,cause:t,argument:n}){super({name:Vt,message:e,cause:t}),this[Wt]=!0,this.argument=n}static isInstance(e){return D.hasMarker(e,Ht)}},qt=`AI_JSONParseError`,Jt=`vercel.ai.error.${qt}`,Yt=Symbol.for(Jt),Xt,Zt,Qt=class extends (Zt=D,Xt=Yt,Zt){constructor({text:e,cause:t}){super({name:qt,message:`JSON parsing failed: Text: ${e}.
+import{i as e,t}from"./rolldown-runtime-Dd_uD5pT.js";import{S as n,_ as r,a as i,b as a,c as o,d as s,f as c,g as l,h as u,l as d,m as f,n as p,o as m,p as h,r as g,s as _,t as v,v as y,x as b,y as x}from"./vendor-core-BdkdbUek.js";import{i as S,t as C}from"./button-MFP9n8Ck.js";import{a as ee}from"./vendor-datadog-fCQhBHGk.js";import{r as te}from"./vendor-react-izWchTRL.js";import{J as ne,L as re,k as ie,z as ae}from"./vendor-tanstack-CQ1aRjVa.js";import{n as oe}from"./setSessionStorage-B0bf71m4.js";import{It as se}from"./vendor-ui-aE1tHcW7.js";import{t as w}from"./createLucideIcon-bziYxJli.js";import{n as ce,r as le,t as ue}from"./chevron-up-CFe8x5Bp.js";import{c as de,f as fe,h as pe,i as me,l as he,m as ge,p as _e,r as ve,t as ye,u as be}from"./setComponentFile-z4-qJCbA.js";import{t as xe}from"./x-vYntCxm4.js";import{n as Se}from"./setLocalStorage-D_kflv4U.js";import{t as Ce}from"./useLocalStorage-BYoZF60G.js";import{Ar as we,Dr as Te,H as Ee,It as De,Mn as Oe,Mt as ke,Nt as Ae,On as je,Pr as Me,Pt as Ne,Sr as Pe,V as Fe,Z as Ie,_n as Le,_r as Re,c as ze,cr as Be,d as Ve,f as He,fr as Ue,ft as We,in as Ge,kr as Ke,m as qe,mr as Je,ur as Ye,ut as Xe,xr as Ze,yt as Qe}from"./index-DGRAzvO4.js";import{t as $e}from"./useEntityRestURL-BKetlINf.js";import{n as et,t as tt}from"./FloatingChat-D4560T0p.js";import{n as nt}from"./getAnalytics-CjthMQqF.js";var rt={name:`between-horizontal-start`,size:24,node:[[`rect`,{width:`13`,height:`7`,x:`8`,y:`3`,rx:`1`,key:`pkso9a`}],[`path`,{d:`m2 9 3 3-3 3`,key:`1agib5`}],[`rect`,{width:`13`,height:`7`,x:`8`,y:`14`,rx:`1`,key:`1q5fc1`}]],aliases:[`between-horizonal-start`]};rt.node;var it=w(rt),at={name:`book`,size:24,node:[[`path`,{d:`M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20`,key:`k3hazp`}]]};at.node;var ot=w(at),st={name:`chart-area`,size:24,node:[[`path`,{d:`M3 3v16a2 2 0 0 0 2 2h16`,key:`c24i48`}],[`path`,{d:`M7 11.207a.5.5 0 0 1 .146-.353l2-2a.5.5 0 0 1 .708 0l3.292 3.292a.5.5 0 0 0 .708 0l4.292-4.292a.5.5 0 0 1 .854.353V16a1 1 0 0 1-1 1H8a1 1 0 0 1-1-1z`,key:`q0gr47`}]],aliases:[`area-chart`]};st.node;var ct=w(st),lt={name:`circle-x`,size:24,node:[[`circle`,{cx:`12`,cy:`12`,r:`10`,key:`1mglay`}],[`path`,{d:`m15 9-6 6`,key:`1uzhvr`}],[`path`,{d:`m9 9 6 6`,key:`z0biqf`}]],aliases:[`x-circle`]};lt.node;var ut=w(lt),dt={name:`file-pen`,size:24,node:[[`path`,{d:`M12.659 22H18a2 2 0 0 0 2-2V8a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 14 2H6a2 2 0 0 0-2 2v9.34`,key:`o6klzx`}],[`path`,{d:`M14 2v5a1 1 0 0 0 1 1h5`,key:`wfsgrz`}],[`path`,{d:`M10.378 12.622a1 1 0 0 1 3 3.003L8.36 20.637a2 2 0 0 1-.854.506l-2.867.837a.5.5 0 0 1-.62-.62l.836-2.869a2 2 0 0 1 .506-.853z`,key:`zhnas1`}]],aliases:[`file-edit`]};dt.node;var ft=w(dt),pt={name:`logs`,size:24,node:[[`path`,{d:`M3 5h1`,key:`1mv5vm`}],[`path`,{d:`M3 12h1`,key:`lp3yf2`}],[`path`,{d:`M3 19h1`,key:`w6f3n9`}],[`path`,{d:`M8 5h1`,key:`1nxr5w`}],[`path`,{d:`M8 12h1`,key:`1con00`}],[`path`,{d:`M8 19h1`,key:`k7p10e`}],[`path`,{d:`M13 5h8`,key:`a7qcls`}],[`path`,{d:`M13 12h8`,key:`h98zly`}],[`path`,{d:`M13 19h8`,key:`c3s6r1`}]]};pt.node;var mt=w(pt),ht={name:`message-square-heart`,size:24,node:[[`path`,{d:`M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z`,key:`18887p`}],[`path`,{d:`M7.5 9.5c0 .687.265 1.383.697 1.844l3.009 3.264a1.14 1.14 0 0 0 .407.314 1 1 0 0 0 .783-.004 1.14 1.14 0 0 0 .398-.31l3.008-3.264A2.77 2.77 0 0 0 16.5 9.5 2.5 2.5 0 0 0 12 8a2.5 2.5 0 0 0-4.5 1.5`,key:`1faxuh`}]]};ht.node;var gt=w(ht),_t={name:`send`,size:24,node:[[`path`,{d:`M14.536 21.686a.5.5 0 0 0 .937-.024l6.5-19a.496.496 0 0 0-.635-.635l-19 6.5a.5.5 0 0 0-.024.937l7.93 3.18a2 2 0 0 1 1.112 1.11z`,key:`1ffxy3`}],[`path`,{d:`m21.854 2.147-10.94 10.939`,key:`12cjpa`}]]};_t.node;var vt=w(_t),yt={name:`wrench`,size:24,node:[[`path`,{d:`M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.106-3.105c.32-.322.863-.22.983.218a6 6 0 0 1-8.259 7.057l-7.91 7.91a1 1 0 0 1-2.999-3l7.91-7.91a6 6 0 0 1 7.057-8.259c.438.12.54.662.219.984z`,key:`1ngwbx`}]]};yt.node;var bt=w(yt);async function xt(){await S.delete(`/Chat/Messages/`)}var T=e(ee(),1),E=te();function St({setMessages:e}){let[t,n]=(0,T.useState)(!1),r=(0,T.useCallback)(async()=>{if(!t){n(!0);try{await xt(),e([])}catch(e){console.error(`Failed to clear chat:`,e)}finally{n(!1)}}},[t,e]);return(0,E.jsxs)(`button`,{type:`button`,className:`clear-chat-button gap-1`,onClick:r,disabled:t,title:`Clear chat`,children:[t?(0,E.jsx)(Ze,{className:`animate-spin`,size:18}):(0,E.jsx)(Ue,{size:18}),`Clear`]})}async function Ct(){let{data:e}=await S.get(`/Chat/Messages/`);return e}var wt=`vercel.ai.error`,Tt=Symbol.for(wt),Et,Dt,D=class e extends (Dt=Error,Et=Tt,Dt){constructor({name:e,message:t,cause:n}){super(t),this[Et]=!0,this.name=e,this.cause=n}static isInstance(t){return e.hasMarker(t,wt)}static hasMarker(e,t){let n=Symbol.for(t);return typeof e==`object`&&!!e&&n in e&&typeof e[n]==`boolean`&&e[n]===!0}},Ot=`AI_APICallError`,kt=`vercel.ai.error.${Ot}`,At=Symbol.for(kt),jt,Mt,Nt=class extends (Mt=D,jt=At,Mt){constructor({message:e,url:t,requestBodyValues:n,statusCode:r,responseHeaders:i,responseBody:a,cause:o,isRetryable:s=r!=null&&(r===408||r===409||r===429||r>=500),data:c}){super({name:Ot,message:e,cause:o}),this[jt]=!0,this.url=t,this.requestBodyValues=n,this.statusCode=r,this.responseHeaders=i,this.responseBody=a,this.isRetryable=s,this.data=c}static isInstance(e){return D.hasMarker(e,kt)}},Pt=`AI_EmptyResponseBodyError`,Ft=`vercel.ai.error.${Pt}`,It=Symbol.for(Ft),Lt,Rt,zt=class extends (Rt=D,Lt=It,Rt){constructor({message:e=`Empty response body`}={}){super({name:Pt,message:e}),this[Lt]=!0}static isInstance(e){return D.hasMarker(e,Ft)}};function Bt(e){return e==null?`unknown error`:typeof e==`string`?e:e instanceof Error?e.toString():JSON.stringify(e)}var Vt=`AI_InvalidArgumentError`,Ht=`vercel.ai.error.${Vt}`,Ut=Symbol.for(Ht),Wt,Gt,Kt=class extends (Gt=D,Wt=Ut,Gt){constructor({message:e,cause:t,argument:n}){super({name:Vt,message:e,cause:t}),this[Wt]=!0,this.argument=n}static isInstance(e){return D.hasMarker(e,Ht)}},qt=`AI_JSONParseError`,Jt=`vercel.ai.error.${qt}`,Yt=Symbol.for(Jt),Xt,Zt,Qt=class extends (Zt=D,Xt=Yt,Zt){constructor({text:e,cause:t}){super({name:qt,message:`JSON parsing failed: Text: ${e}.
 Error message: ${Bt(t)}`,cause:t}),this[Xt]=!0,this.text=e}static isInstance(e){return D.hasMarker(e,Jt)}},$t=`AI_TypeValidationError`,en=`vercel.ai.error.${$t}`,tn=Symbol.for(en),nn,rn,O=class e extends (rn=D,nn=tn,rn){constructor({value:e,cause:t,context:n}){let r=`Type validation failed`;if(n?.field&&(r+=` for ${n.field}`),n?.entityName||n?.entityId){r+=` (`;let e=[];n.entityName&&e.push(n.entityName),n.entityId&&e.push(`id: "${n.entityId}"`),r+=e.join(`, `),r+=`)`}super({name:$t,message:`${r}: Value: ${JSON.stringify(e)}.
 Error message: ${Bt(t)}`,cause:t}),this[nn]=!0,this.value=e,this.context=n}static isInstance(e){return D.hasMarker(e,en)}static wrap({value:t,cause:n,context:r}){return e.isInstance(n)&&n.value===t&&n.context?.field===r?.field&&n.context?.entityName===r?.entityName&&n.context?.entityId===r?.entityId?n:new e({value:t,cause:n,context:r})}},an=`AI_UnsupportedFunctionalityError`,on=`vercel.ai.error.${an}`,sn=Symbol.for(on),cn,ln,un=class extends (ln=D,cn=sn,ln){constructor({functionality:e,message:t=`'${e}' functionality not supported.`}){super({name:an,message:t}),this[cn]=!0,this.functionality=e}static isInstance(e){return D.hasMarker(e,on)}},dn=class extends Error{constructor(e,t){super(e),this.name=`ParseError`,this.type=t.type,this.field=t.field,this.value=t.value,this.line=t.line}},fn=10,pn=13,k=32;function mn(e){}function hn(e){if(typeof e==`function`)throw TypeError("`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?");let{onEvent:t=mn,onError:n=mn,onRetry:r=mn,onComment:i,maxBufferSize:a}=e,o=[],s=0,c=!0,l,u=``,d=0,f,p=!1;function m(e){if(p)throw Error("Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing.");if(c&&(c=!1,e.charCodeAt(0)===239&&e.charCodeAt(1)===187&&e.charCodeAt(2)===191&&(e=e.slice(3))),o.length===0){let t=g(e);t!==``&&(o.push(t),s=t.length),h();return}if(e.indexOf(`
 `)===-1&&e.indexOf(`\r`)===-1){o.push(e),s+=e.length,h();return}o.push(e);let t=o.join(``);o.length=0,s=0;let n=g(t);n!==``&&(o.push(n),s=n.length),h()}function h(){a!==void 0&&(s+u.length<=a||(p=!0,o.length=0,s=0,l=void 0,u=``,d=0,f=void 0,n(new dn(`Buffered data exceeded max buffer size of ${a} characters`,{type:`max-buffer-size-exceeded`}))))}function g(e){let n=0;if(e.indexOf(`\r`)===-1){let r=e.indexOf(`