@absolutejs/absolute 0.19.0-beta.643 → 0.19.0-beta.644

package/dist/react/ai/index.js

@@ -2965,6 +2965,18 @@ var buildComparisonOverviewPresentation = (input) => {
       value: input.resolveLabel(input.summary.bestByMultivectorVectorHitCases)
     });
   }
+  if (input.summary.bestByLowestRuntimeCandidateBudgetExhaustedCases) {
+    rows.push({
+      label: "Lowest runtime budget exhaustion",
+      value: input.resolveLabel(input.summary.bestByLowestRuntimeCandidateBudgetExhaustedCases)
+    });
+  }
+  if (input.summary.bestByLowestRuntimeUnderfilledTopKCases) {
+    rows.push({
+      label: "Lowest runtime underfilled TopK",
+      value: input.resolveLabel(input.summary.bestByLowestRuntimeUnderfilledTopKCases)
+    });
+  }
   return {
     rows,
     winnerLabel,
@@ -3017,6 +3029,9 @@ var buildRAGComparisonTraceSummaryRows = (entry) => {
   }, {
     label: "Multivector",
     value: `${formatTraceRatio(trace.multiVectorCases, trace.totalCases)} \xB7 collapse ${formatTraceRatio(trace.multiVectorCollapsedCases, trace.totalCases)} \xB7 lexical ${formatTraceRatio(trace.multiVectorLexicalHitCases, trace.totalCases)} \xB7 vector ${formatTraceRatio(trace.multiVectorVectorHitCases, trace.totalCases)}`
+  }, {
+    label: "Runtime",
+    value: `budget ${formatTraceRatio(trace.runtimeCandidateBudgetExhaustedCases, trace.totalCases)} \xB7 underfilled ${formatTraceRatio(trace.runtimeUnderfilledTopKCases, trace.totalCases)}`
   }, {
     label: "TopK",
     value: `${trace.averageCandidateTopK.toFixed(1)} / ${trace.averageLexicalTopK.toFixed(1)}`
@@ -3121,6 +3136,12 @@ var buildRAGComparisonTraceDiffRows = (entry, leader) => {
   }, {
     label: "Round robin delta",
     value: formatTraceCountDelta(trace.roundRobinCases - leaderTrace.roundRobinCases)
+  }, {
+    label: "Runtime budget delta",
+    value: formatTraceCountDelta(trace.runtimeCandidateBudgetExhaustedCases - leaderTrace.runtimeCandidateBudgetExhaustedCases)
+  }, {
+    label: "Runtime underfilled delta",
+    value: formatTraceCountDelta(trace.runtimeUnderfilledTopKCases - leaderTrace.runtimeUnderfilledTopKCases)
   });
   if (stageDelta) {
     rows.push({ label: "Stage delta", value: stageDelta });
@@ -3572,6 +3593,77 @@ var buildRAGEvaluationSuiteSnapshotHistoryPresentation = (history) => ({
   snapshots: buildRAGEvaluationSuiteSnapshotPresentations(history),
   summary: history?.latestSnapshot ? `v${history.latestSnapshot.version}` : "No saved suite snapshots yet."
 });
+var isRuntimeGateReason = (reason) => /runtime|candidate-budget|underfilled/i.test(reason);
+var buildRAGRetrievalReleaseHistoryRunPresentation = (run) => {
+  const runtimeGateReasons = (run.decisionSummary?.gate?.reasons ?? run.releaseVerdict?.gate?.reasons ?? []).filter(isRuntimeGateReason);
+  const rows = [
+    { label: "Finished", value: formatDateLabel(run.finishedAt) },
+    {
+      label: "Passing-rate winner",
+      value: run.comparison.summary.bestByPassingRate ?? "n/a"
+    },
+    {
+      label: "Average F1 winner",
+      value: run.comparison.summary.bestByAverageF1 ?? "n/a"
+    }
+  ];
+  if (run.comparison.summary.bestByLowestRuntimeCandidateBudgetExhaustedCases) {
+    rows.push({
+      label: "Lowest runtime budget exhaustion",
+      value: run.comparison.summary.bestByLowestRuntimeCandidateBudgetExhaustedCases
+    });
+  }
+  if (run.comparison.summary.bestByLowestRuntimeUnderfilledTopKCases) {
+    rows.push({
+      label: "Lowest runtime underfilled TopK",
+      value: run.comparison.summary.bestByLowestRuntimeUnderfilledTopKCases
+    });
+  }
+  rows.push({
+    label: "Gate status",
+    value: run.decisionSummary?.gate?.status ?? run.releaseVerdict?.gate?.status ?? "n/a"
+  }, {
+    label: "Runtime gate failures",
+    value: runtimeGateReasons.length > 0 ? runtimeGateReasons.join("; ") : "none"
+  });
+  return {
+    label: run.label,
+    rows,
+    runId: run.id,
+    summary: runtimeGateReasons.length > 0 ? `${run.label} \xB7 runtime gate blocked` : `${run.label} \xB7 ${run.comparison.summary.bestByPassingRate ?? "n/a"} leads passing rate`
+  };
+};
+var buildRAGRetrievalReleaseGroupHistoryPresentation = (input) => {
+  const recentRuns = (input.runs ?? []).map(buildRAGRetrievalReleaseHistoryRunPresentation);
+  const runtimeBlockedRuns = recentRuns.filter((entry) => entry.rows.some((row) => row.label === "Runtime gate failures" && row.value !== "none")).length;
+  const rows = [
+    {
+      label: "Latest decision",
+      value: input.timeline?.latestDecisionKind ?? "none"
+    },
+    {
+      label: "Latest decision at",
+      value: formatDateLabel(input.timeline?.latestDecisionAt)
+    },
+    {
+      label: "Last promoted",
+      value: formatDateLabel(input.timeline?.lastPromotedAt)
+    },
+    {
+      label: "Last reverted",
+      value: formatDateLabel(input.timeline?.lastRevertedAt)
+    },
+    {
+      label: "Recent runtime-blocked runs",
+      value: String(runtimeBlockedRuns)
+    }
+  ];
+  return {
+    recentRuns,
+    rows,
+    summary: input.timeline?.latestDecisionKind ? `${input.timeline.latestDecisionKind} \xB7 ${recentRuns.length} recent runs` : recentRuns.length > 0 ? `${recentRuns.length} recent runs` : "No release history yet."
+  };
+};
 var buildRAGAnswerGroundingCaseSnapshotPresentations = (history) => {
   if (!history?.caseSnapshots.length) {
     return [];
@@ -4082,6 +4174,12 @@ var evaluateRetrievalComparisonGate = ({
   if (typeof policy.minMultiVectorVectorHitCasesDelta === "number" && (delta.multiVectorVectorHitCasesDelta ?? 0) < policy.minMultiVectorVectorHitCasesDelta) {
     reasons.push(`multivector vector-hit delta ${delta.multiVectorVectorHitCasesDelta ?? 0} is below ${policy.minMultiVectorVectorHitCasesDelta}`);
   }
+  if (typeof policy.maxRuntimeCandidateBudgetExhaustedCasesDelta === "number" && (delta.runtimeCandidateBudgetExhaustedCasesDelta ?? 0) > policy.maxRuntimeCandidateBudgetExhaustedCasesDelta) {
+    reasons.push(`runtime candidate-budget-exhausted delta ${delta.runtimeCandidateBudgetExhaustedCasesDelta ?? 0} exceeds ${policy.maxRuntimeCandidateBudgetExhaustedCasesDelta}`);
+  }
+  if (typeof policy.maxRuntimeUnderfilledTopKCasesDelta === "number" && (delta.runtimeUnderfilledTopKCasesDelta ?? 0) > policy.maxRuntimeUnderfilledTopKCasesDelta) {
+    reasons.push(`runtime underfilled-topk delta ${delta.runtimeUnderfilledTopKCasesDelta ?? 0} exceeds ${policy.maxRuntimeUnderfilledTopKCasesDelta}`);
+  }
   if (reasons.length === 0) {
     return {
       policy,
@@ -4612,6 +4710,20 @@ var buildTraceSummaryAggregate = ({
         direction: "flat",
         metric: "multiVectorCollapsedCases",
         previous: 0
+      },
+      {
+        current: 0,
+        delta: 0,
+        direction: "flat",
+        metric: "runtimeCandidateBudgetExhaustedCases",
+        previous: 0
+      },
+      {
+        current: 0,
+        delta: 0,
+        direction: "flat",
+        metric: "runtimeUnderfilledTopKCases",
+        previous: 0
       }
     ];
     return {
@@ -4734,6 +4846,20 @@ var buildTraceSummaryAggregate = ({
       direction: buildTraceSummaryDirection(latest.multiVectorCollapsedCases - previous.multiVectorCollapsedCases),
       metric: "multiVectorCollapsedCases",
       previous: previous.multiVectorCollapsedCases
+    },
+    {
+      current: latest.runtimeCandidateBudgetExhaustedCases,
+      delta: latest.runtimeCandidateBudgetExhaustedCases - previous.runtimeCandidateBudgetExhaustedCases,
+      direction: buildTraceSummaryDirection(latest.runtimeCandidateBudgetExhaustedCases - previous.runtimeCandidateBudgetExhaustedCases),
+      metric: "runtimeCandidateBudgetExhaustedCases",
+      previous: previous.runtimeCandidateBudgetExhaustedCases
+    },
+    {
+      current: latest.runtimeUnderfilledTopKCases,
+      delta: latest.runtimeUnderfilledTopKCases - previous.runtimeUnderfilledTopKCases,
+      direction: buildTraceSummaryDirection(latest.runtimeUnderfilledTopKCases - previous.runtimeUnderfilledTopKCases),
+      metric: "runtimeUnderfilledTopKCases",
+      previous: previous.runtimeUnderfilledTopKCases
     }
   ];
   const absoluteSorted = [...aggregate].sort((left, right) => Math.abs(right.delta) - Math.abs(left.delta) || left.metric.localeCompare(right.metric));
@@ -4788,12 +4914,15 @@ var summarizeRetrievalTraces = (traces) => {
   let multiVectorVectorHitCases = 0;
   let multiVectorLexicalHitCases = 0;
   let multiVectorCollapsedCases = 0;
+  let runtimeCandidateBudgetExhaustedCases = 0;
+  let runtimeUnderfilledTopKCases = 0;
   let finalCountSum = 0;
   let vectorCountSum = 0;
   let lexicalCountSum = 0;
   let candidateTopKSum = 0;
   let lexicalTopKSum = 0;
   for (const trace of traces) {
+    const vectorSearchMetadata = trace.steps.find((step) => step.stage === "vector_search")?.metadata;
     modeSet.add(trace.mode);
     sourceBalanceStrategySet.add(trace.sourceBalanceStrategy ?? "cap");
     if (trace.runVector) {
@@ -4826,6 +4955,18 @@ var summarizeRetrievalTraces = (traces) => {
     if ((trace.multiVector?.collapsedParents ?? 0) > 0) {
       multiVectorCollapsedCases += 1;
     }
+    if (vectorSearchMetadata?.sqliteQueryCandidateBudgetExhausted) {
+      runtimeCandidateBudgetExhaustedCases += 1;
+    }
+    if (vectorSearchMetadata?.postgresQueryCandidateBudgetExhausted) {
+      runtimeCandidateBudgetExhaustedCases += 1;
+    }
+    if (vectorSearchMetadata?.sqliteQueryUnderfilledTopK) {
+      runtimeUnderfilledTopKCases += 1;
+    }
+    if (vectorSearchMetadata?.postgresQueryUnderfilledTopK) {
+      runtimeUnderfilledTopKCases += 1;
+    }
     finalCountSum += trace.resultCounts.final;
     vectorCountSum += trace.resultCounts.vector;
     lexicalCountSum += trace.resultCounts.lexical;
@@ -4851,6 +4992,8 @@ var summarizeRetrievalTraces = (traces) => {
     multiVectorVectorHitCases,
     multiVectorLexicalHitCases,
     multiVectorCollapsedCases,
+    runtimeCandidateBudgetExhaustedCases,
+    runtimeUnderfilledTopKCases,
     vectorCases
   };
 };
@@ -8436,7 +8579,9 @@ var buildRAGRetrievalComparisonDecisionSummary = ({
     passingRateDelta: candidateEntry.response.passingRate - baselineEntry.response.passingRate,
     multiVectorCollapsedCasesDelta: (candidateEntry.traceSummary?.multiVectorCollapsedCases ?? 0) - (baselineEntry.traceSummary?.multiVectorCollapsedCases ?? 0),
     multiVectorLexicalHitCasesDelta: (candidateEntry.traceSummary?.multiVectorLexicalHitCases ?? 0) - (baselineEntry.traceSummary?.multiVectorLexicalHitCases ?? 0),
-    multiVectorVectorHitCasesDelta: (candidateEntry.traceSummary?.multiVectorVectorHitCases ?? 0) - (baselineEntry.traceSummary?.multiVectorVectorHitCases ?? 0)
+    multiVectorVectorHitCasesDelta: (candidateEntry.traceSummary?.multiVectorVectorHitCases ?? 0) - (baselineEntry.traceSummary?.multiVectorVectorHitCases ?? 0),
+    runtimeCandidateBudgetExhaustedCasesDelta: (candidateEntry.traceSummary?.runtimeCandidateBudgetExhaustedCases ?? 0) - (baselineEntry.traceSummary?.runtimeCandidateBudgetExhaustedCases ?? 0),
+    runtimeUnderfilledTopKCasesDelta: (candidateEntry.traceSummary?.runtimeUnderfilledTopKCases ?? 0) - (baselineEntry.traceSummary?.runtimeUnderfilledTopKCases ?? 0)
   } : undefined;
   return {
     baseline: baselineEntry ? {
@@ -8446,6 +8591,8 @@ var buildRAGRetrievalComparisonDecisionSummary = ({
       multiVectorCollapsedCases: baselineEntry.traceSummary?.multiVectorCollapsedCases,
       multiVectorLexicalHitCases: baselineEntry.traceSummary?.multiVectorLexicalHitCases,
       multiVectorVectorHitCases: baselineEntry.traceSummary?.multiVectorVectorHitCases,
+      runtimeCandidateBudgetExhaustedCases: baselineEntry.traceSummary?.runtimeCandidateBudgetExhaustedCases,
+      runtimeUnderfilledTopKCases: baselineEntry.traceSummary?.runtimeUnderfilledTopKCases,
       passingRate: baselineEntry.response.passingRate,
       retrievalId: baselineEntry.retrievalId
     } : undefined,
@@ -8457,6 +8604,8 @@ var buildRAGRetrievalComparisonDecisionSummary = ({
       multiVectorCollapsedCases: candidateEntry.traceSummary?.multiVectorCollapsedCases,
       multiVectorLexicalHitCases: candidateEntry.traceSummary?.multiVectorLexicalHitCases,
       multiVectorVectorHitCases: candidateEntry.traceSummary?.multiVectorVectorHitCases,
+      runtimeCandidateBudgetExhaustedCases: candidateEntry.traceSummary?.runtimeCandidateBudgetExhaustedCases,
+      runtimeUnderfilledTopKCases: candidateEntry.traceSummary?.runtimeUnderfilledTopKCases,
       passingRate: candidateEntry.response.passingRate,
       retrievalId: candidateEntry.retrievalId
     } : undefined,
@@ -8468,7 +8617,9 @@ var buildRAGRetrievalComparisonDecisionSummary = ({
     winnerByPassingRate: comparison.summary.bestByPassingRate,
     winnerByMultivectorCollapsedCases: comparison.summary.bestByMultivectorCollapsedCases,
     winnerByMultivectorLexicalHitCases: comparison.summary.bestByMultivectorLexicalHitCases,
-    winnerByMultivectorVectorHitCases: comparison.summary.bestByMultivectorVectorHitCases
+    winnerByMultivectorVectorHitCases: comparison.summary.bestByMultivectorVectorHitCases,
+    winnerByLowestRuntimeCandidateBudgetExhaustedCases: comparison.summary.bestByLowestRuntimeCandidateBudgetExhaustedCases,
+    winnerByLowestRuntimeUnderfilledTopKCases: comparison.summary.bestByLowestRuntimeUnderfilledTopKCases
   };
 };
 var loadRAGSearchTracePruneHistory = async ({
@@ -9156,6 +9307,24 @@ var selectComparisonEntryByTraceMetric = (entries, idKey, metric) => {
   }
   return typeof winner[idKey] === "string" ? winner[idKey] : undefined;
 };
+var selectComparisonEntryByLowestTraceMetric = (entries, idKey, metric) => {
+  const ranked = [...entries].sort((left, right) => {
+    const leftMetric = left.traceSummary?.[metric] ?? 0;
+    const rightMetric = right.traceSummary?.[metric] ?? 0;
+    if (leftMetric !== rightMetric) {
+      return leftMetric - rightMetric;
+    }
+    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;
+  });
+  const winner = ranked[0];
+  return typeof winner?.[idKey] === "string" ? winner[idKey] : undefined;
+};
 var resolveRetrievalMode = (candidate) => {
   if (!candidate.retrieval) {
     return "vector";
@@ -9249,7 +9418,9 @@ var compareRAGRetrievalTraceSummaries = (current, previous) => ({
   multiVectorCasesDelta: current.multiVectorCases - previous.multiVectorCases,
   multiVectorVectorHitCasesDelta: current.multiVectorVectorHitCases - previous.multiVectorVectorHitCases,
   multiVectorLexicalHitCasesDelta: current.multiVectorLexicalHitCases - previous.multiVectorLexicalHitCases,
-  multiVectorCollapsedCasesDelta: current.multiVectorCollapsedCases - previous.multiVectorCollapsedCases
+  multiVectorCollapsedCasesDelta: current.multiVectorCollapsedCases - previous.multiVectorCollapsedCases,
+  runtimeCandidateBudgetExhaustedCasesDelta: current.runtimeCandidateBudgetExhaustedCases - previous.runtimeCandidateBudgetExhaustedCases,
+  runtimeUnderfilledTopKCasesDelta: current.runtimeUnderfilledTopKCases - previous.runtimeUnderfilledTopKCases
 });
 var buildSearchTraceResultSnapshots = (results) => results.map((result) => ({
   chunkId: result.chunkId,
@@ -9611,6 +9782,63 @@ var generateRAGEvaluationSuiteFromDocuments = ({
     metadata
   });
 };
+var DEFAULT_NATIVE_PLANNER_BENCHMARK_SUITE_ID = "rag-native-planner-larger-corpus";
+var DEFAULT_NATIVE_PLANNER_BENCHMARK_LABEL = "Adaptive Native Planner Benchmark";
+var DEFAULT_NATIVE_PLANNER_BENCHMARK_QUERY = "Which launch checklist phrase is exact wording?";
+var DEFAULT_NATIVE_PLANNER_BENCHMARK_FILTER = {
+  lane: "focus"
+};
+var createRAGAdaptiveNativePlannerBenchmarkSuite = (input) => createRAGEvaluationSuite({
+  description: input?.description ?? "Stress-tests larger-corpus native planner selection, candidate-budget pressure, and transformed-query recovery on filtered retrieval.",
+  id: input?.id ?? DEFAULT_NATIVE_PLANNER_BENCHMARK_SUITE_ID,
+  input: {
+    cases: [
+      {
+        expectedDocumentIds: ["focus-target"],
+        filter: { ...DEFAULT_NATIVE_PLANNER_BENCHMARK_FILTER },
+        hardNegativeDocumentIds: [
+          "focus-distractor-0",
+          "focus-distractor-1",
+          "focus-distractor-2"
+        ],
+        id: "planner-pressure-exact-phrase",
+        label: "Exact phrase survives larger-corpus native pressure",
+        query: DEFAULT_NATIVE_PLANNER_BENCHMARK_QUERY,
+        topK: input?.topK ?? 1
+      }
+    ],
+    filter: { ...DEFAULT_NATIVE_PLANNER_BENCHMARK_FILTER },
+    retrieval: "vector",
+    topK: input?.topK ?? 1
+  },
+  label: input?.label ?? DEFAULT_NATIVE_PLANNER_BENCHMARK_LABEL,
+  metadata: {
+    benchmarkKind: "adaptive_native_planner",
+    benchmarkScope: "larger_corpus",
+    expectedSignals: [
+      "selected native planner profile",
+      "candidate-budget exhaustion",
+      "underfilled topk"
+    ],
+    recommendedGroupKey: "runtime-native-planner",
+    recommendedTags: ["runtime", "native", "planner"],
+    ...input?.metadata
+  }
+});
+var createRAGAdaptiveNativePlannerBenchmarkSnapshot = (input) => {
+  const suite = input?.suite ?? createRAGAdaptiveNativePlannerBenchmarkSuite();
+  return createRAGEvaluationSuiteSnapshot({
+    createdAt: input?.createdAt,
+    id: input?.id,
+    metadata: {
+      artifactKind: "adaptive_native_planner_benchmark",
+      persistForReleaseHistory: true,
+      ...input?.metadata
+    },
+    suite,
+    version: input?.version
+  });
+};
 var createRAGEvaluationSuiteSnapshot = ({
   suite,
   id,
@@ -9818,7 +10046,9 @@ var summarizeRAGRetrievalComparison = (entries) => ({
   ...summarizeEvaluationResponseComparison(entries, "retrievalId"),
   bestByMultivectorCollapsedCases: selectComparisonEntryByTraceMetric(entries, "retrievalId", "multiVectorCollapsedCases"),
   bestByMultivectorLexicalHitCases: selectComparisonEntryByTraceMetric(entries, "retrievalId", "multiVectorLexicalHitCases"),
-  bestByMultivectorVectorHitCases: selectComparisonEntryByTraceMetric(entries, "retrievalId", "multiVectorVectorHitCases")
+  bestByMultivectorVectorHitCases: selectComparisonEntryByTraceMetric(entries, "retrievalId", "multiVectorVectorHitCases"),
+  bestByLowestRuntimeCandidateBudgetExhaustedCases: selectComparisonEntryByLowestTraceMetric(entries, "retrievalId", "runtimeCandidateBudgetExhaustedCases"),
+  bestByLowestRuntimeUnderfilledTopKCases: selectComparisonEntryByLowestTraceMetric(entries, "retrievalId", "runtimeUnderfilledTopKCases")
 });
 // src/ai/client/actions.ts
 var serverMessageToAction = (message) => {
@@ -10842,6 +11072,9 @@ var createRAGClient = (options) => {
       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);
       }
@@ -10855,6 +11088,51 @@ var createRAGClient = (options) => {
       }
       return payload;
     },
+    async adaptiveNativePlannerBenchmark(input) {
+      const searchParams = new URLSearchParams;
+      if (typeof input?.limit === "number") {
+        searchParams.set("limit", String(input.limit));
+      }
+      if (input?.label) {
+        searchParams.set("label", input.label);
+      }
+      if (input?.description) {
+        searchParams.set("description", input.description);
+      }
+      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 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 retrievalLaneHandoffs(input) {
       const searchParams = new URLSearchParams;
       if (input?.groupKey) {
@@ -12655,5 +12933,5 @@ export {
   AIStreamProvider
 };
 
-//# debugId=CB9BA32111B0F40E64756E2164756E21
+//# debugId=F9571F16FED058B164756E2164756E21
 //# sourceMappingURL=index.js.map