@oxy-hq/sdk 2.3.0 → 2.5.0

package/dist/react-BeweGSYF.cjs

@@ -0,0 +1,2405 @@
+// @oxy/sdk - TypeScript SDK for Oxy data platform
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let react = require("react");
+react = __toESM(react, 1);
+let react_jsx_runtime = require("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__ */ (0, react_jsx_runtime.jsx)(OxyAppContext.Provider, {
+			value: state,
+			children: errorFallback ? errorFallback(err) : defaultErrorFallback(err)
+		});
+	}
+	if (state.status === "loading") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(OxyAppContext.Provider, {
+		value: state,
+		children: fallback ?? null
+	});
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(OxyAppContext.Provider, {
+		value: state,
+		children
+	});
+}
+function defaultErrorFallback(err) {
+	return /* @__PURE__ */ (0, react_jsx_runtime.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__ */ (0, react_jsx_runtime.jsx)("div", {
+				style: { fontWeight: 600 },
+				children: err.title
+			}),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)("pre", {
+				style: {
+					fontSize: "12px",
+					marginTop: "4px"
+				},
+				children: err.message
+			}),
+			/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: { marginTop: "12px" },
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.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__ */ (0, react_jsx_runtime.jsxs)("div", {
+		className,
+		style: styles.answerWrap,
+		children: [
+			isRunning && answer === null ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: styles.statusRow,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					style: styles.spinner,
+					"aria-hidden": "true"
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					style: styles.statusText,
+					children: "Thinking…"
+				})]
+			}) : null,
+			artifacts.length > 0 ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				style: styles.artifactList,
+				children: artifacts.map((a) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SqlArtifactBlock, {
+					artifact: a,
+					maxRows: maxArtifactRows
+				}, a.id))
+			}) : null,
+			answer ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				style: styles.markdown,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MarkdownText, { text: answer })
+			}) : null,
+			needsClarification && clarification ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: styles.clarification,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("strong", { children: "Agent needs clarification:" }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+					style: { marginTop: 4 },
+					children: clarification
+				})]
+			}) : null,
+			isFailed && error ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ErrorBlock, { error }) : null,
+			threadUrl && (answer || artifacts.length > 0) ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: styles.threadLinkRow,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("a", {
+					href: threadUrl,
+					target: "_blank",
+					rel: "noreferrer noopener",
+					style: styles.threadLink,
+					children: [threadLinkLabel, " →"]
+				}), /* @__PURE__ */ (0, react_jsx_runtime.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__ */ (0, react_jsx_runtime.jsxs)("div", {
+		className,
+		style: styles.chatWrap,
+		children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("form", {
+			onSubmit: submit,
+			style: styles.chatForm,
+			children: [
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+					type: "text",
+					value: question,
+					onChange: (e) => setQuestion(e.target.value),
+					placeholder,
+					disabled: run.state === "running",
+					style: styles.chatInput,
+					"aria-label": "Question"
+				}),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+					type: "submit",
+					disabled: run.state === "running" || question.trim() === "",
+					style: styles.chatSubmit,
+					children: run.state === "running" ? "…" : submitLabel
+				}),
+				run.state === "running" ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+					type: "button",
+					onClick: run.cancel,
+					style: styles.chatCancel,
+					children: "Stop"
+				}) : null
+			]
+		}), run.state === "idle" ? emptyState ?? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+			style: styles.emptyState,
+			children: "Ask a question to get started."
+		}) : /* @__PURE__ */ (0, react_jsx_runtime.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__ */ (0, react_jsx_runtime.jsxs)("div", {
+		style: styles.artifact,
+		children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
+			type: "button",
+			onClick: () => setOpen((o) => !o),
+			style: styles.artifactHeader,
+			children: [
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					style: styles.artifactBadge,
+					children: sourceLabel
+				}),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					style: styles.artifactSummary,
+					children: results ? `${results.rowCount} row${results.rowCount === 1 ? "" : "s"}` : artifact.error ? "execution failed" : "SQL only"
+				}),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					style: styles.artifactToggle,
+					children: open ? "Hide" : "Show"
+				})
+			]
+		}), open ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("pre", {
+			style: styles.sqlBlock,
+			children: artifact.sql
+		}), artifact.error ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+			style: styles.error,
+			children: artifact.error
+		}) : results ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+			style: styles.resultsWrap,
+			children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("table", {
+				style: styles.resultsTable,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("thead", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("tr", { children: results.columns.map((c) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("th", {
+					style: styles.resultsTh,
+					children: c
+				}, c)) }) }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("tbody", { children: visibleRows.map((row, i) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("tr", { children: row.map((cell, j) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("td", {
+					style: styles.resultsTd,
+					children: formatCell(cell)
+				}, j)) }, i)) })]
+			}), truncated ? /* @__PURE__ */ (0, react_jsx_runtime.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__ */ (0, react_jsx_runtime.jsxs)("div", {
+		style: styles.error,
+		children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: [
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)("strong", { children: "Run failed:" }),
+			" ",
+			error.message.split("\n\n")[0]
+		] }), error.hint ? /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+			style: {
+				marginTop: 6,
+				fontWeight: 400,
+				whiteSpace: "pre-wrap"
+			},
+			children: [
+				/* @__PURE__ */ (0, react_jsx_runtime.jsx)("strong", { children: "Hint:" }),
+				" ",
+				error.hint
+			]
+		}) : null]
+	});
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+		style: styles.error,
+		children: [
+			/* @__PURE__ */ (0, react_jsx_runtime.jsx)("strong", { children: "Run failed:" }),
+			" ",
+			error.message
+		]
+	});
+}
+function MarkdownText(props) {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { 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__ */ (0, react_jsx_runtime.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__ */ (0, react_jsx_runtime.jsx)("pre", {
+				style: styles.codeBlock,
+				"data-lang": b.lang || void 0,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("code", { children: b.code })
+			}, idx);
+			case "list": return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("ul", {
+				style: styles.list,
+				children: b.items.map((item, i) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", { children: renderInline(item) }, i))
+			}, idx);
+			case "table": return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				style: styles.mdTableWrap,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("table", {
+					style: styles.mdTable,
+					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("thead", { children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("tr", { children: b.headers.map((h, hi) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("th", {
+						style: styles.mdTh,
+						children: renderInline(h)
+					}, `${hi}-${h}`)) }) }), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("tbody", { children: b.rows.map((row, ri) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("tr", { children: b.headers.map((_h, ci) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("td", {
+						style: styles.mdTd,
+						children: renderInline(row[ci] ?? "")
+					}, ci)) }, `${ri}-${row[0] ?? ""}`)) })]
+				})
+			}, idx);
+			case "p": return /* @__PURE__ */ (0, react_jsx_runtime.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__ */ (0, react_jsx_runtime.jsx)("code", {
+				style: styles.inlineCode,
+				children: m[1]
+			})
+		},
+		{
+			re: /\[([^\]]+)\]\(([^)]+)\)/,
+			render: (m) => {
+				if (isSafeLinkHref(m[2])) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("a", {
+					href: m[2],
+					target: "_blank",
+					rel: "noreferrer noopener",
+					style: styles.link,
+					children: m[1]
+				});
+				return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: m[1] });
+			}
+		},
+		{
+			re: /\*\*([^*]+)\*\*/,
+			render: (m) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("strong", { children: m[1] })
+		},
+		{
+			re: /\*([^*]+)\*/,
+			render: (m) => /* @__PURE__ */ (0, react_jsx_runtime.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__ */ (0, react_jsx_runtime.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
+Object.defineProperty(exports, 'OxyAnswer', {
+  enumerable: true,
+  get: function () {
+    return OxyAnswer;
+  }
+});
+Object.defineProperty(exports, 'OxyApiError', {
+  enumerable: true,
+  get: function () {
+    return OxyApiError;
+  }
+});
+Object.defineProperty(exports, 'OxyAppProvider', {
+  enumerable: true,
+  get: function () {
+    return OxyAppProvider;
+  }
+});
+Object.defineProperty(exports, 'OxyChat', {
+  enumerable: true,
+  get: function () {
+    return OxyChat;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, '_resetCustomerAppManifestCacheForTest', {
+  enumerable: true,
+  get: function () {
+    return _resetCustomerAppManifestCacheForTest;
+  }
+});
+Object.defineProperty(exports, 'apiErrorFromResponse', {
+  enumerable: true,
+  get: function () {
+    return apiErrorFromResponse;
+  }
+});
+Object.defineProperty(exports, 'getOxyAppLogger', {
+  enumerable: true,
+  get: function () {
+    return getOxyAppLogger;
+  }
+});
+Object.defineProperty(exports, 'interpretCustomerAppError', {
+  enumerable: true,
+  get: function () {
+    return interpretCustomerAppError;
+  }
+});
+Object.defineProperty(exports, 'loadCustomerAppManifest', {
+  enumerable: true,
+  get: function () {
+    return loadCustomerAppManifest;
+  }
+});
+Object.defineProperty(exports, 'readInjectedAppConfig', {
+  enumerable: true,
+  get: function () {
+    return readInjectedAppConfig;
+  }
+});
+Object.defineProperty(exports, 'setOxyAppLogger', {
+  enumerable: true,
+  get: function () {
+    return setOxyAppLogger;
+  }
+});
+Object.defineProperty(exports, 'useAgentRun', {
+  enumerable: true,
+  get: function () {
+    return useAgentRun;
+  }
+});
+Object.defineProperty(exports, 'useFunction', {
+  enumerable: true,
+  get: function () {
+    return useFunction;
+  }
+});
+Object.defineProperty(exports, 'useOxyApp', {
+  enumerable: true,
+  get: function () {
+    return useOxyApp;
+  }
+});
+Object.defineProperty(exports, 'useProcedureRun', {
+  enumerable: true,
+  get: function () {
+    return useProcedureRun;
+  }
+});
+Object.defineProperty(exports, 'useQuery', {
+  enumerable: true,
+  get: function () {
+    return useQuery;
+  }
+});
+Object.defineProperty(exports, 'useResolvedManifest', {
+  enumerable: true,
+  get: function () {
+    return useResolvedManifest;
+  }
+});
+Object.defineProperty(exports, 'useSemanticQuery', {
+  enumerable: true,
+  get: function () {
+    return useSemanticQuery;
+  }
+});
+Object.defineProperty(exports, 'useTrackEvent', {
+  enumerable: true,
+  get: function () {
+    return useTrackEvent;
+  }
+});
+//# sourceMappingURL=react-BeweGSYF.cjs.map