@corensystem/coren-ui 1.0.0-next.20260924.75108.887a9c2

package/dist/pages/wc3-analysis-shared.mjs

@@ -0,0 +1,1119 @@
+import { Accordion, AccordionContent, AccordionItem, AccordionTrigger } from "../accordion.mjs";
+import { Badge } from "../badge.mjs";
+import { Button } from "../button.mjs";
+import { Card, CardContent, CardHeader, CardTitle } from "../card.mjs";
+import { Empty } from "../empty.mjs";
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from "../dropdown-menu.mjs";
+import { Banner } from "../banner.mjs";
+import { ToggleGroup, ToggleGroupItem } from "../toggle-group.mjs";
+import { usePersistentState } from "../use-persistent-state.mjs";
+import { Table as Table$1, TableBody, TableCell, TableHead, TableHeader, TableRow } from "../table.mjs";
+import { toast } from "../sonner.mjs";
+import { TrendChart } from "../trend-chart.mjs";
+import { WC3_LINK_TYPES } from "./wc3-ontology-data.mjs";
+import { Mono, Pane, TypeGlyphLabel, lineageNav } from "./wc3-lineage-shared.mjs";
+import { WC3_PROCESS_FIXTURE_NOW, WC3_PROCESS_FIXTURE_NOW_MS } from "./wc3-process-data.mjs";
+import { WC3_ANALYSIS_GROUP_BYS, WC3_ANALYSIS_METRICS, WC3_ANALYSIS_SEVERITIES, WC3_ANALYSIS_SOURCE_DATASET_IDS, WC3_ANALYSIS_STAGES, WC3_ANALYSIS_WINDOWS, WC3_OBSERVATION_ROWS, WC3_WORKER_ROWS, analysisDataset, analysisDatasetMaterialised, analysisDatasetName, analysisDatasetRows, analysisMetric, analysisMetricMissingInput, analysisWorker, wc3AnalysisDefaultSpec } from "./wc3-analysis-data.mjs";
+import { WC3_PERSONAS } from "./wc3-product-shared.mjs";
+import { cn } from "@corensystem/coren-utils";
+import { AlertTriangle, BarChart3, ChevronDown, Play, RotateCcw, Table2 } from "lucide-react";
+import { useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/pages/wc3-analysis-shared.tsx
+/**
+* Every user-readable string on this perspective.
+*
+* Verbatim from the prototype (06-unified-workspace.html, PageAnalysis / AnStageConfig / anRoute /
+* AnResult / AnExecMeta / AnPublish / AnSavedList) EXCEPT for four entries that are marked NEW:
+* `noTimeColumn` and `allUnlinked` close the prototype's only genuine gap (it has no state for
+* 0 rows matched), `windowInert` states a verified fact the prototype's silence hides, and the
+* object-mode traverse hint is rewritten because the prototype's version is false — see
+* {@link analysisTraversalKind}.
+*/
+const WC3_ANALYSIS_MESSAGES = {
+	intro: {
+		object: "Start from an ontology object set, traverse links, add metrics, group and chart. Object identity and permissions come from the ontology throughout.",
+		data: "Start from a governed dataset or event history, join, derive and aggregate. Results can be saved as a materialisation or mapped back to an object type."
+	},
+	stageHint: {
+		source: {
+			object: "An ontology object set. Identity, permissions and valid traversals are defined by the object type.",
+			data: "A governed dataset from the catalogue. Datasets declared but not materialised in this prototype return no rows and say so."
+		},
+		filter: "Bounded predicates evaluated before traversal. Filters narrow the set; they never widen permissions.",
+		traverse: {
+			object: "One ontology-declared link traversal and one plain property join. Each option below says which it is: only a traversal backed by a link type is the ontology acting as the semantic plane.",
+			data: "A declared join between governed datasets."
+		},
+		derive: "Metric definitions belong to the ontology, not to this chart. A metric whose input has no materialised rows is unsupported and names what is required.",
+		group: "One hierarchy level at a time. Aggregates come back as grouped rows; the full result set is never materialised in the browser.",
+		viz: "Rendering reads the same grouped aggregate the engine returned. Drilling from a bar re-queries the objects behind it.",
+		publish: "Every control below either mutates session state or states plainly that it is unsupported."
+	},
+	routeWhy: {
+		runtime: "A selected metric depends on an input the ontology does not hold as current state. A bounded product job would have to read the governed event set, compute the metric, and write results back through an Action — it cannot be answered by either the object store or a scan of current objects.",
+		analytical: (grouped) => `A historical time window with ${grouped ? "grouped aggregation" : "a join"} is a columnar scan over fact history, not a lookup of current state. The object store holds current state and would have to reconstruct history row-by-row, so this routes to the analytical adapter which reads columns and returns pages plus aggregates.`,
+		operational: (joined) => `Bounded filters over current object state with ${joined ? "a single link traversal" : "no traversal"} and no historical window. The operational object store answers this directly at low latency; sending it to the analytical engine would add scan cost for no benefit.`
+	},
+	/**
+	* The complete reachable routing rule, stated plainly so the panel does not oversell the thesis.
+	* The Group stage offers no "none" option (faithfully, as in the prototype), so `grouped` is true
+	* for every spec this UI can produce and the traversal choice can never move the branch.
+	*/
+	routeLevers: "The route is computed from the spec, not chosen: any metric with a declared input requirement routes to Product Runtime; otherwise a historical window routes to Analytical and current-state-only routes to Operational. Because the Group stage always sets a grouping, the traversal and group-by choices do not move this decision — the panel does not pretend otherwise.",
+	blockedMetrics: "These need presence intervals per worker. The prototype declares badge_events_import_raw in the dataset catalogue, but it has no materialised rows, so there are no badge-in/badge-out pairs to integrate into exposure hours — and a rate has no denominator without them. Required input: badge events with fld_badge_no and fld_ts landed as a governed event set. No exposure figure is shown, estimated or interpolated.",
+	sourceEmpty: (dsName) => `The selected source is declared in the catalogue but holds no materialised rows in this prototype. Required input: a pipeline that lands ${dsName} into the object store or the analytical adapter. Nothing is estimated in its place.`,
+	/** NEW — the prototype renders a blank panel here. */
+	noTimeColumn: (dsName, window, scanned) => `0 of ${scanned.toLocaleString()} rows matched. ${dsName} has no observed_at column, so the ${window}-week window excludes every row. Switch the window to “current state only” to scan current state.`,
+	/** NEW — likewise. */
+	filtersExcludedAll: (scanned) => `0 of ${scanned.toLocaleString()} rows matched. The declared filters and the time window together exclude every scanned row. Nothing is widened to fill the panel.`,
+	/** NEW — likewise. */
+	allUnlinked: (joinKey) => `Every matched row grouped as “— unlinked —”: grouping by contractor reads it off the joined ot_worker, and the join on ${joinKey} resolved for none of these rows.`,
+	/**
+	* NEW, and verified by executing the engine: all 65 seeded observations fall between
+	* 2026-05-29 14:00 and 2026-07-22 06:55, i.e. inside even the 8-week window measured back from
+	* the 2026-07-22 08:00 fixture clock. Windows 0 / 8 / 26 / 56 all match the same rows and produce
+	* the same groups. Without this note the control reads as a broken filter.
+	*/
+	windowInert: "Changes the execution route, not the row count — every seeded row falls inside even the shortest window.",
+	proofScope: (objects) => `these timings are measured over ${objects.toLocaleString()} seeded objects in one browser tab. They demonstrate the query contract, routing rule and result lifecycle. They are not evidence of production-scale execution, and nothing here is projected to billions of rows.`,
+	scopeQualifier: "declared — no row on this page is permission-filtered",
+	savedEmpty: "Nothing saved yet. Saving keeps the spec, the execution route and the lineage together, so a result can always be traced back to the question that produced it.",
+	resultFooter: (groups, matched) => `${groups.toLocaleString()} groups from ${matched.toLocaleString()} matched rows. Aggregates only; the browser never holds the full set.`,
+	drillThrough: (key, n) => `Drill-through: ${key} — ${n.toLocaleString()} objects. Object identity is preserved from the ontology, so drilling lands on real instances.`,
+	savedToast: (name) => `Saved analysis “${name}” with its execution route and lineage.`,
+	materialisedToast: (groups) => `Materialised ${groups.toLocaleString()} grouped rows. Execution metadata now reads Materialised rather than Live query.`,
+	publish: {
+		commandCentre: "A Command Center tile would bind to this saved analysis by reference, re-running it under the viewer's own permissions rather than caching one user's result. Save the analysis first to create that reference.",
+		mapToObjectType: "Unsupported in this prototype. Mapping an analytical result into the ontology creates a new object type owned by a package, which is a governed package install (spec §3.2) — not a runtime write. This surface cannot author packages.",
+		productRuntime: "Product Runtime would receive a reference to this governed result set, not a copy. It reads the set, computes, and writes back only through ontology Actions.",
+		actionProposal: (key, n) => `Would open a governed Action proposal scoped to ${key} (${n.toLocaleString()} objects). Write-back is an Action, never a direct table write — this is the ontology round-trip.`,
+		noGroups: "No grouped rows to propose against."
+	}
+};
+/**
+* Route → Badge variant. operational = low-latency current state, analytical = columnar scan,
+* runtime = a bounded product job that does not exist yet. Theme tokens only.
+*/
+const WC3_ANALYSIS_ROUTE_VARIANT = {
+	operational: "successSoft",
+	analytical: "infoSoft",
+	runtime: "warningSoft"
+};
+/** The prototype's route labels. Kept here so a saved record's `route` string can be read back. */
+const ROUTE_LABEL = {
+	operational: "Operational",
+	analytical: "Analytical",
+	runtime: "Product Runtime"
+};
+/**
+* DECLARED scope, not enforced. The workspace shell has no persona switcher, so this is the default
+* lens; no row on this page is permission-filtered and the panel says so next to it.
+*/
+const WC3_ANALYSIS_SCOPE = `project · Falcon Heights Medical Tower — acting as ${WC3_PERSONAS[0].name}`;
+/**
+* Intra-perspective nav. Literals rather than an import of PERSPECTIVES, for the same reason
+* lineageNav uses literals: it would close the cycle workspace → registry → tabs → shared →
+* workspace. The shell guards an unknown tab id, so a rename degrades to a no-op rather than a crash.
+*/
+const analysisNav = {
+	object: () => ({
+		perspectiveId: "analysis",
+		tabId: "object"
+	}),
+	data: () => ({
+		perspectiveId: "analysis",
+		tabId: "data"
+	}),
+	saved: () => ({
+		perspectiveId: "analysis",
+		tabId: "saved"
+	})
+};
+/**
+* The execution engine a spec routes to. DERIVED from the shape of the query, never chosen by the
+* user and never faked — this is the architectural point of the whole perspective: one semantic
+* spec, three engines.
+*
+* Transcribed from the prototype's `anRoute`. Two things are transcribed rather than "improved":
+*   · `needsRuntime` tests the metric's DECLARED `needs`, not the OBSERVED
+*     `analysisMetricMissingInput`. Today both `needs` metrics are unmaterialised so the two agree;
+*     the rule is the prototype's and stays. Materialising badge_events_import_raw would still route
+*     to Product Runtime, which is correct — the metric is a product job either way.
+*   · `grouped` is true for every spec this UI can produce, because the Group stage offers no "none"
+*     option. So `joined` never actually moves the branch. See WC3_ANALYSIS_MESSAGES.routeLevers,
+*     which the exec-meta panel renders so the surface does not imply otherwise.
+*/
+function analysisRoute(spec) {
+	const hist = spec.window > 0;
+	const grouped = !!spec.groupBy;
+	const joined = spec.mode === "data" ? !!spec.joinDs : !!spec.traverse;
+	if (spec.metrics.some((id) => !!analysisMetric(id)?.needs)) return {
+		id: "runtime",
+		label: ROUTE_LABEL.runtime,
+		why: WC3_ANALYSIS_MESSAGES.routeWhy.runtime
+	};
+	if (hist && (grouped || joined)) return {
+		id: "analytical",
+		label: ROUTE_LABEL.analytical,
+		why: WC3_ANALYSIS_MESSAGES.routeWhy.analytical(grouped)
+	};
+	return {
+		id: "operational",
+		label: ROUTE_LABEL.operational,
+		why: WC3_ANALYSIS_MESSAGES.routeWhy.operational(joined)
+	};
+}
+const DAY_MS = 864e5;
+/** "2026-07-22 06:55" → epoch ms. The fixture stamps use a space, not a T. */
+const parseStamp = (s) => Date.parse(s.replace(" ", "T"));
+/** The join key an object-mode traversal / a data-mode join actually follows, or null. */
+function analysisJoinKey(spec) {
+	return spec.mode === "object" ? spec.traverse ?? null : spec.joinDs ? "reported_by" : null;
+}
+const stringField = (row, field) => {
+	const v = row[field];
+	return typeof v === "string" ? v : null;
+};
+/**
+* Runs ONE spec over the seeded rows and returns aggregates only — never a materialised full result
+* set, mirroring the prototype's ObjectSetSpec/Costed<T> framing.
+*
+* MUTATION HAZARD, and the reason every step below copies: `WC3_OBSERVATION_ROWS` is not a copy of
+* the observation rows, it is the SAME array object as `WC3_PROCESS_INSTANCES.ot_observation`. The
+* traversal therefore builds joined rows with `{...r, __worker}` and never assigns `r.__worker`, and
+* nothing here calls `.sort()` or `.reverse()` on a source array — only on arrays this function has
+* just created. A single in-place write would silently change the Processes instance queue and the
+* ontology instance counts, and it would not show up in this perspective's own tests.
+*/
+function analysisRun(spec) {
+	const t0 = performance.now();
+	const source = spec.mode === "object" ? WC3_OBSERVATION_ROWS : analysisDatasetRows(spec.sourceDs ?? "");
+	const sourceEmpty = source.length === 0;
+	const sourceHasTimeColumn = source.some((r) => typeof r.observed_at === "string");
+	let rowsScanned = source.length;
+	let rows = source;
+	if (spec.window > 0) {
+		const floor = WC3_PROCESS_FIXTURE_NOW_MS - spec.window * 7 * DAY_MS;
+		rows = rows.filter((r) => {
+			const stamp = stringField(r, "observed_at");
+			return stamp !== null && parseStamp(stamp) >= floor;
+		});
+	}
+	for (const f of spec.filters) rows = rows.filter((r) => String(r[f.field]) === String(f.value));
+	const joinKey = analysisJoinKey(spec);
+	if (joinKey) rowsScanned += WC3_WORKER_ROWS.length;
+	const joined = rows.map((r) => ({
+		...r,
+		__worker: joinKey ? analysisWorker(stringField(r, joinKey)) : null
+	}));
+	const rowsUnlinked = joinKey ? joined.filter((r) => !r.__worker).length : 0;
+	const keyOf = (r) => {
+		const parts = [];
+		if (spec.groupBy === "contractor") parts.push(r.__worker?.contractor ?? "— unlinked —");
+		if (spec.groupBy === "severity") parts.push(stringField(r, "severity_level") ?? "—");
+		if (spec.groupBy === "zone") parts.push(stringField(r, "zone_id") ?? "—");
+		const observedAt = stringField(r, "observed_at");
+		if (spec.grain === "month" && observedAt) parts.push(observedAt.slice(0, 7));
+		return parts.join(" · ");
+	};
+	const buckets = /* @__PURE__ */ new Map();
+	for (const r of joined) {
+		const k = keyOf(r);
+		const bucket = buckets.get(k);
+		if (bucket) bucket.push(r);
+		else buckets.set(k, [r]);
+	}
+	const chosen = spec.metrics.map((id) => analysisMetric(id)).filter((m) => m !== void 0);
+	const supported = chosen.filter((m) => analysisMetricMissingInput(m) === null);
+	const blocked = chosen.filter((m) => analysisMetricMissingInput(m) !== null);
+	const groups = [...buckets.keys()].sort().map((key) => {
+		const bucket = buckets.get(key) ?? [];
+		const vals = {};
+		for (const m of supported) vals[m.id] = m.compute ? m.compute(bucket) : null;
+		return {
+			key,
+			n: bucket.length,
+			vals
+		};
+	}).sort((a, b) => b.n - a.n);
+	const ms = Math.max(1, Math.round((performance.now() - t0) * 10) / 10);
+	return {
+		groups,
+		supported,
+		blocked,
+		sourceEmpty,
+		sourceHasTimeColumn,
+		rowsScanned,
+		rowsMatched: joined.length,
+		rowsReturned: groups.length,
+		rowsUnlinked,
+		ms,
+		route: analysisRoute(spec),
+		exact: true,
+		asOf: WC3_PROCESS_FIXTURE_NOW,
+		materialised: false,
+		scope: WC3_ANALYSIS_SCOPE,
+		lineage: analysisLineage(spec)
+	};
+}
+/**
+* The provenance chain behind a result, as the exec-meta panel prints it.
+*
+* The object-mode middle line interpolates the traversal rather than hardcoding `reported_by`, and
+* appends whether the ontology actually declares that traversal — because one of the two offered
+* options is a plain property join. See {@link analysisTraversalKind}.
+*/
+function analysisLineage(spec) {
+	if (spec.mode === "object") {
+		const lines = ["ot_observation (seeded instances)"];
+		if (spec.traverse) {
+			const kind = analysisTraversalKind(spec.traverse);
+			lines.push(kind.declared ? `→ link ${spec.traverse} (${kind.linkTypeId} · ${kind.apiName})` : `→ property join ${spec.traverse} (no link type declares it)`, "→ ot_worker.contractor");
+		} else lines.push("→ no traversal");
+		return lines;
+	}
+	const lines = [analysisDatasetName(spec.sourceDs ?? "")];
+	if (spec.joinDs) lines.push(`⨝ ${analysisDatasetName(spec.joinDs)}`);
+	return lines;
+}
+/**
+* Why a result panel looks the way it does — ordered, first match wins.
+*
+* This is the fix for the prototype's only genuine gap: `AnResult` handles 0 rows SCANNED but not
+* 0 rows MATCHED, so data mode on ds_workers or ds_activities currently renders a blank result that
+* reads as a bug. Verified: at the shipped default window of 56 weeks, ds_workers scans 290 and
+* matches 0, ds_activities scans 230 and matches 0 — neither row table carries an observed_at
+* column. Drop the window to 0 and ds_workers matches every row but produces ONE group,
+* "— unlinked —", because the data-mode join key is fixed at reported_by.
+*/
+function analysisDiagnose(spec, res) {
+	if (res.sourceEmpty) return "source-empty";
+	if (res.rowsMatched === 0 && spec.window > 0 && !res.sourceHasTimeColumn) return "no-time-column";
+	if (res.rowsMatched === 0) return "filters-excluded-all";
+	if (spec.groupBy === "contractor" && res.rowsMatched > 0 && res.rowsUnlinked === res.rowsMatched) return "all-unlinked";
+	return "ok";
+}
+/**
+* Honest label for an object-mode traversal: is it an ontology-declared link, or a plain FK column
+* the ontology says nothing about?
+*
+* The prototype offers `reported_by → ot_worker` and `assigned_to → ot_worker` under the hint "Only
+* traversals the object type declares are offered". Verified against WC3_LINK_TYPES: ot_observation
+* declares exactly TWO links — lt_obs_reporter (fkProperty reported_by, apiName reportedBy) and
+* lt_obs_zone (fkProperty zone_id). ZERO link types reference assigned_to; it is the plain string
+* property p_assigned_to_139. The join resolves for all 44 non-null values, so the option is worth
+* keeping — but it is not the ontology acting as the semantic plane, and the UI must not say it is.
+*
+* Note the spec field is the raw FK COLUMN (`reported_by`), not the link apiName (`reportedBy`);
+* this maps one to the other so a label can cite the link type without changing the spec vocabulary.
+*/
+function analysisTraversalKind(fkProperty) {
+	const lt = WC3_LINK_TYPES.find((l) => l.backing.fkObjectTypeId === "ot_observation" && l.backing.fkProperty === fkProperty);
+	return lt ? {
+		declared: true,
+		linkTypeId: lt.id,
+		apiName: lt.sideA.apiName
+	} : { declared: false };
+}
+/**
+* The three lines the rail prints per stage — label (from WC3_ANALYSIS_STAGES), a description of
+* what the spec says, and a count of what the run produced. Transcribed from `AnStageRail`, and
+* derivable in full for BOTH modes.
+*
+* `bad` flags a stage that is the reason the result is degenerate: the prototype flags derive when a
+* metric is unsupported and source when it holds no rows; the filter flag is added here because when
+* a source has no time column it is the WINDOW that excluded every row, and the rail should point at
+* the stage that did it.
+*
+* The `publish` entry cannot count saved analyses — that lives on the session, and this function is
+* pure over (spec, result). The workbench fills the count in.
+*/
+function analysisStageSummary(spec, res) {
+	const diagnosis = analysisDiagnose(spec, res);
+	const joinKey = analysisJoinKey(spec);
+	const metricCount = `${spec.metrics.length} metric${spec.metrics.length === 1 ? "" : "s"}`;
+	return {
+		source: {
+			desc: spec.mode === "object" ? "ot_observation" : analysisDatasetName(spec.sourceDs ?? ""),
+			count: res.sourceEmpty ? "0 rows — not materialised" : `${res.rowsScanned.toLocaleString()} scanned`,
+			bad: res.sourceEmpty
+		},
+		filter: {
+			desc: spec.filters.length ? spec.filters.map((f) => `${f.field}=${f.value}`).join(", ") : "none",
+			count: `${res.rowsMatched.toLocaleString()} matched`,
+			bad: diagnosis === "no-time-column"
+		},
+		traverse: {
+			desc: spec.mode === "object" ? spec.traverse ? `→ ot_worker via ${spec.traverse}` : "none" : spec.joinDs ? `⨝ ${analysisDatasetName(spec.joinDs)}` : "none",
+			count: joinKey ? "joined ot_worker" : "—",
+			bad: false
+		},
+		derive: {
+			desc: metricCount,
+			count: res.blocked.length ? `${res.blocked.length} unsupported` : `${res.supported.length} computed`,
+			bad: res.blocked.length > 0
+		},
+		group: {
+			desc: `${spec.groupBy ?? "none"}${spec.grain === "month" ? " × month" : ""}`,
+			count: `${res.rowsReturned.toLocaleString()} groups`,
+			bad: false
+		},
+		viz: {
+			desc: spec.viz,
+			count: res.groups.length ? "ready" : "no rows",
+			bad: false
+		},
+		publish: {
+			desc: spec.name,
+			count: "—",
+			bad: false
+		}
+	};
+}
+const cloneSpec = (spec) => ({
+	...spec,
+	filters: spec.filters.map((f) => ({ ...f })),
+	metrics: [...spec.metrics]
+});
+/** Replace one mode's slot without a computed key, so the session type stays exact. */
+const withMode = (s, mode, state) => mode === "object" ? {
+	...s,
+	object: state
+} : {
+	...s,
+	data: state
+};
+/** One builder tab's live spec + result. */
+function analysisModeState(s, mode) {
+	return mode === "object" ? s.object : s.data;
+}
+/**
+* The ONE way a spec changes. Re-runs the analysis, so the stored result is never stale, and drops
+* `materialised` — a materialisation is a fact about one executed spec, not about the builder.
+*/
+function analysisSetSpec(s, mode, patch) {
+	const next = {
+		...analysisModeState(s, mode).spec,
+		...patch
+	};
+	return withMode(s, mode, {
+		spec: next,
+		result: analysisRun(next)
+	});
+}
+/**
+* Back to the mode's default spec.
+*
+* The prototype resets on every MODE SWITCH, destroying the other mode's half-built query. Here the
+* two modes are two tabs and both stay alive, so the reset is offered explicitly instead — reachable
+* but never accidental. Documented divergence.
+*/
+function analysisResetSpec(s, mode) {
+	const next = wc3AnalysisDefaultSpec(mode);
+	return withMode(s, mode, {
+		spec: next,
+		result: analysisRun(next)
+	});
+}
+/**
+* Save the spec together with the route, the counts and the timing AS EXECUTED — which is why the
+* result is stored beside its spec rather than re-derived: `ms` is a measurement, not a property of
+* the spec, and a saved record must agree with what the panel showed when Save was pressed.
+*/
+function analysisSaveAnalysis(s, mode) {
+	const { spec, result } = analysisModeState(s, mode);
+	const saved = {
+		id: `AN-${s.saved.length + 1}`,
+		name: spec.name,
+		spec: cloneSpec(spec),
+		route: result.route.label,
+		rows: result.rowsMatched,
+		groups: result.rowsReturned,
+		ms: result.ms,
+		at: WC3_PROCESS_FIXTURE_NOW
+	};
+	return {
+		...s,
+		saved: [...s.saved, saved]
+	};
+}
+/** The one mutation that writes a result without touching its spec: it flips `materialised`. */
+function analysisSaveMaterialisation(s, mode) {
+	const { spec, result } = analysisModeState(s, mode);
+	const mat = {
+		id: `MAT-${s.materialisations.length + 1}`,
+		name: `${spec.name} (materialised)`,
+		groups: result.rowsReturned,
+		at: WC3_PROCESS_FIXTURE_NOW,
+		route: result.route.label
+	};
+	return {
+		...withMode(s, mode, {
+			spec,
+			result: {
+				...result,
+				materialised: true
+			}
+		}),
+		materialisations: [...s.materialisations, mat]
+	};
+}
+function analysisDeleteSaved(s, id) {
+	return {
+		...s,
+		saved: s.saved.filter((a) => a.id !== id)
+	};
+}
+function analysisDeleteMaterialisation(s, id) {
+	return {
+		...s,
+		materialisations: s.materialisations.filter((m) => m.id !== id)
+	};
+}
+/** Re-open a saved analysis into ITS OWN mode's slot and re-run it. */
+function analysisReopen(s, saved) {
+	const spec = cloneSpec(saved.spec);
+	return withMode(s, spec.mode, {
+		spec,
+		result: analysisRun(spec)
+	});
+}
+/**
+* One option in a stage config body — the prototype's `.an-opt`.
+*
+* NEVER `disabled` when `unavailable`: selecting the unmaterialised dataset and the unsupported
+* metric is precisely how this page demonstrates the "not materialised" and "Product Runtime"
+* states. A disabled control would hide the two honesty demos the perspective exists to show.
+*
+* An unavailable option keeps the outline variant even when selected, because the amber text a
+* `default` (primary-filled) button would carry is unreadable on a primary background; selection is
+* signalled with a tinted background and a ring instead.
+*/
+function AnalysisOption({ selected, unavailable, onSelect, children, hint }) {
+	return /* @__PURE__ */ jsx(Button, {
+		type: "button",
+		size: "sm",
+		title: hint,
+		variant: selected && !unavailable ? "default" : "outline",
+		onClick: onSelect,
+		"aria-pressed": selected,
+		className: cn("wwc:mr-1.5 wwc:mb-1.5", unavailable && "wwc:border-amber-600/40 wwc:text-amber-700 wwc:dark:text-amber-400", selected && unavailable && "wwc:bg-amber-500/10 wwc:ring-1 wwc:ring-amber-600/40"),
+		children
+	});
+}
+/** The execution route as a Badge. Two consumers: the exec-meta panel and the saved list. */
+function AnalysisRouteBadge({ route }) {
+	const label = typeof route === "string" ? route : route.label;
+	const id = typeof route === "string" ? Object.keys(ROUTE_LABEL).find((k) => ROUTE_LABEL[k] === label) ?? "operational" : route.id;
+	return /* @__PURE__ */ jsx(Badge, {
+		variant: WC3_ANALYSIS_ROUTE_VARIANT[id],
+		children: label
+	});
+}
+/**
+* A spec rendered as labelled key/value pairs. Two consumers: the publish stage and the saved
+* cards/table — which is what lets the saved list's card be LOSSLESS against its row.
+*/
+function AnalysisSpecSummary({ spec, dense }) {
+	const rows = [
+		{
+			label: "Mode",
+			value: spec.mode === "object" ? "Object analysis" : "Data analysis"
+		},
+		{
+			label: "Source",
+			value: spec.mode === "object" ? spec.sourceType ?? "—" : analysisDatasetName(spec.sourceDs ?? ""),
+			mono: true
+		},
+		{
+			label: "Filters",
+			value: spec.filters.length ? spec.filters.map((f) => `${f.field} = ${f.value}`).join(", ") : "none"
+		},
+		{
+			label: spec.mode === "object" ? "Traverse" : "Join",
+			value: spec.mode === "object" ? spec.traverse ? `${spec.traverse} → ot_worker` : "no traversal" : spec.joinDs ? `⨝ ${analysisDatasetName(spec.joinDs)} on reported_by = worker_id` : "no join"
+		},
+		{
+			label: "Metrics",
+			value: spec.metrics.length ? spec.metrics.map((id) => analysisMetric(id)?.label ?? id).join(", ") : "none"
+		},
+		{
+			label: "Group",
+			value: `${spec.groupBy ?? "none"}${spec.grain === "month" ? " × month" : ""}`
+		},
+		{
+			label: "Window",
+			value: spec.window === 0 ? "current state only" : `${spec.window} weeks`
+		},
+		{
+			label: "Chart",
+			value: spec.viz
+		}
+	];
+	return /* @__PURE__ */ jsx("dl", {
+		className: cn("wwc:grid wwc:grid-cols-[minmax(0,7rem)_minmax(0,1fr)] wwc:text-sm", dense ? "wwc:gap-x-3 wwc:gap-y-0.5 wwc:text-xs" : "wwc:gap-x-4 wwc:gap-y-1"),
+		children: rows.map((row) => /* @__PURE__ */ jsxs("div", {
+			className: "wwc:contents",
+			children: [/* @__PURE__ */ jsx("dt", {
+				className: "wwc:truncate wwc:text-muted-foreground",
+				children: row.label
+			}), /* @__PURE__ */ jsx("dd", {
+				className: "wwc:min-w-0 wwc:break-words wwc:text-foreground",
+				children: row.mono ? /* @__PURE__ */ jsx(Mono, { children: row.value }) : row.value
+			})]
+		}, row.label))
+	});
+}
+/**
+* The horizontal bar option for a grouped result.
+*
+* No hardcoded hex: the series colour comes from TrendChart's `seriesThemes`. ECharts draws a
+* category axis bottom-up, so the already size-sorted groups are reversed to put the largest at the
+* top of the chart.
+*
+* DOCUMENTED DIVERGENCE: the prototype caps the chart at 14 bars and the table at 20 rows. Those
+* caps were a CSS-bar limitation, not a data one — the widest grouping this fixture can produce is
+* zone × month at 24 groups — so every group is charted and every group is tabled, and the height
+* grows with the group count instead.
+*/
+function horizontalBarOption(groups) {
+	const ordered = [...groups].reverse();
+	return {
+		grid: {
+			left: 148,
+			right: 24,
+			top: 8,
+			bottom: 28,
+			containLabel: false
+		},
+		tooltip: {
+			trigger: "axis",
+			axisPointer: { type: "shadow" }
+		},
+		xAxis: {
+			type: "value",
+			splitLine: { lineStyle: { type: "dashed" } }
+		},
+		yAxis: {
+			type: "category",
+			data: ordered.map((g) => g.key),
+			axisTick: { show: false }
+		},
+		series: [{
+			type: "bar",
+			data: ordered.map((g) => g.n),
+			barWidth: 12,
+			itemStyle: { borderRadius: 3 }
+		}]
+	};
+}
+function MetaRow({ label, children }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "wwc:contents",
+		children: [/* @__PURE__ */ jsx("dt", {
+			className: "wwc:text-muted-foreground",
+			children: label
+		}), /* @__PURE__ */ jsx("dd", {
+			className: "wwc:min-w-0 wwc:break-words wwc:text-foreground",
+			children
+		})]
+	});
+}
+/**
+* THE STAGED BUILDER. Both builder tabs mount this one component and pass exactly two stage bodies —
+* Source and Traverse / Join, the only two the prototype itself writes differently per mode. The
+* rail, Filter, Derive, Group, Visualize, Publish, the result panel and the execution-meta panel are
+* one implementation, which is the reason the two tabs cannot drift.
+*/
+function AnalysisWorkbench({ mode, session, onSessionChange, onNavigate, renderSourceConfig, renderTraverseConfig }) {
+	const [openStages, setOpenStages] = usePersistentState(`wc3.analysis.${mode}.stages`, ["source"]);
+	const [note, setNote] = useState(null);
+	const [ranSpec, setRanSpec] = usePersistentState(`wc3.analysis.${mode}.ran`, null);
+	const { spec, result } = analysisModeState(session, mode);
+	const setSpec = (patch) => {
+		setNote(null);
+		onSessionChange(analysisSetSpec(session, mode, patch));
+	};
+	const rail = analysisStageSummary(spec, result);
+	const diagnosis = analysisDiagnose(spec, result);
+	const joinKey = analysisJoinKey(spec);
+	const ctx = {
+		spec,
+		result,
+		setSpec
+	};
+	const configStages = WC3_ANALYSIS_STAGES.filter((s) => s.id !== "publish" && s.id !== "viz");
+	const specToken = JSON.stringify(spec);
+	const defaultToken = JSON.stringify(wc3AnalysisDefaultSpec(mode));
+	const hasRun = ranSpec !== null;
+	const stale = hasRun && ranSpec !== specToken;
+	const vizToggle = /* @__PURE__ */ jsxs(ToggleGroup, {
+		type: "single",
+		value: spec.viz,
+		onValueChange: (next) => {
+			if (next === "bar" || next === "table") setSpec({ viz: next });
+		},
+		variant: "outline",
+		size: "sm",
+		children: [/* @__PURE__ */ jsx(ToggleGroupItem, {
+			value: "bar",
+			"aria-label": "Bar chart",
+			title: "Bar chart",
+			children: /* @__PURE__ */ jsx(BarChart3, { className: "wwc:h-3.5 wwc:w-3.5" })
+		}), /* @__PURE__ */ jsx(ToggleGroupItem, {
+			value: "table",
+			"aria-label": "Table",
+			title: "Table",
+			children: /* @__PURE__ */ jsx(Table2, { className: "wwc:h-3.5 wwc:w-3.5" })
+		})]
+	});
+	const groupLabel = `${spec.groupBy ?? "group"}${spec.grain === "month" ? " · month" : ""}`;
+	const stageBody = (id) => {
+		switch (id) {
+			case "source": return /* @__PURE__ */ jsx("div", { children: renderSourceConfig(ctx) });
+			case "filter": return /* @__PURE__ */ jsxs("div", { children: [
+				/* @__PURE__ */ jsx("div", {
+					className: "wwc:flex wwc:flex-wrap",
+					children: WC3_ANALYSIS_SEVERITIES.map((sev) => {
+						const on = spec.filters.some((f) => f.value === sev);
+						return /* @__PURE__ */ jsxs(AnalysisOption, {
+							selected: on,
+							onSelect: () => setSpec({ filters: on ? spec.filters.filter((f) => f.value !== sev) : [...spec.filters, {
+								field: "severity_level",
+								value: sev
+							}] }),
+							children: ["severity = ", sev]
+						}, sev);
+					})
+				}),
+				/* @__PURE__ */ jsx("p", {
+					className: "wwc:mt-2 wwc:text-xs wwc:font-medium wwc:text-foreground",
+					children: "Window"
+				}),
+				/* @__PURE__ */ jsx("div", {
+					className: "wwc:mt-1 wwc:flex wwc:flex-wrap",
+					children: [...WC3_ANALYSIS_WINDOWS, 0].map((w) => {
+						const preview = analysisRoute({
+							...spec,
+							window: w
+						});
+						return /* @__PURE__ */ jsxs(AnalysisOption, {
+							selected: spec.window === w,
+							onSelect: () => setSpec({ window: w }),
+							children: [w === 0 ? "current state only" : `${w} weeks`, /* @__PURE__ */ jsxs("span", {
+								className: "wwc:opacity-70",
+								children: ["· ", preview.label]
+							})]
+						}, w);
+					})
+				}),
+				/* @__PURE__ */ jsx("p", {
+					className: "wwc:mt-2 wwc:text-xs wwc:text-muted-foreground",
+					children: WC3_ANALYSIS_MESSAGES.windowInert
+				})
+			] });
+			case "traverse": return renderTraverseConfig(ctx);
+			case "derive": return /* @__PURE__ */ jsx("div", {
+				className: "wwc:flex wwc:flex-wrap",
+				children: WC3_ANALYSIS_METRICS.map((m) => {
+					const missing = analysisMetricMissingInput(m);
+					const on = spec.metrics.includes(m.id);
+					return /* @__PURE__ */ jsxs(AnalysisOption, {
+						selected: on,
+						unavailable: missing !== null,
+						onSelect: () => setSpec({ metrics: on ? spec.metrics.filter((x) => x !== m.id) : [...spec.metrics, m.id] }),
+						children: [m.label, missing !== null ? /* @__PURE__ */ jsx("span", {
+							className: "wwc:opacity-70",
+							children: "· unavailable"
+						}) : null]
+					}, m.id);
+				})
+			});
+			case "group": return /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsx("div", {
+				className: "wwc:flex wwc:flex-wrap",
+				children: WC3_ANALYSIS_GROUP_BYS.map((g) => /* @__PURE__ */ jsxs(AnalysisOption, {
+					selected: spec.groupBy === g,
+					onSelect: () => setSpec({ groupBy: g }),
+					children: ["by ", g]
+				}, g))
+			}), /* @__PURE__ */ jsx("div", {
+				className: "wwc:mt-1 wwc:flex wwc:flex-wrap",
+				children: /* @__PURE__ */ jsx(AnalysisOption, {
+					selected: spec.grain === "month",
+					onSelect: () => setSpec({ grain: spec.grain === "month" ? null : "month" }),
+					children: "× month"
+				})
+			})] });
+			case "viz": return /* @__PURE__ */ jsx("div", {
+				className: "wwc:flex wwc:flex-wrap",
+				children: ["bar", "table"].map((v) => /* @__PURE__ */ jsx(AnalysisOption, {
+					selected: spec.viz === v,
+					onSelect: () => setSpec({ viz: v }),
+					children: v
+				}, v))
+			});
+		}
+	};
+	const publishActions = /* @__PURE__ */ jsxs("div", {
+		className: "wwc:flex wwc:items-center wwc:gap-1.5",
+		children: [/* @__PURE__ */ jsx(Button, {
+			type: "button",
+			size: "sm",
+			onClick: () => {
+				onSessionChange(analysisSaveAnalysis(session, mode));
+				toast.success(WC3_ANALYSIS_MESSAGES.savedToast(spec.name));
+			},
+			children: "Save analysis"
+		}), /* @__PURE__ */ jsxs(DropdownMenu, { children: [/* @__PURE__ */ jsx(DropdownMenuTrigger, {
+			asChild: true,
+			children: /* @__PURE__ */ jsxs(Button, {
+				type: "button",
+				size: "sm",
+				variant: "outline",
+				children: ["More", /* @__PURE__ */ jsx(ChevronDown, { className: "wwc:h-3.5 wwc:w-3.5" })]
+			})
+		}), /* @__PURE__ */ jsxs(DropdownMenuContent, {
+			align: "start",
+			className: "wwc:w-64",
+			children: [
+				/* @__PURE__ */ jsx(DropdownMenuItem, {
+					onSelect: () => {
+						onSessionChange(analysisSaveMaterialisation(session, mode));
+						toast.success(WC3_ANALYSIS_MESSAGES.materialisedToast(result.rowsReturned));
+					},
+					children: "Save as materialisation"
+				}),
+				/* @__PURE__ */ jsx(DropdownMenuItem, {
+					onSelect: () => {
+						return setNote({
+							variant: "info",
+							title: "Add to Command Center",
+							description: WC3_ANALYSIS_MESSAGES.publish.commandCentre
+						});
+					},
+					children: "Add to Command Center"
+				}),
+				/* @__PURE__ */ jsx(DropdownMenuItem, {
+					onSelect: () => {
+						return setNote({
+							variant: "warning",
+							title: "Map result to an Object Type",
+							description: WC3_ANALYSIS_MESSAGES.publish.mapToObjectType
+						});
+					},
+					children: "Map result to an Object Type"
+				}),
+				/* @__PURE__ */ jsx(DropdownMenuItem, {
+					onSelect: () => {
+						return setNote({
+							variant: "info",
+							title: "Feed to Product Runtime",
+							description: WC3_ANALYSIS_MESSAGES.publish.productRuntime
+						});
+					},
+					children: "Feed to Product Runtime"
+				}),
+				/* @__PURE__ */ jsx(DropdownMenuItem, {
+					onSelect: () => {
+						const top = result.groups[0];
+						setNote(top ? {
+							variant: "info",
+							title: "Create Action proposal",
+							description: WC3_ANALYSIS_MESSAGES.publish.actionProposal(top.key, top.n)
+						} : {
+							variant: "warning",
+							title: "Create Action proposal",
+							description: WC3_ANALYSIS_MESSAGES.publish.noGroups
+						});
+					},
+					children: "Create Action proposal"
+				})
+			]
+		})] })]
+	});
+	const resultBody = () => {
+		if (diagnosis === "source-empty") return /* @__PURE__ */ jsx(Banner, {
+			variant: "warning",
+			title: "No rows to analyse.",
+			description: WC3_ANALYSIS_MESSAGES.sourceEmpty(analysisDatasetName(spec.sourceDs ?? ""))
+		});
+		if (diagnosis === "no-time-column") return /* @__PURE__ */ jsx(Banner, {
+			variant: "warning",
+			title: "0 rows matched — this dataset has no time column.",
+			description: WC3_ANALYSIS_MESSAGES.noTimeColumn(analysisDatasetName(spec.sourceDs ?? ""), spec.window, result.rowsScanned)
+		});
+		if (diagnosis === "filters-excluded-all") return /* @__PURE__ */ jsx(Banner, {
+			variant: "warning",
+			title: "0 rows matched.",
+			description: WC3_ANALYSIS_MESSAGES.filtersExcludedAll(result.rowsScanned)
+		});
+		if (diagnosis === "all-unlinked") return /* @__PURE__ */ jsx(Banner, {
+			variant: "warning",
+			title: "Every matched row is unlinked.",
+			description: WC3_ANALYSIS_MESSAGES.allUnlinked(joinKey ?? "no join key")
+		});
+		if (spec.viz === "bar") return /* @__PURE__ */ jsx(TrendChart, {
+			title: `Grouped by ${groupLabel}`,
+			actions: vizToggle,
+			value: `${result.rowsMatched.toLocaleString()} rows`,
+			option: horizontalBarOption(result.groups),
+			seriesThemes: [{ tone: "primary" }],
+			height: Math.max(240, result.groups.length * 24 + 64)
+		});
+		return /* @__PURE__ */ jsxs("div", { children: [/* @__PURE__ */ jsxs("div", {
+			className: "wwc:mb-2 wwc:flex wwc:items-center wwc:justify-between wwc:gap-3",
+			children: [/* @__PURE__ */ jsxs("span", {
+				className: "wwc:text-sm wwc:font-medium",
+				children: ["Grouped by ", groupLabel]
+			}), vizToggle]
+		}), /* @__PURE__ */ jsx("div", {
+			className: "wwc:overflow-x-auto",
+			children: /* @__PURE__ */ jsxs(Table$1, { children: [/* @__PURE__ */ jsx(TableHeader, { children: /* @__PURE__ */ jsxs(TableRow, { children: [/* @__PURE__ */ jsx(TableHead, { children: groupLabel }), result.supported.map((m) => /* @__PURE__ */ jsx(TableHead, {
+				className: "wwc:text-right",
+				children: m.label
+			}, m.id))] }) }), /* @__PURE__ */ jsx(TableBody, { children: result.groups.map((g) => /* @__PURE__ */ jsxs(TableRow, { children: [/* @__PURE__ */ jsx(TableCell, { children: g.key }), result.supported.map((m) => /* @__PURE__ */ jsx(TableCell, {
+				className: "wwc:text-right wwc:tabular-nums",
+				children: g.vals[m.id] === null || g.vals[m.id] === void 0 ? "—" : g.vals[m.id]?.toLocaleString()
+			}, m.id))] }, g.key)) })] })
+		})] });
+	};
+	return /* @__PURE__ */ jsx("div", {
+		className: "wwc:flex wwc:min-h-0 wwc:flex-1 wwc:flex-col wwc:gap-4 wwc:overflow-hidden wwc:px-6 wwc:pb-6 wwc:pt-4",
+		children: /* @__PURE__ */ jsxs("div", {
+			className: "wwc:grid wwc:min-h-0 wwc:min-w-0 wwc:flex-1 wwc:gap-4 wwc:xl:grid-cols-[21rem_minmax(0,1fr)]",
+			children: [/* @__PURE__ */ jsxs("div", {
+				className: "wwc:flex wwc:min-h-0 wwc:min-w-0 wwc:flex-col wwc:overflow-hidden wwc:rounded-lg wwc:border wwc:border-border wwc:bg-card wwc:text-card-foreground",
+				children: [/* @__PURE__ */ jsxs("div", {
+					className: "wwc:flex wwc:min-h-0 wwc:min-w-0 wwc:flex-1 wwc:flex-col wwc:gap-3 wwc:overflow-y-auto wwc:overflow-x-hidden wwc:p-3",
+					children: [/* @__PURE__ */ jsx(Accordion, {
+						type: "multiple",
+						value: openStages,
+						onValueChange: setOpenStages,
+						className: "wwc:-mx-3 wwc:-mt-3 wwc:min-w-0",
+						children: configStages.map((s) => {
+							const cell = rail[s.id];
+							return /* @__PURE__ */ jsxs(AccordionItem, {
+								value: s.id,
+								className: "wwc:px-3 wwc:last:border-b-0",
+								children: [/* @__PURE__ */ jsx(AccordionTrigger, {
+									className: "wwc:py-2.5 wwc:hover:no-underline",
+									children: /* @__PURE__ */ jsxs("span", {
+										className: "wwc:flex wwc:min-w-0 wwc:flex-1 wwc:flex-col wwc:items-start wwc:gap-0.5 wwc:pr-2 wwc:text-left",
+										children: [/* @__PURE__ */ jsxs("span", {
+											className: "wwc:flex wwc:items-center wwc:gap-1.5 wwc:text-xs wwc:font-semibold",
+											children: [s.label, cell.bad ? /* @__PURE__ */ jsx(AlertTriangle, { className: "wwc:h-3.5 wwc:w-3.5 wwc:text-amber-500" }) : null]
+										}), /* @__PURE__ */ jsx("span", {
+											className: "wwc:w-full wwc:truncate wwc:text-xs wwc:font-normal wwc:text-muted-foreground",
+											children: cell.desc
+										})]
+									})
+								}), /* @__PURE__ */ jsx(AccordionContent, {
+									className: "wwc:pb-3",
+									children: stageBody(s.id)
+								})]
+							}, s.id);
+						})
+					}), note ? /* @__PURE__ */ jsx(Banner, {
+						variant: note.variant,
+						title: note.title,
+						description: note.description,
+						onDismiss: () => setNote(null)
+					}) : null]
+				}), /* @__PURE__ */ jsxs("div", {
+					className: "wwc:flex wwc:shrink-0 wwc:items-center wwc:gap-2 wwc:border-t wwc:border-border wwc:p-3",
+					children: [/* @__PURE__ */ jsxs(Button, {
+						type: "button",
+						className: "wwc:flex-1",
+						onClick: () => {
+							setNote(null);
+							setRanSpec(specToken);
+						},
+						children: [/* @__PURE__ */ jsx(Play, { className: "wwc:h-4 wwc:w-4" }), hasRun ? "Run analysis again" : "Run analysis"]
+					}), /* @__PURE__ */ jsx(Button, {
+						type: "button",
+						variant: "outline",
+						icon: true,
+						"aria-label": "Reset analysis",
+						tooltip: "Reset to the starting point",
+						disabled: !hasRun && specToken === defaultToken,
+						onClick: () => {
+							setNote(null);
+							setRanSpec(null);
+							onSessionChange(analysisResetSpec(session, mode));
+						},
+						children: /* @__PURE__ */ jsx(RotateCcw, { className: "wwc:h-4 wwc:w-4" })
+					})]
+				})]
+			}), /* @__PURE__ */ jsx("div", {
+				className: "wwc:flex wwc:min-h-0 wwc:min-w-0 wwc:flex-col wwc:gap-4 wwc:overflow-hidden",
+				children: !hasRun ? /* @__PURE__ */ jsx(Card, {
+					className: "wwc:flex wwc:min-h-[24rem] wwc:flex-1 wwc:items-center wwc:justify-center",
+					children: /* @__PURE__ */ jsx(Empty, {
+						icon: /* @__PURE__ */ jsx(Play, { className: "wwc:h-6 wwc:w-6" }),
+						title: "No analysis run yet",
+						description: "Set the stages on the left — source, filter, traversal, metrics, grouping — then run the analysis to see its result and how it executed."
+					})
+				}) : /* @__PURE__ */ jsxs("div", {
+					className: "wwc:grid wwc:min-h-0 wwc:min-w-0 wwc:flex-1 wwc:gap-4 wwc:overflow-hidden wwc:xl:grid-cols-[minmax(0,1fr)_19rem]",
+					children: [/* @__PURE__ */ jsxs("div", {
+						className: "wwc:flex wwc:min-h-0 wwc:min-w-0 wwc:flex-col wwc:overflow-hidden wwc:rounded-lg wwc:border wwc:border-border wwc:bg-card wwc:text-card-foreground",
+						children: [/* @__PURE__ */ jsxs("div", {
+							className: "wwc:flex wwc:min-h-0 wwc:min-w-0 wwc:flex-1 wwc:flex-col wwc:overflow-auto",
+							children: [/* @__PURE__ */ jsxs(CardHeader, {
+								className: "wwc:gap-1 wwc:p-3",
+								children: [/* @__PURE__ */ jsx(CardTitle, {
+									className: "wwc:text-sm",
+									children: "Result"
+								}), /* @__PURE__ */ jsx("p", {
+									className: "wwc:text-sm wwc:text-muted-foreground",
+									children: WC3_ANALYSIS_MESSAGES.resultFooter(result.rowsReturned, result.rowsMatched)
+								})]
+							}), /* @__PURE__ */ jsxs(CardContent, {
+								className: "wwc:min-w-0 wwc:flex-1 wwc:space-y-3 wwc:p-3 wwc:pt-0",
+								children: [
+									stale ? /* @__PURE__ */ jsx(Banner, {
+										variant: "warning",
+										title: "Configuration changed since this ran",
+										description: "The result below is from the previous configuration. Run the analysis again to refresh it."
+									}) : null,
+									result.blocked.length > 0 ? /* @__PURE__ */ jsx(Banner, {
+										variant: "warning",
+										title: `${result.blocked.length} metric${result.blocked.length === 1 ? "" : "s"} cannot be computed`,
+										description: WC3_ANALYSIS_MESSAGES.blockedMetrics,
+										items: result.blocked.map((m) => m.label)
+									}) : null,
+									resultBody()
+								]
+							})]
+						}), /* @__PURE__ */ jsx("div", {
+							className: "wwc:shrink-0 wwc:border-t wwc:border-border wwc:p-3",
+							children: publishActions
+						})]
+					}), /* @__PURE__ */ jsxs(Card, {
+						className: "wwc:min-h-0 wwc:min-w-0 wwc:overflow-auto",
+						children: [/* @__PURE__ */ jsx(CardHeader, {
+							className: "wwc:p-3",
+							children: /* @__PURE__ */ jsx(CardTitle, {
+								className: "wwc:text-sm",
+								children: "Execution"
+							})
+						}), /* @__PURE__ */ jsxs(CardContent, {
+							className: "wwc:space-y-3 wwc:p-3 wwc:pt-0",
+							children: [
+								/* @__PURE__ */ jsxs("dl", {
+									className: "wwc:grid wwc:grid-cols-[minmax(0,6.5rem)_minmax(0,1fr)] wwc:gap-x-3 wwc:gap-y-1.5 wwc:text-xs",
+									children: [
+										/* @__PURE__ */ jsx(MetaRow, {
+											label: "Route",
+											children: /* @__PURE__ */ jsx(AnalysisRouteBadge, { route: result.route })
+										}),
+										/* @__PURE__ */ jsx(MetaRow, {
+											label: "Rows scanned",
+											children: result.rowsScanned.toLocaleString()
+										}),
+										/* @__PURE__ */ jsxs(MetaRow, {
+											label: "Rows returned",
+											children: [result.rowsReturned.toLocaleString(), " groups"]
+										}),
+										/* @__PURE__ */ jsxs(MetaRow, {
+											label: "Time",
+											children: [
+												result.ms,
+												" ms ",
+												/* @__PURE__ */ jsx("span", {
+													className: "wwc:text-muted-foreground",
+													children: "measured, in-browser"
+												})
+											]
+										}),
+										/* @__PURE__ */ jsx(MetaRow, {
+											label: "Result",
+											children: result.exact ? "Exact" : "Estimated"
+										}),
+										/* @__PURE__ */ jsx(MetaRow, {
+											label: "As of",
+											children: result.asOf
+										}),
+										/* @__PURE__ */ jsx(MetaRow, {
+											label: "Storage",
+											children: result.materialised ? "Materialised" : "Live query"
+										}),
+										/* @__PURE__ */ jsxs(MetaRow, {
+											label: "Scope",
+											children: [
+												result.scope,
+												" ",
+												/* @__PURE__ */ jsxs("span", {
+													className: "wwc:text-muted-foreground",
+													children: [
+														"(",
+														WC3_ANALYSIS_MESSAGES.scopeQualifier,
+														")"
+													]
+												})
+											]
+										}),
+										/* @__PURE__ */ jsx(MetaRow, {
+											label: "Lineage",
+											children: result.lineage.map((line) => /* @__PURE__ */ jsx("span", {
+												className: "wwc:block wwc:font-mono wwc:text-[11px]",
+												children: line
+											}, line))
+										})
+									]
+								}),
+								/* @__PURE__ */ jsxs("div", {
+									className: "wwc:rounded-md wwc:border wwc:border-border wwc:bg-muted/40 wwc:p-2 wwc:text-xs wwc:text-muted-foreground",
+									children: [
+										/* @__PURE__ */ jsx("span", {
+											className: "wwc:font-semibold wwc:text-foreground",
+											children: "Why this engine:"
+										}),
+										" ",
+										result.route.why,
+										/* @__PURE__ */ jsx("p", {
+											className: "wwc:mt-1.5",
+											children: WC3_ANALYSIS_MESSAGES.routeLevers
+										})
+									]
+								}),
+								/* @__PURE__ */ jsxs("div", {
+									className: "wwc:rounded-md wwc:border wwc:border-amber-600/40 wwc:bg-amber-500/10 wwc:p-2 wwc:text-xs wwc:text-amber-700 wwc:dark:text-amber-400",
+									children: [
+										/* @__PURE__ */ jsx("span", {
+											className: "wwc:font-semibold",
+											children: "Scope of this proof:"
+										}),
+										" ",
+										WC3_ANALYSIS_MESSAGES.proofScope(WC3_OBSERVATION_ROWS.length)
+									]
+								}),
+								/* @__PURE__ */ jsxs("p", {
+									className: "wwc:text-xs wwc:text-muted-foreground",
+									children: [
+										session.saved.length.toLocaleString(),
+										" saved ",
+										session.saved.length === 1 ? "analysis" : "analyses",
+										onNavigate ? /* @__PURE__ */ jsx(Button, {
+											type: "button",
+											size: "sm",
+											variant: "link",
+											className: "wwc:h-auto wwc:px-1 wwc:py-0",
+											onClick: () => onNavigate(analysisNav.saved()),
+											children: "Open Saved analyses"
+										}) : null
+									]
+								})
+							]
+						})]
+					})]
+				})
+			})]
+		})
+	});
+}
+//#endregion
+export { AnalysisOption, AnalysisRouteBadge, AnalysisSpecSummary, AnalysisWorkbench, Mono, Pane, TypeGlyphLabel, WC3_ANALYSIS_GROUP_BYS, WC3_ANALYSIS_MESSAGES, WC3_ANALYSIS_METRICS, WC3_ANALYSIS_ROUTE_VARIANT, WC3_ANALYSIS_SCOPE, WC3_ANALYSIS_SEVERITIES, WC3_ANALYSIS_SOURCE_DATASET_IDS, WC3_ANALYSIS_STAGES, WC3_ANALYSIS_WINDOWS, WC3_OBSERVATION_ROWS, WC3_WORKER_ROWS, analysisDataset, analysisDatasetMaterialised, analysisDatasetName, analysisDatasetRows, analysisDeleteMaterialisation, analysisDeleteSaved, analysisDiagnose, analysisLineage, analysisMetric, analysisMetricMissingInput, analysisModeState, analysisNav, analysisReopen, analysisResetSpec, analysisRoute, analysisRun, analysisSaveAnalysis, analysisSaveMaterialisation, analysisSetSpec, analysisStageSummary, analysisTraversalKind, analysisWorker, lineageNav, wc3AnalysisDefaultSpec };
+
+//# sourceMappingURL=wc3-analysis-shared.mjs.map