@agent-native/core-corpus 0.210.0 → 0.210.1-nightly-20261020010058

package/corpus/README.md

@@ -32,4 +32,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core-corpus/corpu
 
 ## Generated Counts
 
-- template files: 12899
+- template files: 13180

package/corpus/templates/analytics/.agents/skills/bigquery/SKILL.md

@@ -78,10 +78,20 @@ Never label a current partial-month snapshot as last month's completed usage.
 | `data-source-status --key bigquery`                       | Check whether BigQuery credentials and project are configured.       |
 | `find-data --question <topic>`                            | Find ranked metric definitions and saved query examples before SQL.  |
 | `search-bigquery-schema`                                  | List datasets, list tables in a dataset, or describe table columns.  |
+| `estimate-query-cost --sql "<sql>"`                       | Free dry run: bytes, $ per run, and $ per month for scheduled runs.  |
 | `bigquery --sql "<sql>"`                                  | Run a real warehouse query after table/column names are known.       |
 | `query-dbt-semantic-metric --metricName <exact dbt name>` | Run an owner-defined dbt Semantic Layer metric before warehouse SQL. |
 | `get-dbt-connection`                                      | Check dbt readiness (`readiness`) and the missing setup step.        |
 
+## Check Cost Before Big Queries
+
+Before running a query over a large event or pageview table, call
+`estimate-query-cost` with the same SQL. It dry-runs the query (BigQuery reads
+and bills nothing) and prices it at on-demand rates. Pass `runsPerMonth` for
+anything scheduled, such as 8640 for an alert that polls every 5 minutes.
+Estimates over $1 per run or $50 per month are flagged: tell the user the number
+before going ahead.
+
 For direct Amplitude/PostHog/Mixpanel product-event data (outside the warehouse
 copy), there is no first-class action — call `provider-api-catalog` /
 `provider-api-docs` then `provider-api-request` (provider `amplitude`, `posthog`,

package/corpus/templates/analytics/.agents/skills/context-awareness/SKILL.md

@@ -196,6 +196,11 @@ changes. If a command can arrive while a chat stream is rendering, prefer
 `navigate(path, { replace: true, flushSync: true })` over a view-transition
 wrapper so the URL and visible route commit together.
 
+Keep `path` router-local. A segment matching the app mount prefix remains part
+of the local route unless a matching `view` route or explicit `publicPath`
+identifies the mounted URL. Carry the mounted form separately in `publicPath`;
+never infer that `path` is mounted from its prefix alone.
+
 ## Jitter Prevention
 
 Agent-side application-state writes are tagged with

package/corpus/templates/analytics/.agents/skills/dashboard-management/SKILL.md

@@ -944,6 +944,17 @@ unavailable" placeholder.
   `mutate-dashboard` for existing edits, or `update-dashboard` for new/full
   config saves, and fix the action arguments.
 - Never set `panel.source` to a table name or unsupported backend.
+- Before saving a BigQuery or first-party panel that reads a large table, or
+  adding an email report to a dashboard, check its cost with
+  `estimate-query-cost --dashboardId <id>` (add `--panelId` for one panel). It
+  is a free dry run; tell the user any panel flagged over $1 per run or $50 per
+  month. Dashboard estimates count email reports but not alert rules: before
+  adding an alert, estimate an `analytics_events` query with the alert's
+  filters and its window's `event_date` and `timestamp` bounds, as alerts
+  send both (the dry run skips only partitions the `event_date` filter rules
+  out), using `--source first-party --eventsSource raw` (alerts run as
+  first-party SQL on the raw table) and `--runsPerMonth` set from the poll
+  interval (8640 for every 5 minutes).
 - Use `first-party` for `/track` data and `query-agent-native-analytics` for ad-hoc first-party event questions.
 - Use `update-dashboard` for new dashboard config saves and full config
   replacements. Use `mutate-dashboard` for existing dashboard edits.

package/corpus/templates/analytics/.deploy-tmp/agent-native-provided-plugins.mjs

@@ -0,0 +1,10 @@
+// AUTO-GENERATED by @agent-native/core deploy build
+import { markDefaultPluginProvided } from "@agent-native/core/server/edge";
+
+const pluginStems = ["agent-chat","analytics-alert-jobs","analytics-rollup-backfill-jobs","auth","collab","config","core-routes","creative-context","dashboard-report-jobs","db","feature-flags","labs","onboarding","otel","session-replay-retention-jobs","transactional-emails","uptime-monitor-jobs"];
+
+export default function markBuildDiscoveredPlugins(nitroApp) {
+  for (const stem of pluginStems) {
+    markDefaultPluginProvided(nitroApp, stem);
+  }
+}

package/corpus/templates/analytics/actions/estimate-query-cost.ts

@@ -0,0 +1,421 @@
+import { defineAction, fail } from "@agent-native/core/action";
+import type { ActionRunContext } from "@agent-native/core/action";
+import {
+  getCredentialContext,
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { isSafeDashboardId } from "../server/lib/dashboard-id";
+import {
+  pageDashboardConfig,
+  resolveDashboardPanelQueries,
+  type ResolvedDashboardPanelQuery,
+} from "../server/lib/dashboard-panel-verification";
+import { countEnabledDashboardReportSubscriptions } from "../server/lib/dashboard-report-subscriptions";
+import { loadDashboardSeed } from "../server/lib/dashboard-seeds";
+import { getDashboard } from "../server/lib/dashboards-store";
+import type { AnalyticsScope } from "../server/lib/first-party-analytics";
+import {
+  DAYS_PER_MONTH,
+  estimateBigQuerySql,
+  estimateFirstPartySql,
+  estimateResolvedPanel,
+  formatBytes,
+  formatUsd,
+  ON_DEMAND_USD_PER_TIB,
+  QUERY_COST_CAVEATS,
+  QUERY_COST_THRESHOLDS,
+  totalCost,
+  type PanelCostEstimate,
+  type QueryCostEstimate,
+} from "../server/lib/query-cost-estimate";
+import { clipHead } from "../shared/panel-render-contract";
+
+const MAX_PANELS = 60;
+const DRY_RUN_CONCURRENCY = 6;
+/** Stop starting dry runs here so the action returns before its 55 s timeout. */
+const DASHBOARD_DEADLINE_MS = 40_000;
+
+function timedOutPanel(
+  panel: { panelId: string; title: string; source: string },
+  error: string,
+): PanelCostEstimate {
+  return {
+    panelId: panel.panelId,
+    title: panel.title,
+    source: panel.source,
+    status: "failed",
+    failure: "timeout",
+    error,
+  };
+}
+
+/**
+ * Estimate one panel, but give up when the dashboard deadline passes, even
+ * mid-way through credential, table, or backend lookups, so finished panels
+ * still come back before the action's own timeout.
+ */
+async function estimatePanelBefore(
+  deadline: number,
+  panel: ResolvedDashboardPanelQuery,
+  scope: AnalyticsScope,
+  runsPerMonth: number | null,
+  signal?: AbortSignal,
+): Promise<PanelCostEstimate> {
+  const remaining = deadline - Date.now();
+  if (remaining <= 0) {
+    return timedOutPanel(
+      panel,
+      "Skipped: this request ran out of time. Estimate this panel on its own with panelId.",
+    );
+  }
+  const controller = new AbortController();
+  const forwardAbort = () => controller.abort(signal?.reason);
+  if (signal?.aborted) forwardAbort();
+  signal?.addEventListener("abort", forwardAbort, { once: true });
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const timedOut = new Promise<PanelCostEstimate>((resolve) => {
+    timer = setTimeout(() => {
+      resolve(
+        timedOutPanel(
+          panel,
+          "Stopped: this panel's dry run didn't finish in time. Estimate it on its own with panelId.",
+        ),
+      );
+      controller.abort();
+    }, remaining);
+  });
+  try {
+    return await Promise.race([
+      estimateResolvedPanel(panel, scope, runsPerMonth, controller.signal),
+      timedOut,
+    ]);
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", forwardAbort);
+  }
+}
+
+async function mapPool<T, R>(
+  items: readonly T[],
+  concurrency: number,
+  fn: (item: T) => Promise<R>,
+): Promise<R[]> {
+  const results: R[] = Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const index = next++;
+      results[index] = await fn(items[index]);
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, items.length) }, worker),
+  );
+  return results;
+}
+
+function sentence(text: string): string {
+  return /[.!?]$/.test(text) ? text : `${text}.`;
+}
+
+function describeEstimate(estimate: QueryCostEstimate): string {
+  if (
+    estimate.status === "not_bigquery" ||
+    estimate.status === "not_estimated"
+  ) {
+    return estimate.reason;
+  }
+  if (estimate.status === "failed") {
+    return `no estimate (${estimate.failure}): ${estimate.error}`;
+  }
+  const monthly =
+    estimate.usdPerMonth === null
+      ? "not scheduled"
+      : `~${formatUsd(estimate.usdPerMonth)}/month over ${estimate.runsPerMonth} scheduled runs`;
+  const flags = [
+    estimate.overPerRunThreshold
+      ? `over the ${formatUsd(QUERY_COST_THRESHOLDS.perRunUsd)}/run threshold`
+      : null,
+    estimate.overPerMonthThreshold
+      ? `over the ${formatUsd(QUERY_COST_THRESHOLDS.perMonthUsd)}/month threshold`
+      : null,
+  ].filter(Boolean);
+  return `~${formatBytes(estimate.estimatedBytes)}, ${formatUsd(estimate.usdPerRun)} per run, ${monthly}${flags.length ? ` (${flags.join("; ")})` : ""}`;
+}
+
+export default defineAction({
+  description:
+    "Free cost estimate for BigQuery SQL. Dry-runs the query through Analytics' own BigQuery connection (BigQuery reads and bills nothing) and returns the bytes it would scan, dollars per run at on-demand pricing, and dollars per month for scheduled runs. " +
+    "Pass `sql` to estimate any query (source 'bigquery' for warehouse SQL, 'first-party' for analytics_events SQL), or `dashboardId` (plus optional `panelId`) to estimate saved panels exactly as the dashboard runs them. " +
+    `Call it before running or saving a query that may scan a large table, and before setting a byte cap (about 1.5x the estimate is common). Results over $${QUERY_COST_THRESHOLDS.perRunUsd}/run or $${QUERY_COST_THRESHOLDS.perMonthUsd}/month are flagged; tell the user the number before going ahead.`,
+  schema: z.object({
+    sql: z
+      .string()
+      .min(1)
+      .optional()
+      .describe(
+        "SQL to estimate. Use this or dashboardId, not both. Dashboard {{filter}} tokens are not resolved here; pass dashboardId for saved panels.",
+      ),
+    source: z
+      .enum(["bigquery", "first-party"])
+      .optional()
+      .default("bigquery")
+      .describe(
+        "Dialect of `sql`: 'bigquery' (standard SQL against the warehouse, the default) or 'first-party' (Analytics' analytics_events SQL, rendered the way first-party panels send it).",
+      ),
+    eventsSource: z
+      .enum(["raw"])
+      .optional()
+      .describe(
+        "First-party sql only: 'raw' prices the raw events table even when the events model covers the query. Alerts read the raw table, so pass it when estimating an alert.",
+      ),
+    dashboardId: z
+      .string()
+      .min(1)
+      .optional()
+      .describe(
+        "Saved SQL dashboard to estimate. Without panelId, every queryable panel is estimated.",
+      ),
+    panelId: z
+      .string()
+      .min(1)
+      .optional()
+      .describe("One panel inside dashboardId."),
+    filters: z
+      .record(z.string(), z.string())
+      .optional()
+      .describe(
+        "Dashboard filter values keyed by filter id, e.g. {timeRange:'90d'}. Omit for the defaults a fresh tab shows.",
+      ),
+    // null and "" mean "not given", not 0, so the report-schedule default holds.
+    runsPerMonth: z
+      .preprocess(
+        (value) => (value === null || value === "" ? undefined : value),
+        z.coerce.number().int().min(0).max(100_000).optional(),
+      )
+      .describe(
+        "Scheduled runs per month, e.g. 30 for a daily job or 8640 for a 5-minute alert. For a dashboard this defaults to one run a day per enabled email report; for raw SQL there is no monthly figure without it.",
+      ),
+  }),
+  http: { method: "POST" },
+  readOnly: true,
+  mcpTool: true,
+  publicAgent: { expose: true, readOnly: true, requiresAuth: true },
+  timeoutMs: 55_000,
+  run: async (args, context?: ActionRunContext) => {
+    const startedAt = Date.now();
+    if (Boolean(args.sql) === Boolean(args.dashboardId)) {
+      fail("Pass exactly one of sql or dashboardId.", {
+        errorCode: "invalid_target",
+        statusCode: 400,
+      });
+    }
+    if (args.panelId && !args.dashboardId) {
+      fail("panelId needs dashboardId.", {
+        errorCode: "invalid_target",
+        statusCode: 400,
+      });
+    }
+    if (args.eventsSource && !(args.sql && args.source === "first-party")) {
+      fail("eventsSource applies only to first-party sql.", {
+        errorCode: "invalid_target",
+        statusCode: 400,
+      });
+    }
+    const userEmail = getRequestUserEmail();
+    if (!userEmail) {
+      fail("Sign in to use this action.", {
+        errorCode: "unauthenticated",
+        statusCode: 401,
+      });
+    }
+    const orgId = getRequestOrgId() || null;
+    const credentialContext = getCredentialContext();
+    const scope: AnalyticsScope = {
+      userEmail,
+      orgId,
+      ...(credentialContext?.credentialScope === "org"
+        ? { credentialScope: "org" as const }
+        : {}),
+    };
+    const signal = context?.signal;
+    const pricing = {
+      model: "on-demand",
+      usdPerTiB: ON_DEMAND_USD_PER_TIB,
+      thresholds: QUERY_COST_THRESHOLDS,
+    };
+
+    if (args.sql) {
+      const runsPerMonth = args.runsPerMonth ?? null;
+      const estimate =
+        args.source === "first-party"
+          ? await estimateFirstPartySql(args.sql, scope, runsPerMonth, signal, {
+              eventsSource: args.eventsSource,
+            })
+          : await estimateBigQuerySql(args.sql, runsPerMonth, signal);
+      return {
+        target: "sql",
+        source: args.source,
+        ...estimate,
+        pricing,
+        caveats: QUERY_COST_CAVEATS,
+        summary: sentence(`Estimate: ${describeEstimate(estimate)}`),
+      };
+    }
+
+    const dashboardId = args.dashboardId!;
+    if (!isSafeDashboardId(dashboardId)) {
+      fail(
+        `${JSON.stringify(clipHead(dashboardId, 60))} is not a dashboard id: ids hold only letters, digits, dot, dash and underscore.`,
+        { errorCode: "invalid_dashboard_id", statusCode: 400 },
+      );
+    }
+    const dashboard = await getDashboard(dashboardId, {
+      email: userEmail,
+      orgId,
+    });
+    // Like get-sql-dashboard, a seed with the same id stands in for a stored
+    // dashboard that isn't SQL.
+    const stored = dashboard?.kind === "sql" ? dashboard : null;
+    const seed = stored ? null : loadDashboardSeed(dashboardId);
+    if (!stored && !seed) {
+      if (dashboard) {
+        fail(
+          `estimate-query-cost only supports SQL dashboards; "${dashboardId}" is ${dashboard.kind}.`,
+          { errorCode: "dashboard_not_sql", statusCode: 400 },
+        );
+      }
+      fail(
+        `Dashboard "${dashboardId}" was not found, or you don't have access to it.`,
+        { errorCode: "dashboard_not_found", statusCode: 404 },
+      );
+    }
+
+    const config = pageDashboardConfig(
+      stored ? stored.config : seed!,
+      dashboardId,
+    );
+    const resolved = resolveDashboardPanelQueries(config, args.filters);
+    const selected = args.panelId
+      ? resolved.filter((panel) => panel.panelId === args.panelId)
+      : resolved;
+    if (args.panelId && selected.length === 0) {
+      fail(
+        `Panel "${args.panelId}" is not a queryable panel in dashboard "${dashboardId}". Queryable panel ids: ${resolved
+          .slice(0, 40)
+          .map((panel) => panel.panelId)
+          .join(", ")}.`,
+        { errorCode: "panel_not_found", statusCode: 404 },
+      );
+    }
+
+    const reportSchedules = await countEnabledDashboardReportSubscriptions(
+      dashboardId,
+      { email: userEmail, orgId },
+    );
+    const runsPerMonth =
+      args.runsPerMonth ??
+      (reportSchedules > 0 ? reportSchedules * DAYS_PER_MONTH : null);
+    const estimated = selected.slice(0, MAX_PANELS);
+    const deadline = startedAt + DASHBOARD_DEADLINE_MS;
+    const panels: PanelCostEstimate[] = await mapPool(
+      estimated,
+      DRY_RUN_CONCURRENCY,
+      (panel) =>
+        estimatePanelBefore(deadline, panel, scope, runsPerMonth, signal),
+    );
+    const total = totalCost(panels);
+    const flagged = panels.filter(
+      (panel) =>
+        panel.status === "estimated" &&
+        (panel.overPerRunThreshold || panel.overPerMonthThreshold),
+    );
+    const failed = panels.filter((panel) => panel.status === "failed").length;
+    const priced = panels.filter(
+      (panel) => panel.status === "estimated",
+    ).length;
+    const notEstimated = panels.filter(
+      (panel) => panel.status === "not_estimated",
+    ).length;
+    const omitted = Math.max(0, selected.length - MAX_PANELS);
+    // Panels outside BigQuery cost nothing; any other gap makes the total partial.
+    const partial = failed + notEstimated + omitted > 0;
+    // With panelId the total is that panel's, never the dashboard's.
+    const onePanel = args.panelId !== undefined;
+    const totalScope = onePanel
+      ? "per refresh of this panel"
+      : partial
+        ? "per refresh of the priced panels only"
+        : "per full refresh";
+    // Report schedules keep their own saved filters; this prices them at the
+    // filters passed here (or the defaults), so say so.
+    const monthly =
+      total.usdPerMonth === null
+        ? "no scheduled runs"
+        : args.runsPerMonth === undefined
+          ? `~${formatUsd(total.usdPerMonth)}/month if its email reports use these filters`
+          : `~${formatUsd(total.usdPerMonth)}/month in scheduled runs`;
+    const totalFlags = {
+      overPerRunThreshold: total.usdPerRun > QUERY_COST_THRESHOLDS.perRunUsd,
+      overPerMonthThreshold:
+        total.usdPerMonth !== null &&
+        total.usdPerMonth > QUERY_COST_THRESHOLDS.perMonthUsd,
+    };
+    const totalOver = [
+      totalFlags.overPerRunThreshold &&
+        `the ${formatUsd(QUERY_COST_THRESHOLDS.perRunUsd)}/run`,
+      totalFlags.overPerMonthThreshold &&
+        `the ${formatUsd(QUERY_COST_THRESHOLDS.perMonthUsd)}/month`,
+    ].filter(Boolean);
+
+    return {
+      target: "dashboard",
+      dashboardId,
+      filterState:
+        args.filters && Object.keys(args.filters).length > 0
+          ? "overridden"
+          : "defaults",
+      runsPerMonth,
+      runsPerMonthBasis:
+        args.runsPerMonth !== undefined
+          ? "caller"
+          : reportSchedules > 0
+            ? `${reportSchedules} enabled daily email report${reportSchedules === 1 ? "" : "s"} ${orgId ? "in your org" : "of yours"}`
+            : "none",
+      total: {
+        ...total,
+        ...totalFlags,
+        partial,
+        scope: onePanel ? "panel" : "dashboard",
+      },
+      panels,
+      ...(selected.length > MAX_PANELS
+        ? { omittedPanelIds: selected.slice(MAX_PANELS).map((p) => p.panelId) }
+        : {}),
+      pricing,
+      caveats: QUERY_COST_CAVEATS,
+      summary:
+        (priced === 0
+          ? `${panels.length} panel${panels.length === 1 ? "" : "s"}: ${partial ? "none could be priced." : "none read BigQuery, so nothing was priced."}`
+          : `${panels.length} panel${panels.length === 1 ? "" : "s"} (${priced} priced): ~${formatBytes(total.estimatedBytes)} and ${formatUsd(total.usdPerRun)} ${totalScope}, ${monthly}.`) +
+        (totalOver.length && !onePanel
+          ? ` The dashboard as a whole is over ${totalOver.join(" and ")} threshold${totalOver.length > 1 ? "s" : ""}${partial ? ", even counting only the priced panels" : ""}.`
+          : "") +
+        (flagged.length
+          ? ` Over threshold: ${flagged.map((panel) => `"${panel.title}" (${describeEstimate(panel)})`).join("; ")}.`
+          : "") +
+        (failed
+          ? ` ${failed} panel${failed === 1 ? "" : "s"} could not be estimated.`
+          : "") +
+        (notEstimated
+          ? ` ${notEstimated} panel${notEstimated === 1 ? "" : "s"} may read BigQuery but ${notEstimated === 1 ? "isn't" : "aren't"} priced here.`
+          : "") +
+        (omitted
+          ? ` ${omitted} panel${omitted === 1 ? "" : "s"} past the first ${MAX_PANELS} ${omitted === 1 ? "wasn't" : "weren't"} estimated (see omittedPanelIds).`
+          : ""),
+    };
+  },
+});

package/corpus/templates/analytics/actions/mutate-dashboard.ts

@@ -233,7 +233,11 @@ const allowEmptyResultHelp =
   "Set true only when the user expects an edited panel to have no rows right now; the save then reports verified:false. It never overrides missing columns or query errors.";
 
 const agentInputSchema = z.object({
-  dashboardId: z.string().min(1).describe("Dashboard id."),
+  dashboardId: z
+    .string()
+    .min(1)
+    .optional()
+    .describe("Dashboard id. Omit only when requesting returnTypes."),
   operations: z
     .array(mutationOperationSchema)
     .max(MAX_DASHBOARD_MUTATION_OPERATIONS)
@@ -250,6 +254,10 @@ const agentInputSchema = z.object({
     .boolean()
     .optional()
     .describe("Include the full resulting config only when needed."),
+  returnTypes: z
+    .boolean()
+    .optional()
+    .describe("With no dashboardId, return the `code` API and examples."),
 });
 
 function resolveScope() {

package/corpus/templates/analytics/changelog/2026-10-19-composer-focus-remains-safe-when-an-editor-changes-during-na.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-19
+---
+
+Composer focus remains safe when an editor changes during navigation.

package/corpus/templates/analytics/changelog/2026-10-19-dashboard-api-guidance-works-without-an-open-dashboard.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-10-19
+---
+
+Dashboard API guidance works without an open dashboard

package/corpus/templates/analytics/server/lib/analytics-mcp.ts

@@ -4,6 +4,7 @@ import type { AgentChatMcpOptions } from "@agent-native/core/server";
 // framework's cross-app builtins. `mcp-action-contract.spec.ts` serves this
 // config through the real MCP handler and pins the resulting tools/list.
 export const ANALYTICS_MCP = {
+  connectorCatalog: [],
   externalAgents: { writes: "allowlisted" },
   keyToolNames: [
     "list-sql-dashboards",

package/corpus/templates/analytics/server/lib/bigquery.ts

@@ -1121,15 +1121,24 @@ export interface DryRunQueryOptions {
 }
 
 export class BigQueryDryRunPreparationError extends Error {
-  constructor() {
+  /** True when the failure was missing BigQuery credentials or project. */
+  readonly notConfigured: boolean;
+
+  constructor(options: { notConfigured?: boolean } = {}) {
     super("BigQuery dry-run request preparation failed");
     this.name = "BigQueryDryRunPreparationError";
+    this.notConfigured = options.notConfigured === true;
   }
 }
 
+const BIGQUERY_NOT_CONFIGURED_PATTERN =
+  /GOOGLE_APPLICATION_CREDENTIALS_JSON not configured|BIGQUERY_PROJECT_ID|service account|Token exchange failed/i;
+
 export interface DryRunQueryResult {
   error: string | null;
   timedOut?: true;
+  /** HTTP status of a failed dry-run request; 400 means BigQuery rejected the SQL. */
+  status?: number;
   /** Absent when BigQuery's dry-run response carried no schema. */
   schema?: { name: string; type: string }[];
   /** Absent when BigQuery's dry-run response carried no byte estimate. */
@@ -1208,7 +1217,11 @@ export async function dryRunQuerySchema(
       throw error;
     }
     if (options.wrapPreparationErrors) {
-      throw new BigQueryDryRunPreparationError();
+      throw new BigQueryDryRunPreparationError({
+        notConfigured:
+          error instanceof Error &&
+          BIGQUERY_NOT_CONFIGURED_PATTERN.test(error.message),
+      });
     }
     throw error;
   }
@@ -1252,12 +1265,15 @@ export async function dryRunQuerySchema(
         error?: { message?: string };
       };
       const msg = parsed.error?.message?.trim();
-      if (msg) return { error: msg };
+      if (msg) return { error: msg, status: res.status };
       // coercion-ok: malformed BigQuery error bodies use the status fallback below.
     } catch {
       // Fall through
     }
-    return { error: `BigQuery validation failed (${res.status})` };
+    return {
+      error: `BigQuery validation failed (${res.status})`,
+      status: res.status,
+    };
   } catch (error) {
     if (timedOut) return { error: timeoutMessage, timedOut: true };
     throw error;

package/corpus/templates/analytics/server/lib/dashboard-panel-verification.ts

@@ -350,6 +350,44 @@ function interpolationFailure(
   return null;
 }
 
+export type ResolvedDashboardPanelQuery =
+  | { panelId: string; title: string; source: string; query: string }
+  | { panelId: string; title: string; source: string; error: string };
+
+/**
+ * The SQL each queryable panel sends for the given filters (dashboard defaults
+ * when omitted), resolved the way verification does, without running anything.
+ * Section and extension panels have no query and are left out.
+ */
+export function resolveDashboardPanelQueries(
+  rawConfig: Record<string, unknown>,
+  filters?: Record<string, string>,
+): ResolvedDashboardPanelQuery[] {
+  const config = normalizeDashboardConfig(rawConfig);
+  const vars = resolveVerificationVars(config, filters);
+  return panelsOf(config)
+    .filter((panel) => typeof panel.id === "string" && hasSqlToRun(panel))
+    .map((panel) => {
+      const panelId = String(panel.id);
+      const title = typeof panel.title === "string" ? panel.title : panelId;
+      const source = typeof panel.source === "string" ? panel.source : "";
+      try {
+        const query = buildPanelQuery(panel as unknown as SqlPanel, vars);
+        const failure = interpolationFailure(query, panel.sql, vars);
+        return failure
+          ? { panelId, title, source, error: failure }
+          : { panelId, title, source, query };
+      } catch (error) {
+        return {
+          panelId,
+          title,
+          source,
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
+    });
+}
+
 function truncateCell(value: unknown): unknown {
   const text =
     typeof value === "string"

package/corpus/templates/analytics/server/lib/dashboard-report-subscriptions.ts

@@ -434,6 +434,36 @@ export async function listDashboardReportSubscriptions(
   return rows.map(rowToSubscription);
 }
 
+/**
+ * Enabled daily report schedules on a dashboard in the caller's tenant: every
+ * owner's in the caller's org, or only the caller's own without an org. Each
+ * one re-runs the dashboard's panels once a day on its owner's BigQuery
+ * connection, so other tenants' schedules bill other tenants and never count.
+ * Only the number is returned, never the subscriptions themselves.
+ */
+export async function countEnabledDashboardReportSubscriptions(
+  dashboardId: string,
+  ctx: AccessCtx,
+): Promise<number> {
+  const db = getDb() as any;
+  const [row] = await db
+    .select({ count: sql<number>`count(*)` })
+    .from(schema.dashboardReportSubscriptions)
+    .where(
+      and(
+        eq(schema.dashboardReportSubscriptions.dashboardId, dashboardId),
+        eq(schema.dashboardReportSubscriptions.enabled, true),
+        ctx.orgId
+          ? eq(schema.dashboardReportSubscriptions.orgId, ctx.orgId)
+          : and(
+              isNull(schema.dashboardReportSubscriptions.orgId),
+              sql`lower(${schema.dashboardReportSubscriptions.ownerEmail}) = ${ctx.email.toLowerCase()}`,
+            ),
+      ),
+    );
+  return Number(row?.count ?? 0);
+}
+
 export async function getDashboardReportSubscription(
   id: string,
   ctx: AccessCtx,