@oxy-hq/sdk 2.3.0 → 2.5.0

package/dist/react-CVdWXcu8.mjs

@@ -0,0 +1,2258 @@
+// @oxy/sdk - TypeScript SDK for Oxy data platform
+import * as React from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/customer-app/logger.ts
+let activeLogger = createConsoleLogger();
+/** Replace the global logger. Pass `null` to silence everything. */
+function setOxyAppLogger(logger) {
+	activeLogger = logger ?? silentLogger();
+}
+/** Used by the SDK internals; not part of the public surface. */
+function getOxyAppLogger() {
+	return activeLogger;
+}
+function createConsoleLogger() {
+	return { log(level, msg, ctx) {
+		if (typeof console === "undefined") return;
+		const prefix = "[oxy-app]";
+		const args = ctx ? [
+			prefix,
+			msg,
+			ctx
+		] : [prefix, msg];
+		switch (level) {
+			case "debug":
+				console.debug(...args);
+				break;
+			case "info":
+				console.info(...args);
+				break;
+			case "warn":
+				console.warn(...args);
+				break;
+			case "error":
+				console.error(...args);
+				break;
+		}
+	} };
+}
+function silentLogger() {
+	return { log() {} };
+}
+
+//#endregion
+//#region src/customer-app/errors.ts
+/**
+* Error thrown by all customer-app hooks when an API call returns a
+* non-2xx response. Carries the structured `code` + `hint` the server
+* emits so bundle UIs can render an actionable message instead of
+* "404: { ...json... }".
+*/
+var OxyApiError = class extends Error {
+	constructor(opts) {
+		const base = opts.message || `HTTP ${opts.status}`;
+		const code = opts.code ? ` [${opts.code}]` : "";
+		const hint = opts.hint ? `\n\n${opts.hint}` : "";
+		super(`${base}${code}${hint}`);
+		this.name = "OxyApiError";
+		this.status = opts.status;
+		this.code = opts.code ?? null;
+		this.hint = opts.hint ?? null;
+	}
+};
+/**
+* Read a non-2xx response from oxy and return an `OxyApiError`.
+* Parses the JSON envelope when present; falls back to raw text
+* (truncated to 240 chars so a runaway HTML error page doesn't
+* dominate the bundle UI).
+*/
+async function apiErrorFromResponse(resp) {
+	let body;
+	let raw = "";
+	try {
+		raw = await resp.text();
+		body = raw ? JSON.parse(raw) : void 0;
+	} catch {}
+	if (body && typeof body === "object") {
+		const b = body;
+		return new OxyApiError({
+			status: resp.status,
+			message: typeof b.message === "string" ? b.message : `HTTP ${resp.status}`,
+			code: typeof b.code === "string" ? b.code : null,
+			hint: typeof b.hint === "string" ? b.hint : null
+		});
+	}
+	const snippet = raw.length > 240 ? `${raw.slice(0, 237)}…` : raw;
+	return new OxyApiError({
+		status: resp.status,
+		message: snippet || `HTTP ${resp.status}`
+	});
+}
+const ARCH_DOC = "internal-docs/customer-apps.md";
+/** Interpret a thrown error as a structured report for UI display. */
+function interpretCustomerAppError(err) {
+	const message = err instanceof Error ? err.message : String(err);
+	if (/Failed to load oxy-app\.json.*HTTP 404/.test(message)) return {
+		title: "Manifest not found",
+		message,
+		hint: "The bundle is being served, but oxy-app.json was not. Check that public/oxy-app.json is committed in the customer-app repo and that the build copied it into the static output. If you're using Next.js, anything under public/ is auto-copied to out/.",
+		docs: ARCH_DOC
+	};
+	if (/Failed to load oxy-app\.json/.test(message)) return {
+		title: "Manifest could not be loaded",
+		message,
+		hint: "Network error fetching the manifest. Confirm the bundle is being served from a path that matches OXY_APP_BASE_PATH at build time — a mismatch causes assets and the manifest to 404.",
+		docs: ARCH_DOC
+	};
+	if (/schemaVersion/i.test(message)) return {
+		title: "Manifest schema mismatch",
+		message,
+		hint: "This bundle was built against a different version of the data-product contract than the SDK it ships. Rebuild the bundle with a compatible @oxy-hq/sdk version.",
+		docs: ARCH_DOC
+	};
+	if (/^401:/m.test(message)) return {
+		title: "Session expired",
+		message,
+		hint: "Reload the page to re-authenticate via oxy's session cookie.",
+		docs: ARCH_DOC
+	};
+	if (/^403:.*origin not allowed/im.test(message)) return {
+		title: "Request origin not allowed",
+		message,
+		hint: "The bundle's host isn't in oxy's OXY_ALLOWED_ORIGINS. Production: add the bundle's serving origin to the env var. Local dev: oxy auto-allows http://localhost:5173 and :5174.",
+		docs: ARCH_DOC
+	};
+	if (/^403:.*not a member/im.test(message)) return {
+		title: "Access denied",
+		message,
+		hint: "Your account isn't a member of the org that owns this project. Ask an org owner to add you.",
+		docs: ARCH_DOC
+	};
+	if (/^403:.*SELECT.*WITH/im.test(message)) return {
+		title: "Query rejected — read-only endpoint",
+		message,
+		hint: "This proxy only runs SELECT or WITH queries. Mutations (INSERT/UPDATE/DELETE/DROP) are not allowed from customer-app bundles.",
+		docs: ARCH_DOC
+	};
+	if (/^403:/m.test(message)) return {
+		title: "Access denied",
+		message,
+		hint: "The request was rejected by the server. Check the oxy server logs for details.",
+		docs: ARCH_DOC
+	};
+	if (/^404:/m.test(message) && /project/i.test(message)) return {
+		title: "Project not found",
+		message,
+		hint: "The projectId in oxy-app.json doesn't match any registered project. Confirm the manifest's projectId is a real UUID for this deployment.",
+		docs: ARCH_DOC
+	};
+	if (/^400:.*sql.*must be non-empty/im.test(message)) return {
+		title: "Empty SQL",
+		message,
+		hint: "useQuery was called with an empty or whitespace-only `sql`. Pass a real query, or set `enabled: false` to skip the call.",
+		docs: ARCH_DOC
+	};
+	if (/^400:/m.test(message) && /query failed/i.test(message)) return {
+		title: "Query failed",
+		message,
+		hint: "The SQL ran but the warehouse rejected it. Full error in the oxy server logs (look for the projects::query span).",
+		docs: ARCH_DOC
+	};
+	if (/^502:/m.test(message)) return {
+		title: "Warehouse unreachable",
+		message,
+		hint: "Oxy couldn't reach the configured database. Check connector config + warehouse health.",
+		docs: ARCH_DOC
+	};
+	if (/Unexpected token '<'|<!doctype/i.test(message)) return {
+		title: "Fetched HTML where JSON was expected",
+		message,
+		hint: "Most likely the built bundle is stale — built against an old SDK whose endpoints no longer exist on the server. Rebuild the bundle (vite build) with @oxy-hq/sdk@^2.0.0 and reload. If the bundle is current, check that OXY_APP_BASE_PATH matches the path the customer-app row is served at.",
+		docs: ARCH_DOC
+	};
+	return {
+		title: "Unexpected error loading the dashboard",
+		message,
+		hint: "Check the browser console for the full stack trace, and the oxy server logs for the corresponding request.",
+		docs: ARCH_DOC
+	};
+}
+
+//#endregion
+//#region src/customer-app/inject.ts
+/**
+* Read the runtime app-config oxy injected at serve time. Returns
+* `undefined` outside the browser or when the global isn't set
+* (`pnpm dev` against a non-oxy server, etc. — manifest hints are
+* the fallback).
+*/
+function readInjectedAppConfig() {
+	if (typeof window === "undefined") return void 0;
+	return window.__OXY_APP__;
+}
+
+//#endregion
+//#region src/customer-app/manifest.ts
+let cached = null;
+/**
+* Load + validate the manifest. Cached after the first call so callers
+* can invoke this from every component without coordinating.
+*/
+function loadCustomerAppManifest(options = {}) {
+	if (!cached) cached = fetchAndValidate(options);
+	return cached;
+}
+/** For tests: reset the cache between runs. */
+function _resetCustomerAppManifestCacheForTest() {
+	cached = null;
+}
+async function fetchAndValidate(options) {
+	const log = getOxyAppLogger();
+	const injected = readInjectedAppConfig();
+	const manifestUrl = options.manifestUrl ?? defaultManifestUrl(injected);
+	log.log("info", "loading manifest", {
+		manifestUrl,
+		injectionPresent: !!injected,
+		orgSlug: injected?.orgSlug,
+		appSlug: injected?.slug,
+		appId: injected?.appId
+	});
+	const startedAt = Date.now();
+	const res = await fetch(manifestUrl, { credentials: "same-origin" });
+	if (!res.ok) {
+		log.log("error", "manifest fetch failed", {
+			manifestUrl,
+			status: res.status,
+			statusText: res.statusText
+		});
+		throw new Error(`Failed to load oxy-app.json from ${manifestUrl} (HTTP ${res.status}). The customer-app repo must commit this file alongside the bundle.`);
+	}
+	const manifest = validateManifest(await res.json(), manifestUrl);
+	const resolved = {
+		manifest,
+		productNames: [],
+		orgSlug: injected?.orgSlug ?? "",
+		appSlug: injected?.slug ?? "",
+		apiBaseUrl: injected?.apiBaseUrl || "",
+		appId: injected?.appId,
+		projectId: injected?.projectId ?? manifest.projectId
+	};
+	log.log("info", "manifest ready", {
+		durationMs: Date.now() - startedAt,
+		schemaVersion: manifest.schemaVersion,
+		slug: manifest.slug
+	});
+	return resolved;
+}
+/**
+* Default manifest URL.
+*
+* Resolution order (bundler-agnostic):
+*   1. `window.__OXY_APP__.orgSlug`/`slug` injection → the canonical
+*      `/customer-apps/<org>/<app>/oxy-app.json`. Works for every
+*      bundle oxy serves regardless of how it was built.
+*   2. `NEXT_PUBLIC_APP_BASE_PATH` env var — kept for backward compat
+*      with Next.js bundles that bake basePath at build time.
+*   3. Empty basePath → `/oxy-app.json` (only matches when running in
+*      a `vite dev` / `next dev` root mount; will 404 under oxy).
+*/
+function defaultManifestUrl(injected) {
+	if (injected?.orgSlug && injected?.slug) return `/customer-apps/${encodeURIComponent(injected.orgSlug)}/${encodeURIComponent(injected.slug)}/oxy-app.json`;
+	return "/oxy-app.json";
+}
+/**
+* Validate a v2 manifest. Required: schemaVersion === 2, slug (non-empty).
+* Optional: name (display), orgSlug (dev-time hint for the admin dialog),
+* projectId (dev-time hint when there's no server-side injection).
+*
+* At serve time, oxy's identity injection (window.__OXY_APP__) overrides
+* the manifest's orgSlug/projectId — the manifest fields are advisory.
+*/
+function validateManifest(raw, url) {
+	if (!isRecord(raw)) throw new Error(`Manifest at ${url} is not a JSON object`);
+	if (raw.schemaVersion !== 2) throw new Error(`oxy-app.json: schemaVersion must be 2 (got ${JSON.stringify(raw.schemaVersion)}). v1 manifests are no longer supported — upgrade to the identity-only shape.`);
+	if (raw.products !== void 0 || raw.writers !== void 0) throw new Error(`oxy-app.json is schemaVersion 2 (identity-only); \`products\` and \`writers\` are no longer supported`);
+	if (typeof raw.slug !== "string" || !raw.slug.trim()) throw new Error("oxy-app.json: `slug` is required and must be a non-empty string");
+	return {
+		schemaVersion: 2,
+		name: typeof raw.name === "string" ? raw.name : void 0,
+		slug: raw.slug,
+		orgSlug: typeof raw.orgSlug === "string" ? raw.orgSlug : void 0,
+		projectId: typeof raw.projectId === "string" ? raw.projectId : void 0,
+		functions: raw.functions !== void 0 ? validateFunctions(raw.functions) : void 0,
+		ask: isRecord(raw.ask) ? {
+			agent: typeof raw.ask.agent === "string" ? raw.ask.agent : void 0,
+			suggestedQuestions: Array.isArray(raw.ask.suggestedQuestions) ? raw.ask.suggestedQuestions.filter((q) => typeof q === "string") : void 0
+		} : void 0
+	};
+}
+const FUNCTION_NAME_RE = /^[a-z][a-z0-9-]{0,63}$/;
+/**
+* Validate the optional `functions` map. Each key is a function name;
+* each value declares how the function is invoked. Mirrors the
+* server-side validation in `customer_apps_publish.rs` so a bad
+* manifest fails at build, not at publish.
+*/
+function validateFunctions(raw) {
+	if (!isRecord(raw)) throw new Error("oxy-app.json: `functions` must be an object keyed by function name");
+	const out = {};
+	for (const [fnName, value] of Object.entries(raw)) {
+		if (!FUNCTION_NAME_RE.test(fnName)) throw new Error(`oxy-app.json: function name "${fnName}" must match ^[a-z][a-z0-9-]{0,63}$`);
+		if (!isRecord(value)) throw new Error(`oxy-app.json: function "${fnName}" must be an object`);
+		const fn = {};
+		if (value.entry !== void 0) {
+			if (typeof value.entry !== "string" || !value.entry.trim()) throw new Error(`oxy-app.json: function "${fnName}" \`entry\` must be a non-empty string`);
+			fn.entry = value.entry;
+		}
+		if (value.schedule !== void 0) {
+			if (typeof value.schedule !== "string" || !value.schedule.trim()) throw new Error(`oxy-app.json: function "${fnName}" \`schedule\` must be a cron string`);
+			fn.schedule = value.schedule;
+		}
+		if (value.timezone !== void 0) {
+			if (typeof value.timezone !== "string") throw new Error(`oxy-app.json: function "${fnName}" \`timezone\` must be a string`);
+			fn.timezone = value.timezone;
+		}
+		if (value.route !== void 0) {
+			if (typeof value.route !== "boolean") throw new Error(`oxy-app.json: function "${fnName}" \`route\` must be a boolean`);
+			fn.route = value.route;
+		}
+		if (value.airwayStep !== void 0) {
+			const step = value.airwayStep;
+			if (!isRecord(step) || typeof step.pipeline !== "string" || typeof step.resource !== "string") throw new Error(`oxy-app.json: function "${fnName}" \`airwayStep\` must be { pipeline, resource }`);
+			fn.airwayStep = {
+				pipeline: step.pipeline,
+				resource: step.resource
+			};
+		}
+		if (value.timeoutSeconds !== void 0) {
+			const t = value.timeoutSeconds;
+			if (typeof t !== "number" || !Number.isInteger(t) || t < 1 || t > 300) throw new Error(`oxy-app.json: function "${fnName}" \`timeoutSeconds\` must be an integer in [1, 300]`);
+			fn.timeoutSeconds = t;
+		}
+		if (value.cache !== void 0) {
+			const c = value.cache;
+			if (!isRecord(c)) throw new Error(`oxy-app.json: function "${fnName}" \`cache\` must be an object`);
+			if (c.ttlSeconds !== void 0) {
+				const ttl = c.ttlSeconds;
+				if (typeof ttl !== "number" || !Number.isInteger(ttl) || ttl < 1) throw new Error(`oxy-app.json: function "${fnName}" \`cache.ttlSeconds\` must be a positive integer`);
+				fn.cache = { ttlSeconds: ttl };
+			}
+		}
+		if (value.retries !== void 0) {
+			const r = value.retries;
+			if (!isRecord(r)) throw new Error(`oxy-app.json: function "${fnName}" \`retries\` must be an object`);
+			const retries = {};
+			for (const key of [
+				"maxAttempts",
+				"minTimeoutMs",
+				"maxTimeoutMs"
+			]) {
+				const n = r[key];
+				if (n !== void 0) {
+					if (typeof n !== "number" || !Number.isInteger(n) || n < 1) throw new Error(`oxy-app.json: function "${fnName}" \`retries.${key}\` must be a positive integer`);
+					retries[key] = n;
+				}
+			}
+			fn.retries = retries;
+		}
+		if (value.inputExample !== void 0) fn.inputExample = value.inputExample;
+		const hasSchedule = fn.schedule !== void 0;
+		const hasAirway = fn.airwayStep !== void 0;
+		if (!(fn.route ?? !(hasSchedule || hasAirway)) && !hasSchedule && !hasAirway) throw new Error(`oxy-app.json: function "${fnName}" must enable at least one of route/schedule/airwayStep`);
+		out[fnName] = fn;
+	}
+	return out;
+}
+function isRecord(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+//#endregion
+//#region src/customer-app/function-invoke.ts
+const inflight$1 = /* @__PURE__ */ new Map();
+/**
+* Dedup key for an invocation: function name + its (stable-serialized) body,
+* joined by a newline. Function names are `[a-z][a-z0-9-]*` (no newline), so
+* the separator can never collide with a name.
+*/
+function functionInvokeKey(name, body) {
+	return `${name}\n${JSON.stringify(body ?? {})}`;
+}
+/**
+* Run `run()` unless an identical invocation is already in flight, in which
+* case share its promise. The entry is removed once the promise settles — so
+* this dedups concurrency only, it does NOT memoize the result.
+*/
+function sharedFunctionInvoke(key, run) {
+	const existing = inflight$1.get(key);
+	if (existing) return existing;
+	const p = run().finally(() => {
+		inflight$1.delete(key);
+	});
+	inflight$1.set(key, p);
+	return p;
+}
+
+//#endregion
+//#region src/customer-app/function-sse.ts
+/**
+* Read a `text/event-stream` function response to completion. Resolves with the
+* decoded result + captured logs, or rejects (with `.logs` attached) on an
+* `event: error` frame / a stream that ends without a terminal event.
+*/
+async function readFunctionSseStream(resp) {
+	const reader = resp.body?.getReader();
+	if (!reader) throw new Error("function response has no body stream");
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let dataPayload = "";
+	const logs = [];
+	const handleFrame = (frame) => {
+		let event = "message";
+		let data = "";
+		for (const line of frame.split("\n")) if (line.startsWith("event:")) event = line.slice(6).trim();
+		else if (line.startsWith("data:")) data += line.slice(5).trim();
+		if (event === "log") try {
+			const l = JSON.parse(data);
+			logs.push({
+				level: String(l.level ?? "info"),
+				message: String(l.message ?? "")
+			});
+		} catch {}
+		else if (event === "data") dataPayload = data;
+		else if (event === "done") return {
+			done: true,
+			value: dataPayload ? JSON.parse(dataPayload) : null
+		};
+		else if (event === "error") {
+			const payload = data ? JSON.parse(data) : {};
+			const err = new Error(payload.message || payload.error || "function invocation failed");
+			err.name = payload.error || "FunctionError";
+			err.logs = logs;
+			throw err;
+		}
+	};
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+		let sep;
+		while ((sep = buffer.indexOf("\n\n")) !== -1) {
+			const frame = buffer.slice(0, sep);
+			buffer = buffer.slice(sep + 2);
+			const result = handleFrame(frame);
+			if (result) return {
+				value: result.value,
+				logs
+			};
+		}
+	}
+	throw new Error("function stream ended without a terminal event");
+}
+
+//#endregion
+//#region src/customer-app/interpolate.ts
+/**
+* Interpolate `{{ params.X }}` and `{{ params.X | sqlquote }}` placeholders
+* in a SQL template.
+*
+* - `{{ params.X | sqlquote }}` — quote strings ('foo'), pass numbers and
+*   booleans raw, nullish becomes NULL. Mirrors the server's Jinja sqlquote
+*   filter.
+* - `{{ params.X }}` — raw pass-through. Used for already-trusted values
+*   (numbers, identifiers the caller has validated). Caller is responsible
+*   for safety.
+*
+* Not a security boundary. The server still gates SQL execution by
+* project membership. Bundles that accept untrusted user input should
+* use `| sqlquote` or validate/coerce before passing.
+*/
+function interpolateSqlParams(sql, params) {
+	return sql.replace(/\{\{\s*params\.([a-zA-Z0-9_]+)(\s*\|\s*sqlquote)?\s*\}\}/g, (_match, key, sqlquote) => {
+		const v = params[key];
+		if (v === null || v === void 0) return "NULL";
+		if (sqlquote) {
+			if (typeof v === "number" || typeof v === "boolean") return String(v);
+			return `'${String(v).replace(/'/g, "''")}'`;
+		}
+		return String(v);
+	});
+}
+
+//#endregion
+//#region src/customer-app/markdown.ts
+/**
+* Allowlist for `[text](url)` href values in agent-emitted markdown.
+* Markdown comes from an LLM, which sits across an external trust
+* boundary — without this filter, a `javascript:` URL produced by
+* the model would render as a clickable XSS in the bundle's origin.
+*
+* Accepts:
+*   - http(s):// absolute URLs
+*   - mailto: addresses
+*   - root-relative paths (`/foo`)
+*   - same-page fragments (`#section`)
+*
+* Rejects everything else, including `javascript:`, `data:`,
+* protocol-relative `//evil.com`, and any other scheme. Comparison
+* is case-insensitive after stripping leading whitespace + ASCII
+* control bytes (browsers strip these before scheme resolution, so
+* `java\tscript:` would otherwise slip past a naive prefix check).
+*/
+function isSafeLinkHref(raw) {
+	let cleaned = "";
+	for (let i = 0; i < raw.length; i++) {
+		const cc = raw.charCodeAt(i);
+		if (cc > 32 && cc !== 127) cleaned += raw[i];
+	}
+	if (cleaned === "") return false;
+	if (cleaned.startsWith("#") || cleaned.startsWith("/")) {
+		if (cleaned.startsWith("//")) return false;
+		return true;
+	}
+	const lower = cleaned.toLowerCase();
+	return lower.startsWith("http://") || lower.startsWith("https://") || lower.startsWith("mailto:");
+}
+/** Unescape GFM cell escapes (`\|` → `|`, `\\` → `\`). */
+function unescapeCell(cell) {
+	return cell.replace(/\\([|\\])/g, "$1");
+}
+/** Split a GFM table row into trimmed cells, dropping the outer pipes.
+*  Splits on UNESCAPED `|` only — a `\|` inside a cell is a literal pipe,
+*  not a column separator — then unescapes each cell. */
+function splitTableRow(line) {
+	const s = line.trim();
+	const cells = [];
+	let cur = "";
+	for (let i = 0; i < s.length; i++) {
+		const ch = s[i];
+		if (ch === "\\" && i + 1 < s.length) {
+			cur += ch + s[i + 1];
+			i++;
+			continue;
+		}
+		if (ch === "|") {
+			cells.push(cur);
+			cur = "";
+			continue;
+		}
+		cur += ch;
+	}
+	cells.push(cur);
+	if (cells.length > 1 && cells[0].trim() === "") cells.shift();
+	if (cells.length > 1 && cells[cells.length - 1].trim() === "") cells.pop();
+	return cells.map((c) => unescapeCell(c.trim()));
+}
+/** A GFM delimiter row: every cell is `-`s with optional leading/trailing `:`. */
+function isTableDelimiter(line) {
+	if (!line?.includes("-")) return false;
+	const cells = splitTableRow(line);
+	return cells.length > 0 && cells.every((c) => /^:?-{1,}:?$/.test(c));
+}
+/** A table starts at `idx` when that line has a pipe and the next line is a
+*  delimiter row. */
+function isTableStart(lines, idx) {
+	return (lines[idx] ?? "").includes("|") && isTableDelimiter(lines[idx + 1] ?? "");
+}
+
+//#endregion
+//#region src/customer-app/query-cache.ts
+const SWR_TTL_MS = 3e4;
+const inflight = /* @__PURE__ */ new Map();
+const cache = /* @__PURE__ */ new Map();
+function queryKey(projectId, db, sql) {
+	return `${projectId} ${db ?? ""} ${sql}`;
+}
+function getCached(projectId, sql, db) {
+	const e = cache.get(queryKey(projectId, db, sql));
+	return e && Date.now() - e.at < SWR_TTL_MS ? e.data : void 0;
+}
+/** Fetch with in-flight dedup + cache. `force` bypasses the fresh-cache
+*  short-circuit (used by refetch) but still dedupes a concurrent in-flight. */
+async function sharedQuery(fetcher, projectId, sql, db, opts = {}) {
+	const key = queryKey(projectId, db, sql);
+	if (!opts.force) {
+		const fresh = getCached(projectId, sql, db);
+		if (fresh) return fresh;
+	}
+	const existing = inflight.get(key);
+	if (existing) return existing;
+	const body = JSON.stringify({
+		sql,
+		...db ? { database: db } : {}
+	});
+	const p = (async () => {
+		const resp = await fetcher(`/api/projects/${projectId}/query`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body
+		});
+		if (!resp.ok) throw await apiErrorFromResponse(resp);
+		const data = await resp.json();
+		cache.set(key, {
+			at: Date.now(),
+			data
+		});
+		return data;
+	})().finally(() => inflight.delete(key));
+	inflight.set(key, p);
+	return p;
+}
+
+//#endregion
+//#region src/customer-app/react.tsx
+function defaultFetcher(input, init) {
+	return fetch(input, {
+		credentials: "include",
+		...init
+	});
+}
+/**
+* Resolve relative ("/…") request paths against `backendUrl` so the SDK's API
+* calls reach a cross-origin oxy backend instead of the app's own origin.
+*
+* This is what lets a standalone dev app (e.g. served on `localhost:3005`)
+* drive the wired shell — `shell-context`, Ask Oxygen agent asks, events —
+* against oxy on another origin (`localhost:3000`) WITHOUT a same-origin dev
+* proxy. The target origin must permit the app's origin (oxy's main `/api`
+* allows configured dev origins + `credentials`); the external data API is a
+* separate, wildcard-CORS surface.
+*
+* Opt-in: when `backendUrl` is unset the base fetcher is returned unchanged, so
+* apps served same-origin by oxy keep their existing relative-URL behaviour.
+* Absolute URLs and non-string inputs pass through untouched (no double-prefix).
+*/
+function withBackendBase(base, backendUrl) {
+	if (!backendUrl) return base;
+	const origin = backendUrl.replace(/\/+$/, "");
+	return (input, init) => base(typeof input === "string" && input.startsWith("/") ? origin + input : input, init);
+}
+const OxyAppContext = React.createContext(void 0);
+/**
+* Top-level provider. Loads the manifest once on mount; children only
+* render after the manifest is ready (or the error fallback fires).
+*/
+function OxyAppProvider(props) {
+	const { manifestOptions, fallback, errorFallback, fetcher: fetcherProp, backendUrl, children } = props;
+	const fetcher = React.useMemo(() => withBackendBase(fetcherProp ?? defaultFetcher, backendUrl), [fetcherProp, backendUrl]);
+	const [state, setState] = React.useState({
+		status: "loading",
+		fetcher
+	});
+	React.useEffect(() => {
+		let cancelled = false;
+		loadCustomerAppManifest(manifestOptions).then((resolved) => {
+			if (!cancelled) setState({
+				status: "ready",
+				resolved,
+				fetcher
+			});
+		}).catch((e) => {
+			if (!cancelled) setState({
+				status: "error",
+				error: interpretCustomerAppError(e),
+				fetcher
+			});
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [manifestOptions, fetcher]);
+	if (state.status === "error" && state.error) {
+		const err = state.error;
+		return /* @__PURE__ */ jsx(OxyAppContext.Provider, {
+			value: state,
+			children: errorFallback ? errorFallback(err) : defaultErrorFallback(err)
+		});
+	}
+	if (state.status === "loading") return /* @__PURE__ */ jsx(OxyAppContext.Provider, {
+		value: state,
+		children: fallback ?? null
+	});
+	return /* @__PURE__ */ jsx(OxyAppContext.Provider, {
+		value: state,
+		children
+	});
+}
+function defaultErrorFallback(err) {
+	return /* @__PURE__ */ jsxs("div", {
+		style: {
+			margin: "2rem auto",
+			maxWidth: "640px",
+			padding: "1rem",
+			border: "1px solid #fca5a5",
+			background: "#fee2e2",
+			color: "#991b1b",
+			borderRadius: "8px",
+			fontFamily: "system-ui, -apple-system, sans-serif",
+			fontSize: "14px"
+		},
+		children: [
+			/* @__PURE__ */ jsx("div", {
+				style: { fontWeight: 600 },
+				children: err.title
+			}),
+			/* @__PURE__ */ jsx("pre", {
+				style: {
+					fontSize: "12px",
+					marginTop: "4px"
+				},
+				children: err.message
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				style: { marginTop: "12px" },
+				children: [
+					/* @__PURE__ */ jsx("strong", { children: "What to try:" }),
+					" ",
+					err.hint
+				]
+			})
+		]
+	});
+}
+/**
+* Emit a one-time `console.warn` the first time a beta hook is
+* used in a given page load. Bundles upgrading from a future GA
+* release won't see the warning; the message lets us flag rough
+* edges without breaking the build.
+*/
+const _warnedBeta = /* @__PURE__ */ new Set();
+function warnBetaOnce(name) {
+	if (_warnedBeta.has(name)) return;
+	_warnedBeta.add(name);
+	if (typeof console !== "undefined" && typeof console.warn === "function") console.warn(`[@oxy-hq/sdk] \`${name}\` is in beta — interface and behavior may change. See https://github.com/oxy-hq/customer-apps for caveats and the migration guide.`);
+}
+/**
+* Read the resolved manifest from context. Throws if called outside
+* `<OxyAppProvider>` — that's a programmer error worth surfacing
+* loudly, not silently swallowing.
+*/
+function useResolvedManifest() {
+	const ctx = React.useContext(OxyAppContext);
+	if (!ctx) throw new Error("useResolvedManifest must be called inside <OxyAppProvider>");
+	if (ctx.status !== "ready" || !ctx.resolved) throw new Error("useResolvedManifest called before manifest finished loading. Use the provider's `fallback` prop to render while loading.");
+	return ctx.resolved;
+}
+/**
+* Low-level hook that returns the raw context value (including the
+* fetcher). Prefer `useResolvedManifest` for manifest access; use
+* this only when you need the fetcher or identity without requiring
+* the manifest to be ready (e.g. inside `useQuery`, or the shell
+* chrome, which must never block the app on the manifest load).
+*/
+function useOxyApp() {
+	const ctx = React.useContext(OxyAppContext);
+	if (!ctx) throw new Error("useOxyApp must be called inside <OxyAppProvider>");
+	return {
+		projectId: ctx.resolved?.projectId,
+		appSlug: ctx.resolved?.appSlug,
+		orgSlug: ctx.resolved?.orgSlug,
+		fetcher: ctx.fetcher
+	};
+}
+/**
+* Execute an ad-hoc SQL query against the project linked to this
+* customer app. The query is specified inline by the caller; no
+* manifest declaration is involved.
+*
+* Re-runs whenever `input` or enabled `params` change. Use the
+* `enabled` option to defer the first fetch until required data is
+* available (e.g. a user-supplied filter value).
+*/
+function useQuery(input, opts = {}) {
+	const { projectId, fetcher } = useOxyApp();
+	const enabled = opts.enabled !== false;
+	const paramsKey = JSON.stringify(opts.params);
+	const sqlWithParams = React.useMemo(() => interpolateSqlParams(input.sql, opts.params ?? {}), [input.sql, paramsKey]);
+	const [state, setState] = React.useState({
+		rows: [],
+		columns: [],
+		loading: enabled && !!projectId,
+		error: null
+	});
+	const [nonce, setNonce] = React.useState(0);
+	React.useEffect(() => {
+		if (!enabled || !projectId) {
+			setState((s) => s.loading ? {
+				...s,
+				loading: false
+			} : s);
+			return;
+		}
+		let cancelled = false;
+		const cached = getCached(projectId, sqlWithParams, input.database);
+		if (cached && nonce === 0) {
+			const { columns, rows } = cached;
+			const objects = rows.map((r) => Object.fromEntries(columns.map((c, i) => [c, r[i]])));
+			setState({
+				rows: objects,
+				columns,
+				loading: false,
+				error: null
+			});
+			return;
+		}
+		setState((s) => ({
+			...s,
+			loading: true,
+			error: null
+		}));
+		sharedQuery(fetcher, projectId, sqlWithParams, input.database, { force: nonce > 0 }).then(({ columns, rows }) => {
+			if (cancelled) return;
+			const objects = rows.map((r) => Object.fromEntries(columns.map((c, i) => [c, r[i]])));
+			setState({
+				rows: objects,
+				columns,
+				loading: false,
+				error: null
+			});
+		}).catch((err) => {
+			if (cancelled) return;
+			setState((s) => ({
+				...s,
+				loading: false,
+				error: err instanceof Error ? err : new Error(String(err))
+			}));
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		enabled,
+		projectId,
+		sqlWithParams,
+		input.database,
+		nonce,
+		fetcher
+	]);
+	return {
+		rows: state.rows,
+		columns: state.columns,
+		loading: state.loading,
+		error: state.error,
+		refetch: () => setNonce((n) => n + 1)
+	};
+}
+/**
+* Imperative hook for invoking an Oxy Function by name.
+*
+* ```tsx
+* const refresh = useFunction("refresh-sales");
+* <button disabled={refresh.isLoading} onClick={() => refresh.invoke({ full: true })}>
+*   Refresh
+* </button>
+* ```
+*/
+function useFunction(name) {
+	const ctx = React.useContext(OxyAppContext);
+	if (!ctx) throw new Error("useFunction must be called inside <OxyAppProvider>");
+	const fetcher = ctx.fetcher;
+	const resolved = ctx.resolved;
+	const [state, setState] = React.useState({
+		data: null,
+		isLoading: false,
+		error: null,
+		logs: []
+	});
+	return {
+		invoke: React.useCallback(async (body, opts) => {
+			if (!resolved) throw new Error("useFunction.invoke called before the manifest finished loading. Render behind the provider's `fallback` until ready.");
+			const { orgSlug, appSlug, apiBaseUrl } = resolved;
+			const url = `${apiBaseUrl || ""}/customer-apps/${encodeURIComponent(orgSlug)}/${encodeURIComponent(appSlug)}/fn/${encodeURIComponent(name)}`;
+			setState((s) => ({
+				...s,
+				isLoading: true,
+				error: null
+			}));
+			try {
+				const headers = {
+					"content-type": "application/json",
+					accept: "text/event-stream"
+				};
+				if (opts?.idempotencyKey) headers["idempotency-key"] = opts.idempotencyKey;
+				const result = await sharedFunctionInvoke(functionInvokeKey(name, body), async () => {
+					const resp = await fetcher(url, {
+						method: "POST",
+						headers,
+						body: JSON.stringify(body ?? {})
+					});
+					if (!resp.ok && resp.status !== 200) throw await apiErrorFromResponse(resp);
+					return readFunctionSseStream(resp);
+				});
+				setState({
+					data: result.value,
+					isLoading: false,
+					error: null,
+					logs: result.logs
+				});
+				return result.value;
+			} catch (err) {
+				const e = err instanceof Error ? err : new Error(String(err));
+				const logs = e.logs ?? [];
+				setState((s) => ({
+					...s,
+					isLoading: false,
+					error: e,
+					logs
+				}));
+				throw e;
+			}
+		}, [
+			resolved,
+			fetcher,
+			name
+		]),
+		data: state.data,
+		isLoading: state.isLoading,
+		error: state.error,
+		logs: state.logs
+	};
+}
+/**
+* Run a semantic-layer query against the project's `.view.yml` /
+* `.topic.yml` definitions. The server compiles to SQL and executes
+* through the same connector path as `useQuery`, so result shape
+* matches.
+*
+* Re-runs whenever the input shape changes (deep-compared via JSON).
+* Use `opts.enabled = false` to defer the first fetch until required
+* inputs (e.g. a user-picked filter value) are available.
+*/
+function useSemanticQuery(input, opts = {}) {
+	const { projectId, fetcher } = useOxyApp();
+	const enabled = opts.enabled !== false;
+	const debug = opts.debug === true;
+	const inputKey = React.useMemo(() => JSON.stringify(input), [input]);
+	const [state, setState] = React.useState({
+		rows: [],
+		columns: [],
+		truncated: false,
+		sql: null,
+		loading: enabled && !!projectId,
+		error: null
+	});
+	const [nonce, setNonce] = React.useState(0);
+	React.useEffect(() => {
+		if (!enabled || !projectId) {
+			setState((s) => s.loading ? {
+				...s,
+				loading: false
+			} : s);
+			return;
+		}
+		const ctrl = new AbortController();
+		let cancelled = false;
+		setState((s) => ({
+			...s,
+			loading: true,
+			error: null
+		}));
+		const body = JSON.stringify({
+			v: 1,
+			topic: input.topic,
+			dimensions: input.dimensions ?? [],
+			measures: input.measures ?? [],
+			time_dimensions: input.time_dimensions ?? [],
+			filters: input.filters ?? [],
+			...input.limit != null ? { limit: input.limit } : {}
+		});
+		const url = `/api/projects/${projectId}/semantic-query${debug ? "?debug=1" : ""}`;
+		fetcher(url, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body,
+			signal: ctrl.signal
+		}).then(async (resp) => {
+			if (!resp.ok) throw await apiErrorFromResponse(resp);
+			return resp.json();
+		}).then(({ columns, rows, truncated, sql }) => {
+			if (cancelled) return;
+			const objects = rows.map((r) => Object.fromEntries(columns.map((c, i) => [c, r[i]])));
+			setState({
+				rows: objects,
+				columns,
+				truncated,
+				sql: sql ?? null,
+				loading: false,
+				error: null
+			});
+		}).catch((err) => {
+			if (cancelled) return;
+			if (err instanceof DOMException && err.name === "AbortError") return;
+			setState((s) => ({
+				...s,
+				loading: false,
+				error: err instanceof Error ? err : new Error(String(err))
+			}));
+		});
+		return () => {
+			cancelled = true;
+			ctrl.abort();
+		};
+	}, [
+		enabled,
+		projectId,
+		inputKey,
+		debug,
+		nonce,
+		fetcher
+	]);
+	return {
+		rows: state.rows,
+		columns: state.columns,
+		truncated: state.truncated,
+		sql: state.sql,
+		loading: state.loading,
+		error: state.error,
+		refetch: () => setNonce((n) => n + 1)
+	};
+}
+const PROCEDURE_POLL_MS = 2e3;
+const PROCEDURE_BACKOFF_MS = 5e3;
+const PROCEDURE_MAX_WAIT_MS = 3600 * 1e3;
+/**
+* @beta Long-running procedure runner. The wire shape works end-to-end
+* (start → poll → cancel; runs survive server restarts via the
+* `customer_app_procedure_runs` table) but a few rough edges remain
+* before this is GA-ready:
+*
+*   - Hint surfaces for `procedure_not_found` are correct but the
+*     procedure-discovery rules (which directories the server scans,
+*     case-sensitivity, branch awareness) aren't documented yet.
+*   - Cancellation across multi-instance deployments leans on a
+*     periodic sweep — fine for now, but expect occasional latency
+*     between `cancel()` and the run actually stopping.
+*   - Progress reporting requires the procedure to emit named
+*     steps; bundles get `progress: null` until that lands.
+*
+* The API surface is stable; expect breaking changes only if the
+* server-side `customer_app_procedure_runs` schema changes.
+*/
+function useProcedureRun(input, opts = {}) {
+	warnBetaOnce("useProcedureRun");
+	const { projectId, fetcher } = useOxyApp();
+	const pollMs = opts.pollIntervalMs ?? PROCEDURE_POLL_MS;
+	const backoffMs = opts.pollIntervalBackoffMs ?? PROCEDURE_BACKOFF_MS;
+	const maxWaitMs = opts.maxWaitMs ?? PROCEDURE_MAX_WAIT_MS;
+	const [state, setState] = React.useState({
+		state: "idle",
+		progress: null,
+		result: null,
+		error: null
+	});
+	const inflight = React.useRef({});
+	const cancel = React.useCallback(() => {
+		const runId = inflight.current.runId;
+		if (!projectId || !runId) return;
+		inflight.current.abort?.abort();
+		inflight.current.runId = void 0;
+		fetcher(`/api/projects/${projectId}/procedures/runs/${encodeURIComponent(runId)}/cancel`, { method: "POST" }).catch(() => {});
+		setState({
+			state: "failed",
+			progress: null,
+			result: null,
+			error: /* @__PURE__ */ new Error("procedure cancelled by user")
+		});
+	}, [projectId, fetcher]);
+	const run = React.useCallback((params) => {
+		if (!projectId) {
+			setState((s) => ({
+				...s,
+				state: "failed",
+				error: /* @__PURE__ */ new Error("project not configured")
+			}));
+			return;
+		}
+		inflight.current.abort?.abort();
+		const ctrl = new AbortController();
+		inflight.current = { abort: ctrl };
+		setState({
+			state: "running",
+			progress: null,
+			result: null,
+			error: null
+		});
+		(async () => {
+			try {
+				const body = JSON.stringify({
+					v: 1,
+					...params ? { params } : {}
+				});
+				const startResp = await fetcher(`/api/projects/${projectId}/procedures/${encodeURIComponent(input.procedureId)}/runs`, {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body,
+					signal: ctrl.signal
+				});
+				if (!startResp.ok) throw await apiErrorFromResponse(startResp);
+				const { run_id } = await startResp.json();
+				inflight.current.runId = run_id;
+				const startedAt = Date.now();
+				let pollCount = 0;
+				while (true) {
+					if (ctrl.signal.aborted) return;
+					if (Date.now() - startedAt > maxWaitMs) throw new Error("procedure run timed out client-side");
+					await sleep(pollCount < 6 ? pollMs : backoffMs, ctrl.signal);
+					if (ctrl.signal.aborted) return;
+					pollCount += 1;
+					const pollResp = await fetcher(`/api/projects/${projectId}/procedures/runs/${encodeURIComponent(run_id)}`, {
+						method: "GET",
+						signal: ctrl.signal
+					});
+					if (!pollResp.ok) throw await apiErrorFromResponse(pollResp);
+					const poll = await pollResp.json();
+					if (poll.status === "running") {
+						if (poll.progress) setState((s) => ({
+							...s,
+							progress: poll.progress ?? null
+						}));
+						continue;
+					}
+					if (poll.status === "done") {
+						inflight.current.runId = void 0;
+						setState({
+							state: "done",
+							progress: null,
+							result: poll.result,
+							error: null
+						});
+						return;
+					}
+					if (poll.status === "cancelled") {
+						inflight.current.runId = void 0;
+						setState({
+							state: "failed",
+							progress: null,
+							result: null,
+							error: /* @__PURE__ */ new Error("procedure cancelled")
+						});
+						return;
+					}
+					inflight.current.runId = void 0;
+					setState({
+						state: "failed",
+						progress: null,
+						result: null,
+						error: new Error(poll.error.message)
+					});
+					return;
+				}
+			} catch (e) {
+				if (e instanceof DOMException && e.name === "AbortError") return;
+				inflight.current.runId = void 0;
+				setState({
+					state: "failed",
+					progress: null,
+					result: null,
+					error: e instanceof Error ? e : new Error(String(e))
+				});
+			}
+		})();
+	}, [
+		projectId,
+		fetcher,
+		input.procedureId,
+		pollMs,
+		backoffMs,
+		maxWaitMs
+	]);
+	React.useEffect(() => {
+		return () => {
+			inflight.current.abort?.abort();
+		};
+	}, []);
+	return {
+		state: state.state,
+		run,
+		cancel,
+		progress: state.progress,
+		result: state.result,
+		error: state.error
+	};
+}
+function useAgentRun(input) {
+	const { projectId, fetcher } = useOxyApp();
+	const [state, setState] = React.useState({
+		state: "idle",
+		events: [],
+		artifacts: [],
+		answer: null,
+		clarification: null,
+		threadId: null,
+		threadUrl: null,
+		error: null
+	});
+	const inflight = React.useRef({});
+	const cancel = React.useCallback(() => {
+		const runId = inflight.current.runId;
+		if (!projectId || !runId) return;
+		inflight.current.abort?.abort();
+		inflight.current.runId = void 0;
+		fetcher(`/api/projects/${projectId}/agents/asks/${encodeURIComponent(runId)}/cancel`, { method: "POST" }).catch(() => {});
+		setState((s) => ({
+			...s,
+			state: "failed",
+			error: /* @__PURE__ */ new Error("agent run cancelled by user")
+		}));
+	}, [projectId, fetcher]);
+	const ask = React.useCallback((question, opts = {}) => {
+		if (!projectId) {
+			setState((s) => ({
+				...s,
+				state: "failed",
+				error: /* @__PURE__ */ new Error("project not configured")
+			}));
+			return;
+		}
+		inflight.current.abort?.abort();
+		const ctrl = new AbortController();
+		inflight.current = { abort: ctrl };
+		setState({
+			state: "running",
+			events: [],
+			artifacts: [],
+			answer: null,
+			clarification: null,
+			threadId: opts.threadId ?? null,
+			threadUrl: opts.threadId ? `/threads/${opts.threadId}` : null,
+			error: null
+		});
+		(async () => {
+			try {
+				const body = JSON.stringify({
+					v: 1,
+					question,
+					...opts.threadId ? { thread_id: opts.threadId } : {}
+				});
+				const startResp = await fetcher(`/api/projects/${projectId}/agents/${encodeURIComponent(input.agentId)}/asks`, {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body,
+					signal: ctrl.signal
+				});
+				if (!startResp.ok) throw await apiErrorFromResponse(startResp);
+				const { run_id, thread_id, thread_url } = await startResp.json();
+				inflight.current.runId = run_id;
+				setState((s) => ({
+					...s,
+					threadId: thread_id,
+					threadUrl: thread_url ?? `/threads/${thread_id}`
+				}));
+				let lastEventId = "";
+				let attempts = 0;
+				let terminated = false;
+				while (true) {
+					if (ctrl.signal.aborted) return;
+					if (terminated) return;
+					attempts += 1;
+					try {
+						await consumeSseStream({
+							url: `/api/projects/${projectId}/agents/runs/${encodeURIComponent(run_id)}/events`,
+							fetcher,
+							signal: ctrl.signal,
+							lastEventId,
+							onEvent: (ev) => {
+								if (ev.id) lastEventId = ev.id;
+								const data = parseSseData(ev.data);
+								const eventType = ev.event || "message";
+								const artifact = extractSqlArtifact(eventType, ev.id, data);
+								const token = eventType === "text_delta" && typeof data === "object" && data !== null && "token" in data ? String(data.token) : null;
+								setState((s) => ({
+									...s,
+									events: [...s.events, {
+										type: eventType,
+										data
+									}],
+									artifacts: artifact ? [...s.artifacts, artifact] : s.artifacts,
+									answer: token !== null ? (s.answer ?? "") + token : s.answer
+								}));
+								if (ev.event === "done") {
+									terminated = true;
+									inflight.current.runId = void 0;
+									setState((s) => ({
+										...s,
+										state: "done"
+									}));
+								} else if (ev.event === "failed" || ev.event === "error" || ev.event === "cancelled") {
+									terminated = true;
+									inflight.current.runId = void 0;
+									const message = typeof data === "object" && data !== null && "message" in data ? String(data.message) : `agent run ${ev.event}`;
+									setState((s) => ({
+										...s,
+										state: "failed",
+										error: new Error(message)
+									}));
+								} else if (ev.event === "awaiting_input") {
+									terminated = true;
+									const clarification = clarificationFromData(data) ?? "Agent needs clarification.";
+									setState((s) => ({
+										...s,
+										state: "needs_clarification",
+										clarification
+									}));
+								}
+							}
+						});
+					} catch (err) {
+						if (err instanceof DOMException && err.name === "AbortError") return;
+						if (attempts >= 5) {
+							inflight.current.runId = void 0;
+							setState((s) => ({
+								...s,
+								state: "failed",
+								error: err instanceof Error ? err : new Error(String(err))
+							}));
+							return;
+						}
+					}
+					if (terminated) return;
+					if (attempts >= 5) {
+						inflight.current.runId = void 0;
+						setState((s) => ({
+							...s,
+							state: "failed",
+							error: /* @__PURE__ */ new Error("run event stream closed without a terminal event")
+						}));
+						return;
+					}
+					await sleep(1e3, ctrl.signal);
+				}
+			} catch (e) {
+				if (e instanceof DOMException && e.name === "AbortError") return;
+				inflight.current.runId = void 0;
+				setState((s) => ({
+					...s,
+					state: "failed",
+					error: e instanceof Error ? e : new Error(String(e))
+				}));
+			}
+		})();
+	}, [
+		projectId,
+		fetcher,
+		input.agentId
+	]);
+	React.useEffect(() => {
+		return () => {
+			inflight.current.abort?.abort();
+		};
+	}, []);
+	return {
+		state: state.state,
+		ask,
+		cancel,
+		events: state.events,
+		artifacts: state.artifacts,
+		answer: state.answer,
+		clarification: state.clarification,
+		threadId: state.threadId,
+		threadUrl: state.threadUrl,
+		error: state.error
+	};
+}
+/** Parsed JSON payload of an SSE `data:` line, falling back to raw
+*  string on parse failure. */
+function parseSseData(raw) {
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return raw;
+	}
+}
+/** Extract the clarifying-question text from an `awaiting_input` payload.
+*  The server sends `{ questions: [{ prompt, suggestions }] }`; older shapes
+*  used a single `{ question }`. Returns null when neither is present. */
+function clarificationFromData(data) {
+	if (typeof data !== "object" || data === null) return null;
+	const d = data;
+	const first = (Array.isArray(d.questions) ? d.questions : [])[0];
+	if (first && typeof first.prompt === "string") return first.prompt;
+	if (typeof d.question === "string") return d.question;
+	return null;
+}
+/** UI event types in the analytics taxonomy that carry SQL the bundle
+*  may want to render alongside the answer. Each carries the same
+*  shape (`query` / `columns` / `rows` / `success`) so we can parse
+*  uniformly. New types added upstream don't surface as artifacts
+*  until added here — that's intentional, the renderer needs to
+*  know how to display each. */
+const SQL_EVENT_TYPES = /* @__PURE__ */ new Set([
+	"query_executed",
+	"query_generated",
+	"verified_sql",
+	"semantic_query",
+	"omni_query"
+]);
+/** Extract a SQL artifact from a single SSE event when the type +
+*  payload shape match. Returns `null` for events that aren't SQL
+*  carriers or whose payload doesn't include the expected fields. */
+function extractSqlArtifact(eventType, eventId, data) {
+	if (!SQL_EVENT_TYPES.has(eventType)) return null;
+	if (typeof data !== "object" || data === null) return null;
+	const obj = data;
+	const sql = typeof obj.query === "string" ? obj.query : typeof obj.sql === "string" ? obj.sql : null;
+	if (!sql) return null;
+	const columns = Array.isArray(obj.columns) ? obj.columns.map(String) : void 0;
+	const rows = Array.isArray(obj.rows) ? obj.rows : void 0;
+	const rowCount = typeof obj.row_count === "number" ? obj.row_count : typeof obj.rowCount === "number" ? obj.rowCount : rows?.length;
+	const artifact = {
+		type: "sql",
+		id: eventId || `${eventType}-${sql.slice(0, 32)}`,
+		source: eventType,
+		sql
+	};
+	if (columns && rows) artifact.results = {
+		columns,
+		rows,
+		rowCount: rowCount ?? rows.length
+	};
+	const errMsg = typeof obj.error === "string" ? obj.error : obj.success === false && typeof obj.message === "string" ? obj.message : void 0;
+	if (errMsg) artifact.error = errMsg;
+	return artifact;
+}
+/**
+* Hand-rolled SSE consumer using `fetch` + `ReadableStream`. We use
+* this in place of `EventSource` because:
+*   1. EventSource doesn't expose the connection's `Last-Event-ID`
+*      header in a way you can control. The browser tracks it
+*      internally but you can't pass a starting value, so a hook
+*      that wants to resume after a tab switch / network blip has
+*      no way to ask the server to replay from a known point.
+*   2. EventSource can't pass `Authorization` / other custom
+*      headers — only `withCredentials` for cookies. Fine today,
+*      but couples us to cookie auth forever.
+*
+* The parser handles the message-block model from the SSE spec
+* verbatim: lines split by `\n` (or `\r\n` / `\r`), event blocks
+* separated by blank lines, `id:` / `event:` / `data:` fields
+* accumulated per block. Multiple `data:` lines concatenate with
+* `\n` (per spec) — we honor that even though the server emits
+* single-line data today.
+*
+* Throws on network error or non-2xx. Returns when the stream ends
+* normally (server closed connection cleanly).
+*/
+async function consumeSseStream(opts) {
+	const headers = {
+		accept: "text/event-stream",
+		"cache-control": "no-cache"
+	};
+	if (opts.lastEventId) headers["Last-Event-ID"] = opts.lastEventId;
+	const resp = await opts.fetcher(opts.url, {
+		method: "GET",
+		headers,
+		signal: opts.signal
+	});
+	if (!resp.ok) throw await apiErrorFromResponse(resp);
+	if (!resp.body) throw new Error("SSE response has no body");
+	const reader = resp.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let currentId = "";
+	let currentEvent = "message";
+	let currentData = [];
+	const dispatch = () => {
+		if (currentData.length === 0 && currentEvent === "message" && !currentId) return;
+		opts.onEvent({
+			id: currentId,
+			event: currentEvent,
+			data: currentData.join("\n")
+		});
+		currentEvent = "message";
+		currentData = [];
+	};
+	while (true) {
+		const { value, done } = await reader.read();
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+		let nlIndex;
+		while ((nlIndex = buffer.search(/\r\n|\r|\n/)) !== -1) {
+			if (nlIndex === buffer.length - 1 && buffer[nlIndex] === "\r") break;
+			const line = buffer.slice(0, nlIndex);
+			const sep = buffer.slice(nlIndex, nlIndex + 2);
+			buffer = buffer.slice(nlIndex + (sep === "\r\n" ? 2 : 1));
+			if (line === "") {
+				dispatch();
+				continue;
+			}
+			if (line.startsWith(":")) continue;
+			const colonAt = line.indexOf(":");
+			const field = colonAt === -1 ? line : line.slice(0, colonAt);
+			let value = colonAt === -1 ? "" : line.slice(colonAt + 1);
+			if (value.startsWith(" ")) value = value.slice(1);
+			switch (field) {
+				case "id":
+					currentId = value;
+					break;
+				case "event":
+					currentEvent = value;
+					break;
+				case "data":
+					currentData.push(value);
+					break;
+			}
+		}
+	}
+	if (currentData.length > 0) dispatch();
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		const t = setTimeout(resolve, ms);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(t);
+			reject(new DOMException("aborted", "AbortError"));
+		}, { once: true });
+	});
+}
+/**
+* Engineer-tagged usage event. Free-form `event_name` (≤ 64 chars,
+* `[a-z][a-z0-9-]*` validated server-side) + optional JSON `payload`
+* (object, ≤ 4 KiB serialized). Surfaces in the admin Activity tab
+* grouped by name, with drill-down into recent occurrences.
+*
+* The handler returned by [`useTrackEvent`] is **fire-and-forget**:
+* it enqueues the event into an in-memory batch flushed every second
+* (and on `pagehide` so a navigation away doesn't drop the tail).
+* No await semantics — call it inline from a click handler without
+* awaiting it. Server-side validation errors are logged to the
+* console; the call site doesn't need to handle them.
+*
+* Example:
+* ```tsx
+* const track = useTrackEvent();
+* <button
+*   onClick={() => {
+*     track("export-clicked", { format: "csv", rowCount });
+*     doExport();
+*   }}
+* >Export</button>
+* ```
+*
+* Rate-limited at 60/min per (user, app) on the server. A burst that
+* trips the limit drops the excess events with a console warning;
+* within-limit events are unaffected.
+*/
+function useTrackEvent() {
+	const { projectId, fetcher } = useOxyApp();
+	const queueRef = React.useRef([]);
+	const flushTimerRef = React.useRef(null);
+	const flush = React.useCallback(() => {
+		flushTimerRef.current = null;
+		if (!projectId) return;
+		const batch = queueRef.current;
+		if (batch.length === 0) return;
+		queueRef.current = [];
+		for (const evt of batch) {
+			const url = `/api/customer-apps/${projectId}/events`;
+			const body = JSON.stringify(evt);
+			try {
+				if (typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function" && document.visibilityState === "hidden") navigator.sendBeacon(url, new Blob([body], { type: "application/json" }));
+				else fetcher(url, {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body
+				}).catch((e) => {
+					console.warn("[oxy] useTrackEvent flush failed:", e);
+				});
+			} catch (e) {
+				console.warn("[oxy] useTrackEvent enqueue failed:", e);
+			}
+		}
+	}, [projectId, fetcher]);
+	React.useEffect(() => {
+		if (typeof window === "undefined") return;
+		const onHide = () => flush();
+		window.addEventListener("pagehide", onHide);
+		return () => {
+			window.removeEventListener("pagehide", onHide);
+			flush();
+			if (flushTimerRef.current !== null) {
+				clearTimeout(flushTimerRef.current);
+				flushTimerRef.current = null;
+			}
+		};
+	}, [flush]);
+	return React.useCallback((name, payload) => {
+		queueRef.current.push({
+			event_name: name,
+			payload: payload ?? {}
+		});
+		if (flushTimerRef.current === null) flushTimerRef.current = setTimeout(flush, 1e3);
+	}, [flush]);
+}
+/**
+* Renders an agent run's answer + artifacts + thread link as a
+* single block. The default styling is intentionally neutral
+* (system fonts, gray surfaces) so it blends into any bundle.
+*
+* Designed to be paired with `useAgentRun`:
+*
+* ```tsx
+* const run = useAgentRun({ agentId: "analyst" });
+* return (
+*   <>
+*     <button onClick={() => run.ask("how many users last week?")}>Ask</button>
+*     <OxyAnswer {...run} />
+*   </>
+* );
+* ```
+*/
+function OxyAnswer(props) {
+	ensureSpinKeyframes();
+	const { answer, artifacts = [], state, clarification, error, threadUrl, threadLinkLabel = "Continue this thread in Oxy", maxArtifactRows = 10, className } = props;
+	const isRunning = state === "running";
+	const isFailed = state === "failed";
+	const needsClarification = state === "needs_clarification";
+	return /* @__PURE__ */ jsxs("div", {
+		className,
+		style: styles.answerWrap,
+		children: [
+			isRunning && answer === null ? /* @__PURE__ */ jsxs("div", {
+				style: styles.statusRow,
+				children: [/* @__PURE__ */ jsx("span", {
+					style: styles.spinner,
+					"aria-hidden": "true"
+				}), /* @__PURE__ */ jsx("span", {
+					style: styles.statusText,
+					children: "Thinking…"
+				})]
+			}) : null,
+			artifacts.length > 0 ? /* @__PURE__ */ jsx("div", {
+				style: styles.artifactList,
+				children: artifacts.map((a) => /* @__PURE__ */ jsx(SqlArtifactBlock, {
+					artifact: a,
+					maxRows: maxArtifactRows
+				}, a.id))
+			}) : null,
+			answer ? /* @__PURE__ */ jsx("div", {
+				style: styles.markdown,
+				children: /* @__PURE__ */ jsx(MarkdownText, { text: answer })
+			}) : null,
+			needsClarification && clarification ? /* @__PURE__ */ jsxs("div", {
+				style: styles.clarification,
+				children: [/* @__PURE__ */ jsx("strong", { children: "Agent needs clarification:" }), /* @__PURE__ */ jsx("div", {
+					style: { marginTop: 4 },
+					children: clarification
+				})]
+			}) : null,
+			isFailed && error ? /* @__PURE__ */ jsx(ErrorBlock, { error }) : null,
+			threadUrl && (answer || artifacts.length > 0) ? /* @__PURE__ */ jsxs("div", {
+				style: styles.threadLinkRow,
+				children: [/* @__PURE__ */ jsxs("a", {
+					href: threadUrl,
+					target: "_blank",
+					rel: "noreferrer noopener",
+					style: styles.threadLink,
+					children: [threadLinkLabel, " →"]
+				}), /* @__PURE__ */ jsx("span", {
+					style: styles.betaBadge,
+					title: "Thread linking is in beta — see docs",
+					children: "beta"
+				})]
+			}) : null
+		]
+	});
+}
+/**
+* Complete drop-in chat surface. One agent, one input, one answer
+* view. The chat is single-turn by default — each new question
+* cancels the previous run and clears the answer. Bundles that
+* want a multi-turn conversation history compose their own UI
+* using `useAgentRun` directly.
+*
+* Single-turn keeps the surface dead simple: bundles use this for
+* the "ask anything about your data" widget that sits next to
+* structured panels. Multi-turn is rare in those contexts and
+* better expressed by the bundle.
+*/
+function OxyChat(props) {
+	ensureSpinKeyframes();
+	const { agentId, placeholder = "Ask a question about your data…", submitLabel = "Ask", emptyState, maxArtifactRows, className } = props;
+	const run = useAgentRun({ agentId });
+	const [question, setQuestion] = React.useState("");
+	const submit = React.useCallback((e) => {
+		e?.preventDefault();
+		const q = question.trim();
+		if (!q || run.state === "running") return;
+		run.ask(q);
+	}, [question, run]);
+	return /* @__PURE__ */ jsxs("div", {
+		className,
+		style: styles.chatWrap,
+		children: [/* @__PURE__ */ jsxs("form", {
+			onSubmit: submit,
+			style: styles.chatForm,
+			children: [
+				/* @__PURE__ */ jsx("input", {
+					type: "text",
+					value: question,
+					onChange: (e) => setQuestion(e.target.value),
+					placeholder,
+					disabled: run.state === "running",
+					style: styles.chatInput,
+					"aria-label": "Question"
+				}),
+				/* @__PURE__ */ jsx("button", {
+					type: "submit",
+					disabled: run.state === "running" || question.trim() === "",
+					style: styles.chatSubmit,
+					children: run.state === "running" ? "…" : submitLabel
+				}),
+				run.state === "running" ? /* @__PURE__ */ jsx("button", {
+					type: "button",
+					onClick: run.cancel,
+					style: styles.chatCancel,
+					children: "Stop"
+				}) : null
+			]
+		}), run.state === "idle" ? emptyState ?? /* @__PURE__ */ jsx("div", {
+			style: styles.emptyState,
+			children: "Ask a question to get started."
+		}) : /* @__PURE__ */ jsx(OxyAnswer, {
+			answer: run.answer,
+			artifacts: run.artifacts,
+			state: run.state,
+			clarification: run.clarification,
+			error: run.error,
+			threadUrl: run.threadUrl,
+			maxArtifactRows
+		})]
+	});
+}
+function SqlArtifactBlock(props) {
+	const { artifact, maxRows } = props;
+	const [open, setOpen] = React.useState(false);
+	const results = artifact.results;
+	const truncated = results ? results.rows.length > maxRows : false;
+	const visibleRows = results ? results.rows.slice(0, maxRows) : [];
+	const sourceLabel = artifact.source === "verified_sql" ? "Verified query" : artifact.source === "semantic_query" ? "Semantic query" : artifact.source === "omni_query" ? "Omni query" : "Query";
+	return /* @__PURE__ */ jsxs("div", {
+		style: styles.artifact,
+		children: [/* @__PURE__ */ jsxs("button", {
+			type: "button",
+			onClick: () => setOpen((o) => !o),
+			style: styles.artifactHeader,
+			children: [
+				/* @__PURE__ */ jsx("span", {
+					style: styles.artifactBadge,
+					children: sourceLabel
+				}),
+				/* @__PURE__ */ jsx("span", {
+					style: styles.artifactSummary,
+					children: results ? `${results.rowCount} row${results.rowCount === 1 ? "" : "s"}` : artifact.error ? "execution failed" : "SQL only"
+				}),
+				/* @__PURE__ */ jsx("span", {
+					style: styles.artifactToggle,
+					children: open ? "Hide" : "Show"
+				})
+			]
+		}), open ? /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("pre", {
+			style: styles.sqlBlock,
+			children: artifact.sql
+		}), artifact.error ? /* @__PURE__ */ jsx("div", {
+			style: styles.error,
+			children: artifact.error
+		}) : results ? /* @__PURE__ */ jsxs("div", {
+			style: styles.resultsWrap,
+			children: [/* @__PURE__ */ jsxs("table", {
+				style: styles.resultsTable,
+				children: [/* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsx("tr", { children: results.columns.map((c) => /* @__PURE__ */ jsx("th", {
+					style: styles.resultsTh,
+					children: c
+				}, c)) }) }), /* @__PURE__ */ jsx("tbody", { children: visibleRows.map((row, i) => /* @__PURE__ */ jsx("tr", { children: row.map((cell, j) => /* @__PURE__ */ jsx("td", {
+					style: styles.resultsTd,
+					children: formatCell(cell)
+				}, j)) }, i)) })]
+			}), truncated ? /* @__PURE__ */ jsxs("div", {
+				style: styles.truncatedNote,
+				children: [
+					"+",
+					results.rows.length - maxRows,
+					" more rows. Open the thread in Oxy to see all."
+				]
+			}) : null]
+		}) : null] }) : null]
+	});
+}
+function formatCell(value) {
+	if (value === null || value === void 0) return "—";
+	if (typeof value === "object") return JSON.stringify(value);
+	return String(value);
+}
+/**
+* Renders a thrown Error with the server's `hint` line broken out
+* if the error is an `OxyApiError`. Falls back to `error.message`
+* for plain Errors. Whitespace-preserving so multi-line hints from
+* the server land readably.
+*/
+function ErrorBlock(props) {
+	const { error } = props;
+	if (error instanceof OxyApiError) return /* @__PURE__ */ jsxs("div", {
+		style: styles.error,
+		children: [/* @__PURE__ */ jsxs("div", { children: [
+			/* @__PURE__ */ jsx("strong", { children: "Run failed:" }),
+			" ",
+			error.message.split("\n\n")[0]
+		] }), error.hint ? /* @__PURE__ */ jsxs("div", {
+			style: {
+				marginTop: 6,
+				fontWeight: 400,
+				whiteSpace: "pre-wrap"
+			},
+			children: [
+				/* @__PURE__ */ jsx("strong", { children: "Hint:" }),
+				" ",
+				error.hint
+			]
+		}) : null]
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		style: styles.error,
+		children: [
+			/* @__PURE__ */ jsx("strong", { children: "Run failed:" }),
+			" ",
+			error.message
+		]
+	});
+}
+function MarkdownText(props) {
+	return /* @__PURE__ */ jsx(Fragment$1, { children: React.useMemo(() => parseMarkdown(props.text), [props.text]) });
+}
+function parseMarkdown(text) {
+	const lines = text.replace(/\r\n/g, "\n").split("\n");
+	const blocks = [];
+	let i = 0;
+	while (i < lines.length) {
+		const line = lines[i];
+		if (line === void 0) {
+			i++;
+			continue;
+		}
+		const fence = line.match(/^```(\w*)\s*$/);
+		if (fence) {
+			const lang = fence[1] ?? "";
+			const buf = [];
+			i++;
+			while (i < lines.length && !/^```\s*$/.test(lines[i] ?? "")) {
+				buf.push(lines[i] ?? "");
+				i++;
+			}
+			i++;
+			blocks.push({
+				kind: "code",
+				lang,
+				code: buf.join("\n")
+			});
+			continue;
+		}
+		const h = line.match(/^(#{1,3})\s+(.+)$/);
+		if (h) {
+			blocks.push({
+				kind: "h",
+				level: h[1]?.length,
+				text: h[2]
+			});
+			i++;
+			continue;
+		}
+		if (isTableStart(lines, i)) {
+			const headers = splitTableRow(line);
+			i += 2;
+			const rows = [];
+			while (i < lines.length && (lines[i] ?? "").includes("|") && (lines[i] ?? "").trim() !== "") {
+				rows.push(splitTableRow(lines[i] ?? ""));
+				i++;
+			}
+			blocks.push({
+				kind: "table",
+				headers,
+				rows
+			});
+			continue;
+		}
+		if (/^\s*[-*]\s+/.test(line)) {
+			const items = [];
+			while (i < lines.length && /^\s*[-*]\s+/.test(lines[i] ?? "")) {
+				items.push((lines[i] ?? "").replace(/^\s*[-*]\s+/, ""));
+				i++;
+			}
+			blocks.push({
+				kind: "list",
+				items
+			});
+			continue;
+		}
+		if (line.trim() === "") {
+			i++;
+			continue;
+		}
+		const buf = [line];
+		i++;
+		while (i < lines.length) {
+			const next = lines[i] ?? "";
+			if (next.trim() === "" || /^#{1,3}\s+/.test(next) || /^```/.test(next) || /^\s*[-*]\s+/.test(next) || isTableStart(lines, i)) break;
+			buf.push(next);
+			i++;
+		}
+		blocks.push({
+			kind: "p",
+			text: buf.join(" ")
+		});
+	}
+	return blocks.map((b, idx) => {
+		switch (b.kind) {
+			case "h": return /* @__PURE__ */ jsx(`h${b.level}`, {
+				style: b.level === 1 ? styles.h1 : b.level === 2 ? styles.h2 : styles.h3,
+				children: renderInline(b.text)
+			}, idx);
+			case "code": return /* @__PURE__ */ jsx("pre", {
+				style: styles.codeBlock,
+				"data-lang": b.lang || void 0,
+				children: /* @__PURE__ */ jsx("code", { children: b.code })
+			}, idx);
+			case "list": return /* @__PURE__ */ jsx("ul", {
+				style: styles.list,
+				children: b.items.map((item, i) => /* @__PURE__ */ jsx("li", { children: renderInline(item) }, i))
+			}, idx);
+			case "table": return /* @__PURE__ */ jsx("div", {
+				style: styles.mdTableWrap,
+				children: /* @__PURE__ */ jsxs("table", {
+					style: styles.mdTable,
+					children: [/* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsx("tr", { children: b.headers.map((h, hi) => /* @__PURE__ */ jsx("th", {
+						style: styles.mdTh,
+						children: renderInline(h)
+					}, `${hi}-${h}`)) }) }), /* @__PURE__ */ jsx("tbody", { children: b.rows.map((row, ri) => /* @__PURE__ */ jsx("tr", { children: b.headers.map((_h, ci) => /* @__PURE__ */ jsx("td", {
+						style: styles.mdTd,
+						children: renderInline(row[ci] ?? "")
+					}, ci)) }, `${ri}-${row[0] ?? ""}`)) })]
+				})
+			}, idx);
+			case "p": return /* @__PURE__ */ jsx("p", {
+				style: styles.paragraph,
+				children: renderInline(b.text)
+			}, idx);
+		}
+	});
+}
+/**
+* Inline tokenizer for **bold**, *italic*, `code`, and [text](url).
+* Lazy: scan once, split into segments. The patterns are matched in
+* priority order (code first so backticks don't get eaten by bold).
+*/
+function renderInline(text) {
+	const segments = [];
+	let remaining = text;
+	let key = 0;
+	const patterns = [
+		{
+			re: /`([^`]+)`/,
+			render: (m) => /* @__PURE__ */ jsx("code", {
+				style: styles.inlineCode,
+				children: m[1]
+			})
+		},
+		{
+			re: /\[([^\]]+)\]\(([^)]+)\)/,
+			render: (m) => {
+				if (isSafeLinkHref(m[2])) return /* @__PURE__ */ jsx("a", {
+					href: m[2],
+					target: "_blank",
+					rel: "noreferrer noopener",
+					style: styles.link,
+					children: m[1]
+				});
+				return /* @__PURE__ */ jsx(Fragment$1, { children: m[1] });
+			}
+		},
+		{
+			re: /\*\*([^*]+)\*\*/,
+			render: (m) => /* @__PURE__ */ jsx("strong", { children: m[1] })
+		},
+		{
+			re: /\*([^*]+)\*/,
+			render: (m) => /* @__PURE__ */ jsx("em", { children: m[1] })
+		}
+	];
+	while (remaining.length > 0) {
+		let earliest = null;
+		for (const { re, render } of patterns) {
+			const m = re.exec(remaining);
+			if (m && (earliest === null || m.index < earliest.idx)) earliest = {
+				idx: m.index,
+				len: m[0].length,
+				node: render(m)
+			};
+		}
+		if (earliest === null) {
+			segments.push(remaining);
+			break;
+		}
+		if (earliest.idx > 0) segments.push(remaining.slice(0, earliest.idx));
+		segments.push(/* @__PURE__ */ jsx(React.Fragment, { children: earliest.node }, key++));
+		remaining = remaining.slice(earliest.idx + earliest.len);
+	}
+	return segments;
+}
+let spinKeyframesInjected = false;
+function ensureSpinKeyframes() {
+	if (spinKeyframesInjected || typeof document === "undefined") return;
+	spinKeyframesInjected = true;
+	if (document.getElementById("oxy-spin-keyframes")) return;
+	const el = document.createElement("style");
+	el.id = "oxy-spin-keyframes";
+	el.textContent = "@keyframes oxy-spin { to { transform: rotate(360deg); } }";
+	document.head.appendChild(el);
+}
+const SANS = "-apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, \"Helvetica Neue\", Arial, sans-serif";
+const MONO = "ui-monospace, SFMono-Regular, \"SF Mono\", Menlo, Consolas, monospace";
+const styles = {
+	answerWrap: {
+		fontFamily: SANS,
+		fontSize: 14,
+		lineHeight: 1.5,
+		color: "var(--oxy-shell-foreground, #1f2937)"
+	},
+	statusRow: {
+		display: "flex",
+		alignItems: "center",
+		gap: 8,
+		padding: "8px 0"
+	},
+	spinner: {
+		display: "inline-block",
+		width: 12,
+		height: 12,
+		borderRadius: "50%",
+		border: "2px solid var(--oxy-shell-border, #d1d5db)",
+		borderTopColor: "var(--oxy-shell-muted-fg, #6b7280)",
+		animation: "oxy-spin 0.8s linear infinite"
+	},
+	statusText: { color: "var(--oxy-shell-muted-fg, #6b7280)" },
+	markdown: { marginTop: 8 },
+	h1: {
+		fontSize: 20,
+		fontWeight: 600,
+		margin: "16px 0 8px"
+	},
+	h2: {
+		fontSize: 17,
+		fontWeight: 600,
+		margin: "14px 0 6px"
+	},
+	h3: {
+		fontSize: 15,
+		fontWeight: 600,
+		margin: "12px 0 4px"
+	},
+	paragraph: { margin: "0 0 8px" },
+	list: {
+		margin: "0 0 8px",
+		paddingLeft: 20
+	},
+	codeBlock: {
+		fontFamily: MONO,
+		fontSize: 12,
+		background: "var(--oxy-shell-accent, #f3f4f6)",
+		border: "1px solid var(--oxy-shell-border, #e5e7eb)",
+		borderRadius: 6,
+		padding: "8px 10px",
+		overflowX: "auto",
+		margin: "8px 0"
+	},
+	inlineCode: {
+		fontFamily: MONO,
+		fontSize: "0.92em",
+		background: "var(--oxy-shell-accent, #f3f4f6)",
+		padding: "1px 4px",
+		borderRadius: 3
+	},
+	link: {
+		color: "var(--oxy-shell-link, #2563eb)",
+		textDecoration: "underline"
+	},
+	clarification: {
+		marginTop: 12,
+		padding: "10px 12px",
+		background: "#fef3c7",
+		border: "1px solid #fcd34d",
+		borderRadius: 6,
+		color: "#78350f"
+	},
+	error: {
+		marginTop: 12,
+		padding: "10px 12px",
+		background: "#fee2e2",
+		border: "1px solid #fca5a5",
+		borderRadius: 6,
+		color: "#991b1b"
+	},
+	threadLinkRow: {
+		marginTop: 12,
+		textAlign: "right",
+		display: "flex",
+		justifyContent: "flex-end",
+		alignItems: "center",
+		gap: 6
+	},
+	threadLink: {
+		fontSize: 12,
+		color: "var(--oxy-shell-muted-fg, #6b7280)",
+		textDecoration: "none"
+	},
+	betaBadge: {
+		fontSize: 9,
+		fontWeight: 600,
+		letterSpacing: .5,
+		textTransform: "uppercase",
+		padding: "1px 5px",
+		borderRadius: 3,
+		background: "#fef3c7",
+		color: "#92400e",
+		border: "1px solid #fcd34d"
+	},
+	artifactList: {
+		display: "flex",
+		flexDirection: "column",
+		gap: 8,
+		marginBottom: 8
+	},
+	artifact: {
+		border: "1px solid var(--oxy-shell-border, #e5e7eb)",
+		borderRadius: 6,
+		background: "var(--oxy-shell-accent, #fafafa)",
+		overflow: "hidden"
+	},
+	artifactHeader: {
+		display: "flex",
+		alignItems: "center",
+		gap: 10,
+		width: "100%",
+		padding: "6px 10px",
+		background: "transparent",
+		border: "none",
+		borderBottom: "1px solid transparent",
+		cursor: "pointer",
+		fontFamily: SANS,
+		fontSize: 12,
+		color: "var(--oxy-shell-foreground, #374151)"
+	},
+	artifactBadge: {
+		fontWeight: 600,
+		fontSize: 11,
+		textTransform: "uppercase",
+		letterSpacing: .4,
+		color: "var(--oxy-shell-muted-fg, #4b5563)"
+	},
+	artifactSummary: {
+		color: "var(--oxy-shell-muted-fg, #6b7280)",
+		flex: 1
+	},
+	artifactToggle: { color: "var(--oxy-shell-link, #2563eb)" },
+	sqlBlock: {
+		fontFamily: MONO,
+		fontSize: 12,
+		margin: 0,
+		padding: "8px 10px",
+		background: "#0f172a",
+		color: "#e2e8f0",
+		overflowX: "auto"
+	},
+	resultsWrap: {
+		padding: 8,
+		overflowX: "auto"
+	},
+	resultsTable: {
+		width: "100%",
+		borderCollapse: "collapse",
+		fontSize: 12
+	},
+	resultsTh: {
+		textAlign: "left",
+		padding: "4px 8px",
+		borderBottom: "1px solid var(--oxy-shell-border, #e5e7eb)",
+		fontWeight: 600,
+		color: "var(--oxy-shell-foreground, #374151)"
+	},
+	resultsTd: {
+		padding: "4px 8px",
+		borderBottom: "1px solid var(--oxy-shell-border, #f3f4f6)",
+		color: "var(--oxy-shell-foreground, #1f2937)"
+	},
+	truncatedNote: {
+		fontSize: 11,
+		color: "var(--oxy-shell-muted-fg, #6b7280)",
+		padding: "6px 8px"
+	},
+	mdTableWrap: {
+		overflowX: "auto",
+		margin: "8px 0"
+	},
+	mdTable: {
+		width: "100%",
+		borderCollapse: "collapse",
+		fontSize: 12.5,
+		border: "1px solid var(--oxy-shell-border, #e5e7eb)"
+	},
+	mdTh: {
+		textAlign: "left",
+		padding: "5px 9px",
+		borderBottom: "1px solid var(--oxy-shell-border, #e5e7eb)",
+		background: "var(--oxy-shell-accent, #f3f4f6)",
+		fontWeight: 600,
+		whiteSpace: "nowrap",
+		color: "var(--oxy-shell-foreground, #374151)"
+	},
+	mdTd: {
+		padding: "5px 9px",
+		borderTop: "1px solid var(--oxy-shell-border, #f3f4f6)",
+		verticalAlign: "top",
+		color: "var(--oxy-shell-foreground, #1f2937)"
+	},
+	chatWrap: {
+		fontFamily: SANS,
+		fontSize: 14,
+		color: "var(--oxy-shell-foreground, #1f2937)"
+	},
+	chatForm: {
+		display: "flex",
+		gap: 8,
+		marginBottom: 12
+	},
+	chatInput: {
+		flex: 1,
+		padding: "8px 12px",
+		border: "1px solid var(--oxy-shell-border, #d1d5db)",
+		borderRadius: 6,
+		fontSize: 14,
+		fontFamily: SANS
+	},
+	chatSubmit: {
+		padding: "8px 16px",
+		border: "none",
+		borderRadius: 6,
+		background: "var(--oxy-shell-link, #2563eb)",
+		color: "#ffffff",
+		fontSize: 14,
+		fontWeight: 500,
+		cursor: "pointer"
+	},
+	chatCancel: {
+		padding: "8px 12px",
+		border: "1px solid var(--oxy-shell-border, #d1d5db)",
+		borderRadius: 6,
+		background: "var(--oxy-shell-background, #ffffff)",
+		color: "var(--oxy-shell-foreground, #374151)",
+		fontSize: 14,
+		cursor: "pointer"
+	},
+	emptyState: {
+		padding: "12px 0",
+		color: "var(--oxy-shell-muted-fg, #9ca3af)",
+		fontStyle: "italic"
+	}
+};
+
+//#endregion
+export { interpretCustomerAppError as _, useFunction as a, useQuery as c, useTrackEvent as d, _resetCustomerAppManifestCacheForTest as f, apiErrorFromResponse as g, OxyApiError as h, useAgentRun as i, useResolvedManifest as l, readInjectedAppConfig as m, OxyAppProvider as n, useOxyApp as o, loadCustomerAppManifest as p, OxyChat as r, useProcedureRun as s, OxyAnswer as t, useSemanticQuery as u, getOxyAppLogger as v, setOxyAppLogger as y };
+//# sourceMappingURL=react-CVdWXcu8.mjs.map