diff --git a/apps/api/src/routes/v2/share.http.ts b/apps/api/src/routes/v2/share.http.ts
index 812b438ca1..f43321e3ce 100644
--- a/apps/api/src/routes/v2/share.http.ts
+++ b/apps/api/src/routes/v2/share.http.ts
@@ -302,6 +302,16 @@ export const HttpV2SharePublicLive = HttpApiBuilder.group(MapleApiV2, "sharePubl
 						})
 					})
 
+					const promQlQueries = document.widgets.flatMap((widget) => {
+						const source = widget.dataSource as {
+							readonly kind?: unknown
+							readonly query?: unknown
+						}
+						return source.kind === "promql" && typeof source.query === "string"
+							? [source.query]
+							: []
+					})
+
 					// Query-variable options are listed server-side over the same window,
 					// so the board's ladder (selection → default → All → first option)
 					// and its "All" expansion resolve to the same values here.
@@ -312,6 +322,7 @@ export const HttpV2SharePublicLive = HttpApiBuilder.group(MapleApiV2, "sharePubl
 						payload.variableValues ?? {},
 						queryOptions,
 						whereClauses,
+						promQlQueries,
 					)
 
 					const results: Array<ShareWidgetDataOutcome> = []
diff --git a/apps/landing/src/content/docs/dashboards/build-dashboards.md b/apps/landing/src/content/docs/dashboards/build-dashboards.md
index 973292338c..62de85b8e3 100644
--- a/apps/landing/src/content/docs/dashboards/build-dashboards.md
+++ b/apps/landing/src/content/docs/dashboards/build-dashboards.md
@@ -65,10 +65,11 @@ Most types come with presets you can start from. Pick one, then edit its query.
 
 ### Queries
 
-A widget's editor has two tabs:
+A widget's editor has these source tabs:
 
 - **Query Builder** reads **Traces**, **Logs**, **Metrics** or **Product events**. Pick an aggregation, add filters and a group-by, and combine queries with a formula.
 - **Raw SQL** runs your own SQL. The query must reference `$__orgFilter`. See the [SQL reference](/docs/reference/sql).
+- **Google Cloud** charts a PromQL query over your Google Cloud Monitoring metrics, read live from Google. It is there for line, area, bar, stat and gauge widgets and needs a [Google Cloud connection](/docs/integrations/gcp). See [Live queries](/docs/integrations/gcp#live-queries).
 
 The preview updates as you edit. Save the widget to put it on the dashboard.
 
@@ -112,7 +113,7 @@ Open **⋮ → Share…** and pick who can open the dashboard's link:
 | Anyone in this organization | Signed-in members of your organization, from the link.                            |
 | Anyone with the link        | Anyone who has the link, without signing in. They see the dashboard and its data. |
 
-**Replace** issues a new link and stops the old one working. Shared views render query builder charts, raw SQL, notes, funnels, paths, and the errors, service and logs widgets. The dialog names any widget that will not render for viewers.
+**Replace** issues a new link and stops the old one working. Shared views render query builder charts, raw SQL, Google Cloud PromQL charts, notes, funnels, paths, and the errors, service and logs widgets. The dialog names any widget that will not render for viewers.
 
 To put a single chart into another page, see [Embed dashboard charts](/docs/dashboards/embed-charts).
 
diff --git a/apps/landing/src/content/docs/integrations/gcp.md b/apps/landing/src/content/docs/integrations/gcp.md
index 0122264a08..5da649c46b 100644
--- a/apps/landing/src/content/docs/integrations/gcp.md
+++ b/apps/landing/src/content/docs/integrations/gcp.md
@@ -514,6 +514,30 @@ Until a connection's setup script has run, the page reads **Finish setting up Go
 
 With **Key metrics** off on every connection, the page leaves the sidebar and the overview. Its address still opens it: for a time range with data it shows the service tabs with what Maple collected before, under the notice **Google Cloud metrics are switched off**, and otherwise it reads **Turn on metrics for Google Cloud**. The **Resources** tab is back once a connection collects again.
 
+## Live queries
+
+A dashboard widget can chart any Cloud Monitoring metric with a PromQL query, read from Google each time the widget loads. Nothing is stored in Maple. Live queries work on every connection, with **Key metrics** on or off, once its setup script has run.
+
+To add one, edit a widget, choose a line, area, bar, stat or gauge panel, and pick **Google Cloud** as the source. **Start from a metric** searches the metric names of your projects and writes a starter query for the one you pick: a rate for counters, an average for gauges, the 95th percentile for distributions. Click **Run preview** to read it.
+
+Write metric names in PromQL's UTF-8 form, in quotes inside the braces:
+
+```promql
+sum by (project_id, service_name) (rate({"run.googleapis.com/request_count", monitored_resource="cloud_run_revision"}[5m]))
+```
+
+- A metric written by more than one resource type needs a `monitored_resource` matcher, as above. Without it Google refuses the query and the widget shows Google's message.
+- A distribution metric is three series: `_bucket`, `_count` and `_sum`. For a percentile, use `histogram_quantile(0.95, sum by (project_id, le) (rate({"run.googleapis.com/request_latencies_bucket"}[5m])))`.
+- **Legend** names each series from its labels, for example `{{service_name}}`. Without one, a series is named after all its labels.
+- Dashboard variables go inside a quoted regex matcher: `service_name=~"$service"`. **All** becomes `checkout|cart|…`, which `=~` matches.
+- A stat or gauge reduces the series to one number by its **Aggregate**: write a query that returns one series, such as `sum(…)` without `by`.
+
+Maple runs the query once per project and every series carries a `project_id` label, so an aggregation such as `sum` adds up within a project, never across projects. A query reads up to 20 projects: with more, list the projects to read in **Projects**. An answer holds up to 500 series across its projects; past that the widget asks you to aggregate with `sum by` or `avg by`, or to narrow the selector. When some projects could not be read, the widget shows the rest and names the ones missing under the chart.
+
+Data arrives in Cloud Monitoring within about 2 minutes. How far back a query reaches is Google's retention: 24 months for Compute Engine, GKE, Cloud SQL and a few other services, six weeks for most other Google Cloud metrics. See **Data retention** in [Cloud Monitoring quotas and limits](https://cloud.google.com/monitoring/quotas). A widget shared through a link runs its saved query; viewers can change the time range and dashboard variables, not the query.
+
+Google bills the time series each read returns to your Google Cloud project, separately from your Maple plan. Maple caches each answer for a minute, and older time ranges for 10 minutes. Aggregating with `sum by` or `avg by` returns fewer series and costs less. See [Google Cloud Observability pricing](https://cloud.google.com/stackdriver/pricing).
+
 ## Google Cloud costs
 
 Google bills Pub/Sub and Cloud Monitoring usage to your account, separately from your Maple plan.
diff --git a/apps/web/perf/check-bundle-budget.ts b/apps/web/perf/check-bundle-budget.ts
index e61f92a544..c39c0bfc38 100644
--- a/apps/web/perf/check-bundle-budget.ts
+++ b/apps/web/perf/check-bundle-budget.ts
@@ -115,9 +115,10 @@ const gzipBytes = chunks.reduce((total, chunk) => total + chunk.gzipBytes, 0)
 // /infra/gcp pages stay in their route chunks.
 // 702.5 KB from the PromQL query contract (#1475, 2026-10-15), measured in CI at 701.3.
 // 703.5 KB from the connection access settings (#1477, 2026-10-15), measured in CI at 702.1.
-// 707.5 KB with the Google Cloud page redesign (#1336) merged up.
-// 708.5 KB with main's 1 KB from #1494, #1500, #1502 merged up the stack.
-const maxGzipBytes = 708.5 * 1024
+// 706 KB from the PromQL dashboard widget (#1480, 2026-10-15), measured in CI at 704.4.
+// 710 KB with the Google Cloud page redesign (#1336) merged up.
+// 711 KB with main's 1 KB from #1494, #1500, #1502 merged up the stack.
+const maxGzipBytes = 711 * 1024
 const budgetLabel = `${(maxGzipBytes / 1024).toFixed(1)} KB`
 
 // Anything lazy-only: chat, replay, and every dev-only lab surface. The
diff --git a/apps/web/src/api/warehouse/gcp-promql.ts b/apps/web/src/api/warehouse/gcp-promql.ts
new file mode 100644
index 0000000000..2360636225
--- /dev/null
+++ b/apps/web/src/api/warehouse/gcp-promql.ts
@@ -0,0 +1,67 @@
+import { Effect, Schema } from "effect"
+import { GcpPromQlRangeRequest } from "@maple/domain/http"
+import { promQlRangeInput, promQlWidgetData } from "@maple/query-engine"
+import { MapleInternalAtomClient } from "@/lib/services/common/internal-atom-client"
+import {
+	WarehouseDateTimeString,
+	decodeInput,
+	invalidWarehouseInput,
+	runWarehouseQuery,
+} from "@/api/warehouse/effect-utils"
+
+// Live Google Cloud Monitoring reads through the API's PromQL proxy (widget data source
+// `gcp_promql`). Nothing comes from the warehouse; the API edge-caches each answer.
+
+const PromQlChartInput = Schema.Struct({
+	promql: Schema.String,
+	projects: Schema.optional(Schema.Array(Schema.String)),
+	legend: Schema.optional(Schema.String),
+	startTime: WarehouseDateTimeString,
+	endTime: WarehouseDateTimeString,
+})
+
+/** A PromQL range query as chart rows, plus a one-line notice when some projects could not be read. */
+export const getGcpPromQlChart = Effect.fn("Integrations.getGcpPromQlChart")(function* ({
+	data,
+}: {
+	data: (typeof PromQlChartInput)["Encoded"]
+}) {
+	const input = yield* decodeInput(PromQlChartInput, data, "getGcpPromQlChart")
+	// A bad project id or an over-long query is the author's to fix, not a support case.
+	const payload = yield* Schema.decodeUnknownEffect(GcpPromQlRangeRequest)(
+		promQlRangeInput(input, input),
+	).pipe(Effect.catch((error) => invalidWarehouseInput("gcpPromQlRangeRequest", error.message)))
+	const result = yield* runWarehouseQuery("gcpPromQlQueryRange", () =>
+		Effect.gen(function* () {
+			const client = yield* MapleInternalAtomClient
+			return yield* client.integrations.gcpPromQlQueryRange({ payload })
+		}),
+	)
+	return promQlWidgetData(result, input.legend, true)
+})
+
+/** Metric names containing `search`, for the PromQL editor's metric picker. */
+export const getGcpMetricSearch = Effect.fn("Integrations.getGcpMetricSearch")(function* ({
+	data,
+}: {
+	data: { readonly search: string }
+}) {
+	return yield* runWarehouseQuery("gcpMetricSearch", () =>
+		Effect.gen(function* () {
+			const client = yield* MapleInternalAtomClient
+			return yield* client.integrations.gcpMetricSearch({ query: { search: data.search, limit: 50 } })
+		}),
+	)
+})
+
+/** What a starter query needs to know about a metric. */
+export const getGcpMetricDescriptor = Effect.fn("Integrations.getGcpMetricDescriptor")(function* (
+	type: string,
+) {
+	return yield* runWarehouseQuery("gcpMetricDescribe", () =>
+		Effect.gen(function* () {
+			const client = yield* MapleInternalAtomClient
+			return yield* client.integrations.gcpMetricDescribe({ query: { type } })
+		}),
+	)
+})
diff --git a/apps/web/src/components/dashboard-builder/config/promql-editor-panel.tsx b/apps/web/src/components/dashboard-builder/config/promql-editor-panel.tsx
new file mode 100644
index 0000000000..7862253c79
--- /dev/null
+++ b/apps/web/src/components/dashboard-builder/config/promql-editor-panel.tsx
@@ -0,0 +1,207 @@
+import { type Dispatch, type SetStateAction, useDeferredValue, useState } from "react"
+import { Effect, Exit } from "effect"
+import { promQlStarterQuery } from "@maple/query-engine"
+import { Badge } from "@maple/ui/components/ui/badge"
+import { Button } from "@maple/ui/components/ui/button"
+import {
+	Combobox,
+	ComboboxContent,
+	ComboboxInput,
+	ComboboxItem,
+	ComboboxList,
+} from "@maple/ui/components/ui/combobox"
+import { EmptyMessage } from "@maple/ui/components/ui/empty"
+import { Field, FieldLabel } from "@maple/ui/components/ui/field"
+import { Input } from "@maple/ui/components/ui/input"
+import { TONE_TEXT } from "@maple/ui/lib/tone"
+import { cn } from "@maple/ui/lib/utils"
+import { getGcpMetricDescriptor } from "@/api/warehouse/gcp-promql"
+import { useAsyncAction } from "@/hooks/use-mutation-action"
+import { displayError } from "@/lib/error-messages"
+import { Result, useAtomValue } from "@/lib/effect-atom"
+import { disabledResultAtom } from "@/lib/services/atoms/disabled-result-atom"
+import { gcpMetricSearchResultAtom } from "@/lib/services/atoms/warehouse-query-atoms"
+
+/** The editor's form. `projects` stays the typed text until it is saved. */
+export interface PromQlDraft {
+	query: string
+	projects: string
+	legend: string
+}
+
+/** Project ids from the comma- or space-separated field; none means every project. */
+export const parsePromQlProjects = (text: string): ReadonlyArray<string> =>
+	text.split(/[\s,]+/u).filter((projectId) => projectId !== "")
+
+interface PromQlEditorPanelProps {
+	draft: PromQlDraft
+	onDraftChange: Dispatch<SetStateAction<PromQlDraft>>
+	onRunPreview: () => void
+	/** The draft differs from what the preview last ran. */
+	stale: boolean
+	/** The preview's failure, e.g. Google's message for a query it refused. */
+	error?: { title: string; message?: string }
+}
+
+export function PromQlEditorPanel({
+	draft,
+	onDraftChange,
+	onRunPreview,
+	stale,
+	error,
+}: PromQlEditorPanelProps) {
+	const [search, setSearch] = useState("")
+	const deferredSearch = useDeferredValue(search.trim())
+	const searchResult = useAtomValue(
+		deferredSearch === ""
+			? disabledResultAtom()
+			: gcpMetricSearchResultAtom({ data: { search: deferredSearch } }),
+	)
+	const metrics = Result.builder(searchResult)
+		.onSuccess((response) => (response as { metrics: ReadonlyArray<string> }).metrics)
+		.orElse((): ReadonlyArray<string> => [])
+	const searchHint =
+		deferredSearch === ""
+			? "Type part of a metric name."
+			: Result.builder(searchResult)
+					.onError((searchError) => displayError(searchError).message)
+					.onSuccess(() => `No metric name contains "${deferredSearch}".`)
+					.orElse(() => "Searching...")
+
+	const [starterError, setStarterError] = useState<string | null>(null)
+	const [insertStarter, inserting] = useAsyncAction(async (metric: string) => {
+		setStarterError(null)
+		const exit = await Effect.runPromiseExit(getGcpMetricDescriptor(metric))
+		if (Exit.isFailure(exit)) {
+			setStarterError(displayError(exit.cause).message)
+			return
+		}
+		const query = promQlStarterQuery(metric, exit.value)
+		onDraftChange((current) => ({ ...current, query }))
+	})
+
+	return (
+		<div className="space-y-3">
+			<div className="border rounded-md">
+				<div className="flex items-center gap-2 px-3 py-2 bg-muted/30">
+					<Badge
+						variant="outline"
+						className="font-mono text-2xs text-white border-0 shrink-0 bg-primary/80"
+					>
+						promql
+					</Badge>
+					<span className="text-2xs text-muted-foreground shrink-0">
+						Google Cloud Monitoring, live
+					</span>
+					<div className="flex-1" />
+					{error && (
+						<span
+							className={cn("text-2xs truncate", TONE_TEXT.crit)}
+							title={error.message ?? error.title}
+						>
+							{error.title}
+						</span>
+					)}
+				</div>
+
+				<div className="p-3 space-y-3">
+					<Field className="gap-1.5">
+						<FieldLabel className="font-normal text-2xs text-muted-foreground">
+							Start from a metric: picking one replaces the query below
+						</FieldLabel>
+						<Combobox<string | null>
+							value={null}
+							onValueChange={(metric) => {
+								if (typeof metric === "string") void insertStarter(metric)
+							}}
+						>
+							<ComboboxInput
+								placeholder={
+									inserting
+										? "Writing a starter query..."
+										: "Search metrics, e.g. run.googleapis.com"
+								}
+								className="h-8 text-xs"
+								disabled={inserting}
+								onChange={(e) => setSearch(e.target.value)}
+							/>
+							<ComboboxContent>
+								{metrics.length === 0 ? (
+									<EmptyMessage className="px-3 py-4">{searchHint}</EmptyMessage>
+								) : (
+									<ComboboxList>
+										{metrics.map((metric) => (
+											<ComboboxItem
+												key={metric}
+												value={metric}
+												className="font-mono text-xs"
+											>
+												{metric}
+											</ComboboxItem>
+										))}
+									</ComboboxList>
+								)}
+							</ComboboxContent>
+						</Combobox>
+						{starterError !== null && (
+							<span className={cn("text-2xs", TONE_TEXT.crit)}>{starterError}</span>
+						)}
+					</Field>
+
+					<textarea
+						aria-label="PromQL query"
+						value={draft.query}
+						onChange={(e) => onDraftChange({ ...draft, query: e.target.value })}
+						spellCheck={false}
+						placeholder={'sum by (service) (rate({"run.googleapis.com/request_count"}[5m]))'}
+						className="w-full bg-transparent font-mono text-xs leading-5 border border-border rounded-sm px-2 py-1.5 min-h-[120px] resize-y outline-none focus:ring-1 focus:ring-foreground/20"
+					/>
+					{error?.message && (
+						<p className="font-mono text-2xs text-muted-foreground whitespace-pre-wrap break-words">
+							{error.message}
+						</p>
+					)}
+
+					<div className="grid grid-cols-2 gap-3">
+						<Field className="gap-1.5">
+							<FieldLabel className="font-normal text-2xs text-muted-foreground">
+								Projects (empty: every project, up to 20)
+							</FieldLabel>
+							<Input
+								value={draft.projects}
+								onChange={(e) => onDraftChange({ ...draft, projects: e.target.value })}
+								placeholder="shop-prod, shop-staging"
+								className="h-8 font-mono text-xs"
+							/>
+						</Field>
+						<Field className="gap-1.5">
+							<FieldLabel className="font-normal text-2xs text-muted-foreground">
+								Legend (labels as {"{{label}}"})
+							</FieldLabel>
+							<Input
+								value={draft.legend}
+								onChange={(e) => onDraftChange({ ...draft, legend: e.target.value })}
+								placeholder="{{service}}"
+								className="h-8 font-mono text-xs"
+							/>
+						</Field>
+					</div>
+				</div>
+			</div>
+
+			<div className="flex items-center gap-3">
+				<Button size="sm" onClick={onRunPreview} disabled={draft.query.trim() === ""}>
+					Run preview
+				</Button>
+				{stale && (
+					<span className={cn("text-2xs", TONE_TEXT.warn)}>
+						Edited since the last run: the preview applies on Run preview
+					</span>
+				)}
+				<span className="text-2xs text-muted-foreground ml-auto">
+					Google bills the series a read returns to your project.
+				</span>
+			</div>
+		</div>
+	)
+}
diff --git a/apps/web/src/components/dashboard-builder/config/settings-fields.tsx b/apps/web/src/components/dashboard-builder/config/settings-fields.tsx
index e5d2bc8014..c18c07f79c 100644
--- a/apps/web/src/components/dashboard-builder/config/settings-fields.tsx
+++ b/apps/web/src/components/dashboard-builder/config/settings-fields.tsx
@@ -22,7 +22,7 @@ import { useDashboardTimeRange } from "@/components/dashboard-builder/dashboard-
 import { resolveTimeRange } from "@/atoms/dashboard-time-range-atoms"
 import { WidgetBuilderForm } from "@/atoms/widget-query-builder-atoms"
 import { useAtom } from "@/lib/effect-atom"
-import { PANEL_TYPES, fromPanelType, toPanelType } from "@/lib/query-builder/panel-types"
+import { PANEL_TYPES, PROMQL_PANEL_TYPES, fromPanelType, toPanelType } from "@/lib/query-builder/panel-types"
 import { reconcileFunnelSource } from "@/components/dashboard-builder/config/funnel-source"
 import {
 	STAT_AGGREGATES,
@@ -42,8 +42,8 @@ import {
 
 export type LegendPosition = "bottom" | "right" | "hidden"
 
-/** Raw SQL mode hides settings that are built from query-builder state. */
-type SourceMode = "builder" | "rawSql"
+/** Raw SQL and PromQL modes hide settings that are built from query-builder state. */
+export type SourceMode = "builder" | "rawSql" | "promql"
 
 const SourceModeContext = createContext<SourceMode>("builder")
 
@@ -162,14 +162,18 @@ function Description() {
 }
 
 function TypePicker() {
-	const { state, set } = useSettings()
+	const { state, sourceMode, set } = useSettings()
 	const panelType = toPanelType(state.visualization, state.chartId)
 	return (
 		<RailSetting label="Type">
 			{/* Three columns, not four: "Histogram" overflows a quarter of the
 			    272px rail and collides with its neighbour. */}
 			<SegmentedSelect
-				options={PANEL_TYPES}
+				options={
+					sourceMode === "promql"
+						? PANEL_TYPES.filter((option) => PROMQL_PANEL_TYPES.has(option.value))
+						: PANEL_TYPES
+				}
 				value={panelType}
 				onChange={(next) => set(fromPanelType(next, state.chartId))}
 				size="sm"
@@ -397,7 +401,7 @@ function Legend({ seriesStats = true }: { seriesStats?: boolean }) {
 
 /** How the timeseries a stat or gauge reads is reduced to one number. */
 function ScalarReduction() {
-	const { state, seriesFieldOptions, set } = useSettings()
+	const { state, seriesFieldOptions, sourceMode, set } = useSettings()
 	// A widget whose queries changed can hold a value field that no longer
 	// exists; fall back to the first series so the select is never blank.
 	const valueField =
@@ -426,23 +430,25 @@ function ScalarReduction() {
 					</SelectContent>
 				</Select>
 			</RailSetting>
-			<RailSetting label="Value field">
-				<Select
-					value={valueField || seriesFieldOptions[0]}
-					onValueChange={(value) => set({ statValueField: value ?? "" })}
-				>
-					<SelectTrigger className="w-full">
-						<SelectValue placeholder="Select series" />
-					</SelectTrigger>
-					<SelectContent>
-						{seriesFieldOptions.map((field) => (
-							<SelectItem key={field} value={field}>
-								{field}
-							</SelectItem>
-						))}
-					</SelectContent>
-				</Select>
-			</RailSetting>
+			{sourceMode === "builder" && (
+				<RailSetting label="Value field">
+					<Select
+						value={valueField || seriesFieldOptions[0]}
+						onValueChange={(value) => set({ statValueField: value ?? "" })}
+					>
+						<SelectTrigger className="w-full">
+							<SelectValue placeholder="Select series" />
+						</SelectTrigger>
+						<SelectContent>
+							{seriesFieldOptions.map((field) => (
+								<SelectItem key={field} value={field}>
+									{field}
+								</SelectItem>
+							))}
+						</SelectContent>
+					</Select>
+				</RailSetting>
+			)}
 		</>
 	)
 }
diff --git a/apps/web/src/components/dashboard-builder/config/widget-query-builder-page.tsx b/apps/web/src/components/dashboard-builder/config/widget-query-builder-page.tsx
index 40e286d4c5..818209bcc0 100644
--- a/apps/web/src/components/dashboard-builder/config/widget-query-builder-page.tsx
+++ b/apps/web/src/components/dashboard-builder/config/widget-query-builder-page.tsx
@@ -1,6 +1,12 @@
 import * as React from "react"
 import { widgetTypeByVisualization } from "@maple/domain/http"
-import { dataSourceRawSql, dataSourceTransform, makeRawSqlDataSource } from "@maple/widgets/dashboard"
+import {
+	dataSourcePromQl,
+	dataSourceRawSql,
+	dataSourceTransform,
+	makePromQlDataSource,
+	makeRawSqlDataSource,
+} from "@maple/widgets/dashboard"
 
 import { Eyebrow } from "@maple/ui/components/ui/eyebrow"
 import { FieldError } from "@maple/ui/components/ui/field"
@@ -18,11 +24,17 @@ import {
 	RawSqlEditorPanel,
 	type RawSqlDraft,
 } from "@/components/dashboard-builder/config/raw-sql-editor-panel"
+import {
+	PromQlEditorPanel,
+	parsePromQlProjects,
+	type PromQlDraft,
+} from "@/components/dashboard-builder/config/promql-editor-panel"
 import type {
 	DashboardWidget,
 	TimeRange,
 	VisualizationType,
 	WidgetDataSource,
+	WidgetDataState,
 	WidgetDisplayConfig,
 } from "@/components/dashboard-builder/types"
 import { WidgetTimeRangeProvider } from "@/components/dashboard-builder/widgets/widget-time-range-context"
@@ -31,7 +43,7 @@ import { useDashboardTimeRange } from "@/components/dashboard-builder/dashboard-
 import { useWidgetData } from "@/hooks/use-widget-data"
 import { useWidgetMaxDataPoints } from "@/hooks/use-widget-max-data-points"
 import { resolveTimeRange } from "@/atoms/dashboard-time-range-atoms"
-import { toPanelType } from "@/lib/query-builder/panel-types"
+import { PROMQL_PANEL_TYPES, toPanelType } from "@/lib/query-builder/panel-types"
 import { computeBucketSecondsForWidthRange, formatBucketSecondsShort } from "@maple/query-engine"
 import { useWidgetBuilder } from "@/hooks/use-widget-builder"
 import { useWidgetBuilderData } from "@/hooks/use-widget-builder-data"
@@ -47,7 +59,10 @@ import {
 	buildWidgetDisplay,
 	inferDefaultUnitForQueries,
 } from "@/lib/query-builder/widget-builder-utils"
-import { isProductEventsFunnel } from "@/lib/query-builder/widget-builder-shared"
+import {
+	isProductEventsFunnel,
+	type QueryBuilderWidgetState,
+} from "@/lib/query-builder/widget-builder-shared"
 import { reconcileFunnelSource } from "@/components/dashboard-builder/config/funnel-source"
 import { RAW_SQL_TEMPLATES, visualizationToDisplayType } from "@/lib/raw-sql/templates"
 
@@ -72,13 +87,11 @@ interface WidgetQueryBuilderPageProps {
 // as charts in the editor while rendering correctly once saved.
 const WidgetPreview = React.memo(function WidgetPreview({
 	widget,
-	maxDataPoints,
+	dataState,
 }: {
 	widget: DashboardWidget
-	/** From the measured preview pane — see `useWidgetMaxDataPoints`. */
-	maxDataPoints: number
+	dataState: WidgetDataState
 }) {
-	const { dataState } = useWidgetData(widget, true, { maxDataPoints })
 	const Visualization = visualizationFor(widget.visualization)
 
 	// Same provider the canvas wraps a tile in, so the preview's secondary
@@ -91,7 +104,7 @@ const WidgetPreview = React.memo(function WidgetPreview({
 	)
 })
 
-type SourceMode = "builder" | "rawSql"
+type SourceMode = "builder" | "rawSql" | "promql"
 
 function readRawSqlDraftFromWidget(widget: DashboardWidget): RawSqlDraft {
 	const rawSql = dataSourceRawSql(widget.dataSource)
@@ -138,6 +151,35 @@ function buildRawSqlDataSource(
 	})
 }
 
+function readPromQlDraftFromWidget(widget: DashboardWidget): PromQlDraft {
+	const promQl = dataSourcePromQl(widget.dataSource)
+	return {
+		query: promQl?.query ?? "",
+		projects: promQl?.projects?.join(", ") ?? "",
+		legend: promQl?.legend ?? "",
+	}
+}
+
+/** The `promql` data source. A stat or gauge reduces the series by the rail's Aggregate. */
+function buildPromQlDataSource(
+	widget: DashboardWidget,
+	draft: PromQlDraft,
+	state: Pick<QueryBuilderWidgetState, "visualization" | "statAggregate">,
+): WidgetDataSource {
+	const existingTransform = dataSourceTransform(widget.dataSource)
+	const transform =
+		widgetTypeByVisualization(state.visualization)?.isScalar === true
+			? { ...existingTransform, reduceToValue: { field: "value", aggregate: state.statAggregate } }
+			: existingTransform
+	const projects = parsePromQlProjects(draft.projects)
+	return makePromQlDataSource({
+		query: draft.query,
+		...(projects.length > 0 ? { projects } : undefined),
+		...(draft.legend.trim() !== "" ? { legend: draft.legend } : undefined),
+		...(transform === undefined ? undefined : { transform }),
+	})
+}
+
 export function WidgetQueryBuilderPage({
 	widget,
 	onApply,
@@ -175,7 +217,12 @@ export function WidgetQueryBuilderPage({
 		actions: { setTimeRange },
 	} = useDashboardTimeRange()
 
-	const initialMode: SourceMode = dataSourceRawSql(widget.dataSource) !== null ? "rawSql" : "builder"
+	const initialMode: SourceMode =
+		dataSourceRawSql(widget.dataSource) !== null
+			? "rawSql"
+			: dataSourcePromQl(widget.dataSource) !== null
+				? "promql"
+				: "builder"
 	const [chosenMode, setMode] = React.useState<SourceMode>(initialMode)
 	// A paths widget has no SQL rendering and hides the source toggle, so a
 	// raw-SQL widget switched to Paths would otherwise be stuck building SQL.
@@ -209,10 +256,25 @@ export function WidgetQueryBuilderPage({
 	// shouldn't refire the SQL on every keystroke.
 	const [rawSqlPreviewDraft, setRawSqlPreviewDraft] = React.useState<RawSqlDraft>(initialRawSqlDraft)
 
+	// PromQL previews on Run preview too: every read is a billed Google call.
+	const initialPromQlDraft = React.useMemo(() => readPromQlDraftFromWidget(widget), [widget])
+	const [promQlDraft, setPromQlDraft] = React.useState<PromQlDraft>(initialPromQlDraft)
+	const initialPromQlSnapshotRef = React.useRef<PromQlDraft>(initialPromQlDraft)
+	const [promQlPreviewDraft, setPromQlPreviewDraft] = React.useState<PromQlDraft>(initialPromQlDraft)
+
 	const previewWidget = React.useMemo(() => {
 		// The override applies live from the editing state — it costs nothing to
 		// re-resolve and a pinned window you can't see until you save is a trap.
 		const timeRange = state.timeRange ?? undefined
+		if (mode === "promql") {
+			return {
+				...widget,
+				timeRange,
+				visualization: state.visualization,
+				dataSource: buildPromQlDataSource(widget, promQlPreviewDraft, state),
+				display: buildWidgetDisplay(widget, state),
+			}
+		}
 		if (mode === "rawSql") {
 			return {
 				...widget,
@@ -255,7 +317,18 @@ export function WidgetQueryBuilderPage({
 			dataSource: buildWidgetDataSource(widget, previewState, previewSeriesOptions),
 			display: buildWidgetDisplay(widget, previewState),
 		}
-	}, [mode, rawSqlPreviewDraft, stagedState, state, widget])
+	}, [mode, rawSqlPreviewDraft, promQlPreviewDraft, stagedState, state, widget])
+
+	const { dataState: previewDataState } = useWidgetData(previewWidget, true, {
+		maxDataPoints: previewMaxDataPoints,
+	})
+	// Setup states (no query yet, not connected) show muted on the preview, not as an editor error.
+	const promQlError =
+		previewDataState.status === "error" &&
+		previewDataState.kind !== "empty" &&
+		previewDataState.kind !== "config"
+			? { title: previewDataState.title ?? "Unable to load", message: previewDataState.message }
+			: undefined
 
 	// Raw SQL must reference $__orgFilter — every query is tenant-scoped through
 	// that macro. Surfaced as a normal validation message; it used to make Apply a
@@ -266,6 +339,15 @@ export function WidgetQueryBuilderPage({
 			: null
 
 	const applyChanges = () => {
+		if (mode === "promql") {
+			onApply({
+				visualization: state.visualization,
+				dataSource: buildPromQlDataSource(widget, promQlDraft, state),
+				display: buildWidgetDisplay(widget, state),
+				timeRange: state.timeRange ?? undefined,
+			})
+			return
+		}
 		if (mode === "rawSql") {
 			if (rawSqlError) return
 			onApply({
@@ -296,6 +378,9 @@ export function WidgetQueryBuilderPage({
 			if (mode === "rawSql") {
 				return JSON.stringify(rawSqlDraft) !== JSON.stringify(initialRawSqlSnapshotRef.current)
 			}
+			if (mode === "promql") {
+				return JSON.stringify(promQlDraft) !== JSON.stringify(initialPromQlSnapshotRef.current)
+			}
 			return false
 		},
 	}))
@@ -417,6 +502,8 @@ export function WidgetQueryBuilderPage({
 	// Paths read product events only; neither a query set nor raw SQL applies.
 	const isPaths = state.visualization === "paths"
 	const showSourceToggle = !isList && !isMarkdown && !isPaths
+	// PromQL answers are time series: offered for the panels that draw one.
+	const promQlAvailable = PROMQL_PANEL_TYPES.has(toPanelType(state.visualization, state.chartId))
 
 	return (
 		<div className="animate-in fade-in slide-in-from-bottom-2 duration-200 flex flex-1 min-h-0 -m-4">
@@ -450,11 +537,7 @@ export function WidgetQueryBuilderPage({
 					    the previous slices on top of the new ones. */}
 					{/* Matches a default chart tile on the canvas (h:6 → 6*60 + 5*12). */}
 					<div ref={previewRef} className="h-[420px]">
-						<WidgetPreview
-							key={mode}
-							widget={previewWidget}
-							maxDataPoints={previewMaxDataPoints}
-						/>
+						<WidgetPreview key={mode} widget={previewWidget} dataState={previewDataState} />
 					</div>
 				</div>
 
@@ -467,12 +550,23 @@ export function WidgetQueryBuilderPage({
 								<TabsList>
 									<TabsTrigger value="builder">Query Builder</TabsTrigger>
 									<TabsTrigger value="rawSql">Raw SQL</TabsTrigger>
+									{(promQlAvailable || mode === "promql") && (
+										<TabsTrigger value="promql">Google Cloud</TabsTrigger>
+									)}
 								</TabsList>
 							</Tabs>
 						</div>
 					)}
 
-					{mode === "rawSql" && showSourceToggle ? (
+					{mode === "promql" && showSourceToggle ? (
+						<PromQlEditorPanel
+							draft={promQlDraft}
+							onDraftChange={setPromQlDraft}
+							onRunPreview={() => setPromQlPreviewDraft(promQlDraft)}
+							stale={JSON.stringify(promQlDraft) !== JSON.stringify(promQlPreviewDraft)}
+							error={promQlError}
+						/>
+					) : mode === "rawSql" && showSourceToggle ? (
 						<>
 							{rawSqlError && (
 								<FieldError match className="font-medium">
diff --git a/apps/web/src/components/dashboard-builder/config/widget-settings-bar.tsx b/apps/web/src/components/dashboard-builder/config/widget-settings-bar.tsx
index 1aee064d02..631dcb5edf 100644
--- a/apps/web/src/components/dashboard-builder/config/widget-settings-bar.tsx
+++ b/apps/web/src/components/dashboard-builder/config/widget-settings-bar.tsx
@@ -1,5 +1,9 @@
 import { Eyebrow } from "@maple/ui/components/ui/eyebrow"
-import { SettingsSourceMode, WidgetSettings } from "@/components/dashboard-builder/config/settings-fields"
+import {
+	SettingsSourceMode,
+	type SourceMode,
+	WidgetSettings,
+} from "@/components/dashboard-builder/config/settings-fields"
 import { widgetTypes } from "@/components/dashboard-builder/widgets/types"
 import { useWidgetBuilder } from "@/hooks/use-widget-builder"
 import { toPanelType } from "@/lib/query-builder/panel-types"
@@ -13,7 +17,7 @@ import { toPanelType } from "@/lib/query-builder/panel-types"
  * — nine booleans that a tenth widget type would have had to thread through by
  * hand.
  */
-export function WidgetSettingsBar({ sourceMode = "builder" }: { sourceMode?: "builder" | "rawSql" }) {
+export function WidgetSettingsBar({ sourceMode = "builder" }: { sourceMode?: SourceMode }) {
 	const { state } = useWidgetBuilder()
 	const { ConfigPanel } = widgetTypes[toPanelType(state.visualization, state.chartId)]
 
diff --git a/apps/web/src/components/dashboard-builder/data-source-registry.test.ts b/apps/web/src/components/dashboard-builder/data-source-registry.test.ts
index 84a0b23025..08b0a67fe3 100644
--- a/apps/web/src/components/dashboard-builder/data-source-registry.test.ts
+++ b/apps/web/src/components/dashboard-builder/data-source-registry.test.ts
@@ -115,6 +115,14 @@ describe("toWidgetRequest — curated routes", () => {
 	})
 })
 
+describe("toWidgetRequest — Google Cloud PromQL", () => {
+	it("lowers onto a server function that reads Google live", () => {
+		const request = toWidgetRequest({ kind: "promql", query: "up", projects: ["shop-prod"] })
+		expect(request).toEqual({ endpoint: "gcp_promql", params: { promql: "up", projects: ["shop-prod"] } })
+		expect(getServerFunction(request!.endpoint)).toBeDefined()
+	})
+})
+
 describe("toWidgetRequest — nothing to serve", () => {
 	it("returns null rather than a request that cannot resolve", () => {
 		// The hook reports this as a disabled tile. Returning a bogus endpoint
diff --git a/apps/web/src/components/dashboard-builder/data-source-registry.ts b/apps/web/src/components/dashboard-builder/data-source-registry.ts
index cce4d0b654..34949829f5 100644
--- a/apps/web/src/components/dashboard-builder/data-source-registry.ts
+++ b/apps/web/src/components/dashboard-builder/data-source-registry.ts
@@ -42,6 +42,13 @@ type ServerFunction = (opts: { data: any }) => Effect.Effect<any, ServerFunction
 
 const markdownStaticServerFn: ServerFunction = () => Effect.succeed({ data: null })
 
+// Loaded on first use: only Google Cloud tiles need it, and this registry ships in the startup bundle.
+const gcpPromQlServerFn: ServerFunction = (opts) =>
+	Effect.flatMap(
+		Effect.promise(() => import("@/api/warehouse/gcp-promql")),
+		(module) => module.getGcpPromQlChart(opts),
+	)
+
 export const serverFunctionMap: Record<DataSourceEndpoint, ServerFunction> = {
 	service_usage: getServiceUsage,
 	service_overview: getServiceOverview,
@@ -67,6 +74,7 @@ export const serverFunctionMap: Record<DataSourceEndpoint, ServerFunction> = {
 	custom_query_builder_breakdown: getQueryBuilderBreakdown,
 	custom_query_builder_list: getQueryBuilderList,
 	raw_sql_chart: getRawSqlChart,
+	gcp_promql: gcpPromQlServerFn,
 	product_events_funnel: getProductEventsFunnelWidget,
 	product_events_paths: getProductEventsPathsWidget,
 	markdown_static: markdownStaticServerFn,
diff --git a/apps/web/src/components/dashboard-builder/list/dashboard-summary.ts b/apps/web/src/components/dashboard-builder/list/dashboard-summary.ts
index e6a036a30f..9b22264e9d 100644
--- a/apps/web/src/components/dashboard-builder/list/dashboard-summary.ts
+++ b/apps/web/src/components/dashboard-builder/list/dashboard-summary.ts
@@ -5,7 +5,12 @@
 import { countLabel, EMPTY_VALUE } from "@maple/ui/lib/format"
 import type { DashboardSortOption } from "@/atoms/dashboard-preferences-atoms"
 import type { Dashboard } from "@/components/dashboard-builder/types"
-import { dataSourceEndpoint, dataSourceQuerySet, dataSourceRawSql } from "@maple/widgets/dashboard"
+import {
+	dataSourceEndpoint,
+	dataSourcePromQl,
+	dataSourceQuerySet,
+	dataSourceRawSql,
+} from "@maple/widgets/dashboard"
 
 export const widgetCountLabel = (dashboard: Dashboard): string =>
 	countLabel(dashboard.widgets.length, "widget")
@@ -67,10 +72,17 @@ const DRAFT_SOURCE_DOMAIN: Record<string, DashboardDomain> = {
  */
 const DEFAULT_QUERY_DOMAIN: DashboardDomain = "Traces"
 
-export type DashboardDomain = "Traces" | "Logs" | "Errors" | "Metrics" | "Raw SQL"
+export type DashboardDomain = "Traces" | "Logs" | "Errors" | "Metrics" | "Raw SQL" | "Google Cloud"
 
 /** Display order, so two dashboards reading the same signals label identically. */
-const DOMAIN_ORDER: ReadonlyArray<DashboardDomain> = ["Traces", "Logs", "Errors", "Metrics", "Raw SQL"]
+const DOMAIN_ORDER: ReadonlyArray<DashboardDomain> = [
+	"Traces",
+	"Logs",
+	"Errors",
+	"Metrics",
+	"Raw SQL",
+	"Google Cloud",
+]
 
 /** How many domains the lane shows before folding the rest into "+N". */
 const MAX_DOMAIN_TERMS = 2
@@ -78,6 +90,7 @@ const MAX_DOMAIN_TERMS = 2
 /** Every domain one widget reads. A multi-query chart can read more than one. */
 const widgetDomains = (dataSource: unknown): ReadonlyArray<DashboardDomain> => {
 	if (dataSourceRawSql(dataSource) !== null) return ["Raw SQL"]
+	if (dataSourcePromQl(dataSource) !== null) return ["Google Cloud"]
 
 	const querySet = dataSourceQuerySet(dataSource)
 	if (querySet !== null && querySet.queries.length > 0) {
diff --git a/apps/web/src/components/dashboard-builder/toolbar/share-support.test.ts b/apps/web/src/components/dashboard-builder/toolbar/share-support.test.ts
index debb5c2860..eff4de95fa 100644
--- a/apps/web/src/components/dashboard-builder/toolbar/share-support.test.ts
+++ b/apps/web/src/components/dashboard-builder/toolbar/share-support.test.ts
@@ -14,6 +14,7 @@ describe("unsupportedShareWidgets", () => {
 			widget("w1", { kind: "query", resultShape: "timeseries" }),
 			widget("w2", { kind: "raw_sql", sql: "select 1" }),
 			widget("w3", { kind: "static" }),
+			widget("w4", { kind: "promql", query: "up" }),
 		]
 		expect(unsupportedShareWidgets(widgets)).toEqual([])
 	})
diff --git a/apps/web/src/components/dashboard-builder/toolbar/share-support.ts b/apps/web/src/components/dashboard-builder/toolbar/share-support.ts
index 0b471bf7e1..840660b075 100644
--- a/apps/web/src/components/dashboard-builder/toolbar/share-support.ts
+++ b/apps/web/src/components/dashboard-builder/toolbar/share-support.ts
@@ -30,7 +30,7 @@ const SUPPORTED_ROUTE_ENDPOINTS = new Set([
 
 /** Prose for the dialog, so the copy and the list cannot disagree. */
 export const SHAREABLE_WIDGET_KINDS =
-	"query-builder charts, raw SQL, markdown, funnels, paths, and the errors, service and logs tiles"
+	"query-builder charts, raw SQL, Google Cloud PromQL, markdown, funnels, paths, and the errors, service and logs tiles"
 
 interface WidgetLike {
 	readonly id: string
@@ -43,7 +43,14 @@ const isSupported = (dataSource: unknown): boolean => {
 	const source = dataSource as { kind?: string; endpoint?: string }
 
 	// v3 kinds the server builds queries for directly.
-	if (source.kind === "query" || source.kind === "raw_sql" || source.kind === "static") return true
+	if (
+		source.kind === "query" ||
+		source.kind === "raw_sql" ||
+		source.kind === "static" ||
+		source.kind === "promql"
+	) {
+		return true
+	}
 
 	// A route source — v3 `kind: "route"` or a legacy v2 `{ endpoint }` with no
 	// kind at all — is supported only if its endpoint is on the allowlist.
diff --git a/apps/web/src/components/dashboard-builder/types.ts b/apps/web/src/components/dashboard-builder/types.ts
index 4ba5f382f5..7f749fe56e 100644
--- a/apps/web/src/components/dashboard-builder/types.ts
+++ b/apps/web/src/components/dashboard-builder/types.ts
@@ -60,6 +60,7 @@ export type DataSourceEndpoint =
 	| "custom_query_builder_breakdown"
 	| "custom_query_builder_list"
 	| "raw_sql_chart"
+	| "gcp_promql"
 	| "product_events_funnel"
 	| "product_events_paths"
 	| "markdown_static"
@@ -128,7 +129,8 @@ type WidgetErrorKind = "decode" | "runtime" | "range" | "config" | "empty"
 export type WidgetDataState =
 	| { status: "loading" }
 	| { status: "error"; title?: string; message?: string; kind?: WidgetErrorKind }
-	| { status: "ready"; data: unknown }
+	/** `notice`: a one-line caveat drawn under ready data, e.g. a partial answer. */
+	| { status: "ready"; data: unknown; notice?: string }
 
 // `timeRange` is re-typed for the same reason `Dashboard["timeRange"]` is: the
 // schema brands its ISO strings, and every producer in the UI (the time-range
diff --git a/apps/web/src/components/dashboard-builder/widgets/widget-shell.tsx b/apps/web/src/components/dashboard-builder/widgets/widget-shell.tsx
index 1e9ac7abc4..d3d9f9291e 100644
--- a/apps/web/src/components/dashboard-builder/widgets/widget-shell.tsx
+++ b/apps/web/src/components/dashboard-builder/widgets/widget-shell.tsx
@@ -392,7 +392,18 @@ export function WidgetFrame({
 			title={title}
 			mode={mode}
 			contentClassName={contentClassName}
-			footer={dataState.status === "ready" ? footer : undefined}
+			footer={
+				dataState.status !== "ready" ? undefined : dataState.notice === undefined ? (
+					footer
+				) : (
+					<>
+						<span className={cn("block truncate", TONE_TEXT.warn)} title={dataState.notice}>
+							{dataState.notice}
+						</span>
+						{footer}
+					</>
+				)
+			}
 		>
 			{dataState.status === "loading" ? (
 				loadingSkeleton
diff --git a/apps/web/src/hooks/use-share-dashboard.ts b/apps/web/src/hooks/use-share-dashboard.ts
index 8bd591cd7e..5636be719e 100644
--- a/apps/web/src/hooks/use-share-dashboard.ts
+++ b/apps/web/src/hooks/use-share-dashboard.ts
@@ -22,7 +22,7 @@
  * is to fail slightly earlier.
  */
 import type { WidgetDataState } from "@/components/dashboard-builder/types"
-import { toReadyWidgetData } from "@/hooks/use-widget-data"
+import { toReadyWidgetData, widgetDataNotice } from "@/hooks/use-widget-data"
 import { apiBaseUrl } from "@/lib/services/common/api-base-url"
 import { getMapleAuthHeaders } from "@/lib/services/common/auth-headers"
 import { ShareWidgetDataResponse } from "@maple/domain/http"
@@ -463,6 +463,7 @@ export function useShareWidgetData(
 									? {
 											status: "ready",
 											data: toReadyWidgetData(result.data, transforms.get(id)),
+											...widgetDataNotice(result.data),
 										}
 									: {
 											status: "error",
diff --git a/apps/web/src/hooks/use-widget-data.ts b/apps/web/src/hooks/use-widget-data.ts
index 35f523dd70..6999c6ec30 100644
--- a/apps/web/src/hooks/use-widget-data.ts
+++ b/apps/web/src/hooks/use-widget-data.ts
@@ -270,6 +270,19 @@ export function toReadyWidgetData(
 	return applyTransform(envelope?.data ?? response, transform)
 }
 
+/** The caveat a response carries beside its rows (a PromQL answer missing some projects). */
+export function widgetDataNotice(response: unknown): { notice?: string } {
+	const notice = (response as { notice?: unknown } | null | undefined)?.notice
+	return typeof notice === "string" ? { notice } : {}
+}
+
+// Google Cloud setup states, not failures: the tile says what to do next, muted.
+const GCP_SETUP_ERROR_CODES = new Set([
+	"integration_not_connected",
+	"gcp_promql_unavailable",
+	"gcp_promql_too_many_projects",
+])
+
 class WidgetDataAtomError extends Schema.TaggedError<WidgetDataAtomError>()(
 	"@maple/web/hooks/WidgetDataAtomError",
 	{
@@ -505,7 +518,9 @@ export function useWidgetDataSource(
 					: executed?.kind === "disabled"
 						? executed.reason === "metric_not_selected"
 							? "No metric selected"
-							: "Unable to resolve this widget's time range"
+							: executed.reason === "promql_query_empty"
+								? "No query yet"
+								: "Unable to resolve this widget's time range"
 						: !hasServerFn
 							? `Unknown data source endpoint: ${request.endpoint}`
 							: null
@@ -581,6 +596,14 @@ export function useWidgetDataSource(
 				message: "Pick a metric in the query editor to run this tile.",
 			} as const
 		}
+		if (executed?.kind === "disabled" && executed.reason === "promql_query_empty") {
+			return {
+				status: "error",
+				kind: "config",
+				title: "No query yet",
+				message: "Write a PromQL query in the editor to draw this tile.",
+			} as const
+		}
 		if (!dataSource) {
 			return {
 				status: "error",
@@ -618,8 +641,8 @@ export function useWidgetDataSource(
 						message: "No query data found in selected time range",
 					} as const
 				}
-				const { title, message } = displayError(error)
-				const kind = classifyWidgetErrorKind(error)
+				const { title, message, code } = displayError(error)
+				const kind = GCP_SETUP_ERROR_CODES.has(code) ? "config" : classifyWidgetErrorKind(error)
 				return { status: "error", title, message, kind } as const
 			})
 			.onSuccess((rawData) =>
@@ -631,7 +654,11 @@ export function useWidgetDataSource(
 							kind: "empty",
 							message: "No query data found in selected time range",
 						} as const)
-					: ({ status: "ready", data: toReadyWidgetData(rawData, transform) } as const),
+					: ({
+							status: "ready",
+							data: toReadyWidgetData(rawData, transform),
+							...widgetDataNotice(rawData),
+						} as const),
 			)
 			.orElse(() => ({ status: "error", message: "Unknown error" }) as const)
 	}, [
diff --git a/apps/web/src/lib/query-builder/panel-types.ts b/apps/web/src/lib/query-builder/panel-types.ts
index 2ab3ba8ddb..63b2e35963 100644
--- a/apps/web/src/lib/query-builder/panel-types.ts
+++ b/apps/web/src/lib/query-builder/panel-types.ts
@@ -29,6 +29,9 @@ export const PANEL_TYPES: ReadonlyArray<{ value: PanelType; label: string }> = W
 	(meta) => ({ value: meta.panelType, label: meta.label }),
 )
 
+/** Panels that draw a time series, the only answer a Google Cloud PromQL source gives. */
+export const PROMQL_PANEL_TYPES: ReadonlySet<PanelType> = new Set(["line", "area", "bar", "stat", "gauge"])
+
 /**
  * The chartId written when a panel type needs one. Every widget kind that mounts
  * a `chartRegistry` component gets its canonical `query-builder-*` entry so the
diff --git a/apps/web/src/lib/services/atoms/warehouse-query-atoms.ts b/apps/web/src/lib/services/atoms/warehouse-query-atoms.ts
index 0db032695d..5422f1336e 100644
--- a/apps/web/src/lib/services/atoms/warehouse-query-atoms.ts
+++ b/apps/web/src/lib/services/atoms/warehouse-query-atoms.ts
@@ -723,6 +723,17 @@ export const cloudflareTopTrafficResultAtom = makeQueryAtomFamily(getCloudflareT
 	staleTime: 60_000,
 })
 
+// Google Cloud metric names for the PromQL editor; the API caches each project's list for an hour.
+// The module loads with the editor, not at startup.
+export const gcpMetricSearchResultAtom = makeQueryAtomFamily(
+	(input: { readonly data: { readonly search: string } }) =>
+		Effect.flatMap(
+			Effect.promise(() => import("@/api/warehouse/gcp-promql")),
+			(module) => module.getGcpMetricSearch(input),
+		),
+	{ staleTime: 300_000 },
+)
+
 // Service-detail Overview tab bundle: primary chart + releases timeline +
 // environments in one fetch. The chart grid and the environment switcher read
 // this atom with the same input key, so they share a single round-trip.
diff --git a/packages/backend/src/services/dashboards/DashboardWidgetDataService.test.ts b/packages/backend/src/services/dashboards/DashboardWidgetDataService.test.ts
index d60add9a34..b5fb19ae57 100644
--- a/packages/backend/src/services/dashboards/DashboardWidgetDataService.test.ts
+++ b/packages/backend/src/services/dashboards/DashboardWidgetDataService.test.ts
@@ -1,7 +1,17 @@
 import { describe, expect, it } from "@effect/vitest"
-import { DashboardDocument, DashboardId, IsoDateTimeString, OrgId } from "@maple/domain/http"
+import {
+	DashboardDocument,
+	DashboardId,
+	GcpPromQlInvalidQueryError,
+	type GcpPromQlRangeRequest,
+	GcpPromQlResult,
+	IsoDateTimeString,
+	OrgId,
+} from "@maple/domain/http"
+import { GcpProjectId } from "@maple/domain/primitives"
 import { MAX_LIST_RANGE_SECONDS } from "@maple/query-engine"
 import { Effect, Layer, ManagedRuntime, Schema } from "effect"
+import { GcpPromQlService } from "@maple/backend/services/integrations/GcpPromQlService"
 import { QueryEngineService } from "@maple/backend/services/warehouse/QueryEngineService"
 import { WarehouseQueryService } from "@maple/backend/services/warehouse/WarehouseQueryService"
 import { DashboardWidgetDataService } from "./DashboardWidgetDataService"
@@ -9,6 +19,7 @@ import { DashboardWidgetDataService } from "./DashboardWidgetDataService"
 const asDashboardId = Schema.decodeUnknownSync(DashboardId)
 const asIsoDateTimeString = Schema.decodeUnknownSync(IsoDateTimeString)
 const asOrgId = Schema.decodeUnknownSync(OrgId)
+const asProjectId = Schema.decodeUnknownSync(GcpProjectId)
 
 const ORG = asOrgId("org_share_widgets")
 const NOW = asIsoDateTimeString(new Date("2026-01-01T00:00:00.000Z").toISOString())
@@ -25,6 +36,10 @@ const makeHarness = (
 	// execution-failure mapping is asserted, and pinning this to `never` forces
 	// the caller into a cast at exactly the point the test is about.
 	execute: (request: { startTime: string; endTime: string }) => Effect.Effect<unknown, unknown>,
+	queryRange: (
+		orgId: OrgId,
+		request: GcpPromQlRangeRequest,
+	) => Effect.Effect<GcpPromQlResult, unknown> = die,
 ) => {
 	const windows: Array<{ startTime: string; endTime: string }> = []
 	const queryEngine = Layer.succeed(QueryEngineService, {
@@ -41,9 +56,12 @@ const makeHarness = (
 	// oxlint-disable-next-line typescript/no-explicit-any
 	const warehouse = Layer.succeed(WarehouseQueryService, { rawSqlQuery: die } as any)
 
+	// oxlint-disable-next-line typescript/no-explicit-any
+	const gcpPromQl = Layer.succeed(GcpPromQlService, { queryRange } as any)
+
 	const runtime = ManagedRuntime.make(
 		Layer.effect(DashboardWidgetDataService, DashboardWidgetDataService.make).pipe(
-			Layer.provide(Layer.mergeAll(queryEngine, warehouse)),
+			Layer.provide(Layer.mergeAll(queryEngine, warehouse, gcpPromQl)),
 		),
 	)
 	return { runtime, windows }
@@ -252,4 +270,85 @@ describe("DashboardWidgetDataService", () => {
 		expect(windows[0]).toMatchObject({ startTime: WINDOW.startTime, endTime: WINDOW.endTime })
 		await runtime.dispose()
 	})
+
+	it("runs a PromQL tile's stored query for the share's org and window", async () => {
+		const requests: Array<{ orgId: OrgId; request: GcpPromQlRangeRequest }> = []
+		const { runtime } = makeHarness(die, (orgId, request) => {
+			requests.push({ orgId, request })
+			return Effect.succeed(
+				new GcpPromQlResult({
+					resultType: "matrix",
+					series: [
+						{
+							labels: { service: "checkout", project_id: "shop-prod" },
+							points: [[1_767_225_600, 4]],
+						},
+					],
+					projects: [asProjectId("shop-prod")],
+					failures: [{ scope: "projects/shop-staging", message: "Run the setup script again." }],
+				}),
+			)
+		})
+
+		const outcome = await runtime.runPromise(
+			DashboardWidgetDataService.use((service) =>
+				service.resolve(
+					ORG,
+					document([
+						widget("w-promql", {
+							kind: "promql",
+							query: 'sum by (service) (rate({"run.googleapis.com/request_count", service="$service"}[5m]))',
+							projects: ["shop-prod", "shop-staging"],
+						}),
+					]),
+					{ widgetId: "w-promql", source: "primary" },
+					{ startTime: "2026-01-01 00:00:00", endTime: "2026-01-01 06:00:00" },
+					{ service: { value: "checkout", isAll: false, options: [] } },
+				),
+			),
+		)
+
+		expect(requests).toHaveLength(1)
+		expect(requests[0]?.orgId).toBe(ORG)
+		expect(requests[0]?.request).toMatchObject({
+			query: 'sum by (service) (rate({"run.googleapis.com/request_count", service="checkout"}[5m]))',
+			startTime: "2026-01-01 00:00:00",
+			endTime: "2026-01-01 06:00:00",
+			stepSeconds: 300,
+			projects: ["shop-prod", "shop-staging"],
+		})
+		expect(outcome.data).toEqual({
+			data: [{ bucket: "2026-01-01T00:00:00.000Z", "service=checkout": 4 }],
+			// The share counts what failed: no project ids, no setup advice.
+			notice: "Partial result: 1 Google Cloud scope could not be read.",
+		})
+		await runtime.dispose()
+	})
+
+	it("keeps Google's refusal of a PromQL tile off the share", async () => {
+		const { runtime } = makeHarness(die, () =>
+			Effect.fail(
+				new GcpPromQlInvalidQueryError({
+					message: 'parse error near "internal_metric"',
+					projectId: asProjectId("shop-prod"),
+				}),
+			),
+		)
+
+		const outcome = await runtime.runPromise(
+			DashboardWidgetDataService.use((service) =>
+				service.resolve(
+					ORG,
+					document([widget("w-promql", { kind: "promql", query: "sum(internal_metric" })]),
+					{ widgetId: "w-promql", source: "primary" },
+					WINDOW,
+					{},
+				),
+			).pipe(Effect.flip),
+		)
+
+		expect(outcome._tag).toBe("@maple/http/errors/ShareWidgetExecutionError")
+		expect(outcome.message).not.toContain("internal_metric")
+		await runtime.dispose()
+	})
 })
diff --git a/packages/backend/src/services/dashboards/DashboardWidgetDataService.ts b/packages/backend/src/services/dashboards/DashboardWidgetDataService.ts
index 8d30e9f519..1c8626b379 100644
--- a/packages/backend/src/services/dashboards/DashboardWidgetDataService.ts
+++ b/packages/backend/src/services/dashboards/DashboardWidgetDataService.ts
@@ -29,6 +29,7 @@
 import {
 	type DashboardDocument,
 	type DashboardVariable,
+	GcpPromQlRangeRequest,
 	OrgId,
 	ShareUnsupportedWidgetError,
 	ShareWidgetExecutionError,
@@ -45,6 +46,8 @@ import {
 	formatWarehouseDateTime,
 	parseWarehouseDateTime,
 	planWidgetRequest,
+	promQlRangeInput,
+	promQlWidgetData,
 	rawSqlRowsForDisplay,
 	type PlannedWidgetRequest,
 	type VariableValues,
@@ -55,12 +58,14 @@ import type { WarehouseExecutionError } from "@maple/query-engine/execution"
 import type { RawSqlValidationError } from "@maple/domain/http"
 import {
 	dataSourceQuerySet,
+	GCP_PROMQL_ENDPOINT,
 	MARKDOWN_STATIC_ENDPOINT,
 	QUERY_RESULT_ENDPOINTS,
 	RAW_SQL_ENDPOINT,
 	toWidgetRequest,
 } from "@maple/widgets/dashboard"
 import { Context, Effect, Layer, Schema } from "effect"
+import { GcpPromQlService } from "@maple/backend/services/integrations/GcpPromQlService"
 import { QueryEngineService } from "@maple/backend/services/warehouse/QueryEngineService"
 import { WarehouseQueryService } from "@maple/backend/services/warehouse/WarehouseQueryService"
 import type { TenantContext } from "@maple/backend/services/auth/tenant-context"
@@ -186,6 +191,13 @@ const PlannedRawSqlParams = Schema.Struct({
 })
 const decodePlannedRawSql = Schema.decodeUnknownEffect(PlannedRawSqlParams)
 
+const PlannedPromQlParams = Schema.Struct({
+	promql: Schema.String,
+	projects: Schema.optionalKey(Schema.Array(Schema.String)),
+	legend: Schema.optionalKey(Schema.String),
+})
+const decodePlannedPromQl = Schema.decodeUnknownEffect(PlannedPromQlParams)
+
 /** The list cap applied to a window that exceeds it: last `MAX_LIST_RANGE_SECONDS` up to its end. */
 const narrowToListCap = (window: ResolvedWindow): ResolvedWindow => ({
 	startTime: formatWarehouseDateTime(
@@ -225,6 +237,7 @@ export class DashboardWidgetDataService extends Context.Service<
 	make: Effect.gen(function* () {
 		const queryEngine = yield* QueryEngineService
 		const warehouse = yield* WarehouseQueryService
+		const gcpPromQl = yield* GcpPromQlService
 
 		const resolve = Effect.fn("DashboardWidgetDataService.resolve")(function* (
 			orgId: OrgId,
@@ -293,7 +306,9 @@ export class DashboardWidgetDataService extends Context.Service<
 						message:
 							plan.reason === "metric_not_selected"
 								? "This widget has no metric selected."
-								: "This widget's own time range couldn't be resolved.",
+								: plan.reason === "promql_query_empty"
+									? "This widget has no query yet."
+									: "This widget's own time range couldn't be resolved.",
 						widgetId: request.widgetId,
 					}),
 				)
@@ -415,6 +430,22 @@ export class DashboardWidgetDataService extends Context.Service<
 				return outcome({ data: rows })
 			}
 
+			if (executed.endpoint === GCP_PROMQL_ENDPOINT) {
+				// The query and projects are the author's, off the stored document; the viewer moves
+				// only the window and the variable values (bounded by `share-variables.ts`). The
+				// request decode refuses a project id that is not one, and the service refuses a
+				// project outside this org's connections. Google's own error text stays off the share.
+				const data = yield* Effect.gen(function* () {
+					const params = yield* decodePlannedPromQl(executed.params)
+					const rangeRequest = yield* Schema.decodeUnknownEffect(GcpPromQlRangeRequest)(
+						promQlRangeInput(params, executed.window),
+					)
+					const result = yield* gcpPromQl.queryRange(orgId, rangeRequest)
+					return promQlWidgetData(result, params.legend, false)
+				}).pipe(asWidgetOutcomeFailure(request.widgetId, "promql"))
+				return outcome(data)
+			}
+
 			const routePlan = ROUTE_ENDPOINT_PLANS[executed.endpoint]
 			if (routePlan === undefined) {
 				return yield* Effect.fail(
@@ -498,7 +529,9 @@ export class DashboardWidgetDataService extends Context.Service<
 	}),
 }) {
 	static readonly layer = Layer.effect(this, this.make).pipe(
-		Layer.provide(Layer.mergeAll(WarehouseQueryService.layer, QueryEngineService.layer)),
+		Layer.provide(
+			Layer.mergeAll(WarehouseQueryService.layer, QueryEngineService.layer, GcpPromQlService.layer),
+		),
 	)
 }
 
diff --git a/packages/backend/src/services/dashboards/share-variables.test.ts b/packages/backend/src/services/dashboards/share-variables.test.ts
index 89066f2ada..629e11b721 100644
--- a/packages/backend/src/services/dashboards/share-variables.test.ts
+++ b/packages/backend/src/services/dashboards/share-variables.test.ts
@@ -166,6 +166,23 @@ describe("resolveShareVariables", () => {
 		if (text._tag === "Success") expect(text.success.search?.value).toBe("")
 	})
 
+	it("holds a query variable a PromQL tile reads to the free-text charset", async () => {
+		// Telemetry values reach PromQL unescaped: one that closes the matcher would rewrite the query.
+		const env = { name: "env", type: "query" as const, includeAll: true }
+		const planted = { env: ["prod", 'x"} or {__name__=~".+'] }
+		const promql = ['sum({"m", env=~"$env"})']
+
+		const safe = await run(resolveShareVariables([env], { env: "prod" }, planted, [], promql))
+		expect(safe._tag).toBe("Success")
+		const picked = await run(resolveShareVariables([env], { env: planted.env[1]! }, planted, [], promql))
+		expect(picked._tag).toBe("Failure")
+		const all = await run(resolveShareVariables([env], { env: "$__all" }, planted, [], promql))
+		expect(all._tag).toBe("Failure")
+		// A board without PromQL keeps accepting whatever the warehouse listed.
+		const elsewhere = await run(resolveShareVariables([env], { env: planted.env[1]! }, planted))
+		expect(elsewhere._tag).toBe("Success")
+	})
+
 	it("still refuses a query variable value that rewrites a clause", async () => {
 		// The fallback is a weaker check, not an absent one.
 		const definition = { name: "env", type: "query" as const }
diff --git a/packages/backend/src/services/dashboards/share-variables.ts b/packages/backend/src/services/dashboards/share-variables.ts
index dbf7564be9..e9a5ed0420 100644
--- a/packages/backend/src/services/dashboards/share-variables.ts
+++ b/packages/backend/src/services/dashboards/share-variables.ts
@@ -41,6 +41,7 @@
 import { splitWhereClause } from "@maple/domain/where-clause"
 import {
 	ALL_VALUE,
+	collectVariableRefs,
 	resolveDashboardVariableValue,
 	type ResolvedVariable,
 	type VariableValues,
@@ -115,7 +116,14 @@ export const resolveShareVariables = Effect.fn("ShareVariables.resolveShareVaria
 	 * not own. If the charset is ever loosened, this is what still catches it.
 	 */
 	whereClauseTemplates: ReadonlyArray<string> = [],
+	/**
+	 * Every PromQL query on the board. A `query` variable's options are telemetry values with any
+	 * characters, and PromQL takes them unescaped, so a variable these reference keeps to the
+	 * free-text charset, every option of an "All" included.
+	 */
+	promQlTemplates: ReadonlyArray<string> = [],
 ) {
+	const promQlNames = new Set(promQlTemplates.flatMap(collectVariableRefs))
 	const resolveOne = (
 		definition: ShareVariableDefinition,
 	): Effect.Effect<Option.Option<readonly [string, ResolvedVariable]>, ShareVariableInvalidError> => {
@@ -139,12 +147,18 @@ export const resolveShareVariables = Effect.fn("ShareVariables.resolveShareVaria
 
 		const accept = (isAll: boolean) =>
 			Effect.succeedSome([definition.name, { value, isAll, options }] as const)
+		const promQlUnsafe = (candidates: ReadonlyArray<string>) =>
+			definition.type === "query" &&
+			promQlNames.has(definition.name) &&
+			!candidates.every((candidate) => TEXTBOX_ALLOWED.test(candidate))
 
 		if (value === ALL_VALUE) {
 			// "All" is only selectable when the board offers it. Otherwise it is a
 			// hand-crafted way to drop the filter entirely, which is exactly the
 			// widening this module exists to prevent.
-			return definition.includeAll !== true ? invalid(definition.name) : accept(true)
+			return definition.includeAll !== true || promQlUnsafe(options)
+				? invalid(definition.name)
+				: accept(true)
 		}
 
 		/** The free-text defence: conservative charset, then the direct clause check. */
@@ -167,7 +181,7 @@ export const resolveShareVariables = Effect.fn("ShareVariables.resolveShareVaria
 				// "unknown", not "nothing is allowed", and treating the two the same
 				// rejected the board's own stored `defaultValue` and blanked the share.
 				if (options.length > 0) {
-					if (!options.includes(value)) return invalid(definition.name)
+					if (!options.includes(value) || promQlUnsafe([value])) return invalid(definition.name)
 					break
 				}
 				if (!passesFreeTextChecks()) return invalid(definition.name)
diff --git a/packages/backend/src/services/dashboards/widget-data-parity.test.ts b/packages/backend/src/services/dashboards/widget-data-parity.test.ts
index 738bee795e..b9d1493b55 100644
--- a/packages/backend/src/services/dashboards/widget-data-parity.test.ts
+++ b/packages/backend/src/services/dashboards/widget-data-parity.test.ts
@@ -33,6 +33,7 @@ import { dataSourceQuerySet, toWidgetRequest } from "@maple/widgets/dashboard"
 import { Effect, Layer, ManagedRuntime, Schema } from "effect"
 import { QueryEngineService } from "@maple/backend/services/warehouse/QueryEngineService"
 import { WarehouseQueryService } from "@maple/backend/services/warehouse/WarehouseQueryService"
+import { GcpPromQlService } from "@maple/backend/services/integrations/GcpPromQlService"
 import { DashboardWidgetDataService, shareViewerTenant } from "./DashboardWidgetDataService"
 import { makeServerQuerySetExecutor } from "./server-query-set-executor"
 import { compiledQueryOf, type CompiledQueryInput } from "@maple/query-engine/execution"
@@ -142,7 +143,14 @@ const makeHarness = () => {
 	} as any)
 	const runtime = ManagedRuntime.make(
 		Layer.effect(DashboardWidgetDataService, DashboardWidgetDataService.make).pipe(
-			Layer.provide(Layer.mergeAll(queryEngine, warehouse)),
+			Layer.provide(
+				Layer.mergeAll(
+					queryEngine,
+					warehouse,
+					// oxlint-disable-next-line typescript/no-explicit-any
+					Layer.succeed(GcpPromQlService, {} as any),
+				),
+			),
 		),
 	)
 	return { runtime, captured, queryEngineLayer: queryEngine, warehouseLayer: warehouse }
diff --git a/packages/domain/src/http/v2/dashboard-widget-parity.test.ts b/packages/domain/src/http/v2/dashboard-widget-parity.test.ts
index 85bcae5a2c..3f3bb75421 100644
--- a/packages/domain/src/http/v2/dashboard-widget-parity.test.ts
+++ b/packages/domain/src/http/v2/dashboard-widget-parity.test.ts
@@ -264,6 +264,7 @@ describe("the v2 data source covers every stored kind", () => {
 			raw_sql: { kind: "raw_sql", sql: "SELECT count() FROM logs WHERE $__orgFilter" },
 			route: { kind: "route", endpoint: "list_traces" },
 			static: { kind: "static" },
+			promql: { kind: "promql", query: "up" },
 		}[kind]!
 
 		expect(() => decode(fixture)).not.toThrow()
@@ -301,4 +302,14 @@ describe("the v2 data source covers every stored kind", () => {
 		expect(wire).toHaveProperty("result_shape", "breakdown")
 		expect(wire).toHaveProperty("default_limit", 20)
 	})
+
+	it("round-trips a PromQL source with its projects and legend", () => {
+		const source = {
+			kind: "promql",
+			query: 'sum by (service) (rate({"run.googleapis.com/request_count"}[5m]))',
+			projects: ["shop-prod"],
+			legend: "{{service}}",
+		}
+		expect(decode(Schema.encodeUnknownSync(V2WidgetDataSource)(source))).toEqual(source)
+	})
 })
diff --git a/packages/domain/src/http/v2/dashboards.ts b/packages/domain/src/http/v2/dashboards.ts
index 97ac304e42..1bc0775b89 100644
--- a/packages/domain/src/http/v2/dashboards.ts
+++ b/packages/domain/src/http/v2/dashboards.ts
@@ -1,5 +1,6 @@
 import { RAW_SQL_ENDPOINT } from "@maple/widgets/dashboard"
 import { RawSqlText } from "../../raw-sql"
+import { GCP_PROMQL_MAX_QUERY_LENGTH } from "../gcp-promql"
 import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api"
 import { Schema, SchemaGetter } from "effect"
 import {
@@ -267,11 +268,21 @@ const V2StaticDataSource = Schema.Struct({
 	transform: optional(V2WidgetTransform),
 })
 
+// Google validates the query itself on every read; an empty one is a draft.
+const V2PromQlDataSource = Schema.Struct({
+	kind: Schema.Literal("promql"),
+	query: Schema.String.check(Schema.isMaxLength(GCP_PROMQL_MAX_QUERY_LENGTH)),
+	projects: optional(Schema.Array(Schema.String)),
+	legend: optional(Schema.String),
+	transform: optional(V2WidgetTransform),
+})
+
 export const V2WidgetDataSource = Schema.Union([
 	V2QueryDataSource,
 	V2RawSqlDataSource,
 	V2RouteDataSource,
 	V2StaticDataSource,
+	V2PromQlDataSource,
 ]).annotate({ identifier: "DashboardWidgetDataSource", title: "Dashboard widget data source" })
 
 const V2WidgetDisplayColumn = Schema.Struct({
diff --git a/packages/query-engine/src/dashboard-variables/interpolate.ts b/packages/query-engine/src/dashboard-variables/interpolate.ts
index 57107fa0e8..d058dc3a51 100644
--- a/packages/query-engine/src/dashboard-variables/interpolate.ts
+++ b/packages/query-engine/src/dashboard-variables/interpolate.ts
@@ -14,6 +14,8 @@
 //     crafted variable value cannot break out of its literal position.
 //   - `whereClause`-like values are handled clause-by-clause: a clause that
 //     references an "All" selection is dropped entirely (All = don't filter).
+//   - `promql` values substitute plainly, with "All" as a regex alternation
+//     (`a|b`) for a `=~` matcher.
 //   - everything else gets plain text substitution.
 
 import { escapeClickHouseString } from "@maple-dev/effect-orm/sql"
@@ -97,6 +99,13 @@ function interpolateString(input: string, key: string | undefined, values: Varia
 	if (key !== undefined && WHERE_CLAUSE_KEY.test(key)) {
 		return interpolateWhereClause(input, values)
 	}
+	if (key === "promql") {
+		return replaceRefs(input, (name) => {
+			const variable = values[name]
+			if (variable === undefined) return null
+			return variable.isAll ? variable.options.join("|") : variable.value
+		})
+	}
 	return replaceRefs(input, (name) => {
 		const variable = values[name]
 		if (variable === undefined) return null
diff --git a/packages/query-engine/src/gcp-promql.test.ts b/packages/query-engine/src/gcp-promql.test.ts
new file mode 100644
index 0000000000..14bff9d622
--- /dev/null
+++ b/packages/query-engine/src/gcp-promql.test.ts
@@ -0,0 +1,193 @@
+import { GcpMetricDescriptor } from "@maple/domain/http"
+import { describe, expect, it } from "vitest"
+import { promQlChartRows, promQlRangeInput, promQlStarterQuery, promQlWidgetData } from "./gcp-promql"
+
+const T0 = 1_760_000_000
+const iso = (seconds: number) => new Date(seconds * 1000).toISOString()
+
+describe("promQlChartRows", () => {
+	it("keys a single project's series by their labels without project_id", () => {
+		const rows = promQlChartRows(
+			[
+				{
+					labels: { service: "api", project_id: "shop" },
+					points: [
+						[T0, 1],
+						[T0 + 60, 2],
+					],
+				},
+				{ labels: { service: "web", project_id: "shop" }, points: [[T0, 3]] },
+			],
+			1,
+		)
+
+		expect(rows).toEqual([
+			{ bucket: iso(T0), "service=api": 1, "service=web": 3 },
+			// `web` has no point here: the key is absent rather than zero.
+			{ bucket: iso(T0 + 60), "service=api": 2 },
+		])
+	})
+
+	it("keeps project_id in the key when several projects answered", () => {
+		const rows = promQlChartRows(
+			[
+				{ labels: { service: "api", project_id: "shop" }, points: [[T0, 1]] },
+				{ labels: { service: "api", project_id: "shop-staging" }, points: [[T0, 2]] },
+			],
+			2,
+		)
+
+		expect(rows).toEqual([
+			{ bucket: iso(T0), "project_id=shop, service=api": 1, "project_id=shop-staging, service=api": 2 },
+		])
+	})
+
+	it("names series from the legend template and keeps colliding names apart", () => {
+		const rows = promQlChartRows(
+			[
+				{ labels: { service: "api", region: "eu" }, points: [[T0, 1]] },
+				{ labels: { service: "api", region: "us" }, points: [[T0, 2]] },
+				{ labels: { region: "us" }, points: [[T0, 3]] },
+			],
+			1,
+			"{{service}} requests",
+		)
+
+		expect(rows).toEqual([{ bucket: iso(T0), "api requests": 1, "api requests (2)": 2, " requests": 3 }])
+	})
+
+	it("keeps metrics_scope, which tells a scope's projects apart behind one answering project", () => {
+		const rows = promQlChartRows(
+			[
+				{ labels: { metrics_scope: "shop-prod", service: "api" }, points: [[T0, 1]] },
+				{ labels: { metrics_scope: "shop-staging", service: "api" }, points: [[T0, 2]] },
+			],
+			1,
+		)
+
+		expect(rows).toEqual([
+			{
+				bucket: iso(T0),
+				"metrics_scope=shop-prod, service=api": 1,
+				"metrics_scope=shop-staging, service=api": 2,
+			},
+		])
+	})
+
+	it("calls an aggregate with no labels left `value`, the field a stat reads", () => {
+		const rows = promQlChartRows(
+			[
+				{
+					labels: { __name__: "x", project_id: "shop" },
+					points: [
+						[T0 + 60, 5],
+						[T0, 4],
+					],
+				},
+			],
+			1,
+		)
+
+		expect(rows).toEqual([
+			{ bucket: iso(T0), value: 4 },
+			{ bucket: iso(T0 + 60), value: 5 },
+		])
+	})
+})
+
+describe("promQlRangeInput", () => {
+	it("trims the query and never asks Google for a step under a minute", () => {
+		expect(
+			promQlRangeInput(
+				{ promql: "  up\n", projects: ["shop-prod"] },
+				{ startTime: "2026-02-01 00:00:00", endTime: "2026-02-01 00:30:00" },
+			),
+		).toEqual({
+			query: "up",
+			startTime: "2026-02-01 00:00:00",
+			endTime: "2026-02-01 00:30:00",
+			stepSeconds: 60,
+			projects: ["shop-prod"],
+		})
+		expect(
+			promQlRangeInput(
+				{ promql: "up" },
+				{ startTime: "2026-02-01 00:00:00", endTime: "2026-02-08 00:00:00" },
+			).stepSeconds,
+		).toBe(3600)
+	})
+})
+
+describe("promQlWidgetData", () => {
+	const answer = {
+		series: [{ labels: { project_id: "shop-prod" }, points: [[T0, 1]] as const }],
+		projects: ["shop-prod"],
+		failures: [{ scope: "projects/shop-staging", message: "Run the setup script again." }],
+	}
+
+	it("adds no notice to a complete answer", () => {
+		expect(promQlWidgetData({ ...answer, failures: [] }, undefined, true)).toEqual({
+			data: [{ bucket: iso(T0), value: 1 }],
+		})
+	})
+
+	it("names each scope and its cause for members, and only a count on a share link", () => {
+		expect(promQlWidgetData(answer, undefined, true).notice).toBe(
+			"Partial result. projects/shop-staging: Run the setup script again.",
+		)
+		expect(promQlWidgetData(answer, undefined, false).notice).toBe(
+			"Partial result: 1 Google Cloud scope could not be read.",
+		)
+	})
+})
+
+describe("promQlStarterQuery", () => {
+	const descriptor = (fields: Partial<GcpMetricDescriptor>) =>
+		new GcpMetricDescriptor({
+			type: "run.googleapis.com/request_count",
+			metricKind: "DELTA",
+			valueType: "INT64",
+			unit: "1",
+			description: "",
+			monitoredResourceTypes: ["cloud_run_revision"],
+			labels: [{ key: "response_code_class", description: "" }],
+			...fields,
+		})
+
+	it("rates a counter, grouped by its first label", () => {
+		expect(promQlStarterQuery("run.googleapis.com/request_count", descriptor({}))).toBe(
+			'sum by (project_id, response_code_class) (rate({"run.googleapis.com/request_count"}[5m]))',
+		)
+		expect(
+			promQlStarterQuery(
+				"run.googleapis.com/request_count",
+				descriptor({ metricKind: "CUMULATIVE", labels: [] }),
+			),
+		).toBe('sum by (project_id) (rate({"run.googleapis.com/request_count"}[5m]))')
+	})
+
+	it("averages a gauge", () => {
+		expect(
+			promQlStarterQuery(
+				"run.googleapis.com/container/instance_count",
+				descriptor({ type: "run.googleapis.com/container/instance_count", metricKind: "GAUGE" }),
+			),
+		).toBe('avg by (project_id, response_code_class) ({"run.googleapis.com/container/instance_count"})')
+	})
+
+	it("takes the 95th percentile of a distribution and names the resource when there are several", () => {
+		const latencies = descriptor({
+			type: "run.googleapis.com/request_latencies",
+			valueType: "DISTRIBUTION",
+			monitoredResourceTypes: ["cloud_run_revision", "cloud_run_instance"],
+		})
+
+		expect(promQlStarterQuery("run.googleapis.com/request_latencies_bucket", latencies)).toBe(
+			'histogram_quantile(0.95, sum by (project_id, le) (rate({"run.googleapis.com/request_latencies_bucket", monitored_resource="cloud_run_revision"}[5m])))',
+		)
+		// A distribution's `_count` is a counter like any other.
+		expect(promQlStarterQuery("run.googleapis.com/request_latencies_count", latencies)).toBe(
+			'sum by (project_id, response_code_class) (rate({"run.googleapis.com/request_latencies_count", monitored_resource="cloud_run_revision"}[5m]))',
+		)
+	})
+})
diff --git a/packages/query-engine/src/gcp-promql.ts b/packages/query-engine/src/gcp-promql.ts
new file mode 100644
index 0000000000..cd683c52b0
--- /dev/null
+++ b/packages/query-engine/src/gcp-promql.ts
@@ -0,0 +1,117 @@
+/**
+ * Google Cloud PromQL answers, shaped for dashboard widgets. Pure, so the browser's server function
+ * and the share API draw a PromQL widget from the same rows.
+ */
+import {
+	GCP_PROMQL_MIN_STEP_SECONDS,
+	type GcpMetricDescriptor,
+	type GcpPromQlFailure,
+	type GcpPromQlSeries,
+} from "@maple/domain/http"
+import { computeBucketSecondsForRange } from "./datetime"
+
+/**
+ * The range request a widget's planned params make, for `GcpPromQlRangeRequest` to decode. The step
+ * is the chart's own bucket for the window, never under Google's one minute.
+ */
+export const promQlRangeInput = (
+	params: { readonly promql: string; readonly projects?: ReadonlyArray<string> | undefined },
+	window: { readonly startTime: string; readonly endTime: string },
+) => ({
+	query: params.promql.trim(),
+	startTime: window.startTime,
+	endTime: window.endTime,
+	stepSeconds: Math.max(
+		GCP_PROMQL_MIN_STEP_SECONDS,
+		computeBucketSecondsForRange(window.startTime, window.endTime),
+	),
+	...(params.projects === undefined ? undefined : { projects: params.projects }),
+})
+
+const LEGEND_LABEL = /\{\{\s*([^{}\s]+)\s*\}\}/g
+
+/**
+ * The legend template filled from the labels (a missing label renders empty), or by default the
+ * label set without `__name__`, and without `project_id` when a single project answered.
+ */
+const seriesKey = (
+	labels: Readonly<Record<string, string>>,
+	legend: string | undefined,
+	oneProject: boolean,
+): string => {
+	if (legend !== undefined && legend.trim() !== "") {
+		return legend.replace(LEGEND_LABEL, (_, name: string) => labels[name] ?? "")
+	}
+	// `metrics_scope` stays: within one scoping project it is what tells the monitored projects apart.
+	const pairs = Object.entries(labels)
+		.filter(([key]) => key !== "__name__" && !(oneProject && key === "project_id"))
+		.sort(([a], [b]) => a.localeCompare(b))
+	return pairs.length === 0 ? "value" : pairs.map(([key, value]) => `${key}=${value}`).join(", ")
+}
+
+/**
+ * Series as the wide rows the time-series charts take, `{ bucket, [series]: value }`, one row per
+ * timestamp in time order. A series with no point at a timestamp has no key in that row.
+ */
+export const promQlChartRows = (
+	series: ReadonlyArray<GcpPromQlSeries>,
+	projectCount: number,
+	legend?: string,
+): Array<Record<string, string | number>> => {
+	const used = new Set<string>()
+	const rows = new Map<number, Record<string, string | number>>()
+	for (const one of series) {
+		const base = seriesKey(one.labels, legend, projectCount <= 1)
+		let key = base
+		for (let n = 2; used.has(key); n++) key = `${base} (${n})`
+		used.add(key)
+		for (const [seconds, value] of one.points) {
+			const row = rows.get(seconds) ?? { bucket: new Date(seconds * 1000).toISOString() }
+			row[key] = value
+			rows.set(seconds, row)
+		}
+	}
+	return [...rows.entries()].sort(([a], [b]) => a - b).map(([, row]) => row)
+}
+
+/**
+ * An answer as widget data: the chart rows, and a one-line notice when some scopes could not be read.
+ * Members get each scope and its cause; a share link gets only the count, no project ids or setup.
+ */
+export const promQlWidgetData = (
+	result: {
+		readonly series: ReadonlyArray<GcpPromQlSeries>
+		readonly projects: ReadonlyArray<string>
+		readonly failures: ReadonlyArray<GcpPromQlFailure>
+	},
+	legend: string | undefined,
+	withCauses: boolean,
+): { data: Array<Record<string, string | number>>; notice?: string } => {
+	const data = promQlChartRows(result.series, result.projects.length, legend)
+	const { failures } = result
+	if (failures.length === 0) return { data }
+	return {
+		data,
+		notice: withCauses
+			? `Partial result. ${failures.map((failure) => `${failure.scope}: ${failure.message}`).join(" ")}`
+			: `Partial result: ${failures.length === 1 ? "1 Google Cloud scope" : `${failures.length} Google Cloud scopes`} could not be read.`,
+	}
+}
+
+/**
+ * A query that runs as written for a metric picked from the metric search: a rate for DELTA and
+ * CUMULATIVE metrics, an average for a GAUGE, the 95th percentile for a distribution's buckets,
+ * each kept per project.
+ * Google refuses a selector without `monitored_resource` when the metric has several resource types.
+ */
+export const promQlStarterQuery = (metric: string, descriptor: GcpMetricDescriptor): string => {
+	const [resource] = descriptor.monitoredResourceTypes
+	const matcher = descriptor.monitoredResourceTypes.length > 1 ? `, monitored_resource="${resource}"` : ""
+	const selector = (name: string) => `{"${name}"${matcher}}`
+	const by = ` by (${["project_id", ...descriptor.labels.slice(0, 1).map((label) => label.key)].join(", ")})`
+	if (descriptor.valueType === "DISTRIBUTION" && !/_(count|sum)$/u.test(metric)) {
+		return `histogram_quantile(0.95, sum by (project_id, le) (rate(${selector(`${descriptor.type}_bucket`)}[5m])))`
+	}
+	if (descriptor.metricKind === "GAUGE") return `avg${by} (${selector(metric)})`
+	return `sum${by} (rate(${selector(metric)}[5m]))`
+}
diff --git a/packages/query-engine/src/index.ts b/packages/query-engine/src/index.ts
index e53818ed53..58c4545cfe 100644
--- a/packages/query-engine/src/index.ts
+++ b/packages/query-engine/src/index.ts
@@ -9,6 +9,7 @@ export * from "./dashboard-variables/time-macros"
 export * from "./dashboard-variables/options"
 export * from "./widget-request"
 export * from "./raw-sql-chart-rows"
+export * from "./gcp-promql"
 export * from "./route-rows"
 export * from "./traces-shared"
 export * from "./span-events"
diff --git a/packages/query-engine/src/widget-request.test.ts b/packages/query-engine/src/widget-request.test.ts
index 005be46d41..350f0df1c5 100644
--- a/packages/query-engine/src/widget-request.test.ts
+++ b/packages/query-engine/src/widget-request.test.ts
@@ -119,6 +119,31 @@ describe("planWidgetRequest", () => {
 		expect(plan).toEqual({ kind: "disabled", reason: "metric_not_selected" })
 	})
 
+	it("holds a PromQL tile with no query", () => {
+		const blank = planWidgetRequest({
+			request: { endpoint: "gcp_promql", params: { promql: "  " } },
+			dashboardWindow: DASHBOARD,
+		})
+		expect(blank).toEqual({ kind: "disabled", reason: "promql_query_empty" })
+	})
+
+	it("substitutes a PromQL variable, and All as a regex alternation for `=~`", () => {
+		const promql = 'sum({"m", service=~"$service"})'
+		const plan = (service: VariableValues[string]) => {
+			const planned = planWidgetRequest({
+				request: { endpoint: "gcp_promql", params: { promql } },
+				dashboardWindow: DASHBOARD,
+				variableValues: { service },
+			})
+			return planned.kind === "request" ? planned.params.promql : undefined
+		}
+
+		expect(plan(single("checkout"))).toBe('sum({"m", service=~"checkout"})')
+		expect(plan({ value: "$__all", isAll: true, options: ["checkout", "cart"] })).toBe(
+			'sum({"m", service=~"checkout|cart"})',
+		)
+	})
+
 	it("ignores a disabled metrics draft with no metric", () => {
 		const plan = planWidgetRequest({
 			request: {
diff --git a/packages/query-engine/src/widget-request.ts b/packages/query-engine/src/widget-request.ts
index f76dc60918..de1b090ac9 100644
--- a/packages/query-engine/src/widget-request.ts
+++ b/packages/query-engine/src/widget-request.ts
@@ -73,8 +73,9 @@ export interface DisabledWidgetRequest {
 	 * - `metric_not_selected`: a metrics-source query with no metric name. The
 	 *   server would reject it (`"Metric source requires a metric name"`), so the
 	 *   request is never sent — a half-configured tile is a state, not an error.
+	 * - `promql_query_empty`: a Google Cloud PromQL tile with no query written yet.
 	 */
-	readonly reason: "invalid_widget_time_range" | "metric_not_selected"
+	readonly reason: "invalid_widget_time_range" | "metric_not_selected" | "promql_query_empty"
 }
 
 export type WidgetRequestPlan = PlannedWidgetRequest | DisabledWidgetRequest
@@ -85,6 +86,9 @@ export const WIDGET_FETCH_STRATEGY = { enableEmptyRangeFallback: false } as cons
 /** Endpoint whose params carry `maxDataPoints`. Mirrors `QUERY_RESULT_ENDPOINTS.timeseries`. */
 const TIMESERIES_ENDPOINT = "custom_query_builder_timeseries"
 
+/** Mirrors `GCP_PROMQL_ENDPOINT` in `@maple/widgets`. */
+const GCP_PROMQL_ENDPOINT = "gcp_promql"
+
 /** Query-set endpoints: `params.queries` is an array of query-builder drafts. */
 const QUERY_SET_ENDPOINTS = new Set([
 	"custom_query_builder_timeseries",
@@ -161,6 +165,9 @@ export function planWidgetRequest(input: PlanWidgetRequestInput): WidgetRequestP
 	if (isMetricNotSelected(endpoint, interpolated)) {
 		return { kind: "disabled", reason: "metric_not_selected" }
 	}
+	if (endpoint === GCP_PROMQL_ENDPOINT && isBlank(interpolated.promql)) {
+		return { kind: "disabled", reason: "promql_query_empty" }
+	}
 
 	return {
 		kind: "request",
diff --git a/packages/widgets/src/dashboard/access.ts b/packages/widgets/src/dashboard/access.ts
index 1fc3400f0e..1429ed85cd 100644
--- a/packages/widgets/src/dashboard/access.ts
+++ b/packages/widgets/src/dashboard/access.ts
@@ -172,3 +172,21 @@ export const dataSourceRouteParams = (dataSource: unknown): Record<string, unkno
 	}
 	return isRecord(dataSource.params) ? dataSource.params : undefined
 }
+
+export interface PromQlDataSource {
+	readonly query: string
+	readonly projects?: ReadonlyArray<string>
+	readonly legend?: string
+}
+
+/** The PromQL payload of a `kind: "promql"` source. v3 only: no v2 form ever existed. */
+export const dataSourcePromQl = (dataSource: unknown): PromQlDataSource | null => {
+	if (!isRecord(dataSource) || dataSource.kind !== "promql") return null
+	return {
+		query: isString(dataSource.query) ? dataSource.query : "",
+		...(Array.isArray(dataSource.projects)
+			? { projects: dataSource.projects.filter(isString) }
+			: undefined),
+		...(isString(dataSource.legend) ? { legend: dataSource.legend } : undefined),
+	}
+}
diff --git a/packages/widgets/src/dashboard/construct.ts b/packages/widgets/src/dashboard/construct.ts
index 3d2318ad69..4454c57b39 100644
--- a/packages/widgets/src/dashboard/construct.ts
+++ b/packages/widgets/src/dashboard/construct.ts
@@ -10,9 +10,10 @@ import type {
 	QueryResultContract,
 	QuerySet,
 } from "@maple/query-model"
-import type { RawSqlDataSource } from "./access"
+import type { PromQlDataSource, RawSqlDataSource } from "./access"
 import type { WidgetDataSourceTransformV2 } from "./shared/transform"
 import type {
+	PromQlWidgetDataSource,
 	QueryWidgetDataSource,
 	RawSqlWidgetDataSource,
 	RouteWidgetDataSource,
@@ -103,6 +104,19 @@ export const makeRawSqlDataSource = (input: RawSqlDataSourceInput): typeof RawSq
 	...(!(input.transform === undefined) ? { transform: input.transform } : undefined),
 })
 
+export interface PromQlDataSourceInput extends PromQlDataSource {
+	readonly transform?: WidgetDataSourceTransform
+}
+
+/** A widget charting a PromQL query over the organization's Google Cloud metrics. */
+export const makePromQlDataSource = (input: PromQlDataSourceInput): typeof PromQlWidgetDataSource.Type => ({
+	kind: "promql",
+	query: input.query,
+	...(!(input.projects === undefined) ? { projects: input.projects } : undefined),
+	...(!(input.legend === undefined) ? { legend: input.legend } : undefined),
+	...(!(input.transform === undefined) ? { transform: input.transform } : undefined),
+})
+
 /**
  * A widget backed by one of the curated fixed routes (`service_overview`, …).
  *
diff --git a/packages/widgets/src/dashboard/index.ts b/packages/widgets/src/dashboard/index.ts
index bb26567e6d..8e86e95338 100644
--- a/packages/widgets/src/dashboard/index.ts
+++ b/packages/widgets/src/dashboard/index.ts
@@ -27,11 +27,13 @@ export {
 } from "./migrations"
 export {
 	dataSourceEndpoint,
+	dataSourcePromQl,
 	dataSourceQuerySet,
 	dataSourceRawSql,
 	dataSourceRouteParams,
 	dataSourceTransform,
 	isQueryDataSource,
+	type PromQlDataSource,
 	QUERY_RESULT_ENDPOINTS,
 	RAW_SQL_ENDPOINT,
 	type RawSqlDataSource,
@@ -41,6 +43,7 @@ export { toWidgetRequest, type WidgetRequest } from "./request"
 export {
 	makeProductEventsFunnelDataSource,
 	makeProductEventsPathsDataSource,
+	makePromQlDataSource,
 	makeQueryDataSource,
 	makeRawSqlDataSource,
 	makeRouteDataSource,
@@ -56,6 +59,7 @@ export {
 // exported for the upgrade transform and its tests, which must name a version
 // explicitly.
 export {
+	PromQlWidgetDataSource,
 	QueryWidgetDataSource,
 	RawSqlWidgetDataSource,
 	RouteWidgetDataSource,
@@ -66,7 +70,11 @@ export {
 } from "./v3/data-source"
 export { DashboardDocumentV3, PortableDashboardDocumentV3 } from "./v3/document"
 export { DashboardWidgetV3, WidgetDisplayConfigV3 } from "./v3/widget"
-export { MARKDOWN_STATIC_ENDPOINT, QUERY_ENDPOINT_RESULT_KINDS } from "./legacy-endpoints"
+export {
+	GCP_PROMQL_ENDPOINT,
+	MARKDOWN_STATIC_ENDPOINT,
+	QUERY_ENDPOINT_RESULT_KINDS,
+} from "./legacy-endpoints"
 // The one-shot upgrade the backfill script runs against Postgres. Deliberately
 // not a `DashboardMigration` — see the header of `upgrade-to-v3.ts`.
 export {
diff --git a/packages/widgets/src/dashboard/legacy-endpoints.ts b/packages/widgets/src/dashboard/legacy-endpoints.ts
index c0e99ee2c5..62fb819ae5 100644
--- a/packages/widgets/src/dashboard/legacy-endpoints.ts
+++ b/packages/widgets/src/dashboard/legacy-endpoints.ts
@@ -53,3 +53,6 @@ export const RAW_SQL_ENDPOINT = "raw_sql_chart"
  * encoder, and the web registry that stops needing a server function for it).
  */
 export const MARKDOWN_STATIC_ENDPOINT = "markdown_static"
+
+/** The transport name of a `kind: "promql"` source: a live Google Cloud PromQL range query. */
+export const GCP_PROMQL_ENDPOINT = "gcp_promql"
diff --git a/packages/widgets/src/dashboard/promql-source.test.ts b/packages/widgets/src/dashboard/promql-source.test.ts
new file mode 100644
index 0000000000..ebe12e0d8b
--- /dev/null
+++ b/packages/widgets/src/dashboard/promql-source.test.ts
@@ -0,0 +1,63 @@
+import { Schema } from "effect"
+import { describe, expect, it } from "vitest"
+import { makePromQlDataSource } from "./construct"
+import { redactForShare } from "./redact"
+import { toWidgetRequest } from "./request"
+import { WidgetDataSourceV3 } from "./v3/data-source"
+
+const QUERY =
+	'sum by (service) (rate({"run.googleapis.com/request_count", monitored_resource="cloud_run_revision"}[5m]))'
+
+describe("a Google Cloud PromQL data source", () => {
+	it("survives a decode/encode round trip with every field", () => {
+		const source = makePromQlDataSource({
+			query: QUERY,
+			projects: ["shop-prod", "shop-staging"],
+			legend: "{{service}}",
+			transform: { reduceToValue: { field: "value", aggregate: "avg" } },
+		})
+		const decoded = Schema.decodeUnknownSync(WidgetDataSourceV3)(source)
+
+		expect(Schema.encodeUnknownSync(WidgetDataSourceV3)(decoded)).toEqual(source)
+	})
+
+	it("lowers to the live PromQL endpoint with only the fields it has", () => {
+		expect(toWidgetRequest(makePromQlDataSource({ query: QUERY }))).toEqual({
+			endpoint: "gcp_promql",
+			params: { promql: QUERY },
+		})
+		expect(
+			toWidgetRequest(
+				makePromQlDataSource({ query: QUERY, projects: ["shop-prod"], legend: "{{service}}" }),
+			),
+		).toEqual({
+			endpoint: "gcp_promql",
+			params: { promql: QUERY, projects: ["shop-prod"], legend: "{{service}}" },
+		})
+	})
+
+	it("reaches a share link without its query, projects or legend", () => {
+		const redacted = redactForShare({
+			id: "dash-1",
+			name: "Cloud Run",
+			timeRange: { type: "relative", value: "1h" },
+			widgets: [
+				{
+					id: "w-promql",
+					visualization: "chart",
+					display: { title: "Requests" },
+					layout: { x: 0, y: 0, w: 6, h: 4 },
+					dataSource: makePromQlDataSource({
+						query: QUERY,
+						projects: ["shop-prod"],
+						legend: "{{service}}",
+						transform: { limit: 5 },
+					}),
+				},
+			],
+		})
+
+		expect(redacted?.widgets[0]?.dataSource).toEqual({ kind: "promql", transform: { limit: 5 } })
+		expect(JSON.stringify(redacted)).not.toContain("shop-prod")
+	})
+})
diff --git a/packages/widgets/src/dashboard/redact.ts b/packages/widgets/src/dashboard/redact.ts
index b9c0ec150d..1e7696969b 100644
--- a/packages/widgets/src/dashboard/redact.ts
+++ b/packages/widgets/src/dashboard/redact.ts
@@ -16,7 +16,13 @@
  * denylist would leak every future field by default, which is exactly the wrong
  * direction for a payload served without a session.
  */
-import { dataSourceEndpoint, dataSourceQuerySet, dataSourceRawSql, dataSourceTransform } from "./access"
+import {
+	dataSourceEndpoint,
+	dataSourcePromQl,
+	dataSourceQuerySet,
+	dataSourceRawSql,
+	dataSourceTransform,
+} from "./access"
 import type { DashboardVariable } from "./shared/variables"
 
 /**
@@ -30,7 +36,7 @@ import type { DashboardVariable } from "./shared/variables"
  * reveals a query.
  */
 export interface RedactedDataSource {
-	readonly kind: "query" | "raw_sql" | "route" | "static"
+	readonly kind: "query" | "raw_sql" | "route" | "static" | "promql"
 	readonly resultShape?: string
 	readonly transform?: unknown
 }
@@ -81,6 +87,11 @@ const redactDataSource = (dataSource: unknown): RedactedDataSource => {
 		return { kind: "raw_sql", ...transformField }
 	}
 
+	if (dataSourcePromQl(dataSource) !== null) {
+		// Drops `query`, `projects` and `legend`: the query and the org's project ids.
+		return { kind: "promql", ...transformField }
+	}
+
 	const querySet = dataSourceQuerySet(dataSource)
 	if (querySet !== null) {
 		// Drops `queries`, `formulas`, `comparison`, `columns`: every one of them
diff --git a/packages/widgets/src/dashboard/request.ts b/packages/widgets/src/dashboard/request.ts
index 7eba22a9c4..000ff846d4 100644
--- a/packages/widgets/src/dashboard/request.ts
+++ b/packages/widgets/src/dashboard/request.ts
@@ -1,11 +1,13 @@
 import {
 	dataSourceEndpoint,
+	dataSourcePromQl,
 	dataSourceQuerySet,
 	dataSourceRawSql,
 	dataSourceRouteParams,
 	QUERY_RESULT_ENDPOINTS,
 	RAW_SQL_ENDPOINT,
 } from "./access"
+import { GCP_PROMQL_ENDPOINT } from "./legacy-endpoints"
 
 /**
  * A stored data source lowered to "which endpoint, with which params".
@@ -55,6 +57,13 @@ export function toWidgetRequest(dataSource: unknown): WidgetRequest | null {
 		}
 	}
 
+	// `promql`, not `query`: the key tells variable interpolation to format for PromQL.
+	const promQl = dataSourcePromQl(dataSource)
+	if (promQl !== null) {
+		const { query, ...rest } = promQl
+		return { endpoint: GCP_PROMQL_ENDPOINT, params: { promql: query, ...rest } }
+	}
+
 	const querySet = dataSourceQuerySet(dataSource)
 	if (querySet !== null) {
 		return {
diff --git a/packages/widgets/src/dashboard/v3/data-source.ts b/packages/widgets/src/dashboard/v3/data-source.ts
index 7531387ab0..af276663e2 100644
--- a/packages/widgets/src/dashboard/v3/data-source.ts
+++ b/packages/widgets/src/dashboard/v3/data-source.ts
@@ -125,6 +125,22 @@ export const StaticWidgetDataSource = Schema.Struct({
 	title: "Static widget data source",
 })
 
+/**
+ * A PromQL query over the organization's Google Cloud Monitoring metrics, read live from Google on
+ * every view. Nothing is stored in Maple's warehouse. `projects` narrows the read to some of the
+ * projects the connections reach; `legend` names each series from its labels (`{{label}}`).
+ */
+export const PromQlWidgetDataSource = Schema.Struct({
+	kind: Schema.Literal("promql"),
+	query: Schema.String,
+	projects: Schema.optionalKey(Schema.Array(Schema.String)),
+	legend: Schema.optionalKey(Schema.String),
+	...transformField,
+}).annotate({
+	identifier: "@maple/PromQlWidgetDataSource",
+	title: "Google Cloud PromQL widget data source",
+})
+
 /**
  * The discriminant values, exported so tests can assert coverage.
  *
@@ -133,7 +149,7 @@ export const StaticWidgetDataSource = Schema.Struct({
  * what the v2 HTTP API does with it. That is the structural successor to the
  * assignability assertions the union replaced.
  */
-export const WIDGET_DATA_SOURCE_KINDS = ["query", "raw_sql", "route", "static"] as const
+export const WIDGET_DATA_SOURCE_KINDS = ["query", "raw_sql", "route", "static", "promql"] as const
 export type WidgetDataSourceKind = (typeof WIDGET_DATA_SOURCE_KINDS)[number]
 
 export const WidgetDataSourceV3 = Schema.Union([
@@ -141,6 +157,7 @@ export const WidgetDataSourceV3 = Schema.Union([
 	RawSqlWidgetDataSource,
 	RouteWidgetDataSource,
 	StaticWidgetDataSource,
+	PromQlWidgetDataSource,
 ]).annotate({
 	identifier: "@maple/WidgetDataSource",
 	title: "Widget data source",