@trilogy-data/trilogy-studio-components 0.1.25 → 0.1.27

package/dist/stores-LlyiwSbK.js

@@ -0,0 +1,2604 @@
+import { c as e, u as t } from "./base-DuKnVD-A.js";
+import { Ct as n, Dt as r, Et as i, Ft as a, Gt as o, It as s, Ot as c, Tt as l, _t as u, bt as d, fn as f, gt as p, kt as m, vt as h, wt as g } from "./llm-ClU-2rgk.js";
+import { C as _, F as v, H as y, I as b, L as x, N as S, P as C, R as ee, S as te, i as ne, it as w, q as re, s as ie, t as ae, z as T } from "./editorStore-CAlMJftt.js";
+import { t as oe } from "./connections-CWH3zwH2.js";
+import { n as se, t as E } from "./chatHelpers-F_woEbYF.js";
+import { computed as D, ref as O } from "vue";
+import { defineStore as k } from "pinia";
+//#region data/tips.ts
+var ce = [
+	{
+		id: "welcome",
+		title: "Welcome!",
+		content: "Welcome to Trilogy Studio, an analytics IDE! Let's get you started with the basics. If you know what you're doing, feel free to dismiss these tips.",
+		category: "onboarding"
+	},
+	{
+		id: "navigation",
+		title: "Navigation",
+		content: "Access different sections through the sidebar on the left. The right side contains a tabbed browser with your primary workspaces. Opening new items will open new tabs.",
+		category: "onboarding",
+		highlightDataTestId: "sidebar-icons"
+	},
+	{
+		id: "settings",
+		title: "Settings",
+		content: "User settings - such as darkmode - can be accessed through the gear on the bottom of the sidebar.",
+		category: "onboarding",
+		highlightDataTestId: "sidebar-icon-settings"
+	},
+	{
+		id: "trilogy",
+		title: "Trilogy - The Query Language",
+		content: "The studio supports standard SQL, but most rich functionality expects you to write Trilogy, a modified SQL syntax that streamlines analytics. The tutorial in the help section is the best way to get up to speed with it!",
+		category: "onboarding",
+		highlightDataTestId: "sidebar-icon-tutorial"
+	}
+], le = [
+	{
+		id: "editor-intro",
+		title: "Settings",
+		content: "Editors let you run SQL or Trilogy commands. Click the run button in top right to run a query.",
+		category: "editor",
+		highlightDataTestId: "editor-run-button"
+	},
+	{
+		id: "editor-shortcuts",
+		title: "Keyboard Shortcuts",
+		content: "Standard keyboard shortcuts are available to run, validate, generate AI code, format, and save your work.",
+		category: "editor",
+		highlightDataTestId: "editor-shortcut-hints"
+	},
+	{
+		id: "editor-validate",
+		title: "Validate",
+		content: "Click the validate button to parse the current Trilogy script. This will provide syntax feedback and populate the schema explorer on the right.",
+		category: "editor",
+		highlightDataTestId: "editor-validate-button"
+	},
+	{
+		id: "editor-save",
+		title: "Save",
+		content: "Click the save button to save your changes to local browser storage. Trilogy will auto-save regularly, but you can trigger on demand.",
+		category: "editor",
+		highlightDataTestId: "editor-save-button"
+	},
+	{
+		id: "editor-sources",
+		title: "Sources",
+		content: "An editor can be marked as a \"source\". Sources are special editors that can be imported by other editors using import syntax `import <editor_name> as <alias>. Use this to create reusable abstractions and models.",
+		category: "editor",
+		highlightDataTestId: "editor-set-source"
+	},
+	{
+		id: "editor-ai",
+		title: "AI Assistance",
+		content: "If you have configured an LLM connection, you can interact with the AI assistant via a chat window. The assistant can help you generate or update code, but will not have direct access to your db.",
+		category: "editor",
+		highlightDataTestId: "editor-generate-button"
+	}
+], ue = [
+	{
+		id: "dashboard-intro",
+		title: "Dashboard",
+		content: "Welcome to a dashboard - a way of interactively exploring visualized data and markup. It natively support cross-filtering, drilldown, global filtering, and other interactivity. Click or drag on charts to filter. They are designed to be lightweight, customizable, and interactive. You can close these tips in the top right if you know what you're doing!",
+		category: "dashboard"
+	},
+	{
+		id: "dashboard-full-screen",
+		title: "Full Screen",
+		content: "Dashboards can be full-screen for viewing and analysis or in edit mode, which will allow you to modify the layout and content. Use the button in the top right to toggle between modes.",
+		category: "dashboard",
+		highlightDataTestId: "toggle-edit-mode-button"
+	},
+	{
+		id: "dashboard-add-item",
+		title: "Add Dashboard Item",
+		content: "Use the add item button in the top left to add new charts, tables, markdown blocks, or filters to your dashboard. You will need to be in edit mode to see it.",
+		category: "dashboard",
+		highlightDataTestId: "add-item-button"
+	},
+	{
+		id: "dashboard-edit",
+		title: "Dashboard Data",
+		content: "Dashboarding is Trilogy-SQL centric. To populate an item, you need to give it a data query. Click the edit button on the item header to configure data and appearance. (the header is available when you mouse over a widget in edit mode.) ",
+		category: "dashboard",
+		highlightDataTestId: "dashboard-item-header-controls"
+	},
+	{
+		id: "dashboard-filter",
+		title: "Dashboard Filters",
+		content: "The omni-filter bar at the top of dashboards can be used to filter all items. You can also add filter widgets, which are just queries that render as a search box and cross-filter content.",
+		category: "dashboard",
+		highlightDataTestId: "filter-input"
+	},
+	{
+		id: "dashboard-source",
+		title: "Dashboard Source",
+		content: "Dashboards run queries against a source editor. Add any new common fields or calculations to the source so they can be used throughout the dashboard. If you define a calculation locally to a widget, it will not be usable for cross-filtering across widgets.",
+		category: "dashboard",
+		highlightDataTestId: "dashboard-import-wrapper"
+	},
+	{
+		id: "dashboard-connection",
+		title: "Dashboard Connection",
+		content: "Dashboards run queries against a source editor, which in turn runs against a database connection. You can change the connection for the source editor using the connection selector in the top right.",
+		category: "dashboard",
+		highlightDataTestId: "connection-selector-wrapper"
+	},
+	{
+		id: "dashboard-features",
+		title: "Complex Types",
+		content: "A basic dashboard is just charts and tables, but you can use Markdown blocks and filters to make more rich, interactive experiences. Markdown blocks can have source trilogy queries and have a special syntax for embedding results in line.",
+		category: "dashboard"
+	}
+], de = [{
+	id: "model-intro",
+	title: "Community Models",
+	content: "Packages of data and metadata can be shared as community models. You can use this page to browse and import models. Models are open-source and community contributed.",
+	category: "community",
+	highlightDataTestId: "sidebar-icon-community-models"
+}, {
+	id: "feature-update",
+	title: "Sharing Dashboards!",
+	content: "Dashboard share links are a special URL that lets you share dashboards with others. It will automatically import the relevant model to support the dashboard. This will only work with public models though; not any that you have defined locally.",
+	category: "community",
+	highlightDataTestId: "copy-dashboard-share-button"
+}];
+//#endregion
+//#region projects/project.ts
+function fe() {
+	return `proj-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+var A = class e {
+	id;
+	name;
+	description;
+	dataConnectionId;
+	llmConnectionName;
+	editorIds;
+	subchatIds;
+	dashboardIds;
+	directoryPath;
+	promptOverrides;
+	createdAt;
+	updatedAt;
+	storage;
+	changed;
+	deleted;
+	constructor(e = {}) {
+		this.id = e.id || fe(), this.name = e.name || "Untitled project", this.description = e.description || "", this.dataConnectionId = e.dataConnectionId || "", this.llmConnectionName = e.llmConnectionName || "", this.editorIds = e.editorIds || [], this.subchatIds = e.subchatIds || [], this.dashboardIds = e.dashboardIds || [], this.directoryPath = e.directoryPath || "", this.promptOverrides = e.promptOverrides ? { ...e.promptOverrides } : {}, this.createdAt = e.createdAt || /* @__PURE__ */ new Date(), this.updatedAt = e.updatedAt || /* @__PURE__ */ new Date(), this.storage = e.storage || "local", this.changed = e.changed ?? !0, this.deleted = e.deleted ?? !1;
+	}
+	setName(e) {
+		this.name !== e && (this.name = e, this.touch());
+	}
+	setDescription(e) {
+		this.description !== e && (this.description = e, this.touch());
+	}
+	setDirectoryPath(e) {
+		this.directoryPath !== e && (this.directoryPath = e, this.touch());
+	}
+	setPromptOverride(e, t) {
+		let n = t?.trim() ?? "", r = this.promptOverrides[e];
+		if (n) {
+			if (r === n) return;
+			this.promptOverrides[e] = n;
+		} else {
+			if (r === void 0) return;
+			delete this.promptOverrides[e];
+		}
+		this.touch();
+	}
+	addSubchat(e) {
+		return !this.subchatIds.includes(e) && (this.subchatIds.push(e), this.touch(), !0);
+	}
+	removeSubchat(e) {
+		let t = this.subchatIds.indexOf(e);
+		return t !== -1 && (this.subchatIds.splice(t, 1), this.touch(), !0);
+	}
+	addEditor(e) {
+		return !this.editorIds.includes(e) && (this.editorIds.push(e), this.touch(), !0);
+	}
+	removeEditor(e) {
+		let t = this.editorIds.indexOf(e);
+		return t !== -1 && (this.editorIds.splice(t, 1), this.touch(), !0);
+	}
+	addDashboard(e) {
+		return !this.dashboardIds.includes(e) && (this.dashboardIds.push(e), this.touch(), !0);
+	}
+	removeDashboard(e) {
+		let t = this.dashboardIds.indexOf(e);
+		return t !== -1 && (this.dashboardIds.splice(t, 1), this.touch(), !0);
+	}
+	touch() {
+		this.updatedAt = /* @__PURE__ */ new Date(), this.changed = !0;
+	}
+	serialize() {
+		return {
+			id: this.id,
+			name: this.name,
+			description: this.description,
+			dataConnectionId: this.dataConnectionId,
+			llmConnectionName: this.llmConnectionName,
+			editorIds: this.editorIds,
+			subchatIds: this.subchatIds,
+			dashboardIds: this.dashboardIds,
+			directoryPath: this.directoryPath,
+			promptOverrides: { ...this.promptOverrides },
+			createdAt: this.createdAt.toISOString(),
+			updatedAt: this.updatedAt.toISOString(),
+			storage: this.storage
+		};
+	}
+	static fromSerialized(t) {
+		return new e({
+			...t,
+			createdAt: t.createdAt ? new Date(t.createdAt) : /* @__PURE__ */ new Date(),
+			updatedAt: t.updatedAt ? new Date(t.updatedAt) : /* @__PURE__ */ new Date(),
+			changed: !1
+		});
+	}
+}, j = (e) => {
+	let t = e.replace(/'''/g, "```").replace(/"""/g, "```").replace(/```(trilogy|sql|json)(\s|\n)/g, "```");
+	for (let e of ["```\\s*```", "```"]) {
+		let n = t.match(RegExp(`${e}([\\s\\S]*)${e}`, "s"));
+		if (n) return n[n.length - 1];
+	}
+	return e;
+}, pe = k("llmConnections", {
+	state: () => ({
+		connections: {},
+		activeConnection: ""
+	}),
+	actions: {
+		addConnection(e, t = !0) {
+			let n = e.name;
+			return this.activeConnection ||= n, t && Object.values(this.connections).filter((e) => e.isDefault).length === 0 && (e.isDefault = !0), this.connections[n] = e, e;
+		},
+		async resetConnection(e) {
+			if (this.connections[e]) return await this.connections[e].reset();
+			throw Error(`LLM connection with name "${e}" not found.`);
+		},
+		resetConnectionInBackground(e) {
+			this.resetConnection(e).catch(() => {});
+		},
+		connectionStateToStatus(e) {
+			if (!e) return "disabled";
+			let t = e;
+			return t.error ? "failed" : t.running ? "running" : t.connected ? "connected" : "disabled";
+		},
+		async newConnection(e, t, a) {
+			if (this.connections[e]) throw Error(`LLM connection with name "${e}" already exists.`);
+			let o;
+			if (t === "demo") o = new r(e, a.model);
+			else if (t === "anthropic") o = new l(e, a.apiKey, a.model, a.saveCredential);
+			else if (t === "openai") o = new i(e, a.apiKey, a.model, a.saveCredential);
+			else if (t === "google") o = new g(e, a.apiKey, a.model, a.saveCredential);
+			else if (t === "openrouter") o = new c(e, a.apiKey, a.model, a.saveCredential, void 0, {
+				httpReferer: a.httpReferer,
+				appTitle: a.appTitle
+			});
+			else if (t === "deepseek") o = new n(e, a.apiKey, a.model, a.saveCredential);
+			else throw Error(`LLM provider type "${t}" not found.`);
+			return this.addConnection(o), this.resetConnectionInBackground(e), o;
+		},
+		async fetchModelsForProvider(e, t) {
+			let r, a = `__temp_${e}_${Date.now()}`;
+			if (e === "anthropic") r = new l(a, t, "", !1);
+			else if (e === "openai") r = new i(a, t, "", !1);
+			else if (e === "google") r = new g(a, t, "", !1);
+			else if (e === "openrouter") r = new c(a, t, "", !1);
+			else if (e === "deepseek") r = new n(a, t, "", !1);
+			else throw Error(`LLM provider type "${e}" not found.`);
+			return await r.reset(), r.models;
+		},
+		async generateValidatedCompletion(e, t = null, n = 3, r = null, i = null, a = !0) {
+			let o = r || this.activeConnection || "", s = i || [];
+			if (o === "") throw Error("No active LLM connection");
+			let c = 0, l = !1, u = "", d = await this.generateCompletion(o, { prompt: e }, i);
+			if (a && s.push({
+				role: "user",
+				content: e
+			}), s.push({
+				role: "assistant",
+				content: d.text,
+				toolCalls: d.toolCalls
+			}), console.log("Initial LLM response:", d.text), u = j(d.text), t) for (; c < n && !l;) try {
+				if (!u || u.trim() == "") throw Error("Attempt to extract contents of triple backticks returned null or empty string");
+				l = await t(u), console.log("LLM response validation passed"), l = !0;
+			} catch (e) {
+				if (console.log("LLM response validation failed"), console.log(e), c++, c >= n) {
+					console.log(`Max attempts (${n}) reached, returning last response`);
+					break;
+				}
+				let t = e.message, r = `\nYou had given a response: """${u}""" that failed validation on this error: ${t}. Generate a new response that solves the original request while fixing the error. Ensure the new answer to validate is still enclosed within triple double quotes with no extra content. Put your reasoning on the fix before the quotes.`;
+				d = await this.generateCompletion(o, { prompt: r }, s), s.push({
+					role: "user",
+					content: r
+				}), s.push({
+					role: "assistant",
+					content: d.text,
+					toolCalls: d.toolCalls
+				}), u = j(d.text), console.log(`Attempt ${c}. New extract:`, u);
+			}
+			return console.log("Exiting validation loop with attempts:", c), console.log("Final LLM response:", u), {
+				success: l,
+				prompt: e,
+				message: d.text,
+				content: u,
+				attempts: c,
+				error: l ? null : "Validation failed after maximum attempts"
+			};
+		},
+		async generateDashboardCompletion(e, t = null, n = [], r = 3) {
+			let i = p(e, n);
+			return this.generateValidatedCompletion(i, t, r).then((e) => e.content);
+		},
+		async generateQueryCompletion(e, t, n = null, r = 3, i = null) {
+			let a = h(e, t);
+			return this.generateValidatedCompletion(a, n, r, i);
+		},
+		async generateSQLQueryCompletion(e) {
+			return this.generateCompletion(this.activeConnection, { prompt: e }).then((t) => ({
+				success: !0,
+				prompt: e,
+				message: t.text,
+				content: j(t.text),
+				attempts: 1
+			}));
+		},
+		async generateFilterQuery(e, t, n = null, r = 3) {
+			let i = u(e, t);
+			return this.generateValidatedCompletion(i, n, r).then((e) => e.content);
+		},
+		async generateChatName(e, t) {
+			let n = this.connections[e];
+			if (!n) throw Error(`LLM connection with name "${e}" not found.`);
+			let r = E(t), i = n.model, a = n.getFastModel();
+			try {
+				a !== i && (n.model = a);
+				let e = await n.generateCompletion({
+					prompt: r,
+					maxTokens: 50,
+					temperature: .7
+				}, null);
+				return se(e.text);
+			} finally {
+				a !== i && (n.model = i);
+			}
+		},
+		async generateCompletion(e, t, n = null) {
+			if (!this.connections[e]) throw Error(`LLM connection with name "${e}" not found.`);
+			return await this.connections[e].generateCompletion(t, n);
+		}
+	},
+	getters: {
+		connectionList: (e) => Object.keys(e.connections).map((t) => e.connections[t]),
+		unsavedConnections: (e) => Object.values(e.connections).filter((e) => e.changed).length,
+		getConnection: (e) => (t) => e.connections[t] || null,
+		getAllConnections: (e) => Object.values(e.connections),
+		getConnectionStatus: (e) => (t) => {
+			let n = e.connections[t];
+			if (!n) return "disabled";
+			let r = n;
+			return r.error ? "failed" : r.running ? "running" : r.connected ? "connected" : "disabled";
+		},
+		hasActiveDefaultConnection: (e) => Object.values(e.connections).some((e) => e.isDefault && e.connected)
+	}
+});
+//#endregion
+//#region dashboards/dashboardQueryExecutor.ts
+function me(e) {
+	return typeof e == "string" ? e : typeof e?.error == "string" && e.error ? e.error : typeof e?.message == "string" && e.message ? e.message : "Unknown error occurred";
+}
+var M = class {
+	queryQueue = /* @__PURE__ */ new Map();
+	activeQueries = /* @__PURE__ */ new Set();
+	queryWaiters = /* @__PURE__ */ new Map();
+	latestQueryByItemId = /* @__PURE__ */ new Map();
+	itemIdsByQueryId = /* @__PURE__ */ new Map();
+	queryExecutionService;
+	connectionName;
+	dashboardId;
+	getItemData;
+	setItemData;
+	getDashboardData;
+	maxConcurrentQueries;
+	retryAttempts;
+	batchDelay;
+	batchTimeout = null;
+	constructor(e, t, n, r, i, a, o = {}) {
+		this.queryExecutionService = e, this.connectionName = t, this.maxConcurrentQueries = o.maxConcurrentQueries || 10, this.retryAttempts = o.retryAttempts || 2, this.batchDelay = o.batchDelay || 0, this.dashboardId = n, this.getItemData = i, this.setItemData = a, this.getDashboardData = r;
+	}
+	cancelPendingQueriesForItem(e) {
+		let t = this.latestQueryByItemId.get(e), n = [];
+		this.queryQueue.forEach((r, i) => {
+			r.itemId === e && i !== t && n.push(i);
+		}), this.activeQueries.forEach((r) => {
+			let i = this.itemIdsByQueryId.get(r);
+			i?.has(e) && r !== t && ([...i].some((t) => t !== e && this.latestQueryByItemId.get(t) === r) || n.push(r));
+		}), n.forEach((t) => {
+			console.log(`Cancelling outdated query ${t} for itemId ${e}`), this.cancelQuery(t);
+		});
+	}
+	trackQueryForItem(e, t) {
+		this.latestQueryByItemId.set(e, t);
+		let n = this.itemIdsByQueryId.get(t);
+		n ? n.add(e) : this.itemIdsByQueryId.set(t, /* @__PURE__ */ new Set([e]));
+	}
+	isLatestQueryForItem(e, t) {
+		return this.latestQueryByItemId.get(e) === t;
+	}
+	isQueryInFlight(e) {
+		return this.queryQueue.has(e) || this.activeQueries.has(e);
+	}
+	settleQueryLoading(e) {
+		let t = this.itemIdsByQueryId.get(e);
+		if (t) for (let e of t) {
+			let t = this.latestQueryByItemId.get(e);
+			t && this.isQueryInFlight(t) || this.setItemData(e, this.dashboardId, { loading: !1 });
+		}
+	}
+	cleanupQueryTracking(e) {
+		let t = this.itemIdsByQueryId.get(e);
+		if (t) {
+			for (let n of t) this.latestQueryByItemId.get(n) === e && this.latestQueryByItemId.delete(n);
+			this.itemIdsByQueryId.delete(e);
+		}
+	}
+	getDefaultPriority(e) {
+		return this.getDashboardData(this.dashboardId).layout.find((t) => t.i === e)?.y || 0;
+	}
+	setConnection(e) {
+		this.connectionName = e;
+	}
+	getDashboardImports() {
+		return this.getDashboardData(this.dashboardId).imports.map((e) => ({
+			name: e.name,
+			alias: e.alias
+		}));
+	}
+	waitForQuery(e) {
+		return new Promise((t, n) => {
+			if (!this.queryQueue.has(e) && !this.activeQueries.has(e)) {
+				n(/* @__PURE__ */ Error(`Query ${e} not found or already completed`));
+				return;
+			}
+			this.queryWaiters.set(e, {
+				resolve: t,
+				reject: n
+			});
+		});
+	}
+	getItemQueryText(e) {
+		return (e.structured_content ? e.structured_content.query : e.content) || "";
+	}
+	enqueueItemQuery(e, t) {
+		let n = this.getItemData(e, this.dashboardId), r = this.getItemQueryText(n);
+		if (r.trim().length === 0) return this.setItemData(e, this.dashboardId, {
+			error: null,
+			loading: !1
+		}), null;
+		let i = n.filters || [], a = Object.assign({}, ...i.map((e) => e.parameters || {}));
+		this.setItemData(e, this.dashboardId, {
+			loading: !0,
+			error: null
+		});
+		let o, s = () => this.isLatestQueryForItem(e, o), c = {
+			dashboardId: this.dashboardId,
+			queryInput: {
+				text: r,
+				extraFilters: i.map((e) => e.value),
+				parameters: {
+					...n.parameters || {},
+					...a
+				},
+				extraContent: n.rootContent || []
+			},
+			priority: this.getDefaultPriority(e),
+			itemId: e,
+			onSuccess: (t) => {
+				s() ? this.setItemData(e, this.dashboardId, { results: t.results }) : console.log(`Ignoring outdated query result for itemId ${e}`);
+			},
+			onError: (t) => {
+				s() ? this.setItemData(e, this.dashboardId, { error: t }) : console.log(`Ignoring outdated query error for itemId ${e}`);
+			},
+			onProgress: (e) => {}
+		}, l = this.generateQueryId(c);
+		this.cancelPendingQueriesForItem(e);
+		let u = this.findDuplicateQuery(c);
+		if (u) console.log(`Deduplicating query for ${e}`), o = u.id, this.addCallbacksToExistingQuery(u, c);
+		else {
+			o = l;
+			let n = {
+				...c,
+				id: o,
+				timestamp: Date.now(),
+				retryCount: 0
+			};
+			this.queryQueue.set(o, n), t && this.activeQueries.size < this.maxConcurrentQueries && (console.log(`Executing query immediately for ${e}`), this.executeQuery(o));
+		}
+		return this.trackQueryForItem(e, o), o;
+	}
+	runSingle(e) {
+		return this.enqueueItemQuery(e, !0);
+	}
+	runBatch(e) {
+		this.batchTimeout && clearTimeout(this.batchTimeout);
+		let t = e.map((e) => this.enqueueItemQuery(e, !1)).filter((e) => e !== null);
+		return this.batchTimeout = setTimeout(() => {
+			this.processBatch();
+		}, this.batchDelay), t;
+	}
+	cancelQuery(e) {
+		let t = this.queryWaiters.get(e);
+		return t && (t.reject("Query was cancelled"), this.queryWaiters.delete(e)), this.cleanupQueryTracking(e), this.queryQueue.has(e) ? (this.queryQueue.delete(e), !0) : this.activeQueries.has(e) ? (this.activeQueries.delete(e), !0) : !1;
+	}
+	clearQueue() {
+		this.queryWaiters.forEach((e, t) => {
+			e.reject("Queue was cleared");
+		}), this.queryWaiters.clear(), this.queryQueue.clear(), this.latestQueryByItemId.clear(), this.itemIdsByQueryId.clear(), this.batchTimeout &&= (clearTimeout(this.batchTimeout), null);
+	}
+	getStatus() {
+		return {
+			queued: this.queryQueue.size,
+			active: this.activeQueries.size,
+			queuedQueries: Array.from(this.queryQueue.values()),
+			latestQueryByItemId: Object.fromEntries(this.latestQueryByItemId)
+		};
+	}
+	async createDrilldownQuery(e, t, n, r, i = [], a = this.getDashboardImports()) {
+		return await this.queryExecutionService.createConnectionDrilldownQuery(this.connectionName, e, "trilogy", a, t, n, r, i);
+	}
+	generateQueryId(e) {
+		return `${e.dashboardId}-${e.itemId}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+	}
+	findDuplicateQuery(e) {
+		for (let [, t] of this.queryQueue) if (t.dashboardId === e.dashboardId && t.queryInput.text === e.queryInput.text && JSON.stringify(t.queryInput.extraFilters) === JSON.stringify(e.queryInput.extraFilters) && JSON.stringify(t.queryInput.parameters) === JSON.stringify(e.queryInput.parameters)) return t;
+		return null;
+	}
+	addCallbacksToExistingQuery(e, t) {
+		let n = e.onSuccess, r = e.onError, i = e.onProgress;
+		e.onSuccess = (e) => {
+			n(e), t.onSuccess(e);
+		}, e.onError = (e) => {
+			r(e), t.onError(e);
+		}, e.onProgress = (e) => {
+			i(e), t.onProgress(e);
+		}, e.priority = Math.min(e.priority, t.priority);
+	}
+	processBatch() {
+		if (this.queryQueue.size === 0) return;
+		let e = Array.from(this.queryQueue.values()).sort((e, t) => e.priority === t.priority ? e.timestamp - t.timestamp : e.priority - t.priority), t = this.maxConcurrentQueries - this.activeQueries.size, n = e.slice(0, t);
+		this.executeBatchQueries(n);
+	}
+	async executeBatchQueries(e) {
+		if (e.length !== 0) try {
+			let t = this.getDashboardImports(), n = [], r = [];
+			for (let t of e) {
+				let e = t.id;
+				this.activeQueries.has(e) || this.queryQueue.has(e) && (this.queryQueue.delete(e), this.activeQueries.add(e), n.push({
+					query: t.queryInput.text,
+					label: e,
+					extra_filters: t.queryInput.extraFilters,
+					parameters: t.queryInput.parameters
+				}), r.push(t));
+			}
+			if (n.length === 0) return;
+			let i = Object.fromEntries(n.map((e) => [e.label, (t) => {
+				r.find((t) => t.id === e.label)?.onSuccess(t);
+				let n = this.queryWaiters.get(e.label);
+				n && (n.resolve(t), this.queryWaiters.delete(e.label)), this.activeQueries.delete(e.label), this.settleQueryLoading(e.label), this.cleanupQueryTracking(e.label);
+			}])), a = Object.fromEntries(n.map((e) => [e.label, (t) => {
+				let n = me(t), i = r.find((t) => t.id === e.label);
+				i && this.handleQueryError(i, n), this.activeQueries.delete(e.label), this.settleQueryLoading(e.label), this.cleanupQueryTracking(e.label);
+			}])), { resultPromise: o } = await this.queryExecutionService.executeQueriesBatch(this.connectionName, n, "trilogy", t, [], {}, () => {}, () => {}, a, i, !1, r[0]?.queryInput.extraContent || []), s = await o;
+			console.log(`Batch query executed successfully with ${s.results.length} results`);
+		} catch (t) {
+			let n = t instanceof Error ? t.message : "Unknown error occurred";
+			for (let t of e) {
+				let e = t.id;
+				this.activeQueries.has(e) && (t.retryCount < this.retryAttempts ? (console.log(`Retrying query ${e} (attempt ${t.retryCount + 1})`), t.retryCount++, t.timestamp = Date.now(), this.activeQueries.delete(e), this.queryQueue.set(e, t), setTimeout(() => {
+					this.queryQueue.has(e) && this.executeQuery(e);
+				}, 1e3 * t.retryCount)) : (this.handleQueryError(t, n), this.activeQueries.delete(e), this.settleQueryLoading(e), this.cleanupQueryTracking(e)));
+			}
+		} finally {
+			this.processBatch();
+		}
+	}
+	handleQueryError(e, t) {
+		let n = e.id;
+		e.onError(t);
+		let r = this.queryWaiters.get(n);
+		r && (r.reject(t), this.queryWaiters.delete(n));
+	}
+	async executeQuery(e) {
+		let t = this.queryQueue.get(e);
+		if (t) try {
+			this.queryQueue.delete(e), this.activeQueries.add(e);
+			let n = this.getDashboardImports(), r = {
+				...t.queryInput,
+				imports: n,
+				editorType: "trilogy"
+			}, { resultPromise: i } = await this.queryExecutionService.executeQuery(this.connectionName, r, () => {}, (e) => {
+				e.error && t.onProgress(e);
+			}), a = await i;
+			if (a.success && a.results) {
+				t.onSuccess(a);
+				let n = this.queryWaiters.get(e);
+				n && (n.resolve(a), this.queryWaiters.delete(e));
+			} else if (a.error) {
+				t.onError(a.error);
+				let n = this.queryWaiters.get(e);
+				n && (n.reject(a.error), this.queryWaiters.delete(e));
+			}
+		} catch (n) {
+			let r = n instanceof Error ? n.message : "Unknown error occurred";
+			if (t.retryCount < this.retryAttempts) console.log(`Retrying query ${e} (attempt ${t.retryCount + 1})`), t.retryCount++, t.timestamp = Date.now(), this.queryQueue.set(e, t), setTimeout(() => {
+				this.queryQueue.has(e) && this.executeQuery(e);
+			}, 1e3 * t.retryCount);
+			else {
+				t.onError(r);
+				let n = this.queryWaiters.get(e);
+				n && (n.reject(r), this.queryWaiters.delete(e));
+			}
+		} finally {
+			this.activeQueries.delete(e), this.settleQueryLoading(e), this.cleanupQueryTracking(e), this.processBatch();
+		}
+	}
+}, N = (e) => e.replace(/\s+/g, "");
+function P(e) {
+	if (!e) return;
+	let t = te();
+	return t.connections[e] || t.connectionByName(e);
+}
+var F = k("dashboards", {
+	state: () => ({
+		dashboards: {},
+		activeDashboardId: "",
+		queryExecutors: {},
+		pendingChatPrompts: {}
+	}),
+	getters: {
+		dashboardList: (e) => Object.values(e.dashboards),
+		activeDashboard: (e) => e.activeDashboardId ? e.dashboards[e.activeDashboardId] : null,
+		getConnectionDashboards: (e) => (t) => Object.values(e.dashboards).filter((e) => e.connectionId === t),
+		unsavedDashboards: (e) => Object.values(e.dashboards).filter((e) => e.changed).length,
+		activeQueryExecutor: (e) => e.activeDashboardId ? e.queryExecutors[e.activeDashboardId] : null,
+		hasQueryExecutor: (e) => (t) => !!e.queryExecutors[t]
+	},
+	actions: {
+		getOrCreateQueryExecutor(e, t) {
+			if (!this.dashboards[e]) throw Error(`Dashboard with ID "${e}" not found.`);
+			if (this.queryExecutors[e]) {
+				let n = this.queryExecutors[e];
+				return t.connectionName && n.connectionName !== t.connectionName && n.setConnection(t.connectionName), n;
+			}
+			let n = new M(t.queryExecutionService, t.connectionName, t.dashboardId, t.getDashboardData, t.getItemData, t.setItemData, t.options || {});
+			return this.queryExecutors[e] = n, console.log(`Created new query executor for dashboard: ${e}`), n;
+		},
+		getQueryExecutor(e) {
+			return this.queryExecutors[e] || null;
+		},
+		removeQueryExecutor(e) {
+			return this.queryExecutors[e] ? (this.queryExecutors[e].clearQueue(), delete this.queryExecutors[e], console.log(`Removed query executor for dashboard: ${e}`), !0) : !1;
+		},
+		clearAllQueryExecutors() {
+			Object.keys(this.queryExecutors).forEach((e) => {
+				this.queryExecutors[e].clearQueue();
+			}), this.queryExecutors = {}, console.log("Cleared all query executors");
+		},
+		getQueryExecutorStatuses() {
+			let e = {};
+			return Object.entries(this.queryExecutors).forEach(([t, n]) => {
+				e[t] = {
+					dashboardName: this.dashboards[t]?.name || "Unknown",
+					...n.getStatus()
+				};
+			}), e;
+		},
+		getDashboardByName(e) {
+			return Object.values(this.dashboards).find((t) => t.name === e) || null;
+		},
+		newDashboard(e, t) {
+			let n = e;
+			if (Object.values(this.dashboards).some((t) => t.name === e)) throw Error(`A dashboard with name ${e} already exists.`);
+			let r = P(t), i = new s({
+				id: n,
+				name: e,
+				connection: r?.name || t,
+				connectionId: r?.id || t,
+				storage: "local",
+				state: "editing"
+			});
+			return this.dashboards[n] = i, i;
+		},
+		newReport(e, t) {
+			let n = this.newDashboard(e, t);
+			return n.setLayoutType("report"), n;
+		},
+		cloneDashboard(e) {
+			let t = this.dashboards[e];
+			if (!t) throw Error(`Dashboard with ID "${e}" not found.`);
+			let n = `${t.name} (copy)`, r = 1;
+			for (; Object.values(this.dashboards).some((e) => e.name === n);) n = `${t.name} (copy ${r})`, r++;
+			let i = new s({
+				id: n,
+				name: n,
+				connection: t.connection,
+				connectionId: t.connectionId,
+				storage: t.storage,
+				state: "editing"
+			});
+			return i.gridItems = Object.fromEntries(Object.entries(t.gridItems).map(([e, t]) => [e, {
+				...t,
+				chartFilters: [],
+				conceptFilters: [],
+				filters: []
+			}])), i.layout = t.layout.map((e) => ({ ...e })), i.imports = t.imports.map((e) => ({ ...e })), i.filter = t.filter, i.description = t.description, i.updatedAt = /* @__PURE__ */ new Date(), i.nextId = t.nextId, i.changed = !0, this.addDashboard(i), this.activeDashboardId = n, i;
+		},
+		forkDashboard(e, t) {
+			let n = this.dashboards[e];
+			if (!n) throw Error(`Dashboard with ID "${e}" not found.`);
+			let r = `${n.name} / ${t}`, i = 1;
+			for (; this.dashboards[r];) r = `${n.name} / ${t} (${i})`, i++;
+			let a = new s({
+				id: r,
+				name: r,
+				connection: n.connection,
+				connectionId: n.connectionId,
+				storage: n.storage,
+				state: "editing",
+				parentDashboardId: e,
+				investigationName: t,
+				investigationCreatedFrom: { timestamp: /* @__PURE__ */ new Date() },
+				description: n.description
+			});
+			return a.gridItems = Object.fromEntries(Object.entries(n.gridItems).map(([e, t]) => [e, {
+				...t,
+				chartFilters: [],
+				conceptFilters: [],
+				filters: []
+			}])), a.layout = n.layout.map((e) => ({ ...e })), a.imports = n.imports.map((e) => ({ ...e })), a.filter = n.filter, a.nextId = n.nextId, a.changed = !0, n.children ||= [], n.children.push(r), n.changed = !0, this.addDashboard(a), this.activeDashboardId = r, a;
+		},
+		promoteDashboard(e) {
+			let t = this.dashboards[e];
+			if (!t) throw Error(`Dashboard with ID "${e}" not found.`);
+			if (t.parentDashboardId) {
+				let n = this.dashboards[t.parentDashboardId];
+				n?.children && (n.children = n.children.filter((t) => t !== e), n.changed = !0);
+			}
+			return t.parentDashboardId = null, t.investigationName = void 0, t.investigationCreatedFrom = void 0, t.changed = !0, t;
+		},
+		getInvestigations(e) {
+			return Object.values(this.dashboards).filter((t) => t.parentDashboardId === e && !t.deleted);
+		},
+		getRootDashboards() {
+			return Object.values(this.dashboards).filter((e) => !e.parentDashboardId && !e.deleted);
+		},
+		addDashboard(e) {
+			this.dashboards[e.id] = e;
+		},
+		loadDashboards(e) {
+			Object.entries(e).forEach(([e, t]) => {
+				this.dashboards[e] = s.fromSerialized(t);
+			});
+		},
+		removeAllFilters(e) {
+			if (this.dashboards[e]) return this.dashboards[e].removeAllFilters();
+			throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		getConnectionDashboardsSync(e) {
+			return Object.values(this.dashboards).filter((t) => t.connectionId === e);
+		},
+		setPendingChatPrompt(e, t) {
+			this.pendingChatPrompts[e] = t;
+		},
+		consumePendingChatPrompt(e) {
+			let t = this.pendingChatPrompts[e];
+			return t === void 0 ? null : (delete this.pendingChatPrompts[e], t);
+		},
+		setActiveDashboard(e) {
+			if (this.dashboards[e]) this.activeDashboardId = e;
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		setDashboardState(e, t) {
+			if (this.dashboards[e]) this.dashboards[e].state = t;
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateDashboardName(e, t) {
+			if (this.dashboards[e]) this.dashboards[e].name = t, this.dashboards[e].updatedAt = /* @__PURE__ */ new Date();
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateDashboardFilter(e, t) {
+			if (this.dashboards[e]) {
+				let n = this.dashboards[e].filter;
+				return (!t || N(t) === "") && (this.dashboards[e].filter = null, n != null) || (this.dashboards[e].filter = t, n !== t) ? Object.entries(this.dashboards[e].gridItems).map(([e, t]) => e) : [];
+			}
+			throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateDashboardImports(e, t) {
+			if (this.dashboards[e]) this.dashboards[e].imports = t;
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		removeDashboard(e) {
+			if (this.dashboards[e]) this.removeQueryExecutor(e), delete this.dashboards[e], this.activeDashboardId === e && (this.activeDashboardId = "");
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		purgeDeletedDashboards() {
+			for (let e of Object.keys(this.dashboards)) this.dashboards[e].deleted && (this.removeQueryExecutor(e), delete this.dashboards[e], this.activeDashboardId === e && (this.activeDashboardId = ""));
+		},
+		setState(e, t) {
+			this.dashboards[e] && (this.dashboards[e].state = t);
+		},
+		setDashboardLayoutType(e, t) {
+			let n = this.dashboards[e];
+			if (!n) throw Error(`Dashboard with ID "${e}" not found.`);
+			n.setLayoutType(t);
+		},
+		setDashboardTheme(e, t) {
+			let n = this.dashboards[e];
+			if (!n) throw Error(`Dashboard with ID "${e}" not found.`);
+			n.setTheme(t);
+		},
+		addItemToDashboard(e, t, n = 0, r = 0, i = 5, a = null, o = null, s = null) {
+			if (this.dashboards[e]) return this.dashboards[e].addItem(t, n, r, i, a, o, s);
+			throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateDashboardTitle(e, t) {
+			if (this.dashboards[e]) this.dashboards[e].name = t, this.dashboards[e].updatedAt = /* @__PURE__ */ new Date();
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateItemContent(e, t, n) {
+			if (this.dashboards[e]) this.dashboards[e].updateItemContent(t, n);
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateItemCrossFilterEligibility(e, t, n) {
+			if (this.dashboards[e]) this.dashboards[e].updateItemCrossFilterEligibility(t, n);
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateItemResults(e, t, n) {
+			if (this.dashboards[e]) this.dashboards[e].updateItemResults(t, n);
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateItemLoading(e, t, n) {
+			if (this.dashboards[e]) this.dashboards[e].updateItemLoading(t, n);
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateItemError(e, t, n) {
+			if (this.dashboards[e]) this.dashboards[e].updateItemError(t, n);
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateItemDrilldown(e, t, n) {
+			if (this.dashboards[e]) this.dashboards[e].updateItemDrilldown(t, n);
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateItemDrilldownChartConfig(e, t, n) {
+			if (this.dashboards[e]) this.dashboards[e].updateItemDrilldownChartConfig(t, n);
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateItemType(e, t, n) {
+			if (this.dashboards[e]) this.dashboards[e].updateItemType(t, n);
+			else throw Error(`Dashboard with ID "${e} not found`);
+		},
+		updateItemCrossFilters(e, t, n, r, i) {
+			if (this.dashboards[e]) return this.dashboards[e].updateItemCrossFilters(t, n, r, i);
+			throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		removeItemCrossFilter(e, t, n) {
+			if (this.dashboards[e]) return this.dashboards[e].removeItemCrossFilter(t, n), t;
+			throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		removeItemCrossFilterSource(e, t) {
+			if (this.dashboards[e]) return this.dashboards[e].removeItemCrossFilterSource(t);
+			throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateItemName(e, t, n) {
+			if (this.dashboards[e]) this.dashboards[e].updateItemName(t, n);
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateItemChartConfig(e, t, n) {
+			if (this.dashboards[e]) this.dashboards[e].updateItemChartConfig(t, n);
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateMultipleItemProperties(e, t, n) {
+			if (!this.dashboards[e]) throw Error(`Dashboard with ID "${e}" not found.`);
+			this.dashboards[e].updateItemMultipleProperties(t, n);
+		},
+		updateDashboardConnection(e, t) {
+			if (this.dashboards[e]) {
+				let n = P(t);
+				this.dashboards[e].connection = n?.name || t, this.dashboards[e].connectionId = n?.id || t, this.dashboards[e].changed = !0;
+			} else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateDashboardDescription(e, t) {
+			if (this.dashboards[e]) this.dashboards[e].description = t;
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateDashboardLayout(e, t) {
+			if (this.dashboards[e]) this.dashboards[e].updateLayout(t);
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateItemDimensions(e, t, n, r) {
+			if (this.dashboards[e]) this.dashboards[e].updateItemDimensions(t, n, r);
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		updateItemLayoutDimensions(e, t, n = null, r = null, i = null, a = null) {
+			if (this.dashboards[e]) this.dashboards[e].updateItemLayoutDimensions(t, n, r, i, a);
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		removeItemFromDashboard(e, t) {
+			if (this.dashboards[e]) this.dashboards[e].removeItem(t);
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		copyItemInDashboard(e, t) {
+			if (this.dashboards[e]) return this.dashboards[e].copyItem(t);
+			throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		clearDashboardItems(e) {
+			if (this.dashboards[e]) this.dashboards[e].clearItems();
+			else throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		serializeDashboards() {
+			let e = {};
+			return Object.entries(this.dashboards).forEach(([t, n]) => {
+				n.storage === "local" && (e[t] = n.serialize());
+			}), e;
+		},
+		async warmDashboardQueries(e, t, n) {
+			let r = this.dashboards[e];
+			if (r) {
+				for (let e of Object.values(r.gridItems)) if (e.type === a.CHART || e.type === a.TABLE) {
+					let i = typeof e.content == "string" ? e.content : e.content?.query || "";
+					await t?.generateQuery(r.connectionId || r.connection, {
+						text: i,
+						editorType: "trilogy",
+						imports: r.imports,
+						extraContent: r.imports.map((e) => ({
+							alias: e.name,
+							contents: n.editors[e.id]?.contents || n.editors[e.name]?.contents || ""
+						}))
+					});
+				}
+			}
+		},
+		async populateCompletion(e, t, n) {
+			let r = this.dashboards[e];
+			if (r) {
+				let i = await t?.validateQuery(r.connectionId || r.connection, {
+					text: "select 1 as test;",
+					editorType: "trilogy",
+					imports: r.imports,
+					extraContent: r.imports.map((e) => ({
+						alias: e.name,
+						contents: n.editors[e.id]?.contents || n.editors[e.name]?.contents || ""
+					}))
+				});
+				return i ? i.data.completion_items : (console.log(`No results returned from validateQuery for dashboard ID "${e}".`), []);
+			}
+			throw Error(`Dashboard with ID "${e}" not found.`);
+		},
+		async populateAIConcepts(e, t, n) {
+			let r = await this.populateCompletion(e, t, n);
+			if (!r) throw Error(`No completion items found for dashboard ID "${e}".`);
+			return m(r);
+		},
+		async generatePromptSpec(e, t, n, r) {
+			let i = await this.populateAIConcepts(this.activeDashboardId, n, r), a = await t.generateDashboardCompletion(e, d, i, 3);
+			if (!a) throw Error("No response from LLM");
+			return d(a);
+		},
+		async populateFromPromptSpec(e, t, n, r, i) {
+			let o = this.dashboards[e];
+			if (!o) throw Error(`Dashboard with ID "${e}" not found.`);
+			o.name = t.name, o.description = t.description;
+			let s = await this.populateAIConcepts(e, r, i);
+			if (!s) throw Error(`No completion items found for dashboard ID "${e}".`);
+			let c = async (e) => {
+				let t = {
+					text: e,
+					editorType: "trilogy",
+					imports: o.imports,
+					extraContent: o.imports.map((e) => ({
+						alias: e.name,
+						contents: i.editors[e.id]?.contents || i.editors[e.name]?.contents || ""
+					}))
+				};
+				return await (await r.executeQuery(o.connectionId || o.connection, t, () => {}, () => {}, (e) => {
+					throw e;
+				}, () => !0, !0)).resultPromise, !0;
+			}, l = /* @__PURE__ */ new Map();
+			for (let n of t.layout) {
+				let r = t.gridItems[n.id], i = r.content, o = r.type.toLowerCase();
+				[a.CHART, a.TABLE].includes(o) && (i = `Placeholder, prompt: ${i}`);
+				let s = this.addItemToDashboard(e, "markdown", n.x, n.y, n.w, n.h, i, r.name);
+				l.set(s, {
+					type: o,
+					content: i
+				});
+			}
+			for (let t of l) {
+				let r = t[0], i = t[1], o = i.content;
+				[a.CHART, a.TABLE].includes(i.type) && (o = (await n.generateQueryCompletion(i.content, s, c)).content || "No query could be generated"), await this.updateItemContent(e, r, o), await this.updateItemType(e, r, i.type);
+			}
+		}
+	}
+}), I = /* @__PURE__ */ new Map(), L = "trilogy-jobs-api-state", R = (e, t, n) => `${e}::${n}::${t}`, z = (e, t) => `${e}::${t}`, he = (e) => {
+	let t = e.pollingState, n = t === "unable-to-fetch" ? "stopped" : e.pollingState ?? "ok";
+	return {
+		...e,
+		pollingState: n,
+		pollingError: n === "stopped" && !e.pollingError && t === "unable-to-fetch" ? "Polling stopped locally." : e.pollingError ?? null
+	};
+}, ge = (e) => {
+	let t = e instanceof Error ? e.message : "Failed to fetch state";
+	return e instanceof S ? e.status === 401 ? "Authentication required. Set this store’s token to read state." : e.status === 400 && /directory/i.test(t) ? `${t} Directory state requires a Trilogy server on 0.3.306 or newer.` : t : t;
+}, B = (e) => [...e].sort((e, t) => t.submittedAt - e.submittedAt), _e = k("jobsApi", {
+	state: () => ({
+		filesByStore: {},
+		jobsByStore: {},
+		errors: {},
+		storeStatus: {},
+		loadingByStore: {},
+		submittingByTarget: {},
+		pollingByJob: {},
+		stoppingByJob: {},
+		stateByTarget: {},
+		stateLoadingByTarget: {},
+		stateErrorsByTarget: {}
+	}),
+	actions: {
+		getGenericStore(e) {
+			let t = _().stores.find((t) => t.id === e);
+			return !t || t.type !== "generic" ? null : t;
+		},
+		getGenericStores() {
+			return _().stores.filter((e) => e.type === "generic");
+		},
+		getStoreJobs(e) {
+			return B(this.jobsByStore[e] || []);
+		},
+		getJobsForTarget(e, t) {
+			return this.getStoreJobs(e).filter((e) => e.target === t);
+		},
+		getStoreStatus(e) {
+			return (this.jobsByStore[e] || []).some((e) => e.status === "running" && (e.pollingState ?? "ok") === "ok") ? "running" : this.storeStatus[e] || "idle";
+		},
+		isSubmitting(e, t, n) {
+			return !!this.submittingByTarget[R(e, t, n)];
+		},
+		getState(e, t) {
+			return this.stateByTarget[T(e, t)]?.snapshot || null;
+		},
+		getStateMeta(e, t) {
+			let n = this.stateByTarget[T(e, t)];
+			return n ? {
+				cached: n.cached,
+				computedAt: n.computedAt
+			} : null;
+		},
+		isStateLoading(e, t) {
+			return !!this.stateLoadingByTarget[T(e, t)];
+		},
+		getStateError(e, t) {
+			return this.stateErrorsByTarget[T(e, t)] || "";
+		},
+		isPollingJob(e, t) {
+			return !!this.pollingByJob[z(e, t)];
+		},
+		isStoppingJob(e, t) {
+			return !!this.stoppingByJob[z(e, t)];
+		},
+		clearStoreError(e) {
+			delete this.errors[e], this.storeStatus[e] = "idle";
+		},
+		clearStoreData(e) {
+			Array.from(I.keys()).filter((t) => t.startsWith(`${e}:`)).forEach((e) => {
+				let t = I.get(e);
+				t && clearInterval(t), I.delete(e);
+			}), delete this.filesByStore[e], delete this.jobsByStore[e], delete this.errors[e], delete this.storeStatus[e], delete this.loadingByStore[e], this.clearStateForStore(e), this.saveJobsToStorage();
+		},
+		clearStateForStore(e) {
+			let t = (t) => y(t)?.storeId === e, n = (e) => {
+				Object.keys(e).filter(t).forEach((t) => delete e[t]);
+			};
+			n(this.stateByTarget), n(this.stateLoadingByTarget), n(this.stateErrorsByTarget);
+		},
+		clearStateError(e, t) {
+			delete this.stateErrorsByTarget[T(e, t)];
+		},
+		refreshLoadedStateForTarget(e, t) {
+			Object.keys(this.stateByTarget).forEach((n) => {
+				let r = y(n);
+				r && r.storeId === e && re(r.target, t) && this.fetchStateForTarget(e, r.target);
+			});
+		},
+		async fetchStateForTarget(e, t, n = !1) {
+			let r = this.getGenericStore(e);
+			if (!r) return;
+			let i = T(e, t);
+			if (!this.stateLoadingByTarget[i]) {
+				this.stateLoadingByTarget[i] = !0, delete this.stateErrorsByTarget[i];
+				try {
+					let e = await x(r, t, n);
+					this.stateByTarget[i] = {
+						snapshot: e.snapshot,
+						cached: e.cached,
+						computedAt: e.computedAt
+					};
+				} catch (e) {
+					this.stateErrorsByTarget[i] = ge(e);
+				} finally {
+					delete this.stateLoadingByTarget[i];
+				}
+			}
+		},
+		async initialize() {
+			_().loadStoresFromStorage(), this.loadJobsFromStorage(), this.resumePolling(), await this.refreshAllStores();
+		},
+		saveJobsToStorage() {
+			try {
+				localStorage.setItem(L, JSON.stringify(this.jobsByStore));
+			} catch (e) {
+				console.error("Error saving jobs to localStorage:", e);
+			}
+		},
+		loadJobsFromStorage() {
+			try {
+				let e = localStorage.getItem(L);
+				if (!e) return;
+				let t = JSON.parse(e);
+				this.jobsByStore = Object.fromEntries(Object.entries(t).map(([e, t]) => [e, (t || []).map((e) => he(e))]));
+			} catch (e) {
+				console.error("Error loading jobs from localStorage:", e);
+			}
+		},
+		resumePolling() {
+			Object.entries(this.jobsByStore).forEach(([e, t]) => {
+				t.forEach((t) => {
+					t.status === "running" && (t.pollingState ?? "ok") === "ok" && this.startPolling(e, t.job_id);
+				});
+			});
+		},
+		async resumeAuthPausedJobs(e) {
+			let t = (this.jobsByStore[e] || []).filter((e) => e.status === "running" && e.pollingState === "auth-paused");
+			await Promise.all(t.map(async (t) => {
+				let n = {
+					...t,
+					updatedAt: Date.now(),
+					pollingState: "ok",
+					pollingError: null
+				};
+				this.upsertJob(e, n), this.startPolling(e, t.job_id), await this.pollJob(e, t.job_id);
+			}));
+		},
+		async refreshAllStores() {
+			let e = this.getGenericStores();
+			await Promise.all(e.map((e) => this.fetchFilesForStore(e.id)));
+		},
+		async fetchFilesForStore(e) {
+			let t = this.getGenericStore(e);
+			if (t) {
+				this.loadingByStore[e] = !0, this.storeStatus[e] = "idle";
+				try {
+					this.filesByStore[e] = await v(t), delete this.errors[e], this.storeStatus[e] = "connected";
+				} catch (t) {
+					let n = t instanceof Error ? t.message : "Failed to fetch files";
+					this.errors[e] = n, this.storeStatus[e] = "failed";
+				} finally {
+					this.loadingByStore[e] = !1;
+				}
+			}
+		},
+		upsertJob(e, t) {
+			let n = this.jobsByStore[e] || [], r = n.findIndex((e) => e.job_id === t.job_id);
+			if (r === -1) {
+				this.jobsByStore[e] = B([t, ...n]), this.saveJobsToStorage();
+				return;
+			}
+			let i = [...n];
+			i[r] = {
+				...i[r],
+				...t
+			}, this.jobsByStore[e] = B(i), this.saveJobsToStorage();
+		},
+		replaceJobs(e, t) {
+			this.jobsByStore[e] = B(t), this.saveJobsToStorage();
+		},
+		removeJob(e, t) {
+			this.stopPolling(e, t), delete this.pollingByJob[z(e, t)], delete this.stoppingByJob[z(e, t)], this.jobsByStore[e] = (this.jobsByStore[e] || []).filter((e) => e.job_id !== t), this.saveJobsToStorage();
+		},
+		stopPolling(e, t) {
+			let n = `${e}:${t}`, r = I.get(n);
+			r && (clearInterval(r), I.delete(n));
+		},
+		pauseJobPolling(e, t, n, r) {
+			let i = (this.jobsByStore[e] || []).find((e) => e.job_id === t);
+			if (!i) {
+				this.stopPolling(e, t);
+				return;
+			}
+			this.stopPolling(e, t);
+			let a = {
+				...i,
+				updatedAt: Date.now(),
+				pollingState: n,
+				pollingError: r
+			};
+			this.upsertJob(e, a);
+		},
+		startPolling(e, t) {
+			this.stopPolling(e, t);
+			let n = `${e}:${t}`, r = setInterval(() => {
+				this.pollJob(e, t);
+			}, 1e3);
+			I.set(n, r);
+		},
+		buildLocalJob(e, t, n, r, i) {
+			let a = Date.now();
+			return {
+				...r,
+				storeId: e,
+				target: t,
+				operation: n,
+				submittedAt: i || a,
+				updatedAt: a,
+				pollingState: "ok",
+				pollingError: null
+			};
+		},
+		async submitJob(e, t, n) {
+			let r = this.getGenericStore(e);
+			if (!r) throw Error("Store not found or does not support jobs");
+			let i = R(e, t, n);
+			this.submittingByTarget[i] = !0;
+			try {
+				let i = await ee(r, n, t), a = this.buildLocalJob(e, t, n, i);
+				return this.upsertJob(e, a), delete this.errors[e], this.storeStatus[e] = "connected", a.status === "running" && this.startPolling(e, a.job_id), a;
+			} catch (r) {
+				let i = r instanceof Error ? r.message : `Failed to ${n} ${t}`;
+				throw this.errors[e] = i, this.storeStatus[e] = "failed", r;
+			} finally {
+				delete this.submittingByTarget[i];
+			}
+		},
+		async pollJob(e, t) {
+			let n = z(e, t);
+			if (this.pollingByJob[n]) return;
+			this.pollingByJob[n] = !0;
+			let r = this.getGenericStore(e), i = (this.jobsByStore[e] || []).find((e) => e.job_id === t);
+			if (!r || !i) {
+				this.stopPolling(e, t), delete this.pollingByJob[n];
+				return;
+			}
+			try {
+				let n = await b(r, t), a = this.buildLocalJob(e, i.target, i.operation, n, i.submittedAt);
+				this.upsertJob(e, a), a.status !== "running" && (this.stopPolling(e, t), this.fetchFilesForStore(e), this.refreshLoadedStateForTarget(e, a.target));
+			} catch (n) {
+				let r = n instanceof Error ? n.message : `Failed to poll job ${t}`;
+				n instanceof S && n.status === 401 ? this.pauseJobPolling(e, t, "auth-paused", "Polling paused: authentication required. Update the store token to resume tracking.") : n instanceof S && n.status === 404 ? this.pauseJobPolling(e, t, "not-found", "Polling stopped: job was not found on the server.") : this.pauseJobPolling(e, t, "stopped", `Polling stopped locally. ${r}`);
+			} finally {
+				delete this.pollingByJob[n];
+			}
+		},
+		async stopJob(e, t) {
+			let n = z(e, t);
+			if (this.stoppingByJob[n]) return;
+			let r = this.getGenericStore(e), i = (this.jobsByStore[e] || []).find((e) => e.job_id === t);
+			if (!r || !i) {
+				this.stopPolling(e, t);
+				return;
+			}
+			this.stoppingByJob[n] = !0, this.stopPolling(e, t), delete this.pollingByJob[n];
+			try {
+				let n = await C(r, t), a = this.buildLocalJob(e, i.target, i.operation, n, i.submittedAt);
+				a.status === "running" && (a.pollingState = "stopped", a.pollingError = "Cancel requested. Polling stopped locally."), this.upsertJob(e, a);
+			} catch (n) {
+				let r = n instanceof Error ? n.message : `Failed to cancel job ${t}`, a = {
+					...i,
+					updatedAt: Date.now(),
+					pollingState: "stopped",
+					pollingError: `Stopped polling locally. ${r}`
+				};
+				this.upsertJob(e, a);
+			} finally {
+				delete this.stoppingByJob[n];
+			}
+		}
+	}
+}), ve = k("projects", {
+	state: () => ({
+		projects: {},
+		activeProjectId: ""
+	}),
+	getters: {
+		projectList: (e) => Object.values(e.projects).filter((e) => !e.deleted),
+		unsavedProjects: (e) => Object.values(e.projects).filter((e) => e.changed && !e.deleted).length,
+		activeProject: (e) => e.activeProjectId && e.projects[e.activeProjectId] || null,
+		getProjectById: (e) => (t) => e.projects[t] || null
+	},
+	actions: {
+		newProject(e, t = "") {
+			let n = new A({
+				name: e || `Project ${(/* @__PURE__ */ new Date()).toLocaleDateString()}`,
+				description: t
+			});
+			return this.projects[n.id] = n, this.activeProjectId = n.id, n;
+		},
+		addProject(e) {
+			this.projects[e.id] = e;
+		},
+		removeProject(e) {
+			let t = this.projects[e];
+			t && (t.deleted = !0, t.changed = !0, this.activeProjectId === e && (this.activeProjectId = ""));
+		},
+		setActiveProject(e) {
+			this.projects[e] && !this.projects[e].deleted && (this.activeProjectId = e);
+		},
+		clearActiveProject() {
+			this.activeProjectId = "";
+		},
+		renameProject(e, t) {
+			this.projects[e]?.setName(t);
+		},
+		setProjectDescription(e, t) {
+			this.projects[e]?.setDescription(t);
+		},
+		setProjectDataConnection(e, t) {
+			let n = this.projects[e];
+			n && n.dataConnectionId !== t && (n.dataConnectionId = t, n.updatedAt = /* @__PURE__ */ new Date(), n.changed = !0);
+		},
+		setProjectLLMConnection(e, t) {
+			let n = this.projects[e];
+			n && n.llmConnectionName !== t && (n.llmConnectionName = t, n.updatedAt = /* @__PURE__ */ new Date(), n.changed = !0);
+		},
+		setProjectDirectory(e, t) {
+			this.projects[e]?.setDirectoryPath(t);
+		},
+		addSubchatToProject(e, t) {
+			return this.projects[e]?.addSubchat(t) ?? !1;
+		},
+		removeSubchatFromProject(e, t) {
+			return this.projects[e]?.removeSubchat(t) ?? !1;
+		},
+		addEditorToProject(e, t) {
+			return this.projects[e]?.addEditor(t) ?? !1;
+		},
+		removeEditorFromProject(e, t) {
+			return this.projects[e]?.removeEditor(t) ?? !1;
+		},
+		addDashboardToProject(e, t) {
+			return this.projects[e]?.addDashboard(t) ?? !1;
+		},
+		removeDashboardFromProject(e, t) {
+			return this.projects[e]?.removeDashboard(t) ?? !1;
+		},
+		setProjectPromptOverride(e, t, n) {
+			this.projects[e]?.setPromptOverride(t, n);
+		},
+		setProjects(e) {
+			if (this.projects = e, !this.activeProjectId) {
+				let t = Object.values(e).find((e) => !e.deleted);
+				t && (this.activeProjectId = t.id);
+			}
+		}
+	}
+}), V = {
+	SCREEN: "screen",
+	SIDEBAR_SCREEN: "sidebarScreen",
+	EDITORS: "editors",
+	DASHBOARD: "dashboard",
+	CONNECTIONS: "connections",
+	LLMS: "llms",
+	TUTORIAL: "tutorial",
+	MODELS: "models",
+	JOBS: "jobs",
+	COMMUNITY_MODELS: "community-models",
+	DASHBOARD_IMPORT: "dashboard-import",
+	ASSET_IMPORT: "asset-import",
+	WELCOME: "welcome",
+	SETTINGS: "settings",
+	PROFILE: "profile",
+	ACTIVE_EDITOR_TAB: "activeEditorTab",
+	CHAT_PANEL: "chatPanel",
+	DEMO: "demo",
+	SKIP_TIPS: "skipTips",
+	INITIAL_SEARCH: "initialSearch",
+	IMPORT: "import",
+	STORE: "store",
+	STORE_ID: "storeId",
+	STORE_KIND: "kind",
+	TOKEN: "token",
+	REMOTE: "remote",
+	ASSET_TYPE: "assetType",
+	ASSET_NAME: "assetName",
+	MODEL_NAME: "modelName",
+	CONNECTION: "connection"
+};
+function H(e, t = null) {
+	let n = window.location.hash;
+	if (!n || !n.startsWith("#")) return t;
+	let r = new URLSearchParams(n.slice(1)).get(e);
+	return r === null ? t : r;
+}
+function U(e, t) {
+	let n = window.location.hash, r = new URLSearchParams(n.slice(1));
+	r.set(e, t), window.location.hash = `#${r.toString()}`;
+}
+function W(e) {
+	let t = window.location.hash, n = new URLSearchParams(t.slice(1));
+	n.delete(e), window.location.hash = `#${n.toString()}`;
+}
+function ye(e) {
+	let t = window.location.hash, n = new URLSearchParams(t.slice(1));
+	e.forEach((e) => {
+		n.delete(e);
+	}), window.location.hash = `#${n.toString()}`;
+}
+//#endregion
+//#region stores/useScreenNavigation.ts
+var be = () => {
+	let e = F(), t = ae(), n = f(), r = _(), i = ne(), a = null, o = {
+		activeScreen: O(H(V.SCREEN, "")),
+		activeSidebarScreen: O(H(V.SIDEBAR_SCREEN, "editors")),
+		activeEditor: O(H(V.EDITORS, "")),
+		activeDashboard: O(H(V.DASHBOARD, "")),
+		activeConnectionKey: O(H(V.CONNECTIONS, "")),
+		activeModelKey: O(H(V.MODELS, "")),
+		activeCommunityModelKey: O(H(V.COMMUNITY_MODELS, "")),
+		activeJobsKey: O(H(V.JOBS, "")),
+		activeLLMConnectionKey: O(H(V.LLMS, "")),
+		activeDocumentationKey: O(H(V.TUTORIAL, "")),
+		modelImport: O(H(V.IMPORT, H(V.MODELS, ""))),
+		connectionImport: O(H(V.CONNECTION, "")),
+		mobileMenuOpen: O(!1),
+		initialSearch: O(H(V.INITIAL_SEARCH, "")),
+		tabs: O([]),
+		activeTab: O(null),
+		showTipModal: O(!0),
+		displayedTips: O([]),
+		fullScreen: O(!1)
+	}, s = /* @__PURE__ */ new Set([
+		"editors",
+		"tutorial",
+		"llms",
+		"jobs",
+		"dashboard",
+		"models",
+		"community-models",
+		"profile",
+		"settings",
+		"connections"
+	]), c = (e, t = !1) => {
+		if (o.activeSidebarScreen.value !== e && (o.activeSidebarScreen.value = e, !t)) {
+			if (e) {
+				U(V.SIDEBAR_SCREEN, e);
+				return;
+			}
+			W(V.SIDEBAR_SCREEN);
+		}
+	}, l = (e, t = !1) => {
+		s.has(e) && c(e, t);
+	}, u = (n, a, o) => {
+		if (a) return a;
+		if (n === "dashboard") {
+			let t = e.dashboards[o];
+			if (t) return t.name || "Untitled Dashboard";
+		} else if (n === "editors") {
+			let e = t.editors[o];
+			if (e) return e.name || "Untitled Editor";
+		} else if (n === "llms") {
+			let e = o.split("+"), t = e[0], n = e.length > 1 ? e[1] : null;
+			if (n) {
+				let e = i.getChatById(n);
+				if (e) return e.name;
+			}
+			return t || "LLM Chat";
+		} else if (n === "community-models") {
+			let e = o.split("+"), t = e[0], n = r.stores.find((e) => e.id === t);
+			if (n) return e.length === 2 ? `${n.name} - ${e[1]}` : e.length === 3 ? e[2] : n.name;
+		} else if (n === "jobs") {
+			let e = o.split("+"), t = e[0], n = r.stores.find((e) => e.id === t)?.name || t;
+			if (e.length === 1) return n;
+			let i = decodeURIComponent(e[2] || "");
+			if (e[1] === "directory") return i === "__root__" ? `${n} - Root` : i;
+			if (e[1] === "file") {
+				let e = i.split("/");
+				return e[e.length - 1] || n;
+			}
+		}
+		return oe(o, null);
+	}, d = (e, t, n) => {
+		let r = o.tabs.value.find((t) => t.screen === e && t.address === n);
+		r && (r.title = u(e, t, n));
+	}, p = (e, t, n, r = !1) => {
+		let i = o.tabs.value.find((t) => t.screen === e && t.address === n);
+		if (i) {
+			y(i.id, r);
+			return;
+		}
+		let a = o.tabs.value.reduce((e, t) => {
+			let n = parseInt(t.id.replace("tab-", ""));
+			return isNaN(n) ? e : Math.max(e, n);
+		}, 0);
+		r || b(e);
+		let s = u(e, t, n), c = {
+			id: `tab-${++a}`,
+			title: s,
+			screen: e,
+			address: n
+		};
+		o.tabs.value.push(c), y(c.id, r);
+	}, m = (e, t = null) => {
+		if (!e && !t) return;
+		if (!e && t) {
+			let n = o.tabs.value.find((e) => e.address === t);
+			if (n) e = n.id;
+			else return;
+		}
+		let n = o.tabs.value.findIndex((t) => t.id === e);
+		if (n !== -1) {
+			let t = o.activeTab.value === e;
+			if (o.tabs.value.splice(n, 1), t) {
+				if (o.tabs.value.length > 0) {
+					let e = n > 0 ? n - 1 : 0;
+					y(o.tabs.value[e].id);
+				} else p("welcome", "Welcome", "welcome");
+			}
+		}
+		g();
+	}, h = (e) => {
+		let t = o.activeTab.value === e;
+		o.tabs.value = o.tabs.value.filter((t) => t.id === e), t || (o.tabs.value.length > 0 ? y(o.tabs.value[0].id) : p("welcome", "Welcome", "welcome")), g();
+	}, g = () => {
+		let e = o.tabs.value.map((e) => e.screen), t = [];
+		e.includes("editors") || (o.activeEditor.value = "", t.push(V.EDITORS), t.push(V.ACTIVE_EDITOR_TAB)), e.includes("dashboard") || (o.activeDashboard.value = "", t.push(V.DASHBOARD)), e.includes("connections") || (o.activeConnectionKey.value = "", t.push(V.CONNECTIONS)), e.includes("models") || (o.activeModelKey.value = "", t.push(V.MODELS)), e.includes("community-models") || (o.activeCommunityModelKey.value = "", t.push(V.COMMUNITY_MODELS)), e.includes("jobs") || (o.activeJobsKey.value = "", t.push(V.JOBS)), e.includes("tutorial") || (o.activeDocumentationKey.value = "", t.push(V.TUTORIAL)), e.includes("llms") || (o.activeLLMConnectionKey.value = "", t.push(V.LLMS)), e.includes("settings") || t.push(V.SETTINGS), e.includes("profile") || t.push(V.PROFILE), e.includes("welcome") || t.push(V.WELCOME), ye(t);
+	}, v = (e) => {
+		let t = o.tabs.value.findIndex((t) => t.id === e);
+		if (t !== -1) {
+			let e = o.tabs.value.findIndex((e) => e.id === o.activeTab.value) > t;
+			o.tabs.value.splice(t + 1), e && (o.tabs.value.length > 0 ? y(o.tabs.value[o.tabs.value.length - 1].id) : p("welcome", "Welcome", "welcome"));
+		}
+		g();
+	}, y = (r, a = !1) => {
+		let s = o.tabs.value.find((e) => e.id === r);
+		if (s) {
+			o.activeTab.value = r, b(s.screen), l(s.screen, a);
+			let c = n.getUnreadTips(ce);
+			if (s.screen === "editors") o.activeEditor.value = s.address, t.activeEditorId = s.address, c = c.concat(n.getUnreadTips(le));
+			else if (s.screen === "dashboard") o.activeDashboard.value = s.address, e.activeDashboardId = s.address, c = o.fullScreen.value ? [] : c.concat(n.getUnreadTips(ue));
+			else if (s.screen === "connections") o.activeConnectionKey.value = s.address;
+			else if (s.screen === "llms") {
+				o.activeLLMConnectionKey.value = s.address;
+				let e = s.address.split("+");
+				if (e.length > 1) {
+					let t = e[1];
+					i.setActiveChat(t);
+				}
+			} else s.screen === "tutorial" ? o.activeDocumentationKey.value = s.address : s.screen === "models" ? o.activeModelKey.value = s.address : s.screen === "dashboard-import" || s.screen === "asset-import" ? c = [] : s.screen === "community-models" ? (o.activeCommunityModelKey.value = s.address, c = c.concat(n.getUnreadTips(de))) : s.screen === "jobs" && (o.activeJobsKey.value = s.address);
+			o.mobileMenuOpen.value = !1, o.displayedTips.value = c, o.showTipModal.value = c.length > 0, s.address && !a && U(s.screen, s.address);
+		}
+	}, b = (e) => {
+		o.activeScreen.value !== e && (o.activeScreen.value = e, U(V.SCREEN, e));
+	}, x = (e) => {
+		c(e), e == "settings" ? p("settings", "Settings", "settings") : e == "profile" && p("profile", "Profile", "profile");
+	};
+	return {
+		get activeScreen() {
+			return o.activeScreen;
+		},
+		get activeSidebarScreen() {
+			return o.activeSidebarScreen;
+		},
+		get activeEditor() {
+			return o.activeEditor;
+		},
+		get activeDashboard() {
+			return o.activeDashboard;
+		},
+		get activeConnectionKey() {
+			return o.activeConnectionKey;
+		},
+		get activeModelKey() {
+			return o.activeModelKey;
+		},
+		get activeCommunityModelKey() {
+			return o.activeCommunityModelKey;
+		},
+		get activeJobsKey() {
+			return o.activeJobsKey;
+		},
+		get activeDocumentationKey() {
+			return o.activeDocumentationKey;
+		},
+		get activeLLMConnectionKey() {
+			return o.activeLLMConnectionKey;
+		},
+		get modelImport() {
+			return o.modelImport;
+		},
+		get connectionImport() {
+			return o.connectionImport;
+		},
+		get mobileMenuOpen() {
+			return o.mobileMenuOpen;
+		},
+		get initialSearch() {
+			return o.initialSearch;
+		},
+		get tabs() {
+			return o.tabs;
+		},
+		get activeTab() {
+			return o.activeTab;
+		},
+		get showTipModal() {
+			return o.showTipModal;
+		},
+		get displayedTips() {
+			return o.displayedTips;
+		},
+		get fullScreen() {
+			return o.fullScreen;
+		},
+		setActiveScreen: b,
+		setActiveSidebarScreen: x,
+		setActiveEditor: (e) => {
+			if (e === null) {
+				W(V.EDITORS), o.activeEditor.value = "";
+				return;
+			}
+			p("editors", null, e);
+		},
+		setActiveDashboard: (e) => {
+			if (e === null) {
+				W(V.DASHBOARD), o.activeDashboard.value = "";
+				return;
+			}
+			p("dashboard", null, e);
+		},
+		setActiveConnectionKey: (e) => {
+			if (e === null) {
+				W(V.CONNECTIONS), o.activeConnectionKey.value = "";
+				return;
+			}
+			p("connections", null, e);
+		},
+		setActiveDocumentationKey: (e) => {
+			if (e === null) {
+				W(V.TUTORIAL), o.activeDocumentationKey.value = "";
+				return;
+			}
+			let t = e.split("+");
+			p("tutorial", t[t.length - 1], e);
+		},
+		setActiveLLMConnectionKey: (e) => {
+			if (e === null) {
+				W(V.LLMS), o.activeLLMConnectionKey.value = "";
+				return;
+			}
+			p("llms", null, e);
+		},
+		setActiveCommunityModelKey: (e) => {
+			if (e === null) {
+				W(V.COMMUNITY_MODELS), o.activeCommunityModelKey.value = "";
+				return;
+			}
+			o.activeCommunityModelKey.value = e, p("community-models", null, e);
+		},
+		setActiveJobsKey: (e) => {
+			if (e === null) {
+				W(V.JOBS), o.activeJobsKey.value = "";
+				return;
+			}
+			o.activeJobsKey.value = e, p("jobs", null, e);
+		},
+		toggleMobileMenu: () => {
+			o.mobileMenuOpen.value = !o.mobileMenuOpen.value;
+		},
+		setActiveModelKey: (e) => {
+			if (e === null) {
+				W(V.MODELS);
+				return;
+			}
+			U(V.MODELS, e), o.activeModelKey.value = e;
+		},
+		setActiveTab: y,
+		openTab: p,
+		updateTabName: d,
+		closeTab: m,
+		closeOtherTabsExcept: h,
+		closeTabsToRightOf: v,
+		onInitialLoad: () => {
+			let e = o.modelImport.value, t = o.connectionImport.value, r = "editors", i = !1;
+			H(V.SKIP_TIPS, "") === "true" && n.updateSetting("skipAllTips", !0);
+			let a = H(V.ASSET_TYPE, ""), s = H(V.ASSET_NAME, ""), c = H(V.DASHBOARD, ""), l = [
+				"true",
+				"1",
+				"yes"
+			].includes(H(V.REMOTE, "").toLowerCase()) && !!H(V.STORE, "") && !!(s || c);
+			(e && t || l) && (a && s ? p("asset-import", null, "asset-import") : p("dashboard-import", null, "dashboard-import"), i = !0);
+			let u = o.activeScreen.value, d = o.activeSidebarScreen.value, f = [];
+			o.activeEditor.value && !i && f.push({
+				screen: "editors",
+				title: null,
+				key: o.activeEditor.value,
+				isActive: u === "editors"
+			}), o.activeDashboard.value && !i && f.push({
+				screen: "dashboard",
+				title: null,
+				key: o.activeDashboard.value,
+				isActive: u === "dashboard"
+			}), o.activeConnectionKey.value && !i && f.push({
+				screen: "connections",
+				title: null,
+				key: o.activeConnectionKey.value,
+				isActive: u === "connections"
+			}), o.activeModelKey.value && !i && f.push({
+				screen: "models",
+				title: null,
+				key: o.activeModelKey.value,
+				isActive: u === "models"
+			}), o.activeCommunityModelKey.value && !i && f.push({
+				screen: "community-models",
+				title: null,
+				key: o.activeCommunityModelKey.value,
+				isActive: u === "community-models"
+			}), o.activeJobsKey.value && !i && f.push({
+				screen: "jobs",
+				title: null,
+				key: o.activeJobsKey.value,
+				isActive: u === "jobs"
+			}), o.activeDocumentationKey.value && !i && f.push({
+				screen: "tutorial",
+				title: null,
+				key: o.activeDocumentationKey.value,
+				isActive: u === "tutorial"
+			}), o.activeLLMConnectionKey.value && !i && f.push({
+				screen: "llms",
+				title: null,
+				key: o.activeLLMConnectionKey.value,
+				isActive: u === "llms"
+			}), o.activeSidebarScreen.value === "settings" && f.push({
+				screen: "settings",
+				title: "Settings",
+				key: "settings",
+				isActive: u === "settings"
+			}), o.activeSidebarScreen.value === "profile" && f.push({
+				screen: "profile",
+				title: "Profile",
+				key: "profile",
+				isActive: u === "profile"
+			}), f.sort((e, t) => e.isActive ? 1 : t.isActive ? -1 : 0), f.forEach((e) => {
+				p(e.screen, e.title, e.key, !0);
+			}), b(u), !d && f.length > 0 ? r = f[f.length - 1].screen : d && (r = d), x(r);
+		},
+		toggleFullScreen: (e) => {
+			o.fullScreen.value = e;
+		},
+		addBackListeners: () => {
+			a ||= window.addEventListener("hashchange", () => {
+				let e = H(V.EDITORS, ""), t = H(V.DASHBOARD, ""), n = H(V.CONNECTIONS, ""), r = H(V.MODELS, ""), i = H(V.COMMUNITY_MODELS, ""), a = H(V.JOBS, ""), s = H(V.TUTORIAL, ""), c = H(V.LLMS, ""), l = H(V.SCREEN, ""), u = H(V.SIDEBAR_SCREEN, ""), d = !1;
+				u !== o.activeSidebarScreen.value && x(u), l !== o.activeScreen.value && (o.activeScreen.value = l, d = !0);
+				let f = [
+					{
+						hash: e,
+						screen: "editors",
+						current: o.activeEditor.value
+					},
+					{
+						hash: t,
+						screen: "dashboard",
+						current: o.activeDashboard.value
+					},
+					{
+						hash: n,
+						screen: "connections",
+						current: o.activeConnectionKey.value
+					},
+					{
+						hash: r,
+						screen: "models",
+						current: o.activeModelKey.value
+					},
+					{
+						hash: i,
+						screen: "community-models",
+						current: o.activeCommunityModelKey.value
+					},
+					{
+						hash: a,
+						screen: "jobs",
+						current: o.activeJobsKey.value
+					},
+					{
+						hash: s,
+						screen: "tutorial",
+						current: o.activeDocumentationKey.value
+					},
+					{
+						hash: c,
+						screen: "llms",
+						current: o.activeLLMConnectionKey.value
+					}
+				];
+				for (let { hash: e, screen: t, current: n } of f) if (e && e !== n || t === l && d) {
+					let n = o.tabs.value.find((n) => n.screen === t && n.screen === l && n.address === e);
+					if (n && n.id !== o.activeTab.value) {
+						y(n.id, !0);
+						break;
+					}
+					if (!n && e) {
+						p(t, null, e);
+						break;
+					}
+				}
+			});
+		},
+		removeBacklisteners: () => {
+			a &&= (window.removeEventListener("hashchange", a), null);
+		}
+	};
+}, G = null;
+function xe() {
+	return G ||= be(), G;
+}
+//#endregion
+//#region stores/useMobileSidebarNavigation.ts
+var Se = () => {
+	let e = O(!1), t = O(""), n = O([]), r = O(!1), i = () => {
+		for (; n.value.length;) n.value.pop()?.onBack();
+	};
+	return {
+		level: D(() => e.value ? "detail" : "root"),
+		title: D(() => e.value ? r.value ? t.value : n.value[n.value.length - 1]?.title || t.value : ""),
+		depth: D(() => n.value.length),
+		canGoBack: D(() => e.value),
+		searchActive: r,
+		enterDestination(n) {
+			i(), t.value = n, e.value = !0;
+		},
+		push(e) {
+			n.value.push(e);
+		},
+		back() {
+			let t = n.value.pop();
+			if (t) {
+				t.onBack();
+				return;
+			}
+			e.value = !1;
+		},
+		home() {
+			i(), e.value = !1;
+		}
+	};
+}, K = null;
+function Ce() {
+	return K ||= Se(), K;
+}
+//#endregion
+//#region editors/chartStatement.ts
+var we = [
+	"line",
+	"bar",
+	"barh",
+	"point",
+	"area",
+	"headline",
+	"donut",
+	"heatmap",
+	"boxplot",
+	"treemap"
+], Te = [
+	"linear",
+	"log",
+	"sqrt"
+];
+function q(e) {
+	return Te.includes(e) ? e : void 0;
+}
+function J(e) {
+	for (let t of Object.keys(e)) e[t] === void 0 && delete e[t];
+	return e;
+}
+function Ee(e, t) {
+	let n = e.x_fields ?? [], r = e.y_fields ?? [], i;
+	e.geo_field ? i = "geo-map" : we.includes(e.chart_type) ? i = e.chart_type : (i = "bar", t.push(`Unknown chart type '${e.chart_type}'; rendering as a bar chart.`));
+	let a = r[0] || n[0], o = a ? e.field_labels?.[a] : void 0;
+	return J({
+		chartType: i,
+		xField: n[0] || void 0,
+		yField: r[0] || void 0,
+		yField2: r[1] || void 0,
+		colorField: e.color_field || void 0,
+		sizeField: e.size_field || void 0,
+		groupField: e.group_field || void 0,
+		trellisField: e.x_trellis_field || void 0,
+		trellisRowField: e.y_trellis_field || void 0,
+		geoField: e.geo_field || void 0,
+		annotationField: e.annotation_field || void 0,
+		layerLabel: o || void 0
+	});
+}
+function Y(e) {
+	let t = e?.layers?.[0];
+	if (!e || !t) return null;
+	let n = [], r = J({
+		chartType: "bar",
+		hideLegend: e.hide_legend || void 0,
+		showTitle: e.show_title || void 0,
+		scaleX: q(e.scale_x),
+		scaleY: q(e.scale_y),
+		placements: e.placements?.length ? e.placements.filter((e) => e.kind === "hline" || e.kind === "vline").map((e) => ({
+			kind: e.kind,
+			value: e.value ?? 0,
+			label: e.label || void 0
+		})) : void 0
+	}), i = e.layers.map((e) => Ee(e, n));
+	if (i.length === 1) {
+		let { layerLabel: e, ...t } = i[0];
+		return {
+			config: J({
+				...r,
+				...t
+			}),
+			warnings: n
+		};
+	}
+	return {
+		config: J({
+			...r,
+			chartType: i[0].chartType,
+			layers: i
+		}),
+		warnings: n
+	};
+}
+//#endregion
+//#region stores/connectionHistoryStore.ts
+var X = null, Z = () => (X ||= new ie(), X);
+function Q(e) {
+	let t = O([]), n = O(!0), r = O(null), i = async () => {
+		n.value = !0;
+		try {
+			let n = await Z().getQueriesForConnection(e);
+			t.value = n, r.value = null;
+		} catch (e) {
+			console.error("Failed to load query history:", e), r.value = "Failed to load query history";
+		} finally {
+			n.value = !1;
+		}
+	}, a = async (t) => {
+		try {
+			await Z().addQuery(e, t), await i();
+		} catch (e) {
+			console.error("Failed to record query:", e), r.value = "Failed to record query";
+		}
+	};
+	return i(), {
+		history: t,
+		isLoading: n,
+		error: r,
+		recordQuery: a,
+		clearHistory: async () => {
+			n.value = !0;
+			try {
+				await Z().clearConnectionHistory(e), t.value = [], r.value = null;
+			} catch (e) {
+				console.error("Failed to clear query history:", e), r.value = "Failed to clear query history";
+			} finally {
+				n.value = !1;
+			}
+		},
+		executeWithHistory: async (e, t) => {
+			let n = performance.now(), r = "success", i = null, o = 0, s = 0, c = null;
+			try {
+				c = await e(t), c && Array.isArray(c) && (o = c.length, o > 0 && typeof c[0] == "object" && (s = Object.keys(c[0]).length));
+			} catch (e) {
+				throw r = "error", i = e instanceof Error ? e.message : String(e), e;
+			} finally {
+				let e = performance.now() - n;
+				await a({
+					query: t,
+					executionTime: e,
+					status: r,
+					errorMessage: i,
+					resultSize: o,
+					resultColumns: s
+				});
+			}
+			return c;
+		},
+		refreshHistory: i
+	};
+}
+//#endregion
+//#region stores/queryExecutionService.ts
+var De = class {
+	connection;
+	constructor(e) {
+		this.connection = e;
+	}
+	get name() {
+		return this.connection.name;
+	}
+	get queryType() {
+		return this.connection.query_type;
+	}
+	isConnected() {
+		return this.connection.connected;
+	}
+	executeSql(e, t) {
+		return this.connection.query(e, t ?? null);
+	}
+	runScript(e) {
+		return this.connection.runScript(e);
+	}
+	listRegisteredFiles() {
+		return this.connection.listRegisteredFiles ? this.connection.listRegisteredFiles() : [];
+	}
+}, $ = class {
+	connectionStore;
+	workingPathResolver;
+	sourcesResolver;
+	filesResolver;
+	constructor(e, t, n, r) {
+		this.connectionStore = e, this.workingPathResolver = t, this.sourcesResolver = n, this.filesResolver = r;
+	}
+	getConnection(e) {
+		let t = this.connectionStore.connections[e];
+		return t ? new De(t) : null;
+	}
+	async ensureConnected(e) {
+		let t = this.connectionStore.connections[e];
+		if (!t) throw Error(`Connection ${e} not found.`);
+		t.connected || await this.connectionStore.resetConnection(e);
+	}
+	getConnectionSources(e) {
+		return this.sourcesResolver ? this.sourcesResolver(e) : this.connectionStore.getConnectionSources(e);
+	}
+	getConnectionWorkingPath(e) {
+		return this.workingPathResolver ? this.workingPathResolver(e) : null;
+	}
+	getConnectionRegisteredFiles(e) {
+		return this.filesResolver ? this.filesResolver(e) : null;
+	}
+};
+function Oe(e) {
+	return e.split(";").map((e) => e.trim()).filter((e) => e.length > 0);
+}
+function ke(e) {
+	let t = e.trim();
+	for (; t.length > 0;) if (t.startsWith("--")) {
+		let e = t.indexOf("\n");
+		t = e === -1 ? "" : t.slice(e + 1).trimStart();
+	} else if (t.startsWith("/*")) {
+		let e = t.indexOf("*/");
+		t = e === -1 ? "" : t.slice(e + 2).trimStart();
+	} else break;
+	let n = t.match(/^([A-Za-z]+)/)?.[1]?.toUpperCase();
+	return n ? [
+		"CREATE",
+		"DROP",
+		"ALTER",
+		"TRUNCATE",
+		"COPY",
+		"SET",
+		"ATTACH",
+		"DETACH",
+		"USE",
+		"BEGIN",
+		"COMMIT",
+		"ROLLBACK",
+		"VACUUM",
+		"ANALYZE",
+		"REINDEX",
+		"CHECKPOINT",
+		"PRAGMA"
+	].includes(n) : !1;
+}
+function Ae(e) {
+	return typeof e.getConnection == "function" && typeof e.ensureConnected == "function";
+}
+var je = class {
+	trilogyResolver;
+	connectionProvider;
+	storeHistory;
+	eligibleCrossFilterFieldsCache = /* @__PURE__ */ new Map();
+	constructor(e, t, n = !0) {
+		this.trilogyResolver = e, this.connectionProvider = Ae(t) ? t : new $(t), this.storeHistory = n;
+	}
+	resolveRegisteredFiles(e, t) {
+		return this.connectionProvider.getConnectionRegisteredFiles?.(e) ?? t.listRegisteredFiles();
+	}
+	async executeQueriesBatch(e, t, n, r = [], i, a = {}, o, s, c, l, u = !1, d) {
+		if (n === "python") return {
+			cancellation: {
+				cancel: () => {},
+				isActive: () => !1
+			},
+			resultPromise: Promise.resolve({
+				success: !1,
+				results: [],
+				executionTime: 0
+			})
+		};
+		let f = (/* @__PURE__ */ new Date()).getTime(), p = new AbortController();
+		return {
+			cancellation: {
+				cancel: () => p.abort(),
+				isActive: () => !p.signal.aborted
+			},
+			resultPromise: this.executeQueriesBatchInternal(e, t, n, r, i || [], a, f, p, o, s, c, l, u, d)
+		};
+	}
+	async executeQueriesBatchInternal(e, n, r, i = [], a, o = {}, s, c, l, u, d, f, p = !1, m) {
+		l && l();
+		let h = this.connectionProvider.getConnection(e);
+		if (!h) return {
+			success: !1,
+			executionTime: (/* @__PURE__ */ new Date()).getTime() - s,
+			results: n.map((n) => ({
+				success: !1,
+				generated_sql: "",
+				columns: [],
+				error: `Connection ${e} not found.`,
+				executionTime: 0,
+				results: new t(/* @__PURE__ */ new Map(), []),
+				resultSize: 0,
+				columnCount: 0
+			}))
+		};
+		if (p) return {
+			success: !0,
+			results: n.map((e) => ({
+				success: !0,
+				generated_sql: e.query,
+				columns: [],
+				executionTime: (/* @__PURE__ */ new Date()).getTime() - s,
+				results: new t(/* @__PURE__ */ new Map(), []),
+				resultSize: 0,
+				columnCount: 0
+			})),
+			executionTime: (/* @__PURE__ */ new Date()).getTime() - s
+		};
+		if (!h.isConnected()) try {
+			u && u({
+				message: "Connection is not active... Attempting to automatically reconnect.",
+				error: !0
+			}), await this.connectionProvider.ensureConnected(e), u && u({
+				message: "Reconnect Successful",
+				running: !0
+			});
+		} catch {
+			return d && Object.values(d).forEach((e) => e({
+				message: "Connection failed to reconnect.",
+				error: !0,
+				running: !1
+			})), {
+				success: !1,
+				executionTime: (/* @__PURE__ */ new Date()).getTime() - s,
+				results: n.map((n) => ({
+					success: !1,
+					generated_sql: "",
+					columns: [],
+					error: `Connection ${e} not active, failed to reconnect.`,
+					executionTime: (/* @__PURE__ */ new Date()).getTime() - s,
+					results: new t(/* @__PURE__ */ new Map(), []),
+					columnCount: 0,
+					resultSize: 0
+				}))
+			};
+		}
+		let g = this.connectionProvider.getConnectionSources(e);
+		m && (g = g.concat(m));
+		let _ = this.resolveRegisteredFiles(e, h), v = this.connectionProvider.getConnectionWorkingPath?.(e) ?? null;
+		try {
+			let o = await Promise.race([this.trilogyResolver.resolve_queries_batch(n, h.queryType, g, i, a, null, _.length > 0 ? _ : null, v), new Promise((e, t) => {
+				c.signal.addEventListener("abort", () => t(/* @__PURE__ */ Error("Query batch cancelled by user")));
+			})]), l = [];
+			if (o && Array.isArray(o.data.queries)) for (let i = 0; i < o.data.queries.length; i++) {
+				let u = o.data.queries[i];
+				if (u.generated_sql) {
+					let o = {
+						...n[i]?.parameters || {},
+						...u.parameters || {}
+					}, p = Object.keys(o).length ? o : null;
+					try {
+						let t = await Promise.race([h.executeSql(u.generated_sql, p), new Promise((e, t) => {
+							c.signal.addEventListener("abort", () => t(/* @__PURE__ */ Error("Query execution cancelled by user")));
+						})]);
+						w(r) && this.enrichTrilogyColumns(u.columns || [], t);
+						let d = Y(u.chart), m = await this.executeChartLayers(h, u.chart, t, o, c, r), g = {
+							success: !0,
+							generatedSql: u.generated_sql,
+							results: t,
+							resultSize: t.data.length,
+							columnCount: t.headers.size,
+							executionTime: (/* @__PURE__ */ new Date()).getTime() - s,
+							chartConfig: d?.config,
+							chartWarnings: d?.warnings.length ? d.warnings : void 0,
+							layers: m
+						};
+						f && u.label && f[u.label] && f[u.label](g), l.push(g), this.storeHistory && Q(e).recordQuery({
+							query: n[i].query,
+							generatedQuery: u.generated_sql,
+							executionTime: (/* @__PURE__ */ new Date()).getTime() - s,
+							status: "success",
+							resultSize: t.data.length,
+							resultColumns: t.headers.size,
+							errorMessage: null,
+							extraFilters: a
+						});
+					} catch (r) {
+						let o = c.signal.aborted ? "Query execution cancelled by user" : r instanceof Error ? r.message : "Unknown error occurred during execution", f = {
+							success: !1,
+							error: o,
+							generatedSql: u.generated_sql,
+							results: new t(/* @__PURE__ */ new Map(), []),
+							resultSize: 0,
+							columnCount: 0,
+							executionTime: (/* @__PURE__ */ new Date()).getTime() - s
+						};
+						l.push(f), console.error("Error callback for ", u.label, d), console.error("Error details:", r), d && u.label && d[u.label] && d[u.label](f), this.storeHistory && Q(e).recordQuery({
+							query: n[i].query,
+							generatedQuery: u.generated_sql,
+							executionTime: (/* @__PURE__ */ new Date()).getTime() - s,
+							status: "error",
+							resultSize: 0,
+							resultColumns: 0,
+							errorMessage: o,
+							extraFilters: a
+						});
+					}
+				} else if (u.error) {
+					let e = {
+						success: !1,
+						error: u.error,
+						generatedSql: "",
+						executionTime: (/* @__PURE__ */ new Date()).getTime() - s,
+						results: new t(/* @__PURE__ */ new Map(), []),
+						resultSize: 0,
+						columnCount: 0
+					};
+					d && u.label && d[u.label] && d[u.label](e), l.push(e);
+				} else {
+					let e = {
+						success: !1,
+						error: "No SQL was generated for this query",
+						generatedSql: "",
+						executionTime: (/* @__PURE__ */ new Date()).getTime() - s,
+						results: new t(/* @__PURE__ */ new Map(), []),
+						resultSize: 0,
+						columnCount: 0
+					};
+					l.push(e), d && u.label && d[u.label] && d[u.label](e);
+				}
+			}
+			return {
+				success: !0,
+				results: l,
+				executionTime: (/* @__PURE__ */ new Date()).getTime() - s
+			};
+		} catch (e) {
+			let t = c.signal.aborted ? "Query batch cancelled by user" : e instanceof Error ? e.message : "Unknown error occurred";
+			return d && Object.values(d).forEach((e) => e({
+				message: t,
+				error: !0,
+				running: !1
+			})), {
+				success: !1,
+				executionTime: (/* @__PURE__ */ new Date()).getTime() - s,
+				results: []
+			};
+		}
+	}
+	async formatQuery(e, t, n, r = [], i, a, o, s) {
+		if (n === "python") return e;
+		try {
+			let c = await this.trilogyResolver.format_query(e, t, n, i, r, null, null, a || null, o && o.length > 0 ? o : null, s ?? null);
+			return c.data && c.data.text ? c.data.text : null;
+		} catch (e) {
+			throw console.error("Error formatting query:", e), e;
+		}
+	}
+	async createDrilldownQuery(e, t, n, r = [], i, a, o, s, c, l, u) {
+		if (n === "python") return null;
+		try {
+			let d = await this.trilogyResolver.drilldown_query(e, t, n, a, i, o, s, r, null, null, c || null, l && l.length > 0 ? l : null, u ?? null);
+			return d.data && d.data.text ? d.data.text : null;
+		} catch (e) {
+			throw console.error("Error creating drilldown query:", e), e;
+		}
+	}
+	async createConnectionDrilldownQuery(e, t, n, r = [], i, a, o, s, c) {
+		let l = this.connectionProvider.getConnection(e);
+		if (!l) throw Error(`Connection ${e} not found.`);
+		return this.createDrilldownQuery(t, l.queryType, n, r, i, a, o, s, c, this.resolveRegisteredFiles(e, l), this.connectionProvider.getConnectionWorkingPath?.(e) ?? null);
+	}
+	async generateQuery(e, t) {
+		let n = this.connectionProvider.getConnection(e);
+		if (!n) throw Error(`Connection ${e} not found.`);
+		let r = this.connectionProvider.getConnectionSources(e);
+		t.extraContent && (r = r.concat(t.extraContent));
+		let i = this.resolveRegisteredFiles(e, n), a = this.connectionProvider.getConnectionWorkingPath?.(e) ?? null;
+		return this.trilogyResolver.resolve_query(t.text, n.queryType, t.editorType, r, t.imports, t.extraFilters, t.parameters, t.currentFilename || null, i.length > 0 ? i : null, a);
+	}
+	async validateQuery(e, t, n = !0, r = null) {
+		if (t.editorType === "sql" || t.editorType === "python") return null;
+		try {
+			n && console.log(`Validating ${t.editorType} query`);
+		} catch (e) {
+			console.log(e);
+		}
+		let i = this.connectionProvider.getConnection(e);
+		if (!i) return null;
+		r ||= this.connectionProvider.getConnectionSources(e), t.extraContent && (r = r.concat(t.extraContent));
+		let a = this.resolveRegisteredFiles(e, i), o = this.connectionProvider.getConnectionWorkingPath?.(e) ?? null;
+		return await this.trilogyResolver.validate_query(t.text, r, t.imports, t.extraFilters, null, t.currentFilename || null, t.parameters || null, a.length > 0 ? a : null, o);
+	}
+	async getEligibleCrossFilterFields(e, t = {}) {
+		let n = this.connectionProvider.getConnection(e);
+		if (!n) throw Error(`Connection ${e} not found.`);
+		let r = t.imports ?? [], i = t.extraFilters ?? [], a = t.extraContent ?? [], s = this.connectionProvider.getConnectionSources(e).concat(a), c = JSON.stringify({
+			connectionId: e,
+			queryType: n.queryType,
+			imports: r,
+			extraFilters: i,
+			sources: s,
+			currentFilename: t.currentFilename ?? null
+		}), l = this.eligibleCrossFilterFieldsCache.get(c);
+		if (l) return [...l];
+		let u = await this.validateQuery(e, {
+			text: "select 1 as cross_filter_probe;",
+			editorType: "trilogy",
+			imports: r,
+			extraFilters: i,
+			extraContent: a,
+			currentFilename: t.currentFilename
+		}, !1), d = o(u?.data.completion_items ?? []);
+		return this.eligibleCrossFilterFieldsCache.set(c, d), [...d];
+	}
+	clearEligibleCrossFilterFieldsCache() {
+		this.eligibleCrossFilterFieldsCache.clear();
+	}
+	async executeQuery(e, t, n, r, i, a, o = !1) {
+		let s = (/* @__PURE__ */ new Date()).getTime(), c = new AbortController();
+		return {
+			cancellation: {
+				cancel: () => c.abort(),
+				isActive: () => !c.signal.aborted
+			},
+			resultPromise: this.executeQueryInternal(e, t, s, c, n, r, i, a, o)
+		};
+	}
+	async executeQueryInternal(n, r, i, a, o, s, c, l, u = !1) {
+		let d = 0, f = 0, p = "";
+		if (r.editorType === "python") {
+			let e = "Python files are editable but cannot be run locally.";
+			return c && c({
+				message: e,
+				error: !0,
+				running: !1
+			}), {
+				success: !1,
+				error: e,
+				executionTime: 0,
+				resultSize: 0,
+				columnCount: 0
+			};
+		}
+		o && o();
+		let m = this.connectionProvider.getConnection(n);
+		if (!m) return c && c({
+			message: `Connection ${n} not found.`,
+			error: !0,
+			running: !1
+		}), {
+			success: !1,
+			error: `Connection ${n} not found.`,
+			executionTime: 0,
+			resultSize: 0,
+			columnCount: 0
+		};
+		if (!m.isConnected() && !u) try {
+			s && s({
+				message: "Connection is not active... Attempting to automatically reconnect.",
+				error: !0
+			}), await this.connectionProvider.ensureConnected(n), s && s({
+				message: "Reconnect Successful",
+				running: !0
+			});
+		} catch {
+			return c && c({
+				message: "Connection failed to reconnect.",
+				error: !0,
+				running: !1
+			}), {
+				success: !1,
+				error: "Connection is not active.",
+				executionTime: 0,
+				resultSize: 0,
+				columnCount: 0
+			};
+		}
+		if (r.editorType === "sql") try {
+			let e = Oe(r.text);
+			if (e.length === 0) {
+				let e = {
+					success: !0,
+					generatedSql: r.text,
+					results: new t(/* @__PURE__ */ new Map(), []),
+					executionTime: (/* @__PURE__ */ new Date()).getTime() - i,
+					resultSize: 0,
+					columnCount: 0
+				};
+				return l && l(e), e;
+			}
+			if (e.length > 1) {
+				let t = e.slice(0, -1).join(";\n") + ";";
+				await Promise.race([m.runScript(t), new Promise((e, t) => {
+					a.signal.addEventListener("abort", () => t(/* @__PURE__ */ Error("Query cancelled by user")));
+				})]);
+			}
+			let o = e[e.length - 1], s;
+			ke(o) ? (await Promise.race([m.runScript(o), new Promise((e, t) => {
+				a.signal.addEventListener("abort", () => t(/* @__PURE__ */ Error("Query cancelled by user")));
+			})]), s = new t(/* @__PURE__ */ new Map(), [])) : s = await Promise.race([m.executeSql(o, r.parameters ?? null), new Promise((e, t) => {
+				a.signal.addEventListener("abort", () => t(/* @__PURE__ */ Error("Query cancelled by user")));
+			})]);
+			let c = {
+				success: !0,
+				generatedSql: r.text,
+				results: s,
+				executionTime: (/* @__PURE__ */ new Date()).getTime() - i,
+				resultSize: s.data.length,
+				columnCount: s.headers.size
+			};
+			return this.storeHistory && Q(n).recordQuery({
+				query: r.text,
+				generatedQuery: r.text,
+				executionTime: c.executionTime,
+				status: "success",
+				resultSize: c.resultSize,
+				resultColumns: c.columnCount,
+				errorMessage: null,
+				extraFilters: r.extraFilters
+			}), l && l(c), c;
+		} catch (e) {
+			let t = e instanceof Error ? e.message : String(e);
+			return c && c({
+				message: t,
+				error: !0,
+				running: !1
+			}), {
+				success: !1,
+				error: t,
+				executionTime: (/* @__PURE__ */ new Date()).getTime() - i,
+				resultSize: 0,
+				columnCount: 0
+			};
+		}
+		let h = this.connectionProvider.getConnectionSources(n);
+		r.extraContent && (h = h.concat(r.extraContent));
+		let g = this.resolveRegisteredFiles(n, m), _ = this.connectionProvider.getConnectionWorkingPath?.(n) ?? null, v = null;
+		try {
+			if (v = await Promise.race([this.trilogyResolver.resolve_query(r.text, m.queryType, r.editorType, h, r.imports, r.extraFilters, r.parameters, r.currentFilename || null, g.length > 0 ? g : null, _), new Promise((e, t) => {
+				a.signal.addEventListener("abort", () => t(/* @__PURE__ */ Error("Query cancelled by user")));
+			})]), v && v.data.generated_output) {
+				let n = v.data.columns || [], r = {
+					success: !0,
+					generatedSql: v.data.generated_sql,
+					results: new t(new Map(n.map((t) => [t.name, {
+						name: t.name,
+						type: e.STRING,
+						purpose: t.purpose
+					}])), v.data.generated_output),
+					executionTime: (/* @__PURE__ */ new Date()).getTime() - i,
+					resultSize: v.data.generated_output.length,
+					columnCount: n.length,
+					selectCount: v.data.select_count
+				};
+				return console.log(r), l && l(r), r;
+			}
+			if (!v || !v.data.generated_sql || u) {
+				let e = {
+					success: !0,
+					results: new t(/* @__PURE__ */ new Map(), []),
+					executionTime: (/* @__PURE__ */ new Date()).getTime() - i,
+					resultSize: 0,
+					columnCount: 0
+				};
+				return l && l(e), e;
+			}
+			p = v.data.generated_sql;
+			let o = Y(v.data.chart), s = v.data.columns, c = {
+				...r.parameters || {},
+				...v.data.parameters || {}
+			}, y = Object.keys(c).length ? c : null, b = await Promise.race([m.executeSql(p, y), new Promise((e, t) => {
+				a.signal.addEventListener("abort", () => t(/* @__PURE__ */ Error("Query cancelled by user")));
+			})]);
+			w(r.editorType) && this.enrichTrilogyColumns(s, b), d = b.data.length, f = b.headers.size, this.storeHistory && Q(n).recordQuery({
+				query: r.text,
+				generatedQuery: p,
+				executionTime: (/* @__PURE__ */ new Date()).getTime() - i,
+				status: "success",
+				resultSize: d,
+				resultColumns: f,
+				errorMessage: null,
+				extraFilters: r.extraFilters
+			});
+			let x = await this.executeChartLayers(m, v.data.chart, b, c, a, r.editorType), S = v?.data.select_count, C = {
+				success: !0,
+				generatedSql: p,
+				results: b,
+				executionTime: (/* @__PURE__ */ new Date()).getTime() - i,
+				resultSize: d,
+				columnCount: f,
+				selectCount: S,
+				chartConfig: o?.config,
+				chartWarnings: o?.warnings.length ? o.warnings : void 0,
+				layers: x
+			};
+			return l && l(C), C;
+		} catch (e) {
+			console.error("[query catch] raw error:", e, "type:", typeof e, "ctor:", e?.constructor?.name);
+			let t = a.signal.aborted ? "Query cancelled by user" : e instanceof Error ? e.message : typeof e == "string" ? e : (() => {
+				try {
+					return `Unknown error: ${JSON.stringify(e)}`;
+				} catch {
+					return `Unknown error: ${String(e)}`;
+				}
+			})();
+			return this.storeHistory && Q(n).recordQuery({
+				query: r.text,
+				generatedQuery: p,
+				executionTime: (/* @__PURE__ */ new Date()).getTime() - i,
+				status: "error",
+				resultSize: d,
+				resultColumns: f,
+				errorMessage: t
+			}), c && c({
+				message: t,
+				error: !0,
+				running: !1,
+				generatedSql: p
+			}), {
+				success: !1,
+				error: t,
+				executionTime: (/* @__PURE__ */ new Date()).getTime() - i,
+				resultSize: d,
+				columnCount: f
+			};
+		}
+	}
+	async executeChartLayers(e, n, r, i, a, o) {
+		let s = n?.layers;
+		if (!s || s.length < 2) return;
+		let c = [r];
+		for (let n = 1; n < s.length; n++) {
+			let r = s[n];
+			if (!r.generated_sql) {
+				c.push(new t(/* @__PURE__ */ new Map(), []));
+				continue;
+			}
+			let l = {
+				...i,
+				...r.parameters || {}
+			}, u = await Promise.race([e.executeSql(r.generated_sql, Object.keys(l).length ? l : null), new Promise((e, t) => {
+				a.signal.addEventListener("abort", () => t(/* @__PURE__ */ Error("Query cancelled by user")));
+			})]);
+			w(o) && this.enrichTrilogyColumns(r.columns || [], u), c.push(u);
+		}
+		return c;
+	}
+	enrichTrilogyColumns(e, t) {
+		for (let n = 0; n < e.length; n++) {
+			let r = e[n], i = t.headers.get(r.name.replace("local.", "").replaceAll(".", "_"));
+			i && (i.traits = r.traits || [], i.address = r.name, i.purpose = r.purpose, i.keys = r.keys || [], t.headers.set(i.name, i));
+		}
+	}
+};
+//#endregion
+export { A as _, xe as a, U as c, _e as d, N as f, pe as g, j as h, Ce as i, W as l, M as m, je as n, V as o, F as p, Q as r, H as s, $ as t, ve as u };