@absolutejs/rag 0.0.1

package/dist/vue/ai/index.js

@@ -0,0 +1,4905 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __name = (target, name) => {
+  Object.defineProperty(target, "name", {
+    value: name,
+    enumerable: false,
+    configurable: true
+  });
+  return target;
+};
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => (key in obj) ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== undefined && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({
+  kind: __decoratorStrings[kind],
+  name,
+  metadata,
+  addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null))
+});
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length;i < n; i++)
+    flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : {
+    get [name]() {
+      return __privateGet(this, extra);
+    },
+    set [name](x) {
+      __privateSet(this, extra, x);
+    }
+  }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1;i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => (name in x) };
+      if (k ^ 3)
+        access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2)
+        access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? undefined : { get: desc.get, set: desc.set } : target, ctx);
+    done._ = 1;
+    if (k ^ 4 || it === undefined)
+      __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null)
+      __typeError("Object expected");
+    else
+      __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+
+// src/vue/ai/useRAGChunkPreview.ts
+import { computed, ref } from "vue";
+
+// src/ai/client/ragClient.ts
+var UNFOUND_INDEX = -1;
+var jsonHeaders = {
+  "Content-Type": "application/json"
+};
+var normalizeBasePath = (path) => path.endsWith("/") ? path.slice(0, UNFOUND_INDEX) : path;
+var parseJson = async (response) => {
+  const payload = JSON.parse(await response.text());
+  return payload;
+};
+var isErrorPayload = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  return !("error" in value) || typeof value.error === "string";
+};
+var toErrorMessage = async (response) => {
+  try {
+    const payload = JSON.parse(await response.text());
+    if (isErrorPayload(payload) && typeof payload.error === "string" && payload.error) {
+      return payload.error;
+    }
+  } catch {}
+  return `Request failed with status ${response.status}`;
+};
+var createRAGClient = (options) => {
+  const basePath = normalizeBasePath(options.path);
+  const fetchImpl = options.fetch ?? fetch;
+  const search = async (input) => {
+    const response = await fetchImpl(`${basePath}/search`, {
+      body: JSON.stringify(input),
+      headers: jsonHeaders,
+      method: "POST"
+    });
+    if (!response.ok) {
+      throw new Error(await toErrorMessage(response));
+    }
+    const payload = await parseJson(response);
+    if (!payload.ok) {
+      throw new Error(payload.error ?? "RAG search failed");
+    }
+    if (input.includeTrace === true) {
+      return {
+        results: payload.results ?? [],
+        trace: payload.trace
+      };
+    }
+    return payload.results ?? [];
+  };
+  return {
+    async backends() {
+      const response = await fetchImpl(`${basePath}/backends`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async clearIndex() {
+      const response = await fetchImpl(`${basePath}/index`, {
+        method: "DELETE"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async createDocument(input) {
+      const response = await fetchImpl(`${basePath}/documents`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          error: await toErrorMessage(response),
+          ok: false
+        };
+      }
+      return parseJson(response);
+    },
+    async deleteDocument(id) {
+      const response = await fetchImpl(`${basePath}/documents/${encodeURIComponent(id)}`, {
+        method: "DELETE"
+      });
+      if (!response.ok) {
+        return {
+          error: await toErrorMessage(response),
+          ok: false
+        };
+      }
+      return parseJson(response);
+    },
+    async documentChunks(id) {
+      const response = await fetchImpl(`${basePath}/documents/${encodeURIComponent(id)}/chunks`);
+      if (!response.ok) {
+        const error = await toErrorMessage(response);
+        const errorResponse = {
+          error,
+          ok: false
+        };
+        return errorResponse;
+      }
+      return parseJson(response);
+    },
+    async documents(kind) {
+      const query = kind ? `?kind=${encodeURIComponent(kind)}` : "";
+      const response = await fetchImpl(`${basePath}/documents${query}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async evaluate(input) {
+      const response = await fetchImpl(`${basePath}/evaluate`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async compareRetrievals(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.comparison) {
+        throw new Error(payload.error ?? "RAG retrieval comparison failed");
+      }
+      return payload.comparison;
+    },
+    async retrievalComparisonHistory(input) {
+      const searchParams = new URLSearchParams;
+      if (typeof input?.limit === "number") {
+        searchParams.set("limit", String(input.limit));
+      }
+      if (input?.suiteId) {
+        searchParams.set("suiteId", input.suiteId);
+      }
+      if (input?.label) {
+        searchParams.set("label", input.label);
+      }
+      if (input?.winnerId) {
+        searchParams.set("winnerId", input.winnerId);
+      }
+      if (input?.groupKey) {
+        searchParams.set("groupKey", input.groupKey);
+      }
+      if (input?.tag) {
+        searchParams.set("tag", input.tag);
+      }
+      const suffix = searchParams.size > 0 ? `?${searchParams}` : "";
+      const response = await fetchImpl(`${basePath}/compare/retrieval/history${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.runs) {
+        throw new Error(payload.error ?? "RAG retrieval comparison history failed");
+      }
+      return payload.runs;
+    },
+    async retrievalBaselines(input) {
+      const searchParams = new URLSearchParams;
+      if (input?.groupKey) {
+        searchParams.set("groupKey", input.groupKey);
+      }
+      if (input?.tag) {
+        searchParams.set("tag", input.tag);
+      }
+      if (typeof input?.limit === "number") {
+        searchParams.set("limit", String(input.limit));
+      }
+      if (input?.status) {
+        searchParams.set("status", input.status);
+      }
+      const suffix = searchParams.size > 0 ? `?${searchParams}` : "";
+      const response = await fetchImpl(`${basePath}/compare/retrieval/baselines${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.baselines) {
+        throw new Error(payload.error ?? "RAG retrieval baseline list failed");
+      }
+      return payload.baselines;
+    },
+    async promoteRetrievalBaseline(input) {
+      const payload = await this.promoteRetrievalBaselineDetailed(input);
+      return payload.baseline;
+    },
+    async promoteRetrievalBaselineDetailed(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/baselines/promote`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.baseline) {
+        throw new Error(payload.error ?? "RAG retrieval baseline promotion failed");
+      }
+      return payload;
+    },
+    async promoteRetrievalBaselineToLane(input) {
+      const payload = await this.promoteRetrievalBaselineToLaneDetailed(input);
+      return payload.baseline;
+    },
+    async promoteRetrievalBaselineToLaneDetailed(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/baselines/promote-lane`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.baseline) {
+        throw new Error(payload.error ?? "RAG retrieval rollout-lane promotion failed");
+      }
+      return payload;
+    },
+    async promoteRetrievalBaselineFromRun(input) {
+      const payload = await this.promoteRetrievalBaselineFromRunDetailed(input);
+      return payload.baseline;
+    },
+    async promoteRetrievalBaselineFromRunDetailed(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/baselines/promote-run`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.baseline) {
+        throw new Error(payload.error ?? "RAG retrieval baseline promotion from run failed");
+      }
+      return payload;
+    },
+    async revertRetrievalBaseline(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/baselines/revert`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.baseline) {
+        throw new Error(payload.error ?? "RAG retrieval baseline revert failed");
+      }
+      return payload.baseline;
+    },
+    async retrievalBaselineDecisions(input) {
+      const searchParams = new URLSearchParams;
+      if (input?.groupKey) {
+        searchParams.set("groupKey", input.groupKey);
+      }
+      if (typeof input?.limit === "number") {
+        searchParams.set("limit", String(input.limit));
+      }
+      if (input?.kind) {
+        searchParams.set("kind", input.kind);
+      }
+      if (input?.freshnessStatus) {
+        searchParams.set("freshnessStatus", input.freshnessStatus);
+      }
+      if (input?.targetRolloutLabel) {
+        searchParams.set("targetRolloutLabel", input.targetRolloutLabel);
+      }
+      const suffix = searchParams.size > 0 ? `?${searchParams}` : "";
+      const response = await fetchImpl(`${basePath}/compare/retrieval/baselines/decisions${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.decisions) {
+        throw new Error(payload.error ?? "RAG retrieval release decision list failed");
+      }
+      return payload.decisions;
+    },
+    async retrievalReleaseGroupHistory(input) {
+      const searchParams = new URLSearchParams;
+      searchParams.set("groupKey", input.groupKey);
+      if (typeof input.decisionLimit === "number") {
+        searchParams.set("decisionLimit", String(input.decisionLimit));
+      }
+      if (typeof input.baselineLimit === "number") {
+        searchParams.set("baselineLimit", String(input.baselineLimit));
+      }
+      if (typeof input.runLimit === "number") {
+        searchParams.set("runLimit", String(input.runLimit));
+      }
+      if (typeof input.benchmarkLimit === "number") {
+        searchParams.set("benchmarkLimit", String(input.benchmarkLimit));
+      }
+      if (input.targetRolloutLabel) {
+        searchParams.set("targetRolloutLabel", input.targetRolloutLabel);
+      }
+      const response = await fetchImpl(`${basePath}/compare/retrieval/release-history?${searchParams}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok) {
+        throw new Error(payload.error ?? "RAG retrieval release group history failed");
+      }
+      return payload;
+    },
+    async adaptiveNativePlannerBenchmark(input) {
+      const searchParams = new URLSearchParams;
+      if (typeof input?.limit === "number") {
+        searchParams.set("limit", String(input.limit));
+      }
+      if (typeof input?.runLimit === "number") {
+        searchParams.set("runLimit", String(input.runLimit));
+      }
+      if (input?.label) {
+        searchParams.set("label", input.label);
+      }
+      if (input?.description) {
+        searchParams.set("description", input.description);
+      }
+      if (input?.groupKey) {
+        searchParams.set("benchmarkGroupKey", input.groupKey);
+      }
+      if (input?.corpusGroupKey) {
+        searchParams.set("benchmarkCorpusGroupKey", input.corpusGroupKey);
+      }
+      const suffix = searchParams.size ? `?${searchParams}` : "";
+      const response = await fetchImpl(`${basePath}/compare/retrieval/benchmarks/adaptive-native-planner${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok) {
+        throw new Error(payload.error ?? "Adaptive native planner benchmark history failed");
+      }
+      return payload;
+    },
+    async runAdaptiveNativePlannerBenchmark(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/benchmarks/adaptive-native-planner/run`, {
+        body: JSON.stringify({
+          baselineRetrievalId: input?.baselineRetrievalId,
+          candidateRetrievalId: input?.candidateRetrievalId,
+          corpusGroupKey: input?.corpusGroupKey,
+          description: input?.description,
+          groupKey: input?.groupKey,
+          label: input?.label,
+          limit: input?.limit,
+          metadata: input?.metadata,
+          persistRun: input?.persistRun,
+          retrievals: input?.retrievals,
+          runLimit: input?.runLimit,
+          tags: input?.tags,
+          topK: input?.topK
+        }),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok) {
+        throw new Error(payload.error ?? "Adaptive native planner benchmark run failed");
+      }
+      return payload;
+    },
+    async saveAdaptiveNativePlannerBenchmarkSnapshot(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/benchmarks/adaptive-native-planner/snapshots`, {
+        body: JSON.stringify({
+          createdAt: input?.createdAt,
+          description: input?.description,
+          label: input?.label,
+          limit: input?.limit,
+          metadata: input?.metadata,
+          snapshotMetadata: input?.snapshotMetadata,
+          version: input?.version
+        }),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok) {
+        throw new Error(payload.error ?? "Adaptive native planner benchmark snapshot failed");
+      }
+      return payload;
+    },
+    async nativeBackendComparisonBenchmark(input) {
+      const searchParams = new URLSearchParams;
+      if (typeof input?.limit === "number") {
+        searchParams.set("limit", String(input.limit));
+      }
+      if (typeof input?.runLimit === "number") {
+        searchParams.set("runLimit", String(input.runLimit));
+      }
+      if (input?.label) {
+        searchParams.set("label", input.label);
+      }
+      if (input?.description) {
+        searchParams.set("description", input.description);
+      }
+      if (input?.groupKey) {
+        searchParams.set("benchmarkGroupKey", input.groupKey);
+      }
+      if (input?.corpusGroupKey) {
+        searchParams.set("benchmarkCorpusGroupKey", input.corpusGroupKey);
+      }
+      const suffix = searchParams.size ? `?${searchParams}` : "";
+      const response = await fetchImpl(`${basePath}/compare/retrieval/benchmarks/native-backend-comparison${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok) {
+        throw new Error(payload.error ?? "Native backend comparison benchmark history failed");
+      }
+      return payload;
+    },
+    async runNativeBackendComparisonBenchmark(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/benchmarks/native-backend-comparison/run`, {
+        body: JSON.stringify({
+          baselineRetrievalId: input?.baselineRetrievalId,
+          candidateRetrievalId: input?.candidateRetrievalId,
+          corpusGroupKey: input?.corpusGroupKey,
+          description: input?.description,
+          groupKey: input?.groupKey,
+          label: input?.label,
+          limit: input?.limit,
+          metadata: input?.metadata,
+          persistRun: input?.persistRun,
+          retrievals: input?.retrievals,
+          runLimit: input?.runLimit,
+          tags: input?.tags,
+          topK: input?.topK
+        }),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok) {
+        throw new Error(payload.error ?? "Native backend comparison benchmark run failed");
+      }
+      return payload;
+    },
+    async saveNativeBackendComparisonBenchmarkSnapshot(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/benchmarks/native-backend-comparison/snapshots`, {
+        body: JSON.stringify({
+          createdAt: input?.createdAt,
+          description: input?.description,
+          label: input?.label,
+          limit: input?.limit,
+          metadata: input?.metadata,
+          snapshotMetadata: input?.snapshotMetadata,
+          version: input?.version
+        }),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok) {
+        throw new Error(payload.error ?? "Native backend comparison benchmark snapshot failed");
+      }
+      return payload;
+    },
+    async retrievalLaneHandoffs(input) {
+      const searchParams = new URLSearchParams;
+      if (input?.groupKey) {
+        searchParams.set("groupKey", input.groupKey);
+      }
+      if (input?.sourceRolloutLabel) {
+        searchParams.set("sourceRolloutLabel", input.sourceRolloutLabel);
+      }
+      if (input?.targetRolloutLabel) {
+        searchParams.set("targetRolloutLabel", input.targetRolloutLabel);
+      }
+      if (typeof input?.limit === "number") {
+        searchParams.set("limit", String(input.limit));
+      }
+      const suffix = searchParams.size > 0 ? `?${searchParams}` : "";
+      const response = await fetchImpl(`${basePath}/compare/retrieval/handoffs${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.handoffs) {
+        throw new Error(payload.error ?? "RAG retrieval lane handoff list failed");
+      }
+      return payload.handoffs;
+    },
+    async retrievalLaneHandoffDecisions(input) {
+      const searchParams = new URLSearchParams;
+      if (input?.groupKey) {
+        searchParams.set("groupKey", input.groupKey);
+      }
+      if (input?.sourceRolloutLabel) {
+        searchParams.set("sourceRolloutLabel", input.sourceRolloutLabel);
+      }
+      if (input?.targetRolloutLabel) {
+        searchParams.set("targetRolloutLabel", input.targetRolloutLabel);
+      }
+      if (input?.kind) {
+        searchParams.set("kind", input.kind);
+      }
+      if (typeof input?.limit === "number") {
+        searchParams.set("limit", String(input.limit));
+      }
+      const suffix = searchParams.size > 0 ? `?${searchParams}` : "";
+      const response = await fetchImpl(`${basePath}/compare/retrieval/handoffs/decisions${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.decisions) {
+        throw new Error(payload.error ?? "RAG retrieval lane handoff decision list failed");
+      }
+      return payload.decisions;
+    },
+    async retrievalLaneHandoffIncidents(input) {
+      const searchParams = new URLSearchParams;
+      if (input?.groupKey)
+        searchParams.set("groupKey", input.groupKey);
+      if (typeof input?.limit === "number")
+        searchParams.set("limit", String(input.limit));
+      if (input?.status)
+        searchParams.set("status", input.status);
+      if (input?.severity)
+        searchParams.set("severity", input.severity);
+      if (input?.targetRolloutLabel) {
+        searchParams.set("targetRolloutLabel", input.targetRolloutLabel);
+      }
+      const suffix = searchParams.size > 0 ? `?${searchParams}` : "";
+      const response = await fetchImpl(`${basePath}/compare/retrieval/handoffs/incidents${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.incidents) {
+        throw new Error(payload.error ?? "RAG retrieval lane handoff incident list failed");
+      }
+      return payload.incidents;
+    },
+    async retrievalLaneHandoffIncidentHistory(input) {
+      const suffix = input ? `?${new URLSearchParams(Object.entries(input).filter(([, value]) => value !== undefined).map(([key, value]) => [key, String(value)])).toString()}` : "";
+      const response = await fetchImpl(`${basePath}/compare/retrieval/handoffs/incidents/history${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.records) {
+        throw new Error(payload.error ?? "RAG retrieval lane handoff incident history failed");
+      }
+      return payload.records;
+    },
+    async retrievalLaneHandoffAutoCompletePolicyHistory(input) {
+      const suffix = input ? `?${new URLSearchParams(Object.entries(input).filter(([, value]) => value !== undefined).map(([key, value]) => [key, String(value)])).toString()}` : "";
+      const response = await fetchImpl(`${basePath}/compare/retrieval/handoffs/policies/history${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.records) {
+        throw new Error(payload.error ?? "RAG retrieval lane handoff auto-complete policy history failed");
+      }
+      return payload.records;
+    },
+    async retrievalReleaseLanePolicyHistory(input) {
+      const suffix = input ? `?${new URLSearchParams(Object.entries(input).filter(([, value]) => value !== undefined).map(([key, value]) => [key, String(value)])).toString()}` : "";
+      const response = await fetchImpl(`${basePath}/compare/retrieval/release-policies/history${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.records) {
+        throw new Error(payload.error ?? "RAG retrieval release lane policy history failed");
+      }
+      return payload.records;
+    },
+    async retrievalBaselineGatePolicyHistory(input) {
+      const suffix = input ? `?${new URLSearchParams(Object.entries(input).filter(([, value]) => value !== undefined).map(([key, value]) => [key, String(value)])).toString()}` : "";
+      const response = await fetchImpl(`${basePath}/compare/retrieval/gate-policies/history${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.records) {
+        throw new Error(payload.error ?? "RAG retrieval baseline gate policy history failed");
+      }
+      return payload.records;
+    },
+    async retrievalReleaseLaneEscalationPolicyHistory(input) {
+      const suffix = input ? `?${new URLSearchParams(Object.entries(input).filter(([, value]) => value !== undefined).map(([key, value]) => [key, String(value)])).toString()}` : "";
+      const response = await fetchImpl(`${basePath}/compare/retrieval/escalation-policies/history${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.records) {
+        throw new Error(payload.error ?? "RAG retrieval release lane escalation policy history failed");
+      }
+      return payload.records;
+    },
+    async retrievalReleaseIncidentPolicyHistory(input) {
+      const suffix = input ? `?${new URLSearchParams(Object.entries(input).filter(([, value]) => value !== undefined).map(([key, value]) => [key, String(value)])).toString()}` : "";
+      const response = await fetchImpl(`${basePath}/compare/retrieval/incident-policies/history${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.records) {
+        throw new Error(payload.error ?? "RAG retrieval release incident policy history failed");
+      }
+      return payload.records;
+    },
+    async retrievalReleaseIncidentStatus() {
+      const response = await fetchImpl(`${basePath}/status/release/incidents`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async retrievalIncidentRemediationStatus() {
+      const response = await fetchImpl(`${basePath}/status/release/remediations`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async retrievalLaneHandoffIncidentStatus() {
+      const response = await fetchImpl(`${basePath}/status/handoffs/incidents`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async acknowledgeRetrievalLaneHandoffIncident(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/handoffs/incidents/acknowledge`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.incidents) {
+        throw new Error(payload.error ?? "RAG retrieval lane handoff incident acknowledgement failed");
+      }
+      return payload.incidents;
+    },
+    async unacknowledgeRetrievalLaneHandoffIncident(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/handoffs/incidents/unacknowledge`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.incidents) {
+        throw new Error(payload.error ?? "RAG retrieval lane handoff incident unacknowledge failed");
+      }
+      return payload.incidents;
+    },
+    async resolveRetrievalLaneHandoffIncident(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/handoffs/incidents/resolve`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.incidents) {
+        throw new Error(payload.error ?? "RAG retrieval lane handoff incident resolve failed");
+      }
+      return payload.incidents;
+    },
+    async decideRetrievalLaneHandoff(input) {
+      const payload = await this.decideRetrievalLaneHandoffDetailed(input);
+      if (!payload.decision) {
+        throw new Error(payload.error ?? "RAG retrieval lane handoff decision failed");
+      }
+      return payload.decision;
+    },
+    async decideRetrievalLaneHandoffDetailed(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/handoffs/decide`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async retrievalReleaseIncidents(input) {
+      const searchParams = new URLSearchParams;
+      if (input?.groupKey) {
+        searchParams.set("groupKey", input.groupKey);
+      }
+      if (typeof input?.limit === "number") {
+        searchParams.set("limit", String(input.limit));
+      }
+      if (input?.status) {
+        searchParams.set("status", input.status);
+      }
+      if (input?.severity) {
+        searchParams.set("severity", input.severity);
+      }
+      if (input?.kind) {
+        searchParams.set("kind", input.kind);
+      }
+      if (typeof input?.acknowledged === "boolean") {
+        searchParams.set("acknowledged", String(input.acknowledged));
+      }
+      if (input?.targetRolloutLabel) {
+        searchParams.set("targetRolloutLabel", input.targetRolloutLabel);
+      }
+      const suffix = searchParams.size > 0 ? `?${searchParams}` : "";
+      const response = await fetchImpl(`${basePath}/compare/retrieval/incidents${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.incidents) {
+        throw new Error(payload.error ?? "RAG retrieval release incident list failed");
+      }
+      return payload.incidents;
+    },
+    async retrievalIncidentRemediationDecisions(input) {
+      const suffix = input ? `?${new URLSearchParams(Object.entries(input).filter(([, value]) => value !== undefined).map(([key, value]) => [key, String(value)])).toString()}` : "";
+      const response = await fetchImpl(`${basePath}/compare/retrieval/incidents/remediations${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.records) {
+        throw new Error(payload.error ?? "RAG retrieval incident remediation decision list failed");
+      }
+      return payload.records;
+    },
+    async retrievalIncidentRemediationExecutions(input) {
+      const suffix = input ? `?${new URLSearchParams(Object.entries(input).filter(([, value]) => value !== undefined).map(([key, value]) => [key, String(value)])).toString()}` : "";
+      const response = await fetchImpl(`${basePath}/compare/retrieval/incidents/remediations/executions${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.records) {
+        throw new Error(payload.error ?? "RAG retrieval incident remediation execution history failed");
+      }
+      return payload.records;
+    },
+    async recordRetrievalIncidentRemediationDecision(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/incidents/remediations`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.records) {
+        throw new Error(payload.error ?? "RAG retrieval incident remediation decision record failed");
+      }
+      return payload.records;
+    },
+    async executeRetrievalIncidentRemediation(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/incidents/remediations/execute`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.execution) {
+        throw new Error(payload.error ?? "RAG retrieval incident remediation execution failed");
+      }
+      return payload;
+    },
+    async bulkExecuteRetrievalIncidentRemediations(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/incidents/remediations/execute/bulk`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.results) {
+        throw new Error(payload.error ?? "Bulk RAG retrieval incident remediation execution failed");
+      }
+      return payload.results;
+    },
+    async acknowledgeRetrievalReleaseIncident(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/incidents/acknowledge`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.incidents) {
+        throw new Error(payload.error ?? "RAG retrieval release incident acknowledgement failed");
+      }
+      return payload.incidents;
+    },
+    async unacknowledgeRetrievalReleaseIncident(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/incidents/unacknowledge`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.incidents) {
+        throw new Error(payload.error ?? "RAG retrieval release incident unacknowledge failed");
+      }
+      return payload.incidents;
+    },
+    async resolveRetrievalReleaseIncident(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/incidents/resolve`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.incidents) {
+        throw new Error(payload.error ?? "RAG retrieval release incident resolve failed");
+      }
+      return payload.incidents;
+    },
+    async retrievalPromotionCandidates(input) {
+      const searchParams = new URLSearchParams;
+      if (input?.groupKey) {
+        searchParams.set("groupKey", input.groupKey);
+      }
+      if (typeof input?.limit === "number") {
+        searchParams.set("limit", String(input.limit));
+      }
+      if (input?.tag) {
+        searchParams.set("tag", input.tag);
+      }
+      if (input?.targetRolloutLabel) {
+        searchParams.set("targetRolloutLabel", input.targetRolloutLabel);
+      }
+      if (typeof input?.approved === "boolean") {
+        searchParams.set("approved", String(input.approved));
+      }
+      if (typeof input?.ready === "boolean") {
+        searchParams.set("ready", String(input.ready));
+      }
+      if (typeof input?.blocked === "boolean") {
+        searchParams.set("blocked", String(input.blocked));
+      }
+      if (input?.reviewStatus) {
+        searchParams.set("reviewStatus", input.reviewStatus);
+      }
+      if (input?.freshnessStatus) {
+        searchParams.set("freshnessStatus", input.freshnessStatus);
+      }
+      if (input?.sortBy) {
+        searchParams.set("sortBy", input.sortBy);
+      }
+      if (input?.sortDirection) {
+        searchParams.set("sortDirection", input.sortDirection);
+      }
+      const suffix = searchParams.size > 0 ? `?${searchParams}` : "";
+      const response = await fetchImpl(`${basePath}/compare/retrieval/candidates${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.candidates) {
+        throw new Error(payload.error ?? "RAG retrieval promotion candidate list failed");
+      }
+      return payload.candidates;
+    },
+    async approveRetrievalCandidate(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/baselines/approve`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.decisions) {
+        throw new Error(payload.error ?? "RAG retrieval approval failed");
+      }
+      return payload.decisions;
+    },
+    async rejectRetrievalCandidate(input) {
+      const response = await fetchImpl(`${basePath}/compare/retrieval/baselines/reject`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.decisions) {
+        throw new Error(payload.error ?? "RAG retrieval rejection failed");
+      }
+      return payload.decisions;
+    },
+    async ingest(chunks) {
+      const response = await fetchImpl(`${basePath}/ingest`, {
+        body: JSON.stringify({ chunks }),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          error: await toErrorMessage(response),
+          ok: false
+        };
+      }
+      return parseJson(response);
+    },
+    async ingestDocuments(input) {
+      const response = await fetchImpl(`${basePath}/ingest`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          error: await toErrorMessage(response),
+          ok: false
+        };
+      }
+      return parseJson(response);
+    },
+    async ingestUploads(input) {
+      const response = await fetchImpl(`${basePath}/ingest`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          error: await toErrorMessage(response),
+          ok: false
+        };
+      }
+      return parseJson(response);
+    },
+    async ingestUrls(input) {
+      const response = await fetchImpl(`${basePath}/ingest`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          error: await toErrorMessage(response),
+          ok: false
+        };
+      }
+      return parseJson(response);
+    },
+    async analyzeBackend() {
+      const response = await fetchImpl(`${basePath}/backend/analyze`, {
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          error: await toErrorMessage(response),
+          ok: false
+        };
+      }
+      return parseJson(response);
+    },
+    async ops() {
+      const response = await fetchImpl(`${basePath}/ops`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async searchTraceHistory(input) {
+      const searchParams = new URLSearchParams;
+      if (input?.query) {
+        searchParams.set("query", input.query);
+      }
+      if (input?.groupKey) {
+        searchParams.set("groupKey", input.groupKey);
+      }
+      if (input?.tag) {
+        searchParams.set("tag", input.tag);
+      }
+      if (typeof input?.limit === "number") {
+        searchParams.set("limit", String(input.limit));
+      }
+      const suffix = searchParams.size > 0 ? `?${searchParams}` : "";
+      const response = await fetchImpl(`${basePath}/traces${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.history) {
+        throw new Error(payload.error ?? "RAG search trace history failed");
+      }
+      return payload.history;
+    },
+    async searchTraceGroups(input) {
+      const searchParams = new URLSearchParams;
+      if (input?.tag) {
+        searchParams.set("tag", input.tag);
+      }
+      if (typeof input?.limit === "number") {
+        searchParams.set("limit", String(input.limit));
+      }
+      const suffix = searchParams.size > 0 ? `?${searchParams}` : "";
+      const response = await fetchImpl(`${basePath}/traces/groups${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.history) {
+        throw new Error(payload.error ?? "RAG search trace group history failed");
+      }
+      return payload.history;
+    },
+    async searchTraceStats(input) {
+      const searchParams = new URLSearchParams;
+      if (input?.tag) {
+        searchParams.set("tag", input.tag);
+      }
+      const suffix = searchParams.size > 0 ? `?${searchParams}` : "";
+      const response = await fetchImpl(`${basePath}/traces/stats${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.stats) {
+        throw new Error(payload.error ?? "RAG search trace stats failed");
+      }
+      return payload.stats;
+    },
+    async previewSearchTracePrune(input) {
+      const response = await fetchImpl(`${basePath}/traces/prune/preview`, {
+        body: JSON.stringify(input ?? {}),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.preview) {
+        throw new Error(payload.error ?? "RAG search trace prune preview failed");
+      }
+      return payload.preview;
+    },
+    async pruneSearchTraces(input) {
+      const response = await fetchImpl(`${basePath}/traces/prune`, {
+        body: JSON.stringify(input ?? {}),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.result) {
+        throw new Error(payload.error ?? "RAG search trace prune failed");
+      }
+      return payload;
+    },
+    async searchTracePruneHistory(input) {
+      const searchParams = new URLSearchParams;
+      if (typeof input?.limit === "number") {
+        searchParams.set("limit", String(input.limit));
+      }
+      if (input?.trigger) {
+        searchParams.set("trigger", input.trigger);
+      }
+      const suffix = searchParams.size > 0 ? `?${searchParams}` : "";
+      const response = await fetchImpl(`${basePath}/traces/prune/history${suffix}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok || !payload.runs) {
+        throw new Error(payload.error ?? "RAG search trace prune history failed");
+      }
+      return payload.runs;
+    },
+    async syncSources() {
+      const response = await fetchImpl(`${basePath}/sync`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async syncAllSources(options2) {
+      const response = await fetchImpl(`${basePath}/sync`, {
+        body: options2?.background === true ? JSON.stringify({ background: true }) : undefined,
+        headers: options2?.background === true ? jsonHeaders : undefined,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          error: await toErrorMessage(response),
+          ok: false
+        };
+      }
+      return parseJson(response);
+    },
+    async syncSource(id, options2) {
+      const response = await fetchImpl(`${basePath}/sync/${encodeURIComponent(id)}`, {
+        body: options2?.background === true ? JSON.stringify({ background: true }) : undefined,
+        headers: options2?.background === true ? jsonHeaders : undefined,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          error: await toErrorMessage(response),
+          ok: false
+        };
+      }
+      return parseJson(response);
+    },
+    async reindexDocument(id) {
+      const response = await fetchImpl(`${basePath}/reindex/documents/${encodeURIComponent(id)}`, {
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          error: await toErrorMessage(response),
+          ok: false
+        };
+      }
+      return parseJson(response);
+    },
+    async reindexSource(source) {
+      const response = await fetchImpl(`${basePath}/reindex/source`, {
+        body: JSON.stringify({ source }),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          error: await toErrorMessage(response),
+          ok: false
+        };
+      }
+      return parseJson(response);
+    },
+    async reseed() {
+      const response = await fetchImpl(`${basePath}/reseed`, {
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          error: await toErrorMessage(response),
+          ok: false
+        };
+      }
+      return parseJson(response);
+    },
+    async reset() {
+      const response = await fetchImpl(`${basePath}/reset`, {
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          error: await toErrorMessage(response),
+          ok: false
+        };
+      }
+      return parseJson(response);
+    },
+    async rebuildNativeIndex() {
+      const response = await fetchImpl(`${basePath}/backend/reindex-native`, {
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          error: await toErrorMessage(response),
+          ok: false
+        };
+      }
+      return parseJson(response);
+    },
+    search,
+    async searchWithTrace(input) {
+      return search({ ...input, includeTrace: true });
+    },
+    async searchDetailed(input) {
+      return search({ ...input, includeTrace: true });
+    },
+    async status() {
+      const response = await fetchImpl(`${basePath}/status`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async statusMaintenance() {
+      const response = await fetchImpl(`${basePath}/status/maintenance`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async retrievalReleaseStatus() {
+      const response = await fetchImpl(`${basePath}/status/release`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      return payload.retrievalComparisons;
+    },
+    async retrievalReleaseDriftStatus() {
+      const response = await fetchImpl(`${basePath}/status/release/drift`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async retrievalLaneHandoffStatus() {
+      const response = await fetchImpl(`${basePath}/status/handoffs`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    }
+  };
+};
+
+// src/ai/rag/grounding.ts
+var getContextString = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+var getContextNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+var getAttachmentName = (source, title) => {
+  const sourceAttachment = source?.split("/").at(-1);
+  if (sourceAttachment && sourceAttachment.includes(".")) {
+    return sourceAttachment;
+  }
+  const titleAttachment = title?.split(" · ").at(-1);
+  if (titleAttachment && titleAttachment.includes(".")) {
+    return titleAttachment;
+  }
+  return;
+};
+var buildContextLabel = (metadata) => {
+  if (!metadata) {
+    return;
+  }
+  const emailKind = getContextString(metadata.emailKind);
+  const officeBlockKindValue = getContextString(metadata.officeBlockKind);
+  const officeBlockKind = officeBlockKindValue === "table" || officeBlockKindValue === "list" || officeBlockKindValue === "paragraph" ? officeBlockKindValue : undefined;
+  if (emailKind === "attachment") {
+    return "Attachment evidence";
+  }
+  if (emailKind === "message") {
+    const from = getContextString(metadata.from);
+    return from ? `Message from ${from}` : "Message evidence";
+  }
+  const page = getContextNumber(metadata.page) ?? getContextNumber(metadata.pageNumber) ?? (typeof metadata.pageIndex === "number" ? metadata.pageIndex + 1 : undefined);
+  const region = getContextNumber(metadata.regionNumber) ?? (typeof metadata.regionIndex === "number" ? metadata.regionIndex + 1 : undefined);
+  if (page && region) {
+    return `Page ${page} region ${region}`;
+  }
+  if (page) {
+    return `Page ${page}`;
+  }
+  const sheet = getContextString(metadata.sheetName) ?? (Array.isArray(metadata.sheetNames) ? getContextString(metadata.sheetNames[0]) : undefined);
+  if (sheet) {
+    return `Sheet ${sheet}`;
+  }
+  const slide = getContextNumber(metadata.slide) ?? getContextNumber(metadata.slideNumber) ?? (typeof metadata.slideIndex === "number" ? metadata.slideIndex + 1 : undefined);
+  const slideTitle = getContextString(metadata.slideTitle);
+  if (slide) {
+    return slideTitle ? `Slide ${slide} · ${slideTitle}` : `Slide ${slide}`;
+  }
+  const archiveEntry = getContextString(metadata.archiveEntryPath) ?? getContextString(metadata.entryPath);
+  if (archiveEntry) {
+    return `Archive entry ${archiveEntry}`;
+  }
+  const threadTopic = getContextString(metadata.threadTopic);
+  if (threadTopic) {
+    return `Thread ${threadTopic}`;
+  }
+  const speaker = getContextString(metadata.speaker);
+  if (speaker) {
+    return `Speaker ${speaker}`;
+  }
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.map((value) => getContextString(value)).filter((value) => typeof value === "string") : [];
+  const sectionTitle = getContextString(metadata.sectionTitle) ?? sectionPath.at(-1);
+  const officeSectionLabel = sectionPath.length > 0 ? sectionPath.join(" > ") : sectionTitle;
+  if (officeBlockKind === "table" && officeSectionLabel) {
+    return `Office table block ${officeSectionLabel}`;
+  }
+  if (officeBlockKind === "list" && officeSectionLabel) {
+    return `Office list block ${officeSectionLabel}`;
+  }
+  if (officeBlockKind === "paragraph" && officeSectionLabel) {
+    return `Office paragraph block ${officeSectionLabel}`;
+  }
+  if (sectionTitle) {
+    return `Section ${sectionTitle}`;
+  }
+  return;
+};
+var formatMediaTimestamp = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return;
+  }
+  const totalSeconds = Math.floor(value / 1000);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  const milliseconds = Math.floor(value % 1000);
+  return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}.${String(milliseconds).padStart(3, "0")}`;
+};
+var formatMediaDurationLabel = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return;
+  }
+  return formatMediaTimestamp(value);
+};
+var formatOfficeListLevelsLabel = (value) => {
+  if (!Array.isArray(value) || value.length === 0) {
+    return;
+  }
+  const levels = value.map((entry) => getContextNumber(entry)).filter((entry) => typeof entry === "number").sort((left, right) => left - right);
+  if (levels.length === 0) {
+    return;
+  }
+  const minLevel = levels[0];
+  const maxLevel = levels[levels.length - 1];
+  return minLevel === maxLevel ? `Office list level ${minLevel}` : `Office list levels ${minLevel}-${maxLevel}`;
+};
+var getOfficeTableCitationScope = (metadata) => {
+  if (!metadata) {
+    return;
+  }
+  const officeBlockKindValue = getContextString(metadata.officeBlockKind);
+  const officeBlockKind = officeBlockKindValue === "table" || officeBlockKindValue === "list" || officeBlockKindValue === "paragraph" ? officeBlockKindValue : undefined;
+  if (officeBlockKind !== "table" && officeBlockKind !== "list" && officeBlockKind !== "paragraph") {
+    return;
+  }
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.map((value) => getContextString(value)).filter((value) => typeof value === "string") : [];
+  const sectionTitle = getContextString(metadata.sectionTitle) ?? sectionPath.at(-1);
+  const officeContextText = officeBlockKind === "table" ? getContextString(metadata.officeTableContextText) : officeBlockKind === "list" ? getContextString(metadata.officeListContextText) : undefined;
+  if (!sectionTitle) {
+    return;
+  }
+  return {
+    blockKind: officeBlockKind,
+    familyPath: (() => {
+      const explicitGenericFamilyPath = Array.isArray(metadata.sectionFamilyPath) ? metadata.sectionFamilyPath.map((value) => getContextString(value)).filter((value) => typeof value === "string") : [];
+      const explicitGenericOrdinalPath = Array.isArray(metadata.sectionOrdinalPath) ? metadata.sectionOrdinalPath.map((value) => getContextNumber(value)).filter((value) => typeof value === "number") : [];
+      if (explicitGenericFamilyPath.length > 0 && explicitGenericFamilyPath.length === explicitGenericOrdinalPath.length) {
+        return explicitGenericFamilyPath;
+      }
+      const explicitOfficeFamilyPath = Array.isArray(metadata.officeFamilyPath) ? metadata.officeFamilyPath.map((value) => getContextString(value)).filter((value) => typeof value === "string") : [];
+      return explicitOfficeFamilyPath.length > 0 ? explicitOfficeFamilyPath : sectionPath.map((value) => value.replace(/\s+\((\d+)\)$/, "").trim());
+    })(),
+    pathDepth: sectionPath.length,
+    ordinalPath: (() => {
+      const explicitGenericFamilyPath = Array.isArray(metadata.sectionFamilyPath) ? metadata.sectionFamilyPath.map((value) => getContextString(value)).filter((value) => typeof value === "string") : [];
+      const explicitGenericOrdinalPath = Array.isArray(metadata.sectionOrdinalPath) ? metadata.sectionOrdinalPath.map((value) => getContextNumber(value)).filter((value) => typeof value === "number") : [];
+      if (explicitGenericFamilyPath.length > 0 && explicitGenericFamilyPath.length === explicitGenericOrdinalPath.length) {
+        return explicitGenericOrdinalPath;
+      }
+      const explicitOfficeOrdinalPath = Array.isArray(metadata.officeOrdinalPath) ? metadata.officeOrdinalPath.map((value) => typeof value === "number" && Number.isFinite(value) ? value : undefined).filter((value) => typeof value === "number") : [];
+      return explicitOfficeOrdinalPath.length > 0 ? explicitOfficeOrdinalPath : sectionPath.map((value) => {
+        const match = value.match(/\((\d+)\)$/);
+        return match ? Number.parseInt(match[1] ?? "1", 10) : 1;
+      });
+    })(),
+    sectionFamilyKey: getContextString(metadata.sectionSiblingFamilyKey) ?? getContextString(metadata.officeSiblingFamilyKey) ?? sectionPath.at(-1)?.replace(/\s+\((\d+)\)$/, "").trim() ?? sectionTitle,
+    sectionOrdinal: getContextNumber(metadata.sectionSiblingOrdinal) ?? getContextNumber(metadata.officeSiblingOrdinal) ?? (() => {
+      const match = sectionTitle.match(/\((\d+)\)$/);
+      return match ? Number.parseInt(match[1] ?? "1", 10) : 1;
+    })(),
+    sectionTitle,
+    hasContext: typeof officeContextText === "string"
+  };
+};
+var areOfficeCitationScopesComparable = (left, right) => {
+  if (!left || !right) {
+    return false;
+  }
+  if (left.blockKind !== right.blockKind || left.sectionFamilyKey !== right.sectionFamilyKey || left.sectionOrdinal !== right.sectionOrdinal) {
+    return false;
+  }
+  const leftAncestorFamilyPath = left.familyPath.slice(0, -1);
+  const rightAncestorFamilyPath = right.familyPath.slice(0, -1);
+  const leftAncestorOrdinalPath = left.ordinalPath.slice(0, -1);
+  const rightAncestorOrdinalPath = right.ordinalPath.slice(0, -1);
+  const sharedDepth = Math.min(leftAncestorFamilyPath.length, rightAncestorFamilyPath.length);
+  for (let index = 0;index < sharedDepth; index += 1) {
+    if (leftAncestorFamilyPath[index] !== rightAncestorFamilyPath[index] || leftAncestorOrdinalPath[index] !== rightAncestorOrdinalPath[index]) {
+      return false;
+    }
+  }
+  return true;
+};
+var getGenericStructuredCitationScope = (metadata) => {
+  if (!metadata || metadata.officeBlockKind || metadata.pageNumber) {
+    return;
+  }
+  const kind = metadata.sectionKind === "spreadsheet_rows" || metadata.sectionKind === "presentation_slide" ? metadata.sectionKind : undefined;
+  if (!kind) {
+    return;
+  }
+  const explicitFamilyPath = Array.isArray(metadata.sectionFamilyPath) ? metadata.sectionFamilyPath.map((value) => getContextString(value)).filter((value) => typeof value === "string") : [];
+  const explicitOrdinalPath = Array.isArray(metadata.sectionOrdinalPath) ? metadata.sectionOrdinalPath.map((value) => getContextNumber(value)).filter((value) => typeof value === "number") : [];
+  let familyPath = explicitFamilyPath.length > 0 && explicitFamilyPath.length === explicitOrdinalPath.length ? explicitFamilyPath : [];
+  let ordinalPath = explicitFamilyPath.length > 0 && explicitFamilyPath.length === explicitOrdinalPath.length ? explicitOrdinalPath : [];
+  if (familyPath.length === 0) {
+    if (kind === "spreadsheet_rows") {
+      const sheetName = getContextString(metadata.sheetName) ?? "Sheet";
+      const tableIndex = getContextNumber(metadata.spreadsheetTableIndex) ?? 1;
+      familyPath = [sheetName, "Spreadsheet Table"];
+      ordinalPath = [1, tableIndex];
+    } else {
+      const slideFamily = getContextString(metadata.slideTitle) ?? "Slide";
+      const slideOrdinal = getContextNumber(metadata.slideNumber) ?? (typeof metadata.slideIndex === "number" ? metadata.slideIndex + 1 : 1);
+      familyPath = [slideFamily];
+      ordinalPath = [slideOrdinal];
+    }
+  }
+  const sectionFamilyKey = getContextString(metadata.sectionSiblingFamilyKey) ?? familyPath.at(-1);
+  const sectionOrdinal = getContextNumber(metadata.sectionSiblingOrdinal) ?? ordinalPath.at(-1);
+  if (!sectionFamilyKey || typeof sectionOrdinal !== "number") {
+    return;
+  }
+  return {
+    familyPath,
+    kind,
+    ordinalPath,
+    pathDepth: familyPath.length,
+    sectionFamilyKey,
+    sectionOrdinal
+  };
+};
+var areGenericStructuredCitationScopesComparable = (left, right) => {
+  if (!left || !right) {
+    return false;
+  }
+  if (left.kind !== right.kind || left.sectionFamilyKey !== right.sectionFamilyKey || left.sectionOrdinal !== right.sectionOrdinal) {
+    return false;
+  }
+  const leftAncestorFamilyPath = left.familyPath.slice(0, -1);
+  const rightAncestorFamilyPath = right.familyPath.slice(0, -1);
+  const leftAncestorOrdinalPath = left.ordinalPath.slice(0, -1);
+  const rightAncestorOrdinalPath = right.ordinalPath.slice(0, -1);
+  const sharedDepth = Math.min(leftAncestorFamilyPath.length, rightAncestorFamilyPath.length);
+  for (let index = 0;index < sharedDepth; index += 1) {
+    if (leftAncestorFamilyPath[index] !== rightAncestorFamilyPath[index] || leftAncestorOrdinalPath[index] !== rightAncestorOrdinalPath[index]) {
+      return false;
+    }
+  }
+  return true;
+};
+var getOfficeTableCitationPreference = (metadata) => {
+  const scope = getOfficeTableCitationScope(metadata);
+  if (!scope) {
+    return 0;
+  }
+  return scope.pathDepth * 10 + (scope.hasContext ? 1 : 0) + (scope.blockKind === "list" && typeof metadata?.officeListGroupItemCount === "number" && metadata.officeListGroupItemCount > 1 ? 1 : 0);
+};
+var getGenericStructuredCitationPreference = (metadata) => {
+  const scope = getGenericStructuredCitationScope(metadata);
+  if (!scope) {
+    return 0;
+  }
+  return scope.pathDepth * 10 + (scope.kind === "spreadsheet_rows" && typeof metadata?.spreadsheetTableIndex === "number" ? 2 : 0) + (Array.isArray(metadata?.spreadsheetHeaders) && metadata.spreadsheetHeaders.length > 0 ? 1 : 0) + (typeof metadata?.slideNotesText === "string" && metadata.slideNotesText.trim().length > 0 ? 1 : 0);
+};
+var buildLocatorLabel = (metadata, source, title) => {
+  if (!metadata) {
+    return;
+  }
+  const page = getContextNumber(metadata.page) ?? getContextNumber(metadata.pageNumber) ?? (typeof metadata.pageIndex === "number" ? metadata.pageIndex + 1 : undefined);
+  const region = getContextNumber(metadata.regionNumber) ?? (typeof metadata.regionIndex === "number" ? metadata.regionIndex + 1 : undefined);
+  if (page && region) {
+    return `Page ${page} · Region ${region}`;
+  }
+  if (page) {
+    return `Page ${page}`;
+  }
+  const sheet = getContextString(metadata.sheetName) ?? (Array.isArray(metadata.sheetNames) ? getContextString(metadata.sheetNames[0]) : undefined);
+  if (sheet) {
+    return `Sheet ${sheet}`;
+  }
+  const slide = getContextNumber(metadata.slide) ?? getContextNumber(metadata.slideNumber) ?? (typeof metadata.slideIndex === "number" ? metadata.slideIndex + 1 : undefined);
+  const slideTitle = getContextString(metadata.slideTitle);
+  if (slide) {
+    return slideTitle ? `Slide ${slide} · ${slideTitle}` : `Slide ${slide}`;
+  }
+  const archiveEntry = getContextString(metadata.archiveEntryPath) ?? getContextString(metadata.entryPath);
+  if (archiveEntry) {
+    return `Archive entry ${archiveEntry}`;
+  }
+  const emailKind = getContextString(metadata.emailKind);
+  const officeBlockKind = getContextString(metadata.officeBlockKind);
+  const officeBlockNumber = getContextNumber(metadata.officeBlockNumber);
+  const officeTableBodyRowStart = getContextNumber(metadata.officeTableBodyRowStart);
+  const officeTableBodyRowEnd = getContextNumber(metadata.officeTableBodyRowEnd);
+  if (emailKind === "attachment") {
+    const attachmentName = getContextString(metadata.attachmentName) ?? getAttachmentName(source, title);
+    return attachmentName ? `Attachment ${attachmentName}` : "Attachment";
+  }
+  const mediaStart = formatMediaTimestamp(metadata.startMs);
+  const mediaEnd = formatMediaTimestamp(metadata.endMs);
+  if (mediaStart && mediaEnd) {
+    return `Timestamp ${mediaStart} - ${mediaEnd}`;
+  }
+  if (mediaStart) {
+    return `Timestamp ${mediaStart}`;
+  }
+  if (officeBlockNumber && officeBlockKind === "table") {
+    if (typeof officeTableBodyRowStart === "number" && typeof officeTableBodyRowEnd === "number") {
+      return officeTableBodyRowStart === officeTableBodyRowEnd ? `Office table block ${officeBlockNumber} · Row ${officeTableBodyRowStart}` : `Office table block ${officeBlockNumber} · Rows ${officeTableBodyRowStart}-${officeTableBodyRowEnd}`;
+    }
+    return `Office table block ${officeBlockNumber}`;
+  }
+  if (officeBlockNumber && officeBlockKind === "list") {
+    return `Office list block ${officeBlockNumber}`;
+  }
+  if (officeBlockNumber && officeBlockKind === "paragraph") {
+    return `Office paragraph block ${officeBlockNumber}`;
+  }
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.map((value) => getContextString(value)).filter((value) => typeof value === "string") : [];
+  if (sectionPath.length > 0) {
+    return `Section ${sectionPath.join(" > ")}`;
+  }
+  return;
+};
+var formatTimestampLabel = (value) => {
+  const timestamp = typeof value === "number" && Number.isFinite(value) ? value : typeof value === "string" ? Date.parse(value) : Number.NaN;
+  if (!Number.isFinite(timestamp)) {
+    return;
+  }
+  return new Date(timestamp).toLocaleString("en-US", {
+    dateStyle: "medium",
+    timeStyle: "short"
+  });
+};
+var buildProvenanceLabel = (metadata) => {
+  if (!metadata) {
+    return;
+  }
+  const threadTopic = getContextString(metadata.threadTopic);
+  const from = getContextString(metadata.from);
+  const sentAt = formatTimestampLabel(metadata.sentAt) ?? formatTimestampLabel(metadata.receivedAt);
+  const speaker = getContextString(metadata.speaker);
+  const mediaKind = getContextString(metadata.mediaKind);
+  const mediaSegmentCount = getContextNumber(metadata.mediaSegmentCount);
+  const mediaSegmentGroupSize = getContextNumber(metadata.mediaSegmentGroupSize);
+  const mediaSegmentGroupIndex = getContextNumber(metadata.mediaSegmentGroupIndex);
+  const mediaChannel = getContextString(metadata.mediaChannel);
+  const mediaSpeakerCount = getContextNumber(metadata.mediaSpeakerCount);
+  const mediaDurationLabel = formatMediaDurationLabel(metadata.mediaDurationMs);
+  const transcriptSource = getContextString(metadata.transcriptSource);
+  const pdfTextMode = getContextString(metadata.pdfTextMode);
+  const officeBlockKind = getContextString(metadata.officeBlockKind);
+  const officeListContextText = getContextString(metadata.officeListContextText);
+  const officeListGroupItemCount = getContextNumber(metadata.officeListGroupItemCount);
+  const officeListLevelsLabel = formatOfficeListLevelsLabel(metadata.officeListLevels);
+  const officeTableHeaders = Array.isArray(metadata.officeTableHeaders) ? metadata.officeTableHeaders.map((value) => getContextString(value)).filter((value) => typeof value === "string") : [];
+  const officeTableColumnCount = getContextNumber(metadata.officeTableColumnCount);
+  const officeTableBodyRowCount = getContextNumber(metadata.officeTableBodyRowCount);
+  const officeTableBodyRowStart = getContextNumber(metadata.officeTableBodyRowStart);
+  const officeTableBodyRowEnd = getContextNumber(metadata.officeTableBodyRowEnd);
+  const officeTableContextText = getContextString(metadata.officeTableContextText);
+  const officeTableFollowUpText = getContextString(metadata.officeTableFollowUpText);
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.map((value) => getContextString(value)).filter((value) => typeof value === "string") : [];
+  const ocrEngine = getContextString(metadata.ocrEngine);
+  const ocrConfidence = getContextNumber(metadata.ocrRegionConfidence) ?? getContextNumber(metadata.ocrConfidence);
+  const labels = [
+    pdfTextMode ? `PDF ${pdfTextMode}` : "",
+    officeBlockKind ? `Office ${officeBlockKind}` : "",
+    typeof officeListGroupItemCount === "number" ? `Office list ${officeListGroupItemCount} items` : "",
+    officeListLevelsLabel ?? "",
+    sectionPath.length > 0 && officeBlockKind ? `Source-aware office ${officeBlockKind} block ${sectionPath.join(" > ")}` : "",
+    officeListContextText ? `Office list context ${officeListContextText}` : "",
+    officeTableHeaders.length > 0 ? `Office table ${officeTableHeaders.join(", ")}` : "",
+    typeof officeTableColumnCount === "number" ? `Office table ${officeTableColumnCount} cols` : "",
+    typeof officeTableBodyRowCount === "number" ? `Office table ${officeTableBodyRowCount} body rows` : "",
+    typeof officeTableBodyRowStart === "number" && typeof officeTableBodyRowEnd === "number" ? officeTableBodyRowStart === officeTableBodyRowEnd ? `Office table row ${officeTableBodyRowStart}` : `Office table rows ${officeTableBodyRowStart}-${officeTableBodyRowEnd}` : "",
+    officeTableContextText ? `Office table context ${officeTableContextText}` : "",
+    officeTableFollowUpText ? `Office table follow-up ${officeTableFollowUpText}` : "",
+    ocrEngine ? `OCR ${ocrEngine}` : "",
+    typeof ocrConfidence === "number" ? `Confidence ${ocrConfidence.toFixed(2)}` : "",
+    mediaKind ? `Media ${mediaKind}` : "",
+    mediaSegmentCount ? `${mediaSegmentCount} segments` : "",
+    mediaSegmentGroupSize ? `${mediaSegmentGroupSize} grouped segments` : "",
+    mediaSegmentGroupIndex !== undefined ? `Segment group ${mediaSegmentGroupIndex + 1}` : "",
+    mediaChannel ? `Channel ${mediaChannel}` : "",
+    mediaSpeakerCount ? `${mediaSpeakerCount} speakers` : "",
+    mediaDurationLabel ? `Duration ${mediaDurationLabel}` : "",
+    transcriptSource ? `Transcript ${transcriptSource}` : "",
+    threadTopic ? `Thread ${threadTopic}` : "",
+    speaker ? `Speaker ${speaker}` : "",
+    from ? `Sender ${from}` : "",
+    sentAt ? `Sent ${sentAt}` : ""
+  ].filter((value) => value.length > 0);
+  return labels.length > 0 ? labels.join(" · ") : undefined;
+};
+var buildSourceLabel = (source) => source.source ?? source.title ?? source.chunkId;
+var buildExcerpt = (text, maxLength = 160) => {
+  const normalized = text.replaceAll(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return `${normalized.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+};
+var selectPreferredExcerpt = (excerpts, sectionChunkCount) => {
+  if (!excerpts) {
+    return {
+      excerpt: "",
+      mode: "chunk",
+      reason: "single_chunk"
+    };
+  }
+  const chunkExcerpt = excerpts.chunkExcerpt?.trim() ?? "";
+  const windowExcerpt = excerpts.windowExcerpt?.trim() ?? "";
+  const sectionExcerpt = excerpts.sectionExcerpt?.trim() ?? "";
+  if (sectionChunkCount && sectionChunkCount > 1 && chunkExcerpt.length > 0 && chunkExcerpt.length < 72) {
+    if (sectionChunkCount <= 3 && sectionExcerpt) {
+      return {
+        excerpt: sectionExcerpt,
+        mode: "section",
+        reason: "section_small_enough"
+      };
+    }
+    if (windowExcerpt) {
+      return {
+        excerpt: windowExcerpt,
+        mode: "window",
+        reason: "section_too_large_use_window"
+      };
+    }
+    return {
+      excerpt: chunkExcerpt,
+      mode: "chunk",
+      reason: "chunk_too_narrow"
+    };
+  }
+  return {
+    excerpt: chunkExcerpt || windowExcerpt || sectionExcerpt,
+    mode: "chunk",
+    reason: (sectionChunkCount ?? 0) > 1 ? "chunk_too_narrow" : "single_chunk"
+  };
+};
+var buildExcerptModeCounts = (references) => references.reduce((counts, reference) => {
+  if (reference?.excerptSelection) {
+    counts[reference.excerptSelection.mode] += 1;
+  }
+  return counts;
+}, { chunk: 0, section: 0, window: 0 });
+var buildGroundingChunkExcerpts = (sources, activeChunkId) => {
+  if (sources.length === 0) {
+    return;
+  }
+  const activeSource = (activeChunkId ? sources.find((source) => source.chunkId === activeChunkId) : undefined) ?? sources[0];
+  if (!activeSource) {
+    return;
+  }
+  const chunkMap = new Map(sources.map((source) => [source.chunkId, source]));
+  const activeMetadata = activeSource.metadata ?? {};
+  const previousChunkId = getContextString(activeMetadata.previousChunkId);
+  const nextChunkId = getContextString(activeMetadata.nextChunkId);
+  const sectionChunkId = getContextString(activeMetadata.sectionChunkId);
+  const sectionSources = sectionChunkId ? sources.filter((source) => getContextString(source.metadata?.sectionChunkId) === sectionChunkId).sort((left, right) => {
+    const leftIndex = getContextNumber(left.metadata?.sectionChunkIndex) ?? Number.MAX_SAFE_INTEGER;
+    const rightIndex = getContextNumber(right.metadata?.sectionChunkIndex) ?? Number.MAX_SAFE_INTEGER;
+    if (leftIndex !== rightIndex) {
+      return leftIndex - rightIndex;
+    }
+    return left.chunkId.localeCompare(right.chunkId);
+  }) : [activeSource];
+  const collectText = (chunkIds) => chunkIds.map((chunkId) => chunkMap.get(chunkId)?.text).filter((text) => typeof text === "string").join(`
+
+`);
+  const orderedWindowIds = [
+    previousChunkId,
+    activeSource.chunkId,
+    nextChunkId
+  ].filter((chunkId, index, values) => Boolean(chunkId) && values.indexOf(chunkId) === index);
+  return {
+    chunkExcerpt: buildExcerpt(activeSource.text, 160),
+    sectionExcerpt: buildExcerpt(sectionSources.map((source) => source.text).join(`
+
+`), 320),
+    windowExcerpt: buildExcerpt(collectText(orderedWindowIds), 240)
+  };
+};
+var buildGroundingReferenceEvidenceLabel = (reference) => [reference.label, reference.locatorLabel, reference.contextLabel].filter((value) => Boolean(value && value.length > 0)).filter((value, index, values) => values.findIndex((entry) => entry === value) === index).join(" · ");
+var buildGroundingReferenceEvidenceSummary = (reference) => [
+  reference.source ?? reference.title ?? reference.chunkId,
+  reference.locatorLabel,
+  reference.contextLabel,
+  reference.provenanceLabel
+].filter((value) => Boolean(value && value.length > 0)).filter((value, index, values) => values.findIndex((entry) => entry === value) === index).join(" · ");
+var buildGroundingSectionKey = (reference) => reference.contextLabel ?? reference.locatorLabel ?? reference.label ?? reference.source ?? reference.chunkId;
+var buildGroundingSectionSummaryLine = (reference) => [
+  reference.source ?? reference.title ?? reference.chunkId,
+  reference.locatorLabel,
+  reference.contextLabel,
+  reference.provenanceLabel
+].filter((value) => Boolean(value && value.length > 0)).filter((value, index, values) => values.findIndex((entry) => entry === value) === index).join(" · ");
+var buildGroundedAnswerCitationDetail = (reference) => ({
+  contextLabel: reference.contextLabel,
+  evidenceLabel: buildGroundingReferenceEvidenceLabel(reference),
+  evidenceSummary: buildGroundingReferenceEvidenceSummary(reference),
+  excerpt: selectPreferredExcerpt(reference.excerpts, getContextNumber(reference.metadata?.sectionChunkCount)).excerpt || reference.excerpt,
+  excerpts: reference.excerpts,
+  excerptSelection: reference.excerptSelection,
+  label: reference.label,
+  locatorLabel: reference.locatorLabel,
+  number: reference.number,
+  provenanceLabel: reference.provenanceLabel,
+  source: reference.source,
+  title: reference.title
+});
+var buildRAGCitationReferenceMap = (citations) => Object.fromEntries(citations.map((citation, index) => [citation.chunkId, index + 1]));
+var buildRAGCitations = (sources) => {
+  const unique = new Map;
+  for (const source of sources) {
+    const key = source.chunkId;
+    const existing = unique.get(key);
+    const hasBetterExisting = existing !== undefined && existing.score >= source.score;
+    if (hasBetterExisting)
+      continue;
+    const excerpts = buildGroundingChunkExcerpts(sources, source.chunkId);
+    const excerptSelection = selectPreferredExcerpt(excerpts, getContextNumber(source.metadata?.sectionChunkCount));
+    unique.set(key, {
+      chunkId: source.chunkId,
+      contextLabel: source.labels?.contextLabel ?? buildContextLabel(source.metadata),
+      excerpt: excerptSelection.excerpt || buildExcerpt(source.text),
+      excerpts,
+      excerptSelection,
+      key,
+      label: buildSourceLabel(source),
+      locatorLabel: source.labels?.locatorLabel ?? buildLocatorLabel(source.metadata, source.source, source.title),
+      metadata: source.metadata,
+      provenanceLabel: source.labels?.provenanceLabel ?? buildProvenanceLabel(source.metadata),
+      score: source.score,
+      source: source.source,
+      text: source.text,
+      title: source.title
+    });
+  }
+  return [...unique.values()].sort((left, right) => {
+    const leftOfficeScope = getOfficeTableCitationScope(left.metadata);
+    const rightOfficeScope = getOfficeTableCitationScope(right.metadata);
+    if (left.source === right.source && areOfficeCitationScopesComparable(leftOfficeScope, rightOfficeScope)) {
+      const leftOfficePreference = getOfficeTableCitationPreference(left.metadata);
+      const rightOfficePreference = getOfficeTableCitationPreference(right.metadata);
+      if (rightOfficePreference !== leftOfficePreference) {
+        return rightOfficePreference - leftOfficePreference;
+      }
+    }
+    const leftGenericScope = getGenericStructuredCitationScope(left.metadata);
+    const rightGenericScope = getGenericStructuredCitationScope(right.metadata);
+    if (left.source === right.source && areGenericStructuredCitationScopesComparable(leftGenericScope, rightGenericScope)) {
+      const leftGenericPreference = getGenericStructuredCitationPreference(left.metadata);
+      const rightGenericPreference = getGenericStructuredCitationPreference(right.metadata);
+      if (rightGenericPreference !== leftGenericPreference) {
+        return rightGenericPreference - leftGenericPreference;
+      }
+    }
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    return left.label.localeCompare(right.label);
+  });
+};
+var buildRAGGroundedAnswer = (content, sources) => {
+  const references = buildRAGGroundingReferences(sources);
+  const sectionSummaries = buildRAGGroundedAnswerSectionSummaries(references);
+  const referenceMap = new Map(references.map((reference) => [reference.number, reference]));
+  const parts = [];
+  const ungroundedReferenceNumbers = new Set;
+  const citationPattern = /\[(\d+(?:\s*,\s*\d+)*)\]/g;
+  let cursor = 0;
+  for (const match of content.matchAll(citationPattern)) {
+    const raw = match[0];
+    const numbers = (match[1] ?? "").split(",").map((value) => Number.parseInt(value.trim(), 10)).filter((value) => Number.isInteger(value) && value > 0);
+    const start = match.index ?? cursor;
+    if (start > cursor) {
+      parts.push({
+        text: content.slice(cursor, start),
+        type: "text"
+      });
+    }
+    const resolvedReferences = numbers.map((number) => referenceMap.get(number)).filter((reference) => Boolean(reference));
+    for (const number of numbers) {
+      if (!referenceMap.has(number)) {
+        ungroundedReferenceNumbers.add(number);
+      }
+    }
+    const unresolvedNumbers = numbers.filter((number) => !referenceMap.has(number));
+    parts.push({
+      referenceNumbers: numbers,
+      referenceDetails: resolvedReferences.map(buildGroundedAnswerCitationDetail),
+      references: resolvedReferences,
+      text: raw,
+      type: "citation",
+      unresolvedReferenceNumbers: unresolvedNumbers
+    });
+    cursor = start + raw.length;
+  }
+  if (cursor < content.length || parts.length === 0) {
+    parts.push({
+      text: content.slice(cursor),
+      type: "text"
+    });
+  }
+  const hasCitations = parts.some((part) => part.type === "citation");
+  const coverage = !hasCitations ? "ungrounded" : ungroundedReferenceNumbers.size === 0 ? "grounded" : references.length > 0 ? "partial" : "ungrounded";
+  return {
+    content,
+    coverage,
+    excerptModeCounts: buildExcerptModeCounts([
+      ...references,
+      ...sectionSummaries
+    ]),
+    hasCitations,
+    parts,
+    references,
+    sectionSummaries,
+    ungroundedReferenceNumbers: [...ungroundedReferenceNumbers].sort((left, right) => left - right)
+  };
+};
+var buildRAGGroundedAnswerSectionSummaries = (references) => {
+  const groups = new Map;
+  for (const reference of references) {
+    const key = buildGroundingSectionKey(reference);
+    const existing = groups.get(key);
+    if (!existing) {
+      const excerpts = reference.excerpts ? {
+        chunkExcerpt: reference.excerpts.chunkExcerpt,
+        sectionExcerpt: reference.excerpts.sectionExcerpt,
+        windowExcerpt: reference.excerpts.windowExcerpt
+      } : undefined;
+      groups.set(key, {
+        chunkIds: [reference.chunkId],
+        contextLabel: reference.contextLabel,
+        count: 1,
+        excerpt: selectPreferredExcerpt(excerpts, getContextNumber(reference.metadata?.sectionChunkCount)).excerpt || excerpts?.sectionExcerpt || reference.excerpt,
+        excerpts,
+        excerptSelection: reference.excerptSelection,
+        key,
+        label: key,
+        locatorLabel: reference.locatorLabel,
+        provenanceLabel: reference.provenanceLabel,
+        referenceNumbers: [reference.number],
+        references: [reference],
+        summary: buildGroundingSectionSummaryLine(reference) || reference.label || reference.chunkId
+      });
+      continue;
+    }
+    existing.count += 1;
+    if (!existing.chunkIds.includes(reference.chunkId)) {
+      existing.chunkIds.push(reference.chunkId);
+    }
+    if (!existing.referenceNumbers.includes(reference.number)) {
+      existing.referenceNumbers.push(reference.number);
+    }
+    existing.references.push(reference);
+    if (!existing.contextLabel && reference.contextLabel) {
+      existing.contextLabel = reference.contextLabel;
+    }
+    if (!existing.locatorLabel && reference.locatorLabel) {
+      existing.locatorLabel = reference.locatorLabel;
+    }
+    if (!existing.provenanceLabel && reference.provenanceLabel) {
+      existing.provenanceLabel = reference.provenanceLabel;
+    }
+    if (!existing.excerpts && reference.excerpts) {
+      existing.excerpts = {
+        chunkExcerpt: reference.excerpts.chunkExcerpt,
+        sectionExcerpt: reference.excerpts.sectionExcerpt,
+        windowExcerpt: reference.excerpts.windowExcerpt
+      };
+      existing.excerpt = reference.excerpts.sectionExcerpt;
+    }
+    if (!existing.excerptSelection && reference.excerptSelection) {
+      existing.excerptSelection = reference.excerptSelection;
+    }
+  }
+  return [...groups.values()].map((group) => ({
+    ...group,
+    referenceNumbers: [...group.referenceNumbers].sort((left, right) => left - right),
+    references: group.references.slice().sort((left, right) => left.number - right.number)
+  })).sort((left, right) => {
+    const leftFirst = left.referenceNumbers[0] ?? Number.POSITIVE_INFINITY;
+    const rightFirst = right.referenceNumbers[0] ?? Number.POSITIVE_INFINITY;
+    if (leftFirst !== rightFirst) {
+      return leftFirst - rightFirst;
+    }
+    return left.label.localeCompare(right.label);
+  });
+};
+var buildRAGGroundingReferences = (sources) => {
+  const citations = buildRAGCitations(sources);
+  const citationReferenceMap = buildRAGCitationReferenceMap(citations);
+  return citations.map((citation) => {
+    const excerpts = buildGroundingChunkExcerpts(sources, citation.chunkId);
+    const excerptSelection = selectPreferredExcerpt(excerpts, getContextNumber(citation.metadata?.sectionChunkCount));
+    return {
+      chunkId: citation.chunkId,
+      contextLabel: citation.contextLabel ?? buildContextLabel(citation.metadata),
+      excerpt: excerptSelection.excerpt || excerpts?.chunkExcerpt || buildExcerpt(citation.text),
+      excerpts,
+      excerptSelection,
+      label: citation.label,
+      locatorLabel: citation.locatorLabel ?? buildLocatorLabel(citation.metadata, citation.source, citation.title),
+      metadata: citation.metadata,
+      number: citationReferenceMap[citation.chunkId] ?? 0,
+      provenanceLabel: citation.provenanceLabel ?? buildProvenanceLabel(citation.metadata),
+      score: citation.score,
+      source: citation.source,
+      text: citation.text,
+      title: citation.title
+    };
+  });
+};
+
+// src/ai/rag/quality.ts
+var {mkdir, readFile, writeFile} = (() => ({}));
+
+// node:path
+function assertPath(path) {
+  if (typeof path !== "string")
+    throw TypeError("Path must be a string. Received " + JSON.stringify(path));
+}
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, code;
+  for (var i = 0;i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47)
+      break;
+    else
+      code = 47;
+    if (code === 47) {
+      if (lastSlash === i - 1 || dots === 1)
+        ;
+      else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1)
+                res = "", lastSegmentLength = 0;
+              else
+                res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              lastSlash = i, dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "", lastSegmentLength = 0, lastSlash = i, dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += "/..";
+          else
+            res = "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += "/" + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i, dots = 0;
+    } else if (code === 46 && dots !== -1)
+      ++dots;
+    else
+      dots = -1;
+  }
+  return res;
+}
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root, base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir)
+    return base;
+  if (dir === pathObject.root)
+    return dir + base;
+  return dir + sep + base;
+}
+function resolve() {
+  var resolvedPath = "", resolvedAbsolute = false, cwd;
+  for (var i = arguments.length - 1;i >= -1 && !resolvedAbsolute; i--) {
+    var path;
+    if (i >= 0)
+      path = arguments[i];
+    else {
+      if (cwd === undefined)
+        cwd = process.cwd();
+      path = cwd;
+    }
+    if (assertPath(path), path.length === 0)
+      continue;
+    resolvedPath = path + "/" + resolvedPath, resolvedAbsolute = path.charCodeAt(0) === 47;
+  }
+  if (resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute), resolvedAbsolute)
+    if (resolvedPath.length > 0)
+      return "/" + resolvedPath;
+    else
+      return "/";
+  else if (resolvedPath.length > 0)
+    return resolvedPath;
+  else
+    return ".";
+}
+function normalize(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var isAbsolute = path.charCodeAt(0) === 47, trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+  if (path = normalizeStringPosix(path, !isAbsolute), path.length === 0 && !isAbsolute)
+    path = ".";
+  if (path.length > 0 && trailingSeparator)
+    path += "/";
+  if (isAbsolute)
+    return "/" + path;
+  return path;
+}
+function isAbsolute(path) {
+  return assertPath(path), path.length > 0 && path.charCodeAt(0) === 47;
+}
+function join() {
+  if (arguments.length === 0)
+    return ".";
+  var joined;
+  for (var i = 0;i < arguments.length; ++i) {
+    var arg = arguments[i];
+    if (assertPath(arg), arg.length > 0)
+      if (joined === undefined)
+        joined = arg;
+      else
+        joined += "/" + arg;
+  }
+  if (joined === undefined)
+    return ".";
+  return normalize(joined);
+}
+function relative(from, to) {
+  if (assertPath(from), assertPath(to), from === to)
+    return "";
+  if (from = resolve(from), to = resolve(to), from === to)
+    return "";
+  var fromStart = 1;
+  for (;fromStart < from.length; ++fromStart)
+    if (from.charCodeAt(fromStart) !== 47)
+      break;
+  var fromEnd = from.length, fromLen = fromEnd - fromStart, toStart = 1;
+  for (;toStart < to.length; ++toStart)
+    if (to.charCodeAt(toStart) !== 47)
+      break;
+  var toEnd = to.length, toLen = toEnd - toStart, length = fromLen < toLen ? fromLen : toLen, lastCommonSep = -1, i = 0;
+  for (;i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === 47)
+          return to.slice(toStart + i + 1);
+        else if (i === 0)
+          return to.slice(toStart + i);
+      } else if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === 47)
+          lastCommonSep = i;
+        else if (i === 0)
+          lastCommonSep = 0;
+      }
+      break;
+    }
+    var fromCode = from.charCodeAt(fromStart + i), toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode)
+      break;
+    else if (fromCode === 47)
+      lastCommonSep = i;
+  }
+  var out = "";
+  for (i = fromStart + lastCommonSep + 1;i <= fromEnd; ++i)
+    if (i === fromEnd || from.charCodeAt(i) === 47)
+      if (out.length === 0)
+        out += "..";
+      else
+        out += "/..";
+  if (out.length > 0)
+    return out + to.slice(toStart + lastCommonSep);
+  else {
+    if (toStart += lastCommonSep, to.charCodeAt(toStart) === 47)
+      ++toStart;
+    return to.slice(toStart);
+  }
+}
+function _makeLong(path) {
+  return path;
+}
+function dirname(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var code = path.charCodeAt(0), hasRoot = code === 47, end = -1, matchedSlash = true;
+  for (var i = path.length - 1;i >= 1; --i)
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else
+      matchedSlash = false;
+  if (end === -1)
+    return hasRoot ? "/" : ".";
+  if (hasRoot && end === 1)
+    return "//";
+  return path.slice(0, end);
+}
+function basename(path, ext) {
+  if (ext !== undefined && typeof ext !== "string")
+    throw TypeError('"ext" argument must be a string');
+  assertPath(path);
+  var start = 0, end = -1, matchedSlash = true, i;
+  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+    if (ext.length === path.length && ext === path)
+      return "";
+    var extIdx = ext.length - 1, firstNonSlashEnd = -1;
+    for (i = path.length - 1;i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else {
+        if (firstNonSlashEnd === -1)
+          matchedSlash = false, firstNonSlashEnd = i + 1;
+        if (extIdx >= 0)
+          if (code === ext.charCodeAt(extIdx)) {
+            if (--extIdx === -1)
+              end = i;
+          } else
+            extIdx = -1, end = firstNonSlashEnd;
+      }
+    }
+    if (start === end)
+      end = firstNonSlashEnd;
+    else if (end === -1)
+      end = path.length;
+    return path.slice(start, end);
+  } else {
+    for (i = path.length - 1;i >= 0; --i)
+      if (path.charCodeAt(i) === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1)
+        matchedSlash = false, end = i + 1;
+    if (end === -1)
+      return "";
+    return path.slice(start, end);
+  }
+}
+function extname(path) {
+  assertPath(path);
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, preDotState = 0;
+  for (var i = path.length - 1;i >= 0; --i) {
+    var code = path.charCodeAt(i);
+    if (code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+    return "";
+  return path.slice(startDot, end);
+}
+function format(pathObject) {
+  if (pathObject === null || typeof pathObject !== "object")
+    throw TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+  return _format("/", pathObject);
+}
+function parse(path) {
+  assertPath(path);
+  var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+  if (path.length === 0)
+    return ret;
+  var code = path.charCodeAt(0), isAbsolute2 = code === 47, start;
+  if (isAbsolute2)
+    ret.root = "/", start = 1;
+  else
+    start = 0;
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, i = path.length - 1, preDotState = 0;
+  for (;i >= start; --i) {
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    if (end !== -1)
+      if (startPart === 0 && isAbsolute2)
+        ret.base = ret.name = path.slice(1, end);
+      else
+        ret.base = ret.name = path.slice(startPart, end);
+  } else {
+    if (startPart === 0 && isAbsolute2)
+      ret.name = path.slice(1, startDot), ret.base = path.slice(1, end);
+    else
+      ret.name = path.slice(startPart, startDot), ret.base = path.slice(startPart, end);
+    ret.ext = path.slice(startDot, end);
+  }
+  if (startPart > 0)
+    ret.dir = path.slice(0, startPart - 1);
+  else if (isAbsolute2)
+    ret.dir = "/";
+  return ret;
+}
+var sep = "/";
+var delimiter = ":";
+var posix = ((p) => (p.posix = p, p))({ resolve, normalize, isAbsolute, join, relative, _makeLong, dirname, basename, extname, format, parse, sep, delimiter, win32: null, posix: null });
+
+// src/ai/rag/quality.ts
+import { generateId } from "@absolutejs/ai";
+var buildRAGEvaluationLeaderboard = (runs) => {
+  const sorted = [...runs].sort((left, right) => {
+    if (right.response.passingRate !== left.response.passingRate) {
+      return right.response.passingRate - left.response.passingRate;
+    }
+    if (right.response.summary.averageF1 !== left.response.summary.averageF1) {
+      return right.response.summary.averageF1 - left.response.summary.averageF1;
+    }
+    return left.response.summary.averageLatencyMs - right.response.summary.averageLatencyMs;
+  });
+  return sorted.map((run, index) => ({
+    averageF1: run.response.summary.averageF1,
+    averageLatencyMs: run.response.summary.averageLatencyMs,
+    label: run.label,
+    passingRate: run.response.passingRate,
+    rank: index + 1,
+    runId: run.id,
+    suiteId: run.suiteId,
+    totalCases: run.response.totalCases
+  }));
+};
+var runRAGEvaluationSuite = async ({
+  suite,
+  evaluate,
+  overrides,
+  artifacts
+}) => {
+  const startedAt = Date.now();
+  const response = await evaluate({
+    ...suite.input,
+    ...overrides,
+    cases: overrides?.cases ?? suite.input.cases
+  });
+  const finishedAt = Date.now();
+  return {
+    caseTraceSnapshots: artifacts?.caseTraceSnapshots,
+    elapsedMs: finishedAt - startedAt,
+    finishedAt,
+    id: generateId(),
+    label: suite.label ?? suite.id,
+    metadata: suite.metadata,
+    response,
+    startedAt,
+    suiteId: suite.id,
+    traceSummary: artifacts?.traceSummary
+  };
+};
+
+// src/ai/rag/presentation.ts
+var buildSourceGroupKey = (source) => source.source ?? source.title ?? source.chunkId;
+var buildSourceLabel2 = (source) => source.source ?? source.title ?? source.chunkId;
+var getContextNumber2 = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+var getContextString2 = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+var isRAGRetrievalTrace = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.query === "string" && typeof candidate.transformedQuery === "string" && Array.isArray(candidate.variantQueries) && Array.isArray(candidate.steps);
+};
+var formatTimestampLabel2 = (value) => {
+  const timestamp = typeof value === "number" && Number.isFinite(value) ? value : typeof value === "string" ? Date.parse(value) : Number.NaN;
+  if (!Number.isFinite(timestamp)) {
+    return;
+  }
+  return new Date(timestamp).toLocaleString("en-US", {
+    dateStyle: "medium",
+    timeStyle: "short"
+  });
+};
+var formatSourceAwareChunkReason = (value) => {
+  const reason = getContextString2(value);
+  if (reason === "section_boundary") {
+    return "Chunk boundary section";
+  }
+  if (reason === "size_limit") {
+    return "Chunk boundary size limit";
+  }
+  if (reason === "source_native_unit") {
+    return "Chunk boundary source-native unit";
+  }
+  return;
+};
+var buildSourceAwareUnitScopeLabel = (metadata) => {
+  if (!metadata) {
+    return;
+  }
+  const sectionKind = getContextString2(metadata.sectionKind);
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : [];
+  const sectionTitle = getContextString2(metadata.sectionTitle) ?? sectionPath.at(-1);
+  const pdfSemanticRole = getContextString2(metadata.pdfSemanticRole);
+  const pdfTextKind = getContextString2(metadata.pdfTextKind);
+  const officeBlockKindValue = getContextString2(metadata.officeBlockKind);
+  const officeBlockKind = officeBlockKindValue === "table" || officeBlockKindValue === "list" || officeBlockKindValue === "paragraph" ? officeBlockKindValue : undefined;
+  const sheetName = getContextString2(metadata.sheetName);
+  const spreadsheetTableLabel = formatSpreadsheetTableLabel(getContextNumber2(metadata.spreadsheetTableIndex), getContextNumber2(metadata.spreadsheetTableCount));
+  const slideTitle = getContextString2(metadata.slideTitle);
+  const slideNumber = getContextNumber2(metadata.slideNumber) ?? (typeof metadata.slideIndex === "number" ? metadata.slideIndex + 1 : undefined);
+  if (sectionPath.length > 0 && (sectionKind === "markdown_heading" || sectionKind === "html_heading" || sectionKind === "office_heading" || sectionKind === undefined)) {
+    return `Source-aware section ${sectionPath.join(" > ")}`;
+  }
+  if (sectionKind === "pdf_block") {
+    if (pdfSemanticRole === "figure_caption" && sectionTitle) {
+      return `Source-aware PDF figure caption ${sectionTitle}`;
+    }
+    if (pdfSemanticRole === "figure_body" && sectionTitle) {
+      return `Source-aware PDF figure body ${sectionTitle}`;
+    }
+    if (pdfTextKind === "table_like" && sectionTitle) {
+      return `Source-aware PDF table block ${sectionTitle}`;
+    }
+    if (sectionTitle) {
+      return `Source-aware PDF block ${sectionTitle}`;
+    }
+    return "Source-aware PDF block";
+  }
+  if (sectionKind === "office_block") {
+    const officeSectionLabel = sectionPath.length > 0 ? sectionPath.join(" > ") : sectionTitle;
+    if (officeBlockKind && officeSectionLabel) {
+      return `Source-aware office ${officeBlockKind} block ${officeSectionLabel}`;
+    }
+    if (officeSectionLabel) {
+      return `Source-aware office block ${officeSectionLabel}`;
+    }
+    return "Source-aware office block";
+  }
+  if (sectionKind === "spreadsheet_rows" || sectionKind === undefined && (sheetName || spreadsheetTableLabel || getContextNumber2(metadata.spreadsheetRowStart) !== undefined || getContextNumber2(metadata.spreadsheetRowEnd) !== undefined)) {
+    if (sheetName && spreadsheetTableLabel) {
+      return `Source-aware spreadsheet ${sheetName} ${spreadsheetTableLabel}`;
+    }
+    if (sheetName) {
+      return `Source-aware spreadsheet ${sheetName}`;
+    }
+    return "Source-aware spreadsheet";
+  }
+  if (sectionKind === "presentation_slide") {
+    if (slideNumber && slideTitle) {
+      return `Source-aware slide ${slideNumber} ${slideTitle}`;
+    }
+    if (slideTitle) {
+      return `Source-aware slide ${slideTitle}`;
+    }
+    if (slideNumber) {
+      return `Source-aware slide ${slideNumber}`;
+    }
+    return "Source-aware slide";
+  }
+  return;
+};
+var formatMediaTimestamp2 = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return;
+  }
+  const totalSeconds = Math.floor(value / 1000);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  const milliseconds = Math.floor(value % 1000);
+  return `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}.${String(milliseconds).padStart(3, "0")}`;
+};
+var getAttachmentName2 = (source, title) => {
+  const sourceAttachment = source?.split("/").at(-1);
+  if (sourceAttachment && sourceAttachment.includes(".")) {
+    return sourceAttachment;
+  }
+  const titleAttachment = title?.split(" · ").at(-1);
+  if (titleAttachment && titleAttachment.includes(".")) {
+    return titleAttachment;
+  }
+  return;
+};
+var getSpreadsheetHeaders = (metadata) => Array.isArray(metadata?.spreadsheetHeaders) ? metadata.spreadsheetHeaders.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : [];
+var formatSpreadsheetColumnRange = (columnStart, columnEnd) => {
+  if (typeof columnStart !== "string" || columnStart.length === 0) {
+    return;
+  }
+  if (typeof columnEnd !== "string" || columnEnd.length === 0) {
+    return `Columns ${columnStart}`;
+  }
+  if (columnStart === columnEnd) {
+    return `Columns ${columnStart}`;
+  }
+  return `Columns ${columnStart}-${columnEnd}`;
+};
+var formatSpreadsheetRowRange = (rowStart, rowEnd) => {
+  if (typeof rowStart !== "number" || !Number.isFinite(rowStart)) {
+    return;
+  }
+  if (typeof rowEnd !== "number" && typeof rowStart === "number" && Number.isFinite(rowStart)) {
+    return `Rows ${rowStart}`;
+  }
+  if (rowStart === rowEnd) {
+    return `Rows ${rowStart}`;
+  }
+  return `Rows ${rowStart}-${rowEnd}`;
+};
+var formatSpreadsheetTableLabel = (tableIndex, tableCount) => {
+  if (typeof tableIndex !== "number" || !Number.isFinite(tableIndex) || tableIndex < 1) {
+    return;
+  }
+  if (typeof tableCount === "number" && Number.isFinite(tableCount) && tableCount >= tableIndex) {
+    return `Table ${tableIndex} of ${tableCount}`;
+  }
+  return `Table ${tableIndex}`;
+};
+var formatOfficeListLevelsLabel2 = (value) => {
+  if (!Array.isArray(value) || value.length === 0) {
+    return;
+  }
+  const levels = value.map((entry) => getContextNumber2(entry)).filter((entry) => typeof entry === "number").sort((left, right) => left - right);
+  if (levels.length === 0) {
+    return;
+  }
+  const minLevel = levels[0];
+  const maxLevel = levels[levels.length - 1];
+  return minLevel === maxLevel ? `Office list level ${minLevel}` : `Office list levels ${minLevel}-${maxLevel}`;
+};
+var formatMediaDurationLabel2 = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return;
+  }
+  return formatMediaTimestamp2(value);
+};
+var buildContextLabel2 = (metadata) => {
+  if (!metadata) {
+    return;
+  }
+  const pdfTextKind = getContextString2(metadata.pdfTextKind);
+  const pdfSemanticRole = getContextString2(metadata.pdfSemanticRole);
+  const pdfTableBodyRowStart = getContextNumber2(metadata.pdfTableBodyRowStart);
+  const pdfTableBodyRowEnd = getContextNumber2(metadata.pdfTableBodyRowEnd);
+  const officeBlockKindValue = getContextString2(metadata.officeBlockKind);
+  const officeBlockKind = officeBlockKindValue === "table" || officeBlockKindValue === "list" || officeBlockKindValue === "paragraph" ? officeBlockKindValue : undefined;
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : [];
+  const sectionTitle = getContextString2(metadata.sectionTitle) ?? sectionPath.at(-1);
+  if (pdfSemanticRole === "figure_caption" && sectionTitle) {
+    return `PDF figure caption ${sectionTitle}`;
+  }
+  if (pdfSemanticRole === "figure_body" && sectionTitle) {
+    return `PDF figure body ${sectionTitle}`;
+  }
+  if (pdfTextKind === "table_like" && sectionTitle) {
+    return `PDF table block ${sectionTitle}`;
+  }
+  if (pdfTextKind === "paragraph" && sectionTitle) {
+    return `PDF text block ${sectionTitle}`;
+  }
+  if (officeBlockKind === "table" && sectionTitle) {
+    return `Office table block ${sectionPath.join(" > ") || sectionTitle}`;
+  }
+  if (officeBlockKind === "list" && sectionTitle) {
+    return `Office list block ${sectionPath.join(" > ") || sectionTitle}`;
+  }
+  if (officeBlockKind === "paragraph" && sectionTitle) {
+    return `Office paragraph block ${sectionPath.join(" > ") || sectionTitle}`;
+  }
+  const emailKind = getContextString2(metadata.emailKind);
+  if (emailKind === "attachment") {
+    const attachmentName = getContextString2(metadata.attachmentName);
+    const threadTopic2 = getContextString2(metadata.threadTopic);
+    return attachmentName ? threadTopic2 ? `Attachment evidence ${attachmentName} in ${threadTopic2}` : `Attachment evidence ${attachmentName}` : "Attachment evidence";
+  }
+  if (emailKind === "message") {
+    const threadTopic2 = getContextString2(metadata.threadTopic);
+    const from = getContextString2(metadata.from);
+    if (threadTopic2) {
+      return from ? `Message in ${threadTopic2} from ${from}` : `Message in ${threadTopic2}`;
+    }
+    return from ? `Message from ${from}` : "Message evidence";
+  }
+  const page = getContextNumber2(metadata.page) ?? getContextNumber2(metadata.pageNumber) ?? (typeof metadata.pageIndex === "number" ? metadata.pageIndex + 1 : undefined);
+  const region = getContextNumber2(metadata.regionNumber) ?? (typeof metadata.regionIndex === "number" ? metadata.regionIndex + 1 : undefined);
+  const hasOCRTrace = typeof metadata.ocrRegionConfidence === "number" || typeof metadata.ocrConfidence === "number" || getContextString2(metadata.pdfTextMode) === "ocr" || typeof metadata.ocrRegionCount === "number";
+  const ocrPageStart = getContextNumber2(metadata.ocrPageStart);
+  const ocrPageEnd = getContextNumber2(metadata.ocrPageEnd);
+  if (page && region) {
+    if (hasOCRTrace) {
+      return `OCR page ${page} region ${region}`;
+    }
+    return `Page ${page} region ${region}`;
+  }
+  if (page) {
+    if (hasOCRTrace) {
+      return `OCR page ${page}`;
+    }
+    return `Page ${page}`;
+  }
+  if (hasOCRTrace && typeof ocrPageStart === "number" && typeof ocrPageEnd === "number") {
+    return ocrPageStart === ocrPageEnd ? `OCR page ${ocrPageStart}` : `OCR pages ${ocrPageStart}-${ocrPageEnd}`;
+  }
+  const sheet = getContextString2(metadata.sheetName) ?? (Array.isArray(metadata.sheetNames) ? getContextString2(metadata.sheetNames[0]) : undefined);
+  if (sheet) {
+    const tableLabel = formatSpreadsheetTableLabel(getContextNumber2(metadata.spreadsheetTableIndex), getContextNumber2(metadata.spreadsheetTableCount));
+    const columnRange = formatSpreadsheetColumnRange(getContextString2(metadata.spreadsheetColumnStart), getContextString2(metadata.spreadsheetColumnEnd));
+    const rowRange = formatSpreadsheetRowRange(getContextNumber2(metadata.spreadsheetRowStart), getContextNumber2(metadata.spreadsheetRowEnd));
+    const headers = getSpreadsheetHeaders(metadata);
+    if (tableLabel && rowRange && columnRange) {
+      return `Sheet ${sheet} ${tableLabel} ${rowRange} ${columnRange}`;
+    }
+    if (tableLabel && rowRange) {
+      return `Sheet ${sheet} ${tableLabel} ${rowRange}`;
+    }
+    if (tableLabel && columnRange) {
+      return `Sheet ${sheet} ${tableLabel} ${columnRange}`;
+    }
+    if (tableLabel) {
+      return `Sheet ${sheet} ${tableLabel}`;
+    }
+    if (rowRange && columnRange) {
+      return `Sheet ${sheet} ${rowRange} ${columnRange}`;
+    }
+    if (rowRange) {
+      return `Sheet ${sheet} ${rowRange}`;
+    }
+    if (columnRange) {
+      return `Sheet ${sheet} ${columnRange}`;
+    }
+    if (headers.length > 0) {
+      return `Sheet ${sheet} by ${headers.slice(0, 2).join(", ")}`;
+    }
+    return `Sheet ${sheet}`;
+  }
+  const slide = getContextNumber2(metadata.slide) ?? getContextNumber2(metadata.slideNumber) ?? (typeof metadata.slideIndex === "number" ? metadata.slideIndex + 1 : undefined);
+  const slideTitle = getContextString2(metadata.slideTitle);
+  if (slide) {
+    if (slideTitle) {
+      return `Slide ${slide} ${slideTitle}`;
+    }
+    return `Slide ${slide}`;
+  }
+  const archiveEntry = getContextString2(metadata.archiveFullPath) ?? getContextString2(metadata.archivePath) ?? getContextString2(metadata.archiveEntryPath) ?? getContextString2(metadata.entryPath);
+  if (archiveEntry) {
+    return `Archive entry ${archiveEntry}`;
+  }
+  const threadTopic = getContextString2(metadata.threadTopic);
+  if (threadTopic) {
+    return `Thread ${threadTopic}`;
+  }
+  const speaker = getContextString2(metadata.speaker);
+  if (speaker) {
+    return `Speaker ${speaker}`;
+  }
+  if (sectionTitle) {
+    return `Section ${sectionTitle}`;
+  }
+  return;
+};
+var buildLocatorLabel2 = (metadata, source, title) => {
+  if (!metadata) {
+    return;
+  }
+  const pdfTextKind = getContextString2(metadata.pdfTextKind);
+  const pdfSemanticRole = getContextString2(metadata.pdfSemanticRole);
+  const officeBlockKind = getContextString2(metadata.officeBlockKind);
+  const pdfBlockNumber = getContextNumber2(metadata.pdfBlockNumber);
+  const pdfTableBodyRowStart = getContextNumber2(metadata.pdfTableBodyRowStart);
+  const pdfTableBodyRowEnd = getContextNumber2(metadata.pdfTableBodyRowEnd);
+  const officeBlockNumber = getContextNumber2(metadata.officeBlockNumber);
+  const officeTableBodyRowStart = getContextNumber2(metadata.officeTableBodyRowStart);
+  const officeTableBodyRowEnd = getContextNumber2(metadata.officeTableBodyRowEnd);
+  const spreadsheetRowStart = getContextNumber2(metadata.spreadsheetRowStart);
+  const spreadsheetRowEnd = getContextNumber2(metadata.spreadsheetRowEnd);
+  const slideTitle = getContextString2(metadata.slideTitle);
+  const page = getContextNumber2(metadata.page) ?? getContextNumber2(metadata.pageNumber) ?? (typeof metadata.pageIndex === "number" ? metadata.pageIndex + 1 : undefined);
+  const region = getContextNumber2(metadata.regionNumber) ?? (typeof metadata.regionIndex === "number" ? metadata.regionIndex + 1 : undefined);
+  const ocrPageStart = getContextNumber2(metadata.ocrPageStart);
+  const ocrPageEnd = getContextNumber2(metadata.ocrPageEnd);
+  if (page && region) {
+    return `Page ${page} · Region ${region}`;
+  }
+  if (page && pdfBlockNumber && pdfSemanticRole === "figure_caption") {
+    return `Page ${page} · Figure Caption ${pdfBlockNumber}`;
+  }
+  if (page && pdfBlockNumber && pdfSemanticRole === "figure_body") {
+    return `Page ${page} · Figure Body ${pdfBlockNumber}`;
+  }
+  if (page && pdfBlockNumber && pdfTextKind === "table_like") {
+    if (typeof pdfTableBodyRowStart === "number" && typeof pdfTableBodyRowEnd === "number") {
+      return pdfTableBodyRowStart === pdfTableBodyRowEnd ? `Page ${page} · Table Block ${pdfBlockNumber} · Row ${pdfTableBodyRowStart}` : `Page ${page} · Table Block ${pdfBlockNumber} · Rows ${pdfTableBodyRowStart}-${pdfTableBodyRowEnd}`;
+    }
+    return `Page ${page} · Table Block ${pdfBlockNumber}`;
+  }
+  if (page && pdfBlockNumber) {
+    return `Page ${page} · Text Block ${pdfBlockNumber}`;
+  }
+  if (page) {
+    return `Page ${page}`;
+  }
+  if (typeof ocrPageStart === "number" && typeof ocrPageEnd === "number") {
+    return ocrPageStart === ocrPageEnd ? `Page ${ocrPageStart}` : `Pages ${ocrPageStart}-${ocrPageEnd}`;
+  }
+  const sheet = getContextString2(metadata.sheetName) ?? (Array.isArray(metadata.sheetNames) ? getContextString2(metadata.sheetNames[0]) : undefined);
+  if (sheet) {
+    const tableLabel = formatSpreadsheetTableLabel(getContextNumber2(metadata.spreadsheetTableIndex), getContextNumber2(metadata.spreadsheetTableCount));
+    const columnRange = formatSpreadsheetColumnRange(getContextString2(metadata.spreadsheetColumnStart), getContextString2(metadata.spreadsheetColumnEnd));
+    const rowRange = formatSpreadsheetRowRange(spreadsheetRowStart, spreadsheetRowEnd);
+    if (tableLabel && rowRange && columnRange) {
+      return `Sheet ${sheet} · ${tableLabel} · ${rowRange} · ${columnRange}`;
+    }
+    if (tableLabel && rowRange) {
+      return `Sheet ${sheet} · ${tableLabel} · ${rowRange}`;
+    }
+    if (tableLabel && columnRange) {
+      return `Sheet ${sheet} · ${tableLabel} · ${columnRange}`;
+    }
+    if (tableLabel) {
+      return `Sheet ${sheet} · ${tableLabel}`;
+    }
+    if (rowRange && columnRange) {
+      return `Sheet ${sheet} · ${rowRange} · ${columnRange}`;
+    }
+    if (rowRange) {
+      return `Sheet ${sheet} · ${rowRange}`;
+    }
+    return columnRange ? `Sheet ${sheet} · ${columnRange}` : `Sheet ${sheet}`;
+  }
+  const slide = getContextNumber2(metadata.slide) ?? getContextNumber2(metadata.slideNumber) ?? (typeof metadata.slideIndex === "number" ? metadata.slideIndex + 1 : undefined);
+  if (slide) {
+    return slideTitle ? `Slide ${slide} · ${slideTitle}` : `Slide ${slide}`;
+  }
+  const archiveEntry = getContextString2(metadata.archiveFullPath) ?? getContextString2(metadata.archivePath) ?? getContextString2(metadata.archiveEntryPath) ?? getContextString2(metadata.entryPath);
+  if (archiveEntry) {
+    return `Archive entry ${archiveEntry}`;
+  }
+  const emailKind = getContextString2(metadata.emailKind);
+  if (emailKind === "attachment") {
+    const attachmentName = getContextString2(metadata.attachmentName) ?? getAttachmentName2(source, title);
+    const replyDepth = getContextNumber2(metadata.replyDepth);
+    if (attachmentName && replyDepth && replyDepth > 0) {
+      return `Attachment ${attachmentName} · Reply depth ${replyDepth}`;
+    }
+    return attachmentName ? `Attachment ${attachmentName}` : "Attachment";
+  }
+  const mediaStart = formatMediaTimestamp2(metadata.startMs);
+  const mediaEnd = formatMediaTimestamp2(metadata.endMs);
+  if (mediaStart && mediaEnd) {
+    return `Timestamp ${mediaStart} - ${mediaEnd}`;
+  }
+  if (mediaStart) {
+    return `Timestamp ${mediaStart}`;
+  }
+  if (officeBlockNumber && officeBlockKind === "table") {
+    if (typeof officeTableBodyRowStart === "number" && typeof officeTableBodyRowEnd === "number") {
+      return officeTableBodyRowStart === officeTableBodyRowEnd ? `Office table block ${officeBlockNumber} · Row ${officeTableBodyRowStart}` : `Office table block ${officeBlockNumber} · Rows ${officeTableBodyRowStart}-${officeTableBodyRowEnd}`;
+    }
+    return `Office table block ${officeBlockNumber}`;
+  }
+  if (officeBlockNumber && officeBlockKind === "list") {
+    return `Office list block ${officeBlockNumber}`;
+  }
+  if (officeBlockNumber && officeBlockKind === "paragraph") {
+    return `Office paragraph block ${officeBlockNumber}`;
+  }
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : [];
+  if (sectionPath.length > 0) {
+    return `Section ${sectionPath.join(" > ")}`;
+  }
+  return;
+};
+var buildProvenanceLabel2 = (metadata) => {
+  if (!metadata) {
+    return;
+  }
+  const threadTopic = getContextString2(metadata.threadTopic);
+  const replyDepth = getContextNumber2(metadata.replyDepth);
+  const threadMessageCount = getContextNumber2(metadata.threadMessageCount);
+  const threadRootMessageId = getContextString2(metadata.threadRootMessageId);
+  const from = getContextString2(metadata.from);
+  const sentAt = formatTimestampLabel2(metadata.sentAt) ?? formatTimestampLabel2(metadata.receivedAt);
+  const speaker = getContextString2(metadata.speaker);
+  const mediaKind = getContextString2(metadata.mediaKind);
+  const transcriptSource = getContextString2(metadata.transcriptSource);
+  const mediaSpeakerCount = getContextNumber2(metadata.mediaSpeakerCount);
+  const mediaSegmentCount = getContextNumber2(metadata.mediaSegmentCount);
+  const mediaSegmentGroupSize = getContextNumber2(metadata.mediaSegmentGroupSize);
+  const mediaSegmentGroupIndex = getContextNumber2(metadata.mediaSegmentGroupIndex);
+  const mediaChannel = getContextString2(metadata.mediaChannel);
+  const mediaDurationLabel = formatMediaDurationLabel2(metadata.mediaDurationMs);
+  const mediaSegmentWindowDurationLabel = formatMediaDurationLabel2(metadata.mediaSegmentGroupDurationMs);
+  const mediaSegmentGapLabel = formatMediaDurationLabel2(metadata.mediaSegmentGapFromPreviousMs);
+  const spreadsheetHeaders = getSpreadsheetHeaders(metadata);
+  const pdfTableHeaders = Array.isArray(metadata.pdfTableHeaders) ? metadata.pdfTableHeaders.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : [];
+  const pdfTableColumnCount = getContextNumber2(metadata.pdfTableColumnCount);
+  const pdfTableBodyRowCount = getContextNumber2(metadata.pdfTableBodyRowCount);
+  const spreadsheetColumnRange = formatSpreadsheetColumnRange(getContextString2(metadata.spreadsheetColumnStart), getContextString2(metadata.spreadsheetColumnEnd));
+  const slideNotesText = getContextString2(metadata.slideNotesText);
+  const pdfTextMode = getContextString2(metadata.pdfTextMode);
+  const pdfEvidenceMode = getContextString2(metadata.pdfEvidenceMode);
+  const pdfEvidenceOrigin = getContextString2(metadata.pdfEvidenceOrigin);
+  const pdfEvidenceSupplement = getContextString2(metadata.pdfEvidenceSupplement);
+  const pdfTextKind = getContextString2(metadata.pdfTextKind);
+  const pdfSemanticRole = getContextString2(metadata.pdfSemanticRole);
+  const officeBlockKind = getContextString2(metadata.officeBlockKind);
+  const officeListContextText = getContextString2(metadata.officeListContextText);
+  const officeListGroupItemCount = getContextNumber2(metadata.officeListGroupItemCount);
+  const officeListLevelsLabel = formatOfficeListLevelsLabel2(metadata.officeListLevels);
+  const officeTableHeaders = Array.isArray(metadata.officeTableHeaders) ? metadata.officeTableHeaders.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : [];
+  const officeTableColumnCount = getContextNumber2(metadata.officeTableColumnCount);
+  const officeTableBodyRowCount = getContextNumber2(metadata.officeTableBodyRowCount);
+  const officeTableBodyRowStart = getContextNumber2(metadata.officeTableBodyRowStart);
+  const officeTableBodyRowEnd = getContextNumber2(metadata.officeTableBodyRowEnd);
+  const officeTableContextText = getContextString2(metadata.officeTableContextText);
+  const officeTableFollowUpText = getContextString2(metadata.officeTableFollowUpText);
+  const ocrEngine = getContextString2(metadata.ocrEngine);
+  const extractorRegistryMatch = getContextString2(metadata.extractorRegistryMatch);
+  const chunkingProfile = getContextString2(metadata.chunkingProfile);
+  const archiveDepth = getContextNumber2(metadata.archiveDepth);
+  const archiveNestedDepth = getContextNumber2(metadata.archiveNestedDepth);
+  const archiveContainerPath = getContextString2(metadata.archiveContainerPath);
+  const archiveRootName = getContextString2(metadata.archiveRootName);
+  const sourceAwareChunkReason = formatSourceAwareChunkReason(metadata.sourceAwareChunkReason);
+  const sourceAwareUnitScope = buildSourceAwareUnitScopeLabel(metadata);
+  const spreadsheetTableLabel = formatSpreadsheetTableLabel(getContextNumber2(metadata.spreadsheetTableIndex), getContextNumber2(metadata.spreadsheetTableCount));
+  const ocrConfidence = getContextNumber2(metadata.ocrRegionConfidence) ?? getContextNumber2(metadata.ocrConfidence);
+  const ocrAverageConfidence = getContextNumber2(metadata.ocrPageAverageConfidence) ?? getContextNumber2(metadata.ocrAverageConfidence);
+  const ocrMinConfidence = getContextNumber2(metadata.ocrPageMinConfidence) ?? getContextNumber2(metadata.ocrMinConfidence);
+  const ocrMaxConfidence = getContextNumber2(metadata.ocrPageMaxConfidence) ?? getContextNumber2(metadata.ocrMaxConfidence);
+  const ocrRegionCount = getContextNumber2(metadata.ocrRegionCount);
+  const pdfTableBodyRowStart = getContextNumber2(metadata.pdfTableBodyRowStart);
+  const pdfTableBodyRowEnd = getContextNumber2(metadata.pdfTableBodyRowEnd);
+  const labels = [
+    pdfTextMode ? `PDF ${pdfTextMode}` : "",
+    pdfEvidenceMode ? `PDF evidence ${pdfEvidenceMode}` : "",
+    pdfEvidenceOrigin ? `PDF origin ${pdfEvidenceOrigin}` : "",
+    pdfEvidenceSupplement ? `PDF supplement ${pdfEvidenceSupplement}` : "",
+    pdfSemanticRole === "figure_caption" ? "PDF figure caption" : "",
+    pdfSemanticRole === "figure_body" ? "PDF figure body" : "",
+    pdfSemanticRole === "figure_caption" ? "" : pdfSemanticRole === "figure_body" ? "" : pdfTextKind === "table_like" ? "PDF table block" : pdfTextKind === "paragraph" ? "PDF text block" : "",
+    officeBlockKind ? `Office ${officeBlockKind}` : "",
+    typeof officeListGroupItemCount === "number" ? `Office list ${officeListGroupItemCount} items` : "",
+    officeListLevelsLabel ?? "",
+    ocrEngine ? `OCR ${ocrEngine}` : "",
+    extractorRegistryMatch ? `Extractor ${extractorRegistryMatch}` : "",
+    chunkingProfile ? `Chunking ${chunkingProfile}` : "",
+    sourceAwareChunkReason ?? "",
+    sourceAwareUnitScope ?? "",
+    typeof ocrConfidence === "number" ? `Confidence ${ocrConfidence.toFixed(2)}` : "",
+    typeof ocrAverageConfidence === "number" && ocrAverageConfidence !== ocrConfidence ? `Average ${ocrAverageConfidence.toFixed(2)}` : "",
+    typeof ocrMinConfidence === "number" && typeof ocrMaxConfidence === "number" && ocrMinConfidence !== ocrMaxConfidence ? `Range ${ocrMinConfidence.toFixed(2)}-${ocrMaxConfidence.toFixed(2)}` : "",
+    typeof ocrRegionCount === "number" ? `${ocrRegionCount} regions` : "",
+    pdfTableHeaders.length > 0 ? `PDF table ${pdfTableHeaders.join(", ")}` : "",
+    typeof pdfTableColumnCount === "number" ? `PDF table ${pdfTableColumnCount} cols` : "",
+    typeof pdfTableBodyRowCount === "number" ? `PDF table ${pdfTableBodyRowCount} body rows` : "",
+    typeof pdfTableBodyRowStart === "number" && typeof pdfTableBodyRowEnd === "number" ? pdfTableBodyRowStart === pdfTableBodyRowEnd ? `PDF table row ${pdfTableBodyRowStart}` : `PDF table rows ${pdfTableBodyRowStart}-${pdfTableBodyRowEnd}` : "",
+    officeListContextText ? `Office list context ${officeListContextText}` : "",
+    officeTableHeaders.length > 0 ? `Office table ${officeTableHeaders.join(", ")}` : "",
+    typeof officeTableColumnCount === "number" ? `Office table ${officeTableColumnCount} cols` : "",
+    typeof officeTableBodyRowCount === "number" ? `Office table ${officeTableBodyRowCount} body rows` : "",
+    typeof officeTableBodyRowStart === "number" && typeof officeTableBodyRowEnd === "number" ? officeTableBodyRowStart === officeTableBodyRowEnd ? `Office table row ${officeTableBodyRowStart}` : `Office table rows ${officeTableBodyRowStart}-${officeTableBodyRowEnd}` : "",
+    officeTableContextText ? `Office table context ${officeTableContextText}` : "",
+    officeTableFollowUpText ? `Office table follow-up ${officeTableFollowUpText}` : "",
+    spreadsheetHeaders.length > 0 ? `Spreadsheet ${spreadsheetHeaders.join(", ")}` : "",
+    spreadsheetColumnRange ? `Spreadsheet ${spreadsheetColumnRange}` : "",
+    spreadsheetTableLabel ? `Spreadsheet ${spreadsheetTableLabel}` : "",
+    mediaKind ? `Media ${mediaKind}` : "",
+    mediaSegmentCount ? `${mediaSegmentCount} segments` : "",
+    mediaSegmentGroupSize ? `${mediaSegmentGroupSize} grouped segments` : "",
+    mediaSegmentGroupIndex !== undefined ? `Segment group ${mediaSegmentGroupIndex + 1}` : "",
+    mediaChannel ? `Channel ${mediaChannel}` : "",
+    mediaSpeakerCount ? `${mediaSpeakerCount} speakers` : "",
+    mediaDurationLabel ? `Duration ${mediaDurationLabel}` : "",
+    mediaSegmentWindowDurationLabel ? `Segment window ${mediaSegmentWindowDurationLabel}` : "",
+    mediaSegmentGapLabel ? `Gap ${mediaSegmentGapLabel} from previous window` : "",
+    transcriptSource ? `Transcript ${transcriptSource}` : "",
+    threadTopic ? `Thread ${threadTopic}` : "",
+    threadRootMessageId ? `Thread root ${threadRootMessageId}` : "",
+    threadMessageCount ? `${threadMessageCount} thread messages` : "",
+    replyDepth ? `Reply depth ${replyDepth}` : "",
+    slideNotesText ? "Speaker notes" : "",
+    archiveDepth ? `Archive depth ${archiveDepth}` : "",
+    archiveNestedDepth ? `Archive nested depth ${archiveNestedDepth}` : "",
+    archiveContainerPath ? `Archive container ${archiveContainerPath}` : "",
+    archiveRootName ? `Archive root ${archiveRootName}` : "",
+    speaker ? `Speaker ${speaker}` : "",
+    from ? `Sender ${from}` : "",
+    sentAt ? `Sent ${sentAt}` : ""
+  ].filter((value) => value.length > 0);
+  return labels.length > 0 ? labels.join(" · ") : undefined;
+};
+var buildRAGSourceLabels = ({
+  metadata,
+  source,
+  title
+}) => {
+  const contextLabel = buildContextLabel2(metadata);
+  const locatorLabel = buildLocatorLabel2(metadata, source, title);
+  const provenanceLabel = buildProvenanceLabel2(metadata);
+  if (!contextLabel && !locatorLabel && !provenanceLabel) {
+    return;
+  }
+  return {
+    contextLabel,
+    locatorLabel,
+    provenanceLabel
+  };
+};
+var buildRAGChunkStructure = (metadata) => {
+  if (!metadata) {
+    return;
+  }
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.filter((value) => typeof value === "string" && value.trim().length > 0) : undefined;
+  const sectionKind = metadata.sectionKind === "markdown_heading" || metadata.sectionKind === "html_heading" || metadata.sectionKind === "office_heading" || metadata.sectionKind === "office_block" || metadata.sectionKind === "pdf_block" || metadata.sectionKind === "spreadsheet_rows" || metadata.sectionKind === "presentation_slide" ? metadata.sectionKind : undefined;
+  const section = {
+    depth: getContextNumber2(metadata.sectionDepth),
+    kind: sectionKind,
+    path: sectionPath && sectionPath.length > 0 ? sectionPath : undefined,
+    title: getContextString2(metadata.sectionTitle)
+  };
+  const sequence = {
+    nextChunkId: getContextString2(metadata.nextChunkId),
+    previousChunkId: getContextString2(metadata.previousChunkId),
+    sectionChunkCount: getContextNumber2(metadata.sectionChunkCount),
+    sectionChunkId: getContextString2(metadata.sectionChunkId),
+    sectionChunkIndex: getContextNumber2(metadata.sectionChunkIndex)
+  };
+  if (!section.title && (!section.path || section.path.length === 0) && typeof section.depth !== "number" && !section.kind && !sequence.nextChunkId && !sequence.previousChunkId && typeof sequence.sectionChunkCount !== "number" && !sequence.sectionChunkId && typeof sequence.sectionChunkIndex !== "number") {
+    return;
+  }
+  return {
+    section: section.title || section.path && section.path.length > 0 || typeof section.depth === "number" || section.kind ? section : undefined,
+    sequence: sequence.nextChunkId || sequence.previousChunkId || typeof sequence.sectionChunkCount === "number" || sequence.sectionChunkId || typeof sequence.sectionChunkIndex === "number" ? sequence : undefined
+  };
+};
+var buildExcerpt2 = (text, maxLength = 160) => {
+  const normalized = text.replaceAll(/\s+/g, " ").trim();
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return `${normalized.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+};
+var buildRAGChunkExcerpts = (chunks, activeChunkId) => {
+  if (chunks.length === 0) {
+    return;
+  }
+  const graph = buildRAGChunkGraph(chunks.map((chunk) => ({
+    chunkId: chunk.chunkId,
+    metadata: chunk.metadata,
+    structure: chunk.structure
+  })));
+  const navigation = buildRAGChunkGraphNavigation(graph, activeChunkId);
+  const activeChunk = chunks.find((chunk) => chunk.chunkId === navigation.activeChunkId) ?? chunks[0];
+  if (!activeChunk) {
+    return;
+  }
+  const chunkMap = new Map(chunks.map((chunk) => [chunk.chunkId, chunk]));
+  const orderedSectionIds = navigation.sectionNodes.length > 0 ? navigation.sectionNodes.map((node) => node.chunkId) : [activeChunk.chunkId];
+  const orderedWindowIds = navigation.sectionNodes.length > 0 ? (() => {
+    const activeIndex = navigation.sectionNodes.findIndex((node) => node.chunkId === activeChunk.chunkId);
+    const startIndex = Math.max(0, activeIndex - 2);
+    const endIndex = Math.min(navigation.sectionNodes.length, activeIndex + 3);
+    return navigation.sectionNodes.slice(startIndex, endIndex).map((node) => node.chunkId);
+  })() : [
+    navigation.previousNode?.chunkId,
+    activeChunk.chunkId,
+    navigation.nextNode?.chunkId
+  ].filter((chunkId, index, ids) => Boolean(chunkId) && ids.indexOf(chunkId) === index);
+  const collectText = (chunkIds) => chunkIds.map((chunkId) => chunkMap.get(chunkId)?.text).filter((text) => typeof text === "string").join(`
+
+`);
+  return {
+    chunkExcerpt: buildExcerpt2(activeChunk.text, 160),
+    sectionExcerpt: buildExcerpt2(collectText(orderedSectionIds), 320),
+    windowExcerpt: buildExcerpt2(collectText(orderedWindowIds), 240)
+  };
+};
+var buildRAGExcerptSelection = (excerpts, structure) => {
+  if (!excerpts) {
+    return {
+      excerpt: "",
+      mode: "chunk",
+      reason: "single_chunk"
+    };
+  }
+  const chunkLength = excerpts.chunkExcerpt.trim().length;
+  const sectionChunkCount = structure?.sequence?.sectionChunkCount ?? 1;
+  if (sectionChunkCount > 1 && chunkLength > 0 && chunkLength < 72) {
+    if (sectionChunkCount <= 3 && excerpts.sectionExcerpt.trim().length > 0) {
+      return {
+        excerpt: excerpts.sectionExcerpt,
+        mode: "section",
+        reason: "section_small_enough"
+      };
+    }
+    if (excerpts.windowExcerpt.trim().length > 0) {
+      return {
+        excerpt: excerpts.windowExcerpt,
+        mode: "window",
+        reason: "section_too_large_use_window"
+      };
+    }
+    return {
+      excerpt: excerpts.chunkExcerpt,
+      mode: "chunk",
+      reason: "chunk_too_narrow"
+    };
+  }
+  return {
+    excerpt: excerpts.chunkExcerpt,
+    mode: "chunk",
+    reason: sectionChunkCount > 1 ? "chunk_too_narrow" : "single_chunk"
+  };
+};
+var buildRAGExcerptModeCounts = (selections) => selections.reduce((counts, selection) => {
+  if (selection) {
+    counts[selection.mode] += 1;
+  }
+  return counts;
+}, { chunk: 0, section: 0, window: 0 });
+var buildRAGChunkGraph = (chunks) => {
+  const nodes = [];
+  const edges = [];
+  const edgeKeys = new Set;
+  const sections = new Map;
+  for (const chunk of chunks) {
+    const labels = chunk.labels ?? buildRAGSourceLabels({
+      metadata: chunk.metadata,
+      source: chunk.source,
+      title: chunk.title
+    });
+    const structure = chunk.structure ?? buildRAGChunkStructure(chunk.metadata);
+    nodes.push({
+      chunkId: chunk.chunkId,
+      contextLabel: labels?.contextLabel,
+      label: chunk.source ?? chunk.title ?? chunk.chunkId,
+      locatorLabel: labels?.locatorLabel,
+      provenanceLabel: labels?.provenanceLabel,
+      score: chunk.score,
+      source: chunk.source,
+      structure,
+      title: chunk.title
+    });
+    const previousChunkId = structure?.sequence?.previousChunkId;
+    if (previousChunkId) {
+      const key = `previous:${previousChunkId}:${chunk.chunkId}`;
+      if (!edgeKeys.has(key)) {
+        edgeKeys.add(key);
+        edges.push({
+          fromChunkId: previousChunkId,
+          relation: "previous",
+          toChunkId: chunk.chunkId
+        });
+      }
+    }
+    const nextChunkId = structure?.sequence?.nextChunkId;
+    if (nextChunkId) {
+      const key = `next:${chunk.chunkId}:${nextChunkId}`;
+      if (!edgeKeys.has(key)) {
+        edgeKeys.add(key);
+        edges.push({
+          fromChunkId: chunk.chunkId,
+          relation: "next",
+          toChunkId: nextChunkId
+        });
+      }
+    }
+    const sectionId = structure?.sequence?.sectionChunkId;
+    if (sectionId) {
+      const existing = sections.get(sectionId);
+      if (!existing) {
+        sections.set(sectionId, {
+          childSectionIds: [],
+          chunkCount: structure.sequence?.sectionChunkCount ?? 1,
+          chunkIds: [chunk.chunkId],
+          depth: structure.section?.depth,
+          id: sectionId,
+          kind: structure.section?.kind,
+          leadChunkId: chunk.chunkId,
+          path: structure.section?.path,
+          title: structure.section?.title
+        });
+        continue;
+      }
+      if (!existing.chunkIds.includes(chunk.chunkId)) {
+        existing.chunkIds.push(chunk.chunkId);
+      }
+      existing.chunkCount = Math.max(existing.chunkCount, structure.sequence?.sectionChunkCount ?? existing.chunkCount);
+    }
+  }
+  for (const section of sections.values()) {
+    section.chunkIds.sort((left, right) => {
+      const leftNode = nodes.find((node) => node.chunkId === left);
+      const rightNode = nodes.find((node) => node.chunkId === right);
+      const leftIndex = leftNode?.structure?.sequence?.sectionChunkIndex ?? Number.MAX_SAFE_INTEGER;
+      const rightIndex = rightNode?.structure?.sequence?.sectionChunkIndex ?? Number.MAX_SAFE_INTEGER;
+      if (leftIndex !== rightIndex) {
+        return leftIndex - rightIndex;
+      }
+      return left.localeCompare(right);
+    });
+    section.leadChunkId = section.chunkIds[0];
+  }
+  const sectionPathIndex = new Map;
+  for (const section of sections.values()) {
+    const path = section.path && section.path.length > 0 ? section.path : section.title ? [section.title] : undefined;
+    if (path && path.length > 0) {
+      sectionPathIndex.set(path.join("\x00"), section);
+    }
+  }
+  for (const section of sections.values()) {
+    const path = section.path && section.path.length > 0 ? section.path : section.title ? [section.title] : undefined;
+    if (!path || path.length < 2) {
+      continue;
+    }
+    const parent = sectionPathIndex.get(path.slice(0, -1).join("\x00"));
+    if (!parent || parent.id === section.id) {
+      continue;
+    }
+    section.parentSectionId = parent.id;
+    if (!parent.childSectionIds.includes(section.id)) {
+      parent.childSectionIds.push(section.id);
+    }
+    if (parent.leadChunkId && section.leadChunkId) {
+      const parentKey = `section_parent:${section.leadChunkId}:${parent.leadChunkId}`;
+      if (!edgeKeys.has(parentKey)) {
+        edgeKeys.add(parentKey);
+        edges.push({
+          fromChunkId: section.leadChunkId,
+          relation: "section_parent",
+          toChunkId: parent.leadChunkId
+        });
+      }
+      const childKey = `section_child:${parent.leadChunkId}:${section.leadChunkId}`;
+      if (!edgeKeys.has(childKey)) {
+        edgeKeys.add(childKey);
+        edges.push({
+          fromChunkId: parent.leadChunkId,
+          relation: "section_child",
+          toChunkId: section.leadChunkId
+        });
+      }
+    }
+  }
+  nodes.sort((left, right) => {
+    const leftSection = left.structure?.sequence?.sectionChunkIndex ?? Number.MAX_SAFE_INTEGER;
+    const rightSection = right.structure?.sequence?.sectionChunkIndex ?? Number.MAX_SAFE_INTEGER;
+    if (leftSection !== rightSection) {
+      return leftSection - rightSection;
+    }
+    const leftScore = left.score ?? Number.NEGATIVE_INFINITY;
+    const rightScore = right.score ?? Number.NEGATIVE_INFINITY;
+    if (leftScore !== rightScore) {
+      return rightScore - leftScore;
+    }
+    return left.label.localeCompare(right.label);
+  });
+  return {
+    edges,
+    nodes,
+    sections: [...sections.values()].sort((left, right) => (left.title ?? left.id).localeCompare(right.title ?? right.id))
+  };
+};
+var buildRAGChunkPreviewGraph = (preview) => buildRAGChunkGraph(preview.chunks.map((chunk) => ({
+  chunkId: chunk.chunkId,
+  labels: chunk.labels,
+  metadata: chunk.metadata,
+  source: chunk.source ?? preview.document.source,
+  structure: chunk.structure,
+  title: chunk.title ?? preview.document.title
+})));
+var buildRAGChunkPreviewNavigation = (preview, activeChunkId) => buildRAGChunkGraphNavigation(buildRAGChunkPreviewGraph(preview), activeChunkId);
+var buildRAGChunkGraphNavigation = (graph, activeChunkId) => {
+  if (graph.nodes.length === 0) {
+    return {
+      activeChunkId,
+      childSections: [],
+      siblingSections: [],
+      sectionNodes: []
+    };
+  }
+  const activeNode = (activeChunkId ? graph.nodes.find((node) => node.chunkId === activeChunkId) : undefined) ?? graph.nodes[0];
+  const resolvedActiveChunkId = activeNode?.chunkId;
+  const previousNode = activeNode?.structure?.sequence?.previousChunkId ? graph.nodes.find((node) => node.chunkId === activeNode.structure?.sequence?.previousChunkId) : undefined;
+  const nextNode = activeNode?.structure?.sequence?.nextChunkId ? graph.nodes.find((node) => node.chunkId === activeNode.structure?.sequence?.nextChunkId) : undefined;
+  const section = activeNode?.structure?.sequence?.sectionChunkId ? graph.sections.find((entry) => entry.id === activeNode.structure?.sequence?.sectionChunkId) : undefined;
+  const parentSection = section?.parentSectionId ? graph.sections.find((entry) => entry.id === section.parentSectionId) : undefined;
+  const childSections = section ? section.childSectionIds.map((sectionId) => graph.sections.find((entry) => entry.id === sectionId)).filter((entry) => Boolean(entry)) : [];
+  const siblingSections = section?.parentSectionId ? graph.sections.filter((entry) => entry.parentSectionId === section.parentSectionId && entry.id !== section.id) : [];
+  const sectionNodes = section ? section.chunkIds.map((chunkId) => graph.nodes.find((node) => node.chunkId === chunkId)).filter((node) => Boolean(node)) : activeNode ? [activeNode] : [];
+  return {
+    activeChunkId: resolvedActiveChunkId,
+    activeNode,
+    childSections,
+    nextNode,
+    parentSection,
+    previousNode,
+    section,
+    siblingSections,
+    sectionNodes
+  };
+};
+var buildRAGRetrievedState = (messages) => {
+  const message = getLatestRetrievedMessage(messages);
+  if (!message) {
+    return null;
+  }
+  const sources = message.sources ?? [];
+  const citations = buildRAGCitations(sources);
+  const sectionDiagnostics = buildRAGSectionRetrievalDiagnostics(sources, isRAGRetrievalTrace(message.retrievalTrace) ? message.retrievalTrace : undefined);
+  const sourceSummaries = buildRAGSourceSummaries(sources);
+  const groundedAnswer = buildRAGGroundedAnswer(message.content, sources);
+  return {
+    citationReferenceMap: buildRAGCitationReferenceMap(citations),
+    citations,
+    conversationId: message.conversationId,
+    excerptModeCounts: buildRAGExcerptModeCounts([
+      ...citations.map((citation) => citation.excerptSelection),
+      ...sourceSummaries.map((summary) => summary.excerptSelection)
+    ]),
+    groundedAnswer,
+    messageId: message.id,
+    retrievalDurationMs: message.retrievalDurationMs,
+    retrievalStartedAt: message.retrievalStartedAt,
+    retrievedAt: message.retrievedAt,
+    trace: isRAGRetrievalTrace(message.retrievalTrace) ? message.retrievalTrace : undefined,
+    sectionDiagnostics,
+    sourceGroups: buildRAGSourceGroups(sources),
+    sourceSummaries,
+    sources
+  };
+};
+var buildRAGSourceSummaries = (sources) => {
+  const sourceGroups = buildRAGSourceGroups(sources);
+  const citations = buildRAGCitations(sources);
+  const citationReferenceMap = buildRAGCitationReferenceMap(citations);
+  return sourceGroups.map((group) => {
+    const groupCitations = citations.filter((citation) => group.chunks.some((chunk) => chunk.chunkId === citation.chunkId));
+    const leadChunk = getPreferredSourceLeadChunk(group.chunks);
+    const excerpts = leadChunk ? buildRAGChunkExcerpts(group.chunks, leadChunk.chunkId) : undefined;
+    const structure = leadChunk?.structure ?? buildRAGChunkStructure(leadChunk?.metadata);
+    const excerptSelection = buildRAGExcerptSelection(excerpts, structure);
+    return {
+      bestScore: group.bestScore,
+      citationNumbers: groupCitations.map((citation) => citationReferenceMap[citation.chunkId] ?? 0),
+      citations: groupCitations,
+      chunkIds: group.chunks.map((chunk) => chunk.chunkId),
+      contextLabel: leadChunk?.labels?.contextLabel ?? buildContextLabel2(leadChunk?.metadata),
+      count: group.count,
+      excerpt: excerptSelection.excerpt || buildExcerpt2(leadChunk?.text ?? ""),
+      excerpts,
+      excerptSelection,
+      key: group.key,
+      label: group.label,
+      locatorLabel: leadChunk?.labels?.locatorLabel ?? buildLocatorLabel2(leadChunk?.metadata, leadChunk?.source, leadChunk?.title),
+      provenanceLabel: leadChunk?.labels?.provenanceLabel ?? buildProvenanceLabel2(leadChunk?.metadata),
+      structure,
+      source: group.source,
+      title: group.title
+    };
+  });
+};
+var getSectionPathFromSource = (source) => {
+  const path = source.structure?.section?.path ?? (Array.isArray(source.metadata?.sectionPath) ? source.metadata.sectionPath.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : []);
+  return path.length > 0 ? path : undefined;
+};
+var isBlockAwareContextLabel = (value) => typeof value === "string" && (value.startsWith("PDF ") || value.startsWith("Office ") || value.startsWith("Slide "));
+var getStructuredSectionScoreWeight = (metadata) => {
+  if (!metadata) {
+    return 1;
+  }
+  const pdfTextKind = getContextString2(metadata.pdfTextKind);
+  const officeBlockKind = getContextString2(metadata.officeBlockKind);
+  const sectionKind = getContextString2(metadata.sectionKind);
+  const slideTitle = getContextString2(metadata.slideTitle);
+  const slideNotesText = getContextString2(metadata.slideNotesText);
+  if (pdfTextKind === "table_like") {
+    return 1.28;
+  }
+  if (officeBlockKind === "table" || officeBlockKind === "list") {
+    return 1.24;
+  }
+  if (sectionKind === "pdf_block" || sectionKind === "office_block" || officeBlockKind === "paragraph" || pdfTextKind === "paragraph") {
+    return 1.12;
+  }
+  if (sectionKind === "presentation_slide" && slideNotesText) {
+    return 1.2;
+  }
+  if (sectionKind === "presentation_slide" && slideTitle) {
+    return 1.14;
+  }
+  return 1;
+};
+var getStructuredSourceLeadScore = (source) => source.score * getStructuredSectionScoreWeight(source.metadata);
+var getPDFLeadEvidencePreference = (metadata) => {
+  if (!metadata) {
+    return 0;
+  }
+  const pdfEvidenceMode = getContextString2(metadata.pdfEvidenceMode);
+  const pdfEvidenceOrigin = getContextString2(metadata.pdfEvidenceOrigin);
+  const pdfEvidenceSupplement = getContextString2(metadata.pdfEvidenceSupplement);
+  if (pdfEvidenceMode === "hybrid" && pdfEvidenceOrigin === "native" && pdfEvidenceSupplement === "ocr") {
+    return 3;
+  }
+  if (pdfEvidenceMode === "native" && pdfEvidenceOrigin === "native") {
+    return 2;
+  }
+  if (pdfEvidenceMode === "ocr" && pdfEvidenceOrigin === "ocr") {
+    return 1;
+  }
+  return 0;
+};
+var getPDFLeadScope = (metadata) => {
+  if (!metadata) {
+    return;
+  }
+  const pageNumber = getContextNumber2(metadata.pageNumber) ?? getContextNumber2(metadata.page) ?? (typeof metadata.pageIndex === "number" ? metadata.pageIndex + 1 : undefined);
+  const sectionTitle = getContextString2(metadata.sectionTitle);
+  const sourceNativeKind = getContextString2(metadata.sourceNativeKind);
+  if (typeof pageNumber !== "number" && !sectionTitle && !sourceNativeKind) {
+    return;
+  }
+  return {
+    pageNumber,
+    sectionTitle,
+    sourceNativeKind
+  };
+};
+var getOfficeLeadScope = (metadata) => {
+  if (!metadata) {
+    return;
+  }
+  const officeBlockKindValue = getContextString2(metadata.officeBlockKind);
+  const officeBlockKind = officeBlockKindValue === "table" || officeBlockKindValue === "list" || officeBlockKindValue === "paragraph" ? officeBlockKindValue : undefined;
+  if (officeBlockKind !== "table" && officeBlockKind !== "list" && officeBlockKind !== "paragraph") {
+    return;
+  }
+  const sectionPath = Array.isArray(metadata.sectionPath) ? metadata.sectionPath.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : [];
+  const sectionTitle = getContextString2(metadata.sectionTitle) ?? sectionPath.at(-1);
+  const officeContextText = officeBlockKind === "table" ? getContextString2(metadata.officeTableContextText) : officeBlockKind === "list" ? getContextString2(metadata.officeListContextText) : undefined;
+  if (!sectionTitle) {
+    return;
+  }
+  return {
+    blockKind: officeBlockKind,
+    familyPath: (() => {
+      const explicitGenericFamilyPath = Array.isArray(metadata.sectionFamilyPath) ? metadata.sectionFamilyPath.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : [];
+      const explicitGenericOrdinalPath = Array.isArray(metadata.sectionOrdinalPath) ? metadata.sectionOrdinalPath.map((value) => getContextNumber2(value)).filter((value) => typeof value === "number") : [];
+      if (explicitGenericFamilyPath.length > 0 && explicitGenericFamilyPath.length === explicitGenericOrdinalPath.length) {
+        return explicitGenericFamilyPath;
+      }
+      const explicitOfficeFamilyPath = Array.isArray(metadata.officeFamilyPath) ? metadata.officeFamilyPath.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : [];
+      return explicitOfficeFamilyPath.length > 0 ? explicitOfficeFamilyPath : sectionPath.map((value) => value.replace(/\s+\((\d+)\)$/, "").trim());
+    })(),
+    pathDepth: sectionPath.length,
+    ordinalPath: (() => {
+      const explicitGenericFamilyPath = Array.isArray(metadata.sectionFamilyPath) ? metadata.sectionFamilyPath.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : [];
+      const explicitGenericOrdinalPath = Array.isArray(metadata.sectionOrdinalPath) ? metadata.sectionOrdinalPath.map((value) => getContextNumber2(value)).filter((value) => typeof value === "number") : [];
+      if (explicitGenericFamilyPath.length > 0 && explicitGenericFamilyPath.length === explicitGenericOrdinalPath.length) {
+        return explicitGenericOrdinalPath;
+      }
+      const explicitOfficeOrdinalPath = Array.isArray(metadata.officeOrdinalPath) ? metadata.officeOrdinalPath.map((value) => typeof value === "number" && Number.isFinite(value) ? value : undefined).filter((value) => typeof value === "number") : [];
+      return explicitOfficeOrdinalPath.length > 0 ? explicitOfficeOrdinalPath : sectionPath.map((value) => {
+        const match = value.match(/\((\d+)\)$/);
+        return match ? Number.parseInt(match[1] ?? "1", 10) : 1;
+      });
+    })(),
+    sectionFamilyKey: getContextString2(metadata.sectionSiblingFamilyKey) ?? getContextString2(metadata.officeSiblingFamilyKey) ?? sectionPath.at(-1)?.replace(/\s+\((\d+)\)$/, "").trim() ?? sectionTitle,
+    sectionOrdinal: getContextNumber2(metadata.sectionSiblingOrdinal) ?? getContextNumber2(metadata.officeSiblingOrdinal) ?? (() => {
+      const match = sectionTitle.match(/\((\d+)\)$/);
+      return match ? Number.parseInt(match[1] ?? "1", 10) : 1;
+    })(),
+    sectionTitle,
+    hasContext: typeof officeContextText === "string"
+  };
+};
+var areOfficeLeadScopesComparable = (left, right) => {
+  if (!left || !right) {
+    return false;
+  }
+  if (left.blockKind !== right.blockKind || left.sectionFamilyKey !== right.sectionFamilyKey || left.sectionOrdinal !== right.sectionOrdinal) {
+    return false;
+  }
+  const leftAncestorFamilyPath = left.familyPath.slice(0, -1);
+  const rightAncestorFamilyPath = right.familyPath.slice(0, -1);
+  const leftAncestorOrdinalPath = left.ordinalPath.slice(0, -1);
+  const rightAncestorOrdinalPath = right.ordinalPath.slice(0, -1);
+  const sharedDepth = Math.min(leftAncestorFamilyPath.length, rightAncestorFamilyPath.length);
+  for (let index = 0;index < sharedDepth; index += 1) {
+    if (leftAncestorFamilyPath[index] !== rightAncestorFamilyPath[index] || leftAncestorOrdinalPath[index] !== rightAncestorOrdinalPath[index]) {
+      return false;
+    }
+  }
+  return true;
+};
+var getGenericStructuredLeadScope = (metadata) => {
+  if (!metadata || metadata.officeBlockKind || metadata.pageNumber) {
+    return;
+  }
+  const kind = metadata.sectionKind === "spreadsheet_rows" || metadata.sectionKind === "presentation_slide" ? metadata.sectionKind : undefined;
+  if (!kind) {
+    return;
+  }
+  const explicitFamilyPath = Array.isArray(metadata.sectionFamilyPath) ? metadata.sectionFamilyPath.map((value) => getContextString2(value)).filter((value) => typeof value === "string") : [];
+  const explicitOrdinalPath = Array.isArray(metadata.sectionOrdinalPath) ? metadata.sectionOrdinalPath.map((value) => getContextNumber2(value)).filter((value) => typeof value === "number") : [];
+  let familyPath = explicitFamilyPath.length > 0 && explicitFamilyPath.length === explicitOrdinalPath.length ? explicitFamilyPath : [];
+  let ordinalPath = explicitFamilyPath.length > 0 && explicitFamilyPath.length === explicitOrdinalPath.length ? explicitOrdinalPath : [];
+  if (familyPath.length === 0) {
+    if (kind === "spreadsheet_rows") {
+      const sheetName = getContextString2(metadata.sheetName) ?? "Sheet";
+      const tableIndex = getContextNumber2(metadata.spreadsheetTableIndex) ?? 1;
+      familyPath = [sheetName, "Spreadsheet Table"];
+      ordinalPath = [1, tableIndex];
+    } else {
+      const slideFamily = getContextString2(metadata.slideTitle) ?? "Slide";
+      const slideOrdinal = getContextNumber2(metadata.slideNumber) ?? (typeof metadata.slideIndex === "number" ? metadata.slideIndex + 1 : 1);
+      familyPath = [slideFamily];
+      ordinalPath = [slideOrdinal];
+    }
+  }
+  const sectionFamilyKey = getContextString2(metadata.sectionSiblingFamilyKey) ?? familyPath.at(-1);
+  const sectionOrdinal = getContextNumber2(metadata.sectionSiblingOrdinal) ?? ordinalPath.at(-1);
+  if (!sectionFamilyKey || typeof sectionOrdinal !== "number") {
+    return;
+  }
+  return {
+    familyPath,
+    kind,
+    ordinalPath,
+    pathDepth: familyPath.length,
+    sectionFamilyKey,
+    sectionOrdinal
+  };
+};
+var areGenericStructuredLeadScopesComparable = (left, right) => {
+  if (!left || !right) {
+    return false;
+  }
+  if (left.kind !== right.kind || left.sectionFamilyKey !== right.sectionFamilyKey || left.sectionOrdinal !== right.sectionOrdinal) {
+    return false;
+  }
+  const leftAncestorFamilyPath = left.familyPath.slice(0, -1);
+  const rightAncestorFamilyPath = right.familyPath.slice(0, -1);
+  const leftAncestorOrdinalPath = left.ordinalPath.slice(0, -1);
+  const rightAncestorOrdinalPath = right.ordinalPath.slice(0, -1);
+  const sharedDepth = Math.min(leftAncestorFamilyPath.length, rightAncestorFamilyPath.length);
+  for (let index = 0;index < sharedDepth; index += 1) {
+    if (leftAncestorFamilyPath[index] !== rightAncestorFamilyPath[index] || leftAncestorOrdinalPath[index] !== rightAncestorOrdinalPath[index]) {
+      return false;
+    }
+  }
+  return true;
+};
+var getOfficeLeadEvidencePreference = (metadata) => {
+  const scope = getOfficeLeadScope(metadata);
+  if (!scope) {
+    return 0;
+  }
+  return scope.pathDepth * 10 + (scope.hasContext ? 1 : 0) + (scope.blockKind === "list" && typeof metadata?.officeListGroupItemCount === "number" && metadata.officeListGroupItemCount > 1 ? 1 : 0);
+};
+var getGenericStructuredLeadPreference = (metadata) => {
+  const scope = getGenericStructuredLeadScope(metadata);
+  if (!scope) {
+    return 0;
+  }
+  return scope.pathDepth * 10 + (scope.kind === "spreadsheet_rows" && typeof metadata?.spreadsheetTableIndex === "number" ? 2 : 0) + (Array.isArray(metadata?.spreadsheetHeaders) && metadata.spreadsheetHeaders.length > 0 ? 1 : 0) + (typeof metadata?.slideNotesText === "string" && metadata.slideNotesText.trim().length > 0 ? 1 : 0);
+};
+var getPreferredSourceLeadChunk = (chunks) => chunks.slice().sort((left, right) => {
+  const leftOfficeScope = getOfficeLeadScope(left.metadata);
+  const rightOfficeScope = getOfficeLeadScope(right.metadata);
+  if (left.source === right.source && areOfficeLeadScopesComparable(leftOfficeScope, rightOfficeScope)) {
+    const leftOfficePreference = getOfficeLeadEvidencePreference(left.metadata);
+    const rightOfficePreference = getOfficeLeadEvidencePreference(right.metadata);
+    if (rightOfficePreference !== leftOfficePreference) {
+      return rightOfficePreference - leftOfficePreference;
+    }
+  }
+  const leftGenericScope = getGenericStructuredLeadScope(left.metadata);
+  const rightGenericScope = getGenericStructuredLeadScope(right.metadata);
+  if (left.source === right.source && areGenericStructuredLeadScopesComparable(leftGenericScope, rightGenericScope)) {
+    const leftGenericPreference = getGenericStructuredLeadPreference(left.metadata);
+    const rightGenericPreference = getGenericStructuredLeadPreference(right.metadata);
+    if (rightGenericPreference !== leftGenericPreference) {
+      return rightGenericPreference - leftGenericPreference;
+    }
+  }
+  const leftWeightedScore = getStructuredSourceLeadScore(left);
+  const rightWeightedScore = getStructuredSourceLeadScore(right);
+  if (rightWeightedScore !== leftWeightedScore) {
+    return rightWeightedScore - leftWeightedScore;
+  }
+  const leftScope = getPDFLeadScope(left.metadata);
+  const rightScope = getPDFLeadScope(right.metadata);
+  if (left.source === right.source && leftScope && rightScope && (leftScope.sectionTitle && rightScope.sectionTitle && leftScope.sectionTitle === rightScope.sectionTitle || typeof leftScope.pageNumber === "number" && typeof rightScope.pageNumber === "number" && leftScope.pageNumber === rightScope.pageNumber)) {
+    const leftEvidencePreference = getPDFLeadEvidencePreference(left.metadata);
+    const rightEvidencePreference = getPDFLeadEvidencePreference(right.metadata);
+    if (rightEvidencePreference !== leftEvidencePreference) {
+      return rightEvidencePreference - leftEvidencePreference;
+    }
+  }
+  if (right.score !== left.score) {
+    return right.score - left.score;
+  }
+  return left.chunkId.localeCompare(right.chunkId);
+})[0];
+var buildRAGSectionRetrievalDiagnostics = (sources, trace) => {
+  const totalScore = sources.reduce((sum, source) => sum + source.score * getStructuredSectionScoreWeight(source.metadata), 0);
+  if (sources.length === 0 || totalScore <= 0) {
+    return [];
+  }
+  const sections = new Map;
+  for (const source of sources) {
+    const structuredScore = source.score * getStructuredSectionScoreWeight(source.metadata);
+    const path = getSectionPathFromSource(source);
+    if (!path) {
+      continue;
+    }
+    const key = path.join(" > ");
+    const label = path.at(-1) ?? key;
+    const parentLabel = path.length > 1 ? path.slice(0, -1).join(" > ") : undefined;
+    const existing = sections.get(key);
+    const channels = Array.isArray(source.metadata?.retrievalChannels) ? source.metadata.retrievalChannels.filter((value) => value === "vector" || value === "lexical") : [];
+    const isHybrid = channels.includes("vector") && channels.includes("lexical");
+    const vectorHits = channels.includes("vector") ? 1 : 0;
+    const lexicalHits = channels.includes("lexical") ? 1 : 0;
+    const hybridHits = isHybrid ? 1 : 0;
+    const queryOrigins = Array.isArray(source.metadata?.retrievalQueryOrigins) ? source.metadata.retrievalQueryOrigins.filter((value) => value === "primary" || value === "transformed" || value === "variant") : source.metadata?.retrievalQueryOrigin === "primary" || source.metadata?.retrievalQueryOrigin === "transformed" || source.metadata?.retrievalQueryOrigin === "variant" ? [source.metadata.retrievalQueryOrigin] : [];
+    const primaryHits = queryOrigins.includes("primary") ? 1 : 0;
+    const transformedHits = queryOrigins.includes("transformed") ? 1 : 0;
+    const variantHits = queryOrigins.includes("variant") ? 1 : 0;
+    if (!existing) {
+      sections.set(key, {
+        bestScore: source.score,
+        count: 1,
+        hybridHits,
+        key,
+        label,
+        lexicalHits,
+        parentLabel,
+        path,
+        primaryHits,
+        sourceSet: new Set(source.source ? [source.source] : []),
+        topChunkId: source.chunkId,
+        topSource: source.source,
+        totalScore: structuredScore,
+        transformedHits,
+        variantHits,
+        vectorHits
+      });
+      continue;
+    }
+    existing.count += 1;
+    existing.totalScore += structuredScore;
+    if (source.source) {
+      existing.sourceSet.add(source.source);
+    }
+    existing.vectorHits += vectorHits;
+    existing.lexicalHits += lexicalHits;
+    existing.hybridHits += hybridHits;
+    existing.primaryHits += primaryHits;
+    existing.transformedHits += transformedHits;
+    existing.variantHits += variantHits;
+    if (source.score > existing.bestScore) {
+      existing.bestScore = source.score;
+      existing.topChunkId = source.chunkId;
+      existing.topSource = source.source;
+    }
+  }
+  const diagnostics = [...sections.values()];
+  const strongestBestHit = diagnostics.reduce((highest, section) => Math.max(highest, section.bestScore), 0);
+  const parentLabelByKey = new Map(diagnostics.map((section) => [section.key, section.parentLabel]));
+  const stageSectionCounts = new Map((trace?.steps ?? []).filter((step) => Array.isArray(step.sectionCounts) && step.sectionCounts.length > 0).map((step) => [step.stage, step.sectionCounts ?? []]));
+  const stageSectionScores = new Map((trace?.steps ?? []).filter((step) => Array.isArray(step.sectionScores) && step.sectionScores.length > 0).map((step) => [step.stage, step.sectionScores ?? []]));
+  return diagnostics.map((section) => {
+    const siblingPool = diagnostics.filter((entry) => entry.parentLabel === section.parentLabel);
+    const siblings = siblingPool.filter((entry) => entry.key !== section.key);
+    const strongestSibling = siblings.slice().sort((left, right) => right.totalScore - left.totalScore)[0];
+    const parentTotal = siblingPool.reduce((sum, entry) => sum + entry.totalScore, 0);
+    const scoreShare = section.totalScore / totalScore;
+    const parentShare = parentTotal > 0 ? section.totalScore / parentTotal : undefined;
+    const topChunk = sources.find((source) => source.chunkId === section.topChunkId);
+    const topContextLabel = topChunk?.labels?.contextLabel ?? buildContextLabel2(topChunk?.metadata);
+    const topLocatorLabel = topChunk?.labels?.locatorLabel ?? buildLocatorLabel2(topChunk?.metadata, topChunk?.source, topChunk?.title);
+    const sourceAwareChunkReason = formatSourceAwareChunkReason(topChunk?.metadata?.sourceAwareChunkReason);
+    const sourceAwareUnitScopeLabel = buildSourceAwareUnitScopeLabel(topChunk?.metadata);
+    const parentDistribution = parentTotal > 0 ? siblingPool.map((entry) => ({
+      count: entry.count,
+      isActive: entry.key === section.key,
+      key: entry.key,
+      label: entry.label,
+      parentShare: entry.totalScore / parentTotal,
+      totalScore: entry.totalScore
+    })).sort((left, right) => right.totalScore - left.totalScore) : [];
+    const reasons = [];
+    const stageCounts = trace?.steps.map((step) => ({
+      count: step.sectionCounts?.find((entry) => entry.key === section.key)?.count ?? 0,
+      stage: step.stage
+    })).filter((entry) => entry.count > 0) ?? [];
+    const stageWeights = stageCounts.map((entry) => {
+      const previousStageEntry = stageCounts[stageCounts.findIndex((candidate) => candidate.stage === entry.stage) - 1];
+      const stageEntries = stageSectionCounts.get(entry.stage)?.filter((candidate) => candidate.count > 0) ?? [];
+      const stageScoreEntries = stageSectionScores.get(entry.stage)?.filter((candidate) => candidate.totalScore > 0) ?? [];
+      const stageTotal = stageEntries.reduce((sum, candidate) => sum + candidate.count, 0);
+      const stageScoreTotal = stageScoreEntries.reduce((sum, candidate) => sum + candidate.totalScore, 0);
+      const siblingStageEntries = stageEntries.filter((candidate) => candidate.key !== section.key && parentLabelByKey.get(candidate.key) === section.parentLabel);
+      const parentStageEntries = stageEntries.filter((candidate) => parentLabelByKey.get(candidate.key) === section.parentLabel);
+      const siblingStageScoreEntries = stageScoreEntries.filter((candidate) => candidate.key !== section.key && parentLabelByKey.get(candidate.key) === section.parentLabel);
+      const parentStageScoreEntries = stageScoreEntries.filter((candidate) => parentLabelByKey.get(candidate.key) === section.parentLabel);
+      const strongestStageSibling = siblingStageEntries.slice().sort((left, right) => right.count - left.count)[0];
+      const parentStageTotal = parentStageEntries.reduce((sum, candidate) => sum + candidate.count, 0);
+      const activeStageScore = stageScoreEntries.find((candidate) => candidate.key === section.key)?.totalScore;
+      const strongestStageScoreSibling = siblingStageScoreEntries.slice().sort((left, right) => right.totalScore - left.totalScore)[0];
+      const parentStageScoreTotal = parentStageScoreEntries.reduce((sum, candidate) => sum + candidate.totalScore, 0);
+      const stageShare = stageTotal > 0 ? entry.count / stageTotal : 0;
+      const retentionRate = typeof previousStageEntry?.count === "number" && previousStageEntry.count > 0 ? entry.count / previousStageEntry.count : undefined;
+      const countDelta = typeof previousStageEntry?.count === "number" ? entry.count - previousStageEntry.count : undefined;
+      const parentStageShare = parentStageTotal > 0 ? entry.count / parentStageTotal : undefined;
+      const stageScoreShare = typeof activeStageScore === "number" && stageScoreTotal > 0 ? activeStageScore / stageScoreTotal : undefined;
+      const parentStageScoreShare = typeof activeStageScore === "number" && parentStageScoreTotal > 0 ? activeStageScore / parentStageScoreTotal : undefined;
+      const stageShareGap = stageTotal > 0 && strongestStageSibling ? entry.count / stageTotal - strongestStageSibling.count / stageTotal : undefined;
+      const parentStageShareGap = parentStageTotal > 0 && strongestStageSibling ? entry.count / parentStageTotal - strongestStageSibling.count / parentStageTotal : undefined;
+      const stageScoreShareGap = typeof activeStageScore === "number" && stageScoreTotal > 0 && strongestStageScoreSibling ? activeStageScore / stageScoreTotal - strongestStageScoreSibling.totalScore / stageScoreTotal : undefined;
+      const parentStageScoreShareGap = typeof activeStageScore === "number" && parentStageScoreTotal > 0 && strongestStageScoreSibling ? activeStageScore / parentStageScoreTotal - strongestStageScoreSibling.totalScore / parentStageScoreTotal : undefined;
+      const reasons2 = [];
+      if (entry.stage === "rerank" && stageShare > 0.5 && (typeof stageShareGap !== "number" || stageShareGap > 0)) {
+        reasons2.push("rerank_preserved_lead");
+      }
+      if (entry.stage === "finalize" && stageShare >= 0.5) {
+        reasons2.push("final_stage_concentration");
+      }
+      if (entry.stage === "finalize" && typeof parentStageShare === "number" && parentStageShare >= 0.6 && (typeof parentStageShareGap !== "number" || parentStageShareGap > 0)) {
+        reasons2.push("final_stage_dominant_within_parent");
+      }
+      if (strongestStageSibling && (typeof stageShareGap === "number" && stageShareGap <= 0.1 || typeof parentStageShareGap === "number" && parentStageShareGap <= 0.1)) {
+        reasons2.push("stage_runner_up_pressure");
+      }
+      if (typeof countDelta === "number") {
+        if (countDelta > 0) {
+          reasons2.push("stage_expanded");
+        } else if (countDelta < 0) {
+          reasons2.push("stage_narrowed");
+        } else {
+          reasons2.push("stage_held");
+        }
+      }
+      return {
+        count: entry.count,
+        countDelta,
+        parentStageScoreShare,
+        parentStageShare,
+        parentStageShareGap,
+        previousCount: previousStageEntry?.count,
+        previousStage: previousStageEntry?.stage,
+        reasons: reasons2,
+        retentionRate,
+        stage: entry.stage,
+        stageScoreShare,
+        stageScoreShareGap,
+        stageShare,
+        stageShareGap,
+        totalScore: activeStageScore,
+        strongestSiblingCount: strongestStageSibling?.count,
+        strongestSiblingLabel: strongestStageSibling ? diagnostics.find((candidate) => candidate.key === strongestStageSibling.key)?.label ?? strongestStageSibling.key : undefined
+      };
+    });
+    const firstSeenStage = stageCounts[0]?.stage;
+    const lastSeenStage = stageCounts.at(-1)?.stage;
+    const peakStageEntry = stageCounts.reduce((highest, entry) => !highest || entry.count > highest.count ? entry : highest, undefined);
+    const finalStageEntry = stageCounts.at(-1);
+    const peakCount = peakStageEntry?.count ?? section.count;
+    const finalCount = finalStageEntry?.count;
+    const finalRetentionRate = typeof finalCount === "number" && peakCount > 0 ? finalCount / peakCount : undefined;
+    const dropFromPeak = typeof finalCount === "number" ? peakCount - finalCount : undefined;
+    const queryAttributionReasons = [];
+    const queryAttributionMode = section.primaryHits > 0 && section.transformedHits === 0 && section.variantHits === 0 ? "primary" : section.transformedHits > 0 && section.primaryHits === 0 && section.variantHits === 0 ? "transformed" : section.variantHits > 0 && section.primaryHits === 0 && section.transformedHits === 0 ? "variant" : "mixed";
+    if (queryAttributionMode === "primary") {
+      queryAttributionReasons.push("base_query_only");
+    }
+    if (queryAttributionMode === "transformed") {
+      queryAttributionReasons.push("transformed_query_only");
+      queryAttributionReasons.push("transform_introduced");
+    }
+    if (queryAttributionMode === "variant") {
+      queryAttributionReasons.push("variant_only");
+      queryAttributionReasons.push("variant_supported");
+    }
+    if (queryAttributionMode === "mixed") {
+      queryAttributionReasons.push("mixed_query_sources");
+      if (section.variantHits > 0) {
+        queryAttributionReasons.push("variant_supported");
+      }
+      if (section.transformedHits > 0 && section.primaryHits === 0) {
+        queryAttributionReasons.push("transform_introduced");
+      }
+    }
+    if (section.bestScore >= strongestBestHit) {
+      reasons.push("best_hit");
+    }
+    if (section.count > 1) {
+      reasons.push("multi_hit_section");
+    }
+    if (siblings.length === 0) {
+      reasons.push("only_section_in_parent");
+    } else if (!strongestSibling || section.totalScore >= strongestSibling.totalScore) {
+      reasons.push("dominant_within_parent");
+    }
+    if (scoreShare >= 0.5 || (parentShare ?? 0) >= 0.6) {
+      reasons.push("concentrated_evidence");
+    }
+    const summaryParts = [
+      isBlockAwareContextLabel(topContextLabel) ? topContextLabel : "",
+      `${section.count} hit${section.count === 1 ? "" : "s"}`,
+      `${(scoreShare * 100).toFixed(0)}% score share`,
+      `vector ${section.vectorHits} · lexical ${section.lexicalHits} · hybrid ${section.hybridHits}`,
+      typeof parentShare === "number" ? `${(parentShare * 100).toFixed(0)}% of parent section set` : "",
+      sourceAwareChunkReason ? `boundary ${sourceAwareChunkReason}` : "",
+      sourceAwareUnitScopeLabel ? `scope ${sourceAwareUnitScopeLabel}` : "",
+      strongestSibling ? `ahead of ${strongestSibling.label} by ${(section.totalScore - strongestSibling.totalScore).toFixed(2)}` : "no sibling competition"
+    ].filter(Boolean);
+    return {
+      averageScore: section.totalScore / section.count,
+      bestScore: section.bestScore,
+      count: section.count,
+      key: section.key,
+      label: section.label,
+      parentLabel: section.parentLabel,
+      parentDistribution,
+      parentShare,
+      parentShareGap: typeof parentShare === "number" && strongestSibling && parentTotal > 0 ? parentShare - strongestSibling.totalScore / parentTotal : undefined,
+      path: section.path,
+      firstSeenStage,
+      finalCount,
+      finalRetentionRate,
+      lastSeenStage,
+      dropFromPeak,
+      peakCount,
+      peakStage: peakStageEntry?.stage,
+      queryAttribution: {
+        mode: queryAttributionMode,
+        primaryHits: section.primaryHits,
+        reasons: queryAttributionReasons,
+        transformedHits: section.transformedHits,
+        variantHits: section.variantHits
+      },
+      requestedMode: trace?.requestedMode,
+      retrievalMode: trace?.mode,
+      routingLabel: trace?.routingLabel,
+      routingProvider: trace?.routingProvider,
+      routingReason: trace?.routingReason,
+      queryTransformLabel: trace?.queryTransformLabel,
+      queryTransformProvider: trace?.queryTransformProvider,
+      queryTransformReason: trace?.queryTransformReason,
+      reasons,
+      evidenceReconcileApplied: trace?.steps.some((step) => step.stage === "evidence_reconcile"),
+      rerankApplied: trace?.steps.some((step) => step.stage === "rerank" && step.metadata?.applied === true),
+      scoreShare,
+      scoreThresholdApplied: trace?.steps.some((step) => step.stage === "score_filter"),
+      stageCounts,
+      stageWeights,
+      siblingCount: siblings.length,
+      siblingScoreGap: strongestSibling ? section.totalScore - strongestSibling.totalScore : undefined,
+      sourceCount: section.sourceSet.size,
+      sourceAwareChunkReasonLabel: sourceAwareChunkReason,
+      sourceAwareUnitScopeLabel,
+      topContextLabel,
+      topLocatorLabel,
+      sourceBalanceApplied: trace?.steps.some((step) => step.stage === "source_balance"),
+      strongestSiblingLabel: strongestSibling?.label,
+      strongestSiblingScore: strongestSibling?.totalScore,
+      summary: summaryParts.join(" · "),
+      topChunkId: section.topChunkId,
+      topSource: section.topSource,
+      totalScore: section.totalScore,
+      hybridHits: section.hybridHits,
+      lexicalHits: section.lexicalHits,
+      vectorHits: section.vectorHits
+    };
+  }).sort((left, right) => {
+    if (right.totalScore !== left.totalScore) {
+      return right.totalScore - left.totalScore;
+    }
+    if (right.bestScore !== left.bestScore) {
+      return right.bestScore - left.bestScore;
+    }
+    return left.label.localeCompare(right.label);
+  });
+};
+var buildStreamProgressState = (messages) => {
+  const latestMessage = getLatestAssistantMessage(messages);
+  const retrieved = latestMessage ? buildRAGRetrievedState(messages) : undefined;
+  return {
+    conversationId: latestMessage?.conversationId,
+    latestMessage,
+    messageId: latestMessage?.id,
+    retrieved,
+    sourceCount: retrieved?.sources.length ?? latestMessage?.sources?.length ?? 0
+  };
+};
+var buildRAGStreamProgress = ({
+  error,
+  isStreaming,
+  messages
+}) => {
+  const stage = resolveRAGStreamStage({
+    error,
+    isStreaming,
+    messages
+  });
+  const state = buildStreamProgressState(messages);
+  const hasSources = state.sourceCount > 0;
+  const hasRetrieved = stage === "retrieved" || state.retrieved !== undefined || state.latestMessage?.retrievedAt !== undefined;
+  const hasThinking = typeof state.latestMessage?.thinking === "string" && state.latestMessage.thinking.length > 0;
+  const hasToolCalls = (state.latestMessage?.toolCalls?.length ?? 0) > 0;
+  return {
+    conversationId: state.conversationId,
+    hasContent: typeof state.latestMessage?.content === "string" && state.latestMessage.content.length > 0,
+    hasRetrieved,
+    hasSources,
+    hasThinking,
+    hasToolCalls,
+    isComplete: stage === "complete",
+    isError: stage === "error",
+    isIdle: stage === "idle",
+    isRetrieved: stage === "retrieved",
+    isRetrieving: stage === "submitting" || stage === "retrieving",
+    isStreaming: stage === "streaming",
+    isSubmitting: stage === "submitting",
+    latestMessage: state.latestMessage,
+    messageId: state.messageId,
+    retrievalDurationMs: state.retrieved?.retrievalDurationMs,
+    retrievalStartedAt: state.retrieved?.retrievalStartedAt,
+    retrievedAt: state.retrieved?.retrievedAt,
+    sourceCount: state.sourceCount,
+    stage
+  };
+};
+var buildRAGAnswerWorkflowState = ({
+  error,
+  isStreaming,
+  messages
+}) => {
+  const latestAssistantMessage = getLatestAssistantMessage(messages);
+  const sources = getLatestRAGSources(messages);
+  const sourceGroups = buildRAGSourceGroups(sources);
+  const citations = buildRAGCitations(sources);
+  const citationReferenceMap = buildRAGCitationReferenceMap(citations);
+  const sourceSummaries = buildRAGSourceSummaries(sources);
+  const groundingReferences = buildRAGGroundingReferences(sources);
+  const groundedAnswer = buildRAGGroundedAnswer(latestAssistantMessage?.content ?? "", sources);
+  const retrieval = buildRAGRetrievedState(messages);
+  const sectionDiagnostics = buildRAGSectionRetrievalDiagnostics(sources, retrieval?.trace);
+  const progress = buildRAGStreamProgress({
+    error,
+    isStreaming,
+    messages
+  });
+  return {
+    excerptModeCounts: buildRAGExcerptModeCounts([
+      ...citations.map((citation) => citation.excerptSelection),
+      ...sourceSummaries.map((summary) => summary.excerptSelection),
+      ...groundingReferences.map((reference) => reference.excerptSelection),
+      ...groundedAnswer.sectionSummaries.map((summary) => summary.excerptSelection)
+    ]),
+    citationReferenceMap,
+    citations,
+    coverage: groundedAnswer.coverage,
+    error,
+    groundedAnswer,
+    groundingReferences,
+    hasCitations: groundedAnswer.hasCitations,
+    hasGrounding: groundingReferences.length > 0,
+    hasRetrieved: progress.hasRetrieved,
+    hasSources: sources.length > 0,
+    isAnswerStreaming: progress.isStreaming,
+    isComplete: progress.isComplete,
+    isError: progress.isError,
+    isIdle: progress.isIdle,
+    isRetrieved: progress.isRetrieved,
+    isRetrieving: progress.isRetrieving,
+    isRunning: progress.isSubmitting || progress.isRetrieving || progress.isStreaming,
+    isSubmitting: progress.isSubmitting,
+    latestAssistantMessage,
+    messages,
+    retrieval,
+    retrievalDurationMs: retrieval?.retrievalDurationMs,
+    retrievalStartedAt: retrieval?.retrievalStartedAt,
+    retrievedAt: retrieval?.retrievedAt,
+    sectionDiagnostics,
+    sourceGroups,
+    sourceSummaries,
+    sources,
+    stage: progress.stage,
+    ungroundedReferenceNumbers: groundedAnswer.ungroundedReferenceNumbers
+  };
+};
+var buildRAGSourceGroups = (sources) => {
+  const groups = new Map;
+  for (const source of sources) {
+    updateSourceGroup(groups, source);
+  }
+  return [...groups.values()].sort((left, right) => {
+    if (right.bestScore !== left.bestScore) {
+      return right.bestScore - left.bestScore;
+    }
+    return left.label.localeCompare(right.label);
+  });
+};
+var buildSourceGroup = (source, key) => ({
+  bestScore: source.score,
+  chunks: [source],
+  count: 1,
+  key,
+  label: buildSourceLabel2(source),
+  labels: source.labels ?? buildRAGSourceLabels({
+    metadata: source.metadata,
+    source: source.source,
+    title: source.title
+  }),
+  structure: source.structure ?? buildRAGChunkStructure(source.metadata),
+  source: source.source,
+  title: source.title
+});
+var updateSourceGroup = (groups, source) => {
+  const key = buildSourceGroupKey(source);
+  const existing = groups.get(key);
+  if (!existing) {
+    groups.set(key, buildSourceGroup(source, key));
+    return;
+  }
+  existing.bestScore = Math.max(existing.bestScore, source.score);
+  existing.count += 1;
+  existing.chunks.push(source);
+  const leadChunk = getPreferredSourceLeadChunk(existing.chunks);
+  if (leadChunk) {
+    existing.label = buildSourceLabel2(leadChunk);
+    existing.labels = leadChunk.labels ?? buildRAGSourceLabels({
+      metadata: leadChunk.metadata,
+      source: leadChunk.source,
+      title: leadChunk.title
+    });
+    existing.structure = leadChunk.structure ?? buildRAGChunkStructure(leadChunk.metadata);
+    existing.source = leadChunk.source;
+    existing.title = leadChunk.title;
+  }
+};
+var getLatestAssistantMessage = (messages) => {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role === "assistant") {
+      return message;
+    }
+  }
+  return;
+};
+var getLatestRAGSources = (messages) => getLatestAssistantMessage(messages)?.sources ?? [];
+var getLatestRetrievedMessage = (messages) => {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role === "assistant" && (typeof message.retrievedAt === "number" || (message.sources?.length ?? 0) > 0)) {
+      return message;
+    }
+  }
+  return;
+};
+var resolveRAGStreamStage = ({
+  error,
+  isStreaming,
+  messages
+}) => {
+  if (error) {
+    return "error";
+  }
+  const assistantMessage = getLatestAssistantMessage(messages);
+  if (!assistantMessage) {
+    return isStreaming ? "submitting" : "idle";
+  }
+  const isRetrieving = typeof assistantMessage.retrievalStartedAt === "number" && typeof assistantMessage.retrievedAt !== "number";
+  if (isRetrieving) {
+    return "retrieving";
+  }
+  if (!isStreaming) {
+    return "complete";
+  }
+  const hasRetrieved = typeof assistantMessage.retrievedAt === "number";
+  const hasContent = assistantMessage.content.trim().length > 0 || assistantMessage.thinking?.trim().length || (assistantMessage.toolCalls?.length ?? 0) > 0 || (assistantMessage.images?.length ?? 0) > 0;
+  if (hasRetrieved && !hasContent) {
+    return "retrieved";
+  }
+  return "streaming";
+};
+// src/vue/ai/useRAGChunkPreview.ts
+var useRAGChunkPreview = (path) => {
+  const client = createRAGClient({ path });
+  const preview = ref(null);
+  const activeChunkId = ref(null);
+  const error = ref(null);
+  const isLoading = ref(false);
+  const chunkGraph = computed(() => preview.value ? buildRAGChunkPreviewGraph(preview.value) : null);
+  const navigation = computed(() => preview.value ? buildRAGChunkPreviewNavigation(preview.value, activeChunkId.value ?? undefined) : null);
+  const previewSources = computed(() => preview.value ? preview.value.chunks.map((chunk, index) => ({
+    chunkId: chunk.chunkId,
+    labels: chunk.labels,
+    metadata: chunk.metadata,
+    score: Math.max(0, preview.value.chunks.length - index),
+    source: chunk.source ?? preview.value.document.source,
+    structure: chunk.structure,
+    text: chunk.text,
+    title: chunk.title ?? preview.value.document.title
+  })) : []);
+  const sectionDiagnostics = computed(() => buildRAGSectionRetrievalDiagnostics(previewSources.value));
+  const activeSectionDiagnostic = computed(() => {
+    const sectionKey = navigation.value?.section?.path?.join(" > ");
+    return sectionKey ? sectionDiagnostics.value.find((diagnostic) => diagnostic.key === sectionKey) ?? null : null;
+  });
+  const inspect = async (id) => {
+    isLoading.value = true;
+    error.value = null;
+    try {
+      const response = await client.documentChunks(id);
+      if (!response.ok) {
+        throw new Error(response.error);
+      }
+      preview.value = response;
+      activeChunkId.value = response.chunks[0]?.chunkId ?? null;
+      return response;
+    } catch (caught) {
+      error.value = caught instanceof Error ? caught.message : String(caught);
+      throw caught;
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  const clear = () => {
+    error.value = null;
+    isLoading.value = false;
+    activeChunkId.value = null;
+    preview.value = null;
+  };
+  const selectChunk = (id) => {
+    activeChunkId.value = id;
+  };
+  const selectParentSection = () => {
+    const leadChunkId = navigation.value?.parentSection?.leadChunkId;
+    if (leadChunkId) {
+      activeChunkId.value = leadChunkId;
+    }
+  };
+  const selectChildSection = (sectionId) => {
+    const leadChunkId = navigation.value?.childSections.find((section) => section.id === sectionId)?.leadChunkId;
+    if (leadChunkId) {
+      activeChunkId.value = leadChunkId;
+    }
+  };
+  const selectSiblingSection = (sectionId) => {
+    const leadChunkId = navigation.value?.siblingSections.find((section) => section.id === sectionId)?.leadChunkId;
+    if (leadChunkId) {
+      activeChunkId.value = leadChunkId;
+    }
+  };
+  return {
+    activeChunkId,
+    activeSectionDiagnostic,
+    clear,
+    chunkGraph,
+    error,
+    inspect,
+    isLoading,
+    navigation,
+    preview,
+    sectionDiagnostics,
+    selectChildSection,
+    selectChunk,
+    selectParentSection,
+    selectSiblingSection
+  };
+};
+// src/vue/ai/useRAG.ts
+import { computed as computed9 } from "vue";
+
+// src/vue/ai/useRAGCitations.ts
+import { computed as computed2 } from "vue";
+var useRAGCitations = (sources) => {
+  const citations = computed2(() => buildRAGCitations(sources.value));
+  const citationReferenceMap = computed2(() => buildRAGCitationReferenceMap(citations.value));
+  const sourceGroups = computed2(() => buildRAGSourceGroups(sources.value));
+  const sourceSummaries = computed2(() => buildRAGSourceSummaries(sources.value));
+  const hasCitations = computed2(() => citations.value.length > 0);
+  return {
+    citationReferenceMap,
+    citations,
+    hasCitations,
+    sourceGroups,
+    sourceSummaries
+  };
+};
+
+// src/vue/ai/useRAGDocuments.ts
+import { ref as ref2 } from "vue";
+var useRAGDocuments = (path) => {
+  const client = createRAGClient({ path });
+  const documents = ref2([]);
+  const error = ref2(null);
+  const isLoading = ref2(false);
+  const lastResponse = ref2(null);
+  const load = async (kind) => {
+    isLoading.value = true;
+    error.value = null;
+    try {
+      const response = await client.documents(kind);
+      documents.value = response.documents;
+      lastResponse.value = response;
+      return response;
+    } catch (caught) {
+      error.value = caught instanceof Error ? caught.message : String(caught);
+      throw caught;
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  const reset = () => {
+    documents.value = [];
+    error.value = null;
+    isLoading.value = false;
+    lastResponse.value = null;
+  };
+  return {
+    documents,
+    error,
+    isLoading,
+    lastResponse,
+    load,
+    reset
+  };
+};
+
+// src/vue/ai/useRAGEvaluate.ts
+import { computed as computed3, ref as ref3 } from "vue";
+var useRAGEvaluate = (path) => {
+  const client = createRAGClient({ path });
+  const error = ref3(null);
+  const isEvaluating = ref3(false);
+  const suites = ref3([]);
+  const suiteRuns = ref3([]);
+  const lastRequest = ref3(null);
+  const lastResponse = ref3(null);
+  const evaluate = async (input) => {
+    isEvaluating.value = true;
+    error.value = null;
+    lastRequest.value = input;
+    try {
+      const response = await client.evaluate(input);
+      lastResponse.value = response;
+      return response;
+    } catch (caught) {
+      error.value = caught instanceof Error ? caught.message : String(caught);
+      throw caught;
+    } finally {
+      isEvaluating.value = false;
+    }
+  };
+  const saveSuite = (suite) => {
+    suites.value = [
+      ...suites.value.filter((entry) => entry.id !== suite.id),
+      suite
+    ];
+    return suite;
+  };
+  const removeSuite = (id) => {
+    suites.value = suites.value.filter((suite) => suite.id !== id);
+  };
+  const runSuite = async (suite, overrides) => {
+    isEvaluating.value = true;
+    error.value = null;
+    lastRequest.value = overrides ? { ...suite.input, ...overrides } : suite.input;
+    try {
+      const run = await runRAGEvaluationSuite({
+        evaluate: client.evaluate,
+        overrides,
+        suite
+      });
+      lastResponse.value = run.response;
+      suiteRuns.value = [run, ...suiteRuns.value];
+      return run;
+    } catch (caught) {
+      error.value = caught instanceof Error ? caught.message : String(caught);
+      throw caught;
+    } finally {
+      isEvaluating.value = false;
+    }
+  };
+  const clearRuns = () => {
+    suiteRuns.value = [];
+  };
+  const leaderboard = computed3(() => buildRAGEvaluationLeaderboard(suiteRuns.value));
+  const reset = () => {
+    error.value = null;
+    lastRequest.value = null;
+    lastResponse.value = null;
+    suiteRuns.value = [];
+  };
+  return {
+    clearRuns,
+    error,
+    evaluate,
+    isEvaluating,
+    lastRequest,
+    lastResponse,
+    leaderboard,
+    removeSuite,
+    reset,
+    runSuite,
+    saveSuite,
+    suiteRuns,
+    suites
+  };
+};
+
+// src/vue/ai/useRAGGrounding.ts
+import { computed as computed4 } from "vue";
+var useRAGGrounding = (content, sources) => {
+  const groundedAnswer = computed4(() => buildRAGGroundedAnswer(content.value, sources.value));
+  const references = computed4(() => buildRAGGroundingReferences(sources.value));
+  const hasCitations = computed4(() => groundedAnswer.value.hasCitations);
+  const hasGrounding = computed4(() => references.value.length > 0);
+  const coverage = computed4(() => groundedAnswer.value.coverage);
+  const ungroundedReferenceNumbers = computed4(() => groundedAnswer.value.ungroundedReferenceNumbers);
+  return {
+    coverage,
+    groundedAnswer,
+    hasCitations,
+    hasGrounding,
+    references,
+    ungroundedReferenceNumbers
+  };
+};
+
+// src/vue/ai/useRAGIngest.ts
+import { ref as ref4 } from "vue";
+var useRAGIngest = (path) => {
+  const client = createRAGClient({ path });
+  const error = ref4(null);
+  const isIngesting = ref4(false);
+  const lastIngestCount = ref4(null);
+  const lastDocumentCount = ref4(null);
+  const lastResponse = ref4(null);
+  const ingestChunks = async (chunks) => {
+    isIngesting.value = true;
+    error.value = null;
+    try {
+      const response = await client.ingest(chunks);
+      if (!response.ok) {
+        throw new Error(response.error ?? "RAG ingest failed");
+      }
+      lastIngestCount.value = response.count ?? chunks.length;
+      lastDocumentCount.value = null;
+      lastResponse.value = response;
+      return response;
+    } catch (caught) {
+      error.value = caught instanceof Error ? caught.message : String(caught);
+      throw caught;
+    } finally {
+      isIngesting.value = false;
+    }
+  };
+  const ingestDocuments = async (input) => {
+    isIngesting.value = true;
+    error.value = null;
+    try {
+      const response = await client.ingestDocuments(input);
+      if (!response.ok) {
+        throw new Error(response.error ?? "RAG document ingest failed");
+      }
+      lastDocumentCount.value = response.documentCount ?? input.documents.length;
+      lastIngestCount.value = response.count ?? null;
+      lastResponse.value = response;
+      return response;
+    } catch (caught) {
+      error.value = caught instanceof Error ? caught.message : String(caught);
+      throw caught;
+    } finally {
+      isIngesting.value = false;
+    }
+  };
+  const ingestUrls = async (input) => {
+    isIngesting.value = true;
+    error.value = null;
+    try {
+      const response = await client.ingestUrls(input);
+      if (!response.ok) {
+        throw new Error(response.error ?? "RAG URL ingest failed");
+      }
+      lastIngestCount.value = response.count ?? null;
+      lastDocumentCount.value = response.documentCount ?? input.urls.length;
+      lastResponse.value = response;
+      return response;
+    } catch (caught) {
+      error.value = caught instanceof Error ? caught.message : String(caught);
+      throw caught;
+    } finally {
+      isIngesting.value = false;
+    }
+  };
+  const ingestUploads = async (input) => {
+    isIngesting.value = true;
+    error.value = null;
+    try {
+      const response = await client.ingestUploads(input);
+      if (!response.ok) {
+        throw new Error(response.error ?? "RAG upload ingest failed");
+      }
+      lastIngestCount.value = response.count ?? null;
+      lastDocumentCount.value = response.documentCount ?? input.uploads.length;
+      lastResponse.value = response;
+      return response;
+    } catch (caught) {
+      error.value = caught instanceof Error ? caught.message : String(caught);
+      throw caught;
+    } finally {
+      isIngesting.value = false;
+    }
+  };
+  const clearIndex = async () => {
+    isIngesting.value = true;
+    error.value = null;
+    try {
+      return await client.clearIndex();
+    } catch (caught) {
+      error.value = caught instanceof Error ? caught.message : String(caught);
+      throw caught;
+    } finally {
+      isIngesting.value = false;
+    }
+  };
+  const reset = () => {
+    error.value = null;
+    isIngesting.value = false;
+    lastDocumentCount.value = null;
+    lastIngestCount.value = null;
+    lastResponse.value = null;
+  };
+  return {
+    clearIndex,
+    error,
+    ingest: ingestChunks,
+    ingestChunks,
+    ingestDocuments,
+    ingestUploads,
+    ingestUrls,
+    isIngesting,
+    lastDocumentCount,
+    lastIngestCount,
+    lastResponse,
+    reset
+  };
+};
+
+// src/vue/ai/useRAGIndexAdmin.ts
+import { ref as ref5 } from "vue";
+var useRAGIndexAdmin = (path) => {
+  const client = createRAGClient({ path });
+  const isLoading = ref5(false);
+  const error = ref5(null);
+  const lastMutation = ref5(null);
+  const backends = ref5(null);
+  const syncSources = ref5(null);
+  const run = async (operation) => {
+    isLoading.value = true;
+    error.value = null;
+    try {
+      return await operation();
+    } catch (caught) {
+      error.value = caught instanceof Error ? caught.message : String(caught);
+      throw caught;
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  const createDocument = async (input) => run(async () => {
+    const response = await client.createDocument(input);
+    lastMutation.value = response;
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to create document");
+    }
+    return response;
+  });
+  const deleteDocument = async (id) => run(async () => {
+    const response = await client.deleteDocument(id);
+    lastMutation.value = response;
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to delete document");
+    }
+    return response;
+  });
+  const reseed = async () => run(async () => {
+    const response = await client.reseed();
+    lastMutation.value = response;
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to reseed index");
+    }
+    return response;
+  });
+  const analyzeBackend = async () => run(async () => {
+    const response = await client.analyzeBackend();
+    lastMutation.value = response;
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to analyze backend");
+    }
+    return response;
+  });
+  const reindexDocument = async (id) => run(async () => {
+    const response = await client.reindexDocument(id);
+    lastMutation.value = response;
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to reindex document");
+    }
+    return response;
+  });
+  const reindexSource = async (source) => run(async () => {
+    const response = await client.reindexSource(source);
+    lastMutation.value = response;
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to reindex source");
+    }
+    return response;
+  });
+  const rebuildNativeIndex = async () => run(async () => {
+    const response = await client.rebuildNativeIndex();
+    lastMutation.value = response;
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to rebuild native index");
+    }
+    return response;
+  });
+  const reset = async () => run(async () => {
+    const response = await client.reset();
+    lastMutation.value = response;
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to reset index");
+    }
+    return response;
+  });
+  const loadBackends = async () => run(async () => {
+    const response = await client.backends();
+    backends.value = response;
+    return response;
+  });
+  const loadSyncSources = async () => run(async () => {
+    const response = await client.syncSources();
+    syncSources.value = response;
+    return response;
+  });
+  const syncAllSources = async (options) => run(async () => {
+    const response = await client.syncAllSources(options);
+    syncSources.value = response;
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to sync sources");
+    }
+    return response;
+  });
+  const syncSource = async (id, options) => run(async () => {
+    const response = await client.syncSource(id, options);
+    syncSources.value = response;
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to sync source");
+    }
+    return response;
+  });
+  const clearIndex = async () => run(async () => {
+    const response = await client.clearIndex();
+    const mutation = { ok: response.ok };
+    lastMutation.value = mutation;
+    return mutation;
+  });
+  const resetState = () => {
+    backends.value = null;
+    error.value = null;
+    isLoading.value = false;
+    lastMutation.value = null;
+    syncSources.value = null;
+  };
+  return {
+    backends,
+    analyzeBackend,
+    clearIndex,
+    createDocument,
+    deleteDocument,
+    error,
+    isLoading,
+    lastMutation,
+    loadBackends,
+    loadSyncSources,
+    rebuildNativeIndex,
+    reindexDocument,
+    reindexSource,
+    reseed,
+    reset,
+    resetState,
+    syncAllSources,
+    syncSource,
+    syncSources
+  };
+};
+
+// src/vue/ai/useRAGOps.ts
+import { onMounted, ref as ref6 } from "vue";
+var useRAGOps = (path, autoLoad = true) => {
+  const client = createRAGClient({ path });
+  const operations = ref6();
+  const admin = ref6();
+  const adminActions = ref6([]);
+  const adminJobs = ref6([]);
+  const status = ref6();
+  const capabilities = ref6();
+  const maintenance = ref6();
+  const health = ref6();
+  const readiness = ref6();
+  const documents = ref6();
+  const ingestJobs = ref6([]);
+  const syncSources = ref6([]);
+  const error = ref6(null);
+  const isLoading = ref6(autoLoad);
+  const refresh = async () => {
+    isLoading.value = true;
+    error.value = null;
+    try {
+      const response = await client.ops();
+      operations.value = response;
+      admin.value = response.admin;
+      adminActions.value = response.adminActions;
+      adminJobs.value = response.adminJobs ?? [];
+      status.value = response.status;
+      capabilities.value = response.capabilities;
+      maintenance.value = response.maintenance;
+      health.value = response.health;
+      readiness.value = response.readiness;
+      documents.value = response.documents;
+      ingestJobs.value = response.ingestJobs ?? [];
+      syncSources.value = response.syncSources ?? [];
+      return response;
+    } catch (caught) {
+      error.value = caught instanceof Error ? caught.message : String(caught);
+      throw caught;
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  const reset = () => {
+    operations.value = undefined;
+    admin.value = undefined;
+    adminActions.value = [];
+    adminJobs.value = [];
+    capabilities.value = undefined;
+    documents.value = undefined;
+    error.value = null;
+    health.value = undefined;
+    ingestJobs.value = [];
+    isLoading.value = false;
+    maintenance.value = undefined;
+    readiness.value = undefined;
+    syncSources.value = [];
+    status.value = undefined;
+  };
+  onMounted(() => {
+    if (!autoLoad) {
+      isLoading.value = false;
+      return;
+    }
+    refresh();
+  });
+  return {
+    admin,
+    adminActions,
+    adminJobs,
+    capabilities,
+    documents,
+    error,
+    health,
+    ingestJobs,
+    isLoading,
+    maintenance,
+    operations,
+    readiness,
+    refresh,
+    reset,
+    status,
+    syncSources
+  };
+};
+
+// src/vue/ai/useRAGSearch.ts
+import { ref as ref7 } from "vue";
+var useRAGSearch = (path) => {
+  const client = createRAGClient({ path });
+  const results = ref7([]);
+  const trace = ref7();
+  const error = ref7(null);
+  const isSearching = ref7(false);
+  const hasSearched = ref7(false);
+  const lastRequest = ref7(null);
+  const search = async (input) => {
+    isSearching.value = true;
+    error.value = null;
+    lastRequest.value = input;
+    try {
+      const nextResults = await client.search({
+        ...input,
+        includeTrace: false
+      });
+      results.value = nextResults;
+      trace.value = undefined;
+      hasSearched.value = true;
+      return nextResults;
+    } catch (caught) {
+      error.value = caught instanceof Error ? caught.message : String(caught);
+      throw caught;
+    } finally {
+      isSearching.value = false;
+    }
+  };
+  const searchWithTrace = async (input) => {
+    isSearching.value = true;
+    error.value = null;
+    lastRequest.value = input;
+    try {
+      const response = await client.searchWithTrace(input);
+      results.value = response.results;
+      trace.value = response.trace;
+      hasSearched.value = true;
+      return response;
+    } catch (caught) {
+      error.value = caught instanceof Error ? caught.message : String(caught);
+      throw caught;
+    } finally {
+      isSearching.value = false;
+    }
+  };
+  const reset = () => {
+    error.value = null;
+    hasSearched.value = false;
+    isSearching.value = false;
+    lastRequest.value = null;
+    results.value = [];
+    trace.value = undefined;
+  };
+  return {
+    error,
+    hasSearched,
+    isSearching,
+    lastRequest,
+    reset,
+    results,
+    search,
+    searchWithTrace,
+    trace
+  };
+};
+
+// src/vue/ai/useRAGSources.ts
+import { computed as computed5 } from "vue";
+var useRAGSources = (messages) => {
+  const latestAssistantMessage = computed5(() => getLatestAssistantMessage(messages.value));
+  const sources = computed5(() => getLatestRAGSources(messages.value));
+  const sourceGroups = computed5(() => buildRAGSourceGroups(sources.value));
+  const sourceSummaries = computed5(() => buildRAGSourceSummaries(sources.value));
+  const sectionDiagnostics = computed5(() => buildRAGSectionRetrievalDiagnostics(sources.value, latestAssistantMessage.value?.retrievalTrace));
+  const chunkGraph = computed5(() => buildRAGChunkGraph(sources.value));
+  const citationReferenceMap = computed5(() => buildRAGCitationReferenceMap(sourceSummaries.value.flatMap((summary) => summary.citations)));
+  const hasSources = computed5(() => sources.value.length > 0);
+  const navigationForChunk = (chunkId) => buildRAGChunkGraphNavigation(chunkGraph.value, chunkId ?? undefined);
+  return {
+    citationReferenceMap,
+    chunkGraph,
+    hasSources,
+    latestAssistantMessage,
+    navigationForChunk,
+    sectionDiagnostics,
+    sourceGroups,
+    sources,
+    sourceSummaries
+  };
+};
+
+// src/vue/ai/useRAGStatus.ts
+import { onMounted as onMounted2, ref as ref8 } from "vue";
+var useRAGStatus = (path, autoLoad = true) => {
+  const client = createRAGClient({ path });
+  const status = ref8();
+  const capabilities = ref8();
+  const error = ref8(null);
+  const isLoading = ref8(autoLoad);
+  const refresh = async () => {
+    isLoading.value = true;
+    error.value = null;
+    try {
+      const response = await client.status();
+      status.value = response.status;
+      capabilities.value = response.capabilities;
+      return response;
+    } catch (caught) {
+      error.value = caught instanceof Error ? caught.message : String(caught);
+      throw caught;
+    } finally {
+      isLoading.value = false;
+    }
+  };
+  const reset = () => {
+    capabilities.value = undefined;
+    error.value = null;
+    isLoading.value = false;
+    status.value = undefined;
+  };
+  onMounted2(() => {
+    if (!autoLoad) {
+      isLoading.value = false;
+      return;
+    }
+    refresh();
+  });
+  return {
+    capabilities,
+    error,
+    isLoading,
+    refresh,
+    reset,
+    status
+  };
+};
+
+// src/vue/ai/useRAGWorkflow.ts
+import { computed as computed8 } from "vue";
+
+// src/vue/ai/useRAGStream.ts
+import { computed as computed7 } from "vue";
+import { useAIStream } from "@absolutejs/ai/vue";
+
+// src/vue/ai/useRAGStreamProgress.ts
+import { computed as computed6 } from "vue";
+var useRAGStreamProgress = (params) => computed6(() => buildRAGStreamProgress({
+  error: params.error.value,
+  isStreaming: params.isStreaming.value,
+  messages: params.messages.value
+}));
+
+// src/vue/ai/useRAGStream.ts
+var useRAGStream = (path, conversationId) => {
+  const stream = useAIStream(path, conversationId);
+  const workflow = computed7(() => buildRAGAnswerWorkflowState({
+    error: stream.error.value,
+    isStreaming: stream.isStreaming.value,
+    messages: stream.messages.value
+  }));
+  const progress = useRAGStreamProgress({
+    error: stream.error,
+    isStreaming: stream.isStreaming,
+    messages: stream.messages
+  });
+  const query = (content, attachments) => {
+    stream.send(content, attachments);
+  };
+  const hasRetrieved = computed7(() => workflow.value.hasRetrieved);
+  const isRetrieving = computed7(() => workflow.value.isRetrieving);
+  const isRetrieved = computed7(() => workflow.value.isRetrieved);
+  const isAnswerStreaming = computed7(() => workflow.value.isAnswerStreaming);
+  const isComplete = computed7(() => workflow.value.isComplete);
+  const hasSources = computed7(() => workflow.value.hasSources);
+  return {
+    ...stream,
+    citationReferenceMap: computed7(() => workflow.value.citationReferenceMap),
+    citations: computed7(() => workflow.value.citations),
+    coverage: computed7(() => workflow.value.coverage),
+    groundedAnswer: computed7(() => workflow.value.groundedAnswer),
+    groundingReferences: computed7(() => workflow.value.groundingReferences),
+    hasGrounding: computed7(() => workflow.value.hasGrounding),
+    hasRetrieved,
+    hasSources,
+    isAnswerStreaming,
+    isComplete,
+    isError: computed7(() => workflow.value.isError),
+    isRetrieved,
+    isRetrieving,
+    isRunning: computed7(() => workflow.value.isRunning),
+    latestAssistantMessage: computed7(() => workflow.value.latestAssistantMessage),
+    progress,
+    query,
+    retrieval: computed7(() => workflow.value.retrieval),
+    sourceGroups: computed7(() => workflow.value.sourceGroups),
+    sourceSummaries: computed7(() => workflow.value.sourceSummaries),
+    sources: computed7(() => workflow.value.sources),
+    stage: computed7(() => workflow.value.stage),
+    ungroundedReferenceNumbers: computed7(() => workflow.value.ungroundedReferenceNumbers),
+    workflow
+  };
+};
+
+// src/vue/ai/useRAGWorkflow.ts
+var useRAGWorkflow = (path, conversationId) => {
+  const stream = useRAGStream(path, conversationId);
+  const state = computed8(() => stream.workflow.value);
+  return {
+    ...stream,
+    state
+  };
+};
+
+// src/vue/ai/useRAG.ts
+var useRAG = (path, options = {}) => {
+  const search = useRAGSearch(path);
+  const ingest = useRAGIngest(path);
+  const status = useRAGStatus(path, options.autoLoadStatus ?? true);
+  const ops = useRAGOps(path, options.autoLoadOps ?? true);
+  const documents = useRAGDocuments(path);
+  const chunkPreview = useRAGChunkPreview(path);
+  const evaluate = useRAGEvaluate(path);
+  const index = useRAGIndexAdmin(path);
+  const workflow = useRAGWorkflow(options.streamPath ?? path, options.conversationId);
+  const sources = useRAGSources(workflow.messages);
+  const citations = useRAGCitations(sources.sources);
+  const grounding = useRAGGrounding(computed9(() => workflow.latestAssistantMessage.value?.content ?? ""), sources.sources);
+  return {
+    chunkPreview,
+    citations,
+    documents,
+    evaluate,
+    grounding,
+    index,
+    ingest,
+    ops,
+    search,
+    sources,
+    status,
+    stream: workflow,
+    workflow
+  };
+};
+export {
+  useRAGWorkflow,
+  useRAGStreamProgress,
+  useRAGStream,
+  useRAGStatus,
+  useRAGSources,
+  useRAGSearch,
+  useRAGOps,
+  useRAGIngest,
+  useRAGIndexAdmin,
+  useRAGGrounding,
+  useRAGEvaluate,
+  useRAGDocuments,
+  useRAGCitations,
+  useRAGChunkPreview,
+  useRAG
+};
+
+//# debugId=2E2B39C77DEA7C5864756E2164756E21
+//# sourceMappingURL=index.js.map