@burdenoff/microfe-bigconsole 2026.1012.4 → 2026.1012.6

package/dist/bigconsole/renderers/adapters/CustomRenderer.js

@@ -1,6 +1,6 @@
 import { memo as e, useMemo as t } from "react";
-import { jsx as n, jsxs as r } from "react/jsx-runtime";
-import { useI18n as i } from "@burdenoff/fe-libs/shared/providers/shell/I18nProvider";
+import { useI18n as n } from "@burdenoff/fe-libs/shared/providers/shell/I18nProvider";
+import { jsx as r, jsxs as i } from "react/jsx-runtime";
 //#region src/bigconsole/renderers/adapters/CustomRenderer.tsx
 var a = /* @__PURE__ */ new Map();
 function o(e, t) {
@@ -13,77 +13,77 @@ function c() {
 	return Array.from(a.keys());
 }
 o("SimpleText", ({ data: e, props: t }) => {
-	let { t: r } = i(), a = e.text || t?.text, o = t?.align || "left";
-	return a ? /* @__PURE__ */ n("div", {
+	let { t: i } = n(), a = e.text || t?.text, o = t?.align || "left";
+	return a ? /* @__PURE__ */ r("div", {
 		className: `p-4 text-${o}`,
-		children: /* @__PURE__ */ n("p", {
+		children: /* @__PURE__ */ r("p", {
 			className: "text-primary",
 			children: a
 		})
-	}) : /* @__PURE__ */ n("div", {
+	}) : /* @__PURE__ */ r("div", {
 		className: "flex items-center justify-center h-full p-4 text-secondary",
-		children: /* @__PURE__ */ n("p", {
+		children: /* @__PURE__ */ r("p", {
 			className: "text-sm",
-			children: r("bigconsole.widget.renderer.custom.noData", "No data available")
+			children: i("bigconsole.widget.renderer.custom.noData", "No data available")
 		})
 	});
 }), o("Counter", ({ data: e, props: t }) => {
-	let { t: a } = i(), o = e.value ?? t?.value, s = e.label || t?.label, c = t?.format || "number";
-	if (o == null) return /* @__PURE__ */ n("div", {
+	let { t: a } = n(), o = e.value ?? t?.value, s = e.label || t?.label, c = t?.format || "number";
+	if (o == null) return /* @__PURE__ */ r("div", {
 		className: "flex flex-col items-center justify-center h-full p-4 text-secondary",
-		children: /* @__PURE__ */ n("p", {
+		children: /* @__PURE__ */ r("p", {
 			className: "text-sm",
 			children: a("bigconsole.widget.renderer.custom.noData", "No data available")
 		})
 	});
 	let l = o;
-	return /* @__PURE__ */ r("div", {
+	return /* @__PURE__ */ i("div", {
 		className: "flex flex-col items-center justify-center h-full p-4 animate-in fade-in duration-200",
-		children: [/* @__PURE__ */ n("span", {
+		children: [/* @__PURE__ */ r("span", {
 			className: "text-3xl font-bold text-primary",
 			children: c === "currency" ? new Intl.NumberFormat("en-US", {
 				style: "currency",
 				currency: "USD"
 			}).format(l) : c === "percent" ? `${(l * 100).toFixed(1)}%` : new Intl.NumberFormat().format(l)
-		}), s && /* @__PURE__ */ n("span", {
+		}), s && /* @__PURE__ */ r("span", {
 			className: "text-sm text-secondary mt-1",
 			children: s
 		})]
 	});
 }), o("Card", ({ data: e, props: t, onAction: a }) => {
-	let { t: o } = i(), s = e.title || t?.title, c = e.description || t?.description || "";
-	if (!s && !c) return /* @__PURE__ */ n("div", {
+	let { t: o } = n(), s = e.title || t?.title, c = e.description || t?.description || "";
+	if (!s && !c) return /* @__PURE__ */ r("div", {
 		className: "flex items-center justify-center h-full p-4 text-secondary",
-		children: /* @__PURE__ */ n("p", {
+		children: /* @__PURE__ */ r("p", {
 			className: "text-sm",
 			children: o("bigconsole.widget.renderer.custom.noData", "No data available")
 		})
 	});
 	let l = e.image || t?.image, u = t?.actionLabel || o("bigconsole.widget.renderer.custom.viewDetails", "View Details"), d = t?.showAction !== !1;
-	return /* @__PURE__ */ r("div", {
+	return /* @__PURE__ */ i("div", {
 		className: "flex flex-col h-full bg-surface rounded-lg overflow-hidden animate-in fade-in duration-200",
 		children: [
-			l && /* @__PURE__ */ n("div", {
+			l && /* @__PURE__ */ r("div", {
 				className: "aspect-video bg-bg-sunken",
-				children: /* @__PURE__ */ n("img", {
+				children: /* @__PURE__ */ r("img", {
 					src: l,
 					alt: "",
 					className: "w-full h-full object-cover"
 				})
 			}),
-			/* @__PURE__ */ r("div", {
+			/* @__PURE__ */ i("div", {
 				className: "flex-1 p-4",
-				children: [s && /* @__PURE__ */ n("h3", {
+				children: [s && /* @__PURE__ */ r("h3", {
 					className: "text-lg font-semibold text-primary",
 					children: s
-				}), c && /* @__PURE__ */ n("p", {
+				}), c && /* @__PURE__ */ r("p", {
 					className: "text-sm text-secondary mt-1",
 					children: c
 				})]
 			}),
-			d && /* @__PURE__ */ n("div", {
+			d && /* @__PURE__ */ r("div", {
 				className: "p-4 pt-0",
-				children: /* @__PURE__ */ n("button", {
+				children: /* @__PURE__ */ r("button", {
 					type: "button",
 					onClick: () => a?.("click", { title: s }),
 					className: "w-full px-4 py-2 text-sm font-medium text-white bg-action-primary hover:bg-action-primary/90 rounded-md transition-colors",
@@ -94,25 +94,25 @@ o("SimpleText", ({ data: e, props: t }) => {
 	});
 });
 var l = ({ componentName: e }) => {
-	let { t } = i();
-	return /* @__PURE__ */ n("div", {
+	let { t } = n();
+	return /* @__PURE__ */ r("div", {
 		className: "flex flex-col items-center justify-center h-full p-4 text-secondary animate-in fade-in duration-200",
-		children: /* @__PURE__ */ r("div", {
+		children: /* @__PURE__ */ i("div", {
 			className: "text-center",
 			children: [
-				/* @__PURE__ */ n("p", {
+				/* @__PURE__ */ r("p", {
 					className: "font-medium",
 					children: t("bigconsole.widget.renderer.custom.componentNotFound", "Component Not Found")
 				}),
-				/* @__PURE__ */ n("p", {
+				/* @__PURE__ */ r("p", {
 					className: "text-sm mt-1",
 					children: t("bigconsole.widget.renderer.custom.componentNotRegistered", "Component \"{{name}}\" is not registered", { name: e ?? "" })
 				}),
-				/* @__PURE__ */ r("div", {
+				/* @__PURE__ */ i("div", {
 					className: "mt-4 text-xs",
-					children: [/* @__PURE__ */ n("p", { children: t("bigconsole.widget.renderer.custom.availableComponents", "Available components:") }), /* @__PURE__ */ n("ul", {
+					children: [/* @__PURE__ */ r("p", { children: t("bigconsole.widget.renderer.custom.availableComponents", "Available components:") }), /* @__PURE__ */ r("ul", {
 						className: "mt-1",
-						children: c().map((e) => /* @__PURE__ */ n("li", {
+						children: c().map((e) => /* @__PURE__ */ r("li", {
 							className: "text-link",
 							children: e
 						}, e))
@@ -122,44 +122,44 @@ var l = ({ componentName: e }) => {
 		})
 	});
 }, u = e(function({ widget: e, data: a, template: o, isLoading: c, error: u, onDrilldown: d, onAction: f }) {
-	let { t: p } = i(), m = t(() => {
+	let { t: p } = n(), m = t(() => {
 		if (o && typeof o == "object" && "componentName" in o) return o.componentName;
 		let t = e.config;
 		return t?.componentName || t?.componentId || "";
 	}, [o, e.config]), h = t(() => o && typeof o == "object" && "props" in o ? o.props : {}, [o]), g = t(() => m ? s(m) : null, [m]);
-	return c ? /* @__PURE__ */ n("div", {
+	return c ? /* @__PURE__ */ r("div", {
 		className: "flex items-center justify-center h-full p-4 animate-in fade-in duration-200",
-		children: /* @__PURE__ */ r("div", {
+		children: /* @__PURE__ */ i("div", {
 			className: "animate-pulse space-y-2 w-full",
-			children: [/* @__PURE__ */ n("div", { className: "h-4 bg-bg-sunken rounded w-3/4" }), /* @__PURE__ */ n("div", { className: "h-4 bg-bg-sunken rounded w-1/2" })]
+			children: [/* @__PURE__ */ r("div", { className: "h-4 bg-bg-sunken rounded w-3/4" }), /* @__PURE__ */ r("div", { className: "h-4 bg-bg-sunken rounded w-1/2" })]
 		})
-	}) : u ? /* @__PURE__ */ n("div", {
+	}) : u ? /* @__PURE__ */ r("div", {
 		className: "flex items-center justify-center h-full p-4 text-red-600 dark:text-red-400",
-		children: /* @__PURE__ */ r("div", {
+		children: /* @__PURE__ */ i("div", {
 			className: "text-center",
-			children: [/* @__PURE__ */ n("p", {
+			children: [/* @__PURE__ */ r("p", {
 				className: "font-medium",
 				children: p("bigconsole.widget.renderer.custom.errorRendering", "Error rendering component")
-			}), /* @__PURE__ */ n("p", {
+			}), /* @__PURE__ */ r("p", {
 				className: "text-sm mt-1",
 				children: u
 			})]
 		})
-	}) : m ? g ? /* @__PURE__ */ n(g, {
+	}) : m ? g ? /* @__PURE__ */ r(g, {
 		widget: e,
 		data: a,
 		template: o,
 		props: h,
 		onAction: f,
 		onDrilldown: d
-	}) : /* @__PURE__ */ n(l, { componentName: m }) : /* @__PURE__ */ n("div", {
+	}) : /* @__PURE__ */ r(l, { componentName: m }) : /* @__PURE__ */ r("div", {
 		className: "flex items-center justify-center h-full p-4 text-secondary animate-in fade-in duration-200",
-		children: /* @__PURE__ */ r("div", {
+		children: /* @__PURE__ */ i("div", {
 			className: "text-center",
-			children: [/* @__PURE__ */ n("p", {
+			children: [/* @__PURE__ */ r("p", {
 				className: "font-medium",
 				children: p("bigconsole.widget.renderer.custom.noComponentSpecified", "No Component Specified")
-			}), /* @__PURE__ */ n("p", {
+			}), /* @__PURE__ */ r("p", {
 				className: "text-sm mt-1",
 				children: p("bigconsole.widget.renderer.custom.setComponentName", "Set componentName in template or widget config")
 			})]

package/dist/bigconsole/store/widgetStore.d.ts

@@ -20,6 +20,18 @@ interface WidgetState {
     clipboardWidgetId: string | null;
     clipboardAction: 'copy' | 'cut' | null;
     gridLayout: GridLayoutItem[];
+    /**
+     * Counts the placements a PERSON made: bumped by `updateWidgetPosition` and by
+     * nothing else. The canvas calls that action only when a drag or a resize ENDS
+     * (`DashboardCanvas.handleLayoutChange`), and the inspector's "Position & size"
+     * fields call it only on a typed change that actually moves the widget
+     * (`LayoutSection.commit`). Loading (`setWidgets`), creating (`addWidget`),
+     * saving (`updateWidget`) and deleting (`removeWidget`) leave it alone, so a
+     * reader can tell "the person moved something" from "the list was refreshed"
+     * without comparing positions (BOFF-8060, the dashboard leave guard).
+     * Never reset: a reader keeps the last value it saw across `reset()`.
+     */
+    layoutEditRevision: number;
     typeFilter: WidgetType | null;
     setWidgets: (widgets: Widget[]) => void;
     addWidget: (widget: Widget) => void;

package/dist/bigconsole/store/widgetStore.js

@@ -20,6 +20,7 @@ var i = {
 	typeFilter: null
 }, a = e()(t(n((e, t) => ({
 	...i,
+	layoutEditRevision: 0,
 	setWidgets: (t) => e({
 		widgets: new Map(t.map((e) => [e.id, e])),
 		gridLayout: t.map((e) => ({
@@ -155,7 +156,8 @@ var i = {
 				y: n.y,
 				w: n.width,
 				h: n.height
-			} : e)
+			} : e),
+			layoutEditRevision: e.layoutEditRevision + 1
 		};
 	}),
 	setGridLayout: (t) => e({ gridLayout: t }),

package/dist/bigconsole/utils/backendError.d.ts

@@ -1,3 +1,21 @@
 type TranslateFn = (key: string, fallback: string) => string;
 export declare function resolveBackendErrorMessage(t: TranslateFn, error: unknown): string;
+/**
+ * Every GraphQL `extensions.code` reachable from an error, in the shapes the
+ * fe-libs Apollo 4 client hands back:
+ *
+ *  - `CombinedGraphQLErrors` (a `query()` resolved with `{ error }` under
+ *    errorPolicy "all", or thrown under "none"): `error.errors[]`;
+ *  - legacy Apollo 3 errors: `error.graphQLErrors[]`;
+ *  - `ServerError` for a non-2xx answer sent as `application/json` — a subgraph
+ *    that maps NOT_FOUND to HTTP 404 lands here, with the GraphQL body only in
+ *    `error.bodyText` (Apollo 3 kept it parsed on `error.result`);
+ *  - a bare GraphQL error: `error.extensions.code`;
+ *  - any of those wrapped in `cause` / `error`.
+ *
+ * Returns `[]` when none is found. Never throws.
+ */
+export declare function graphQLErrorCodes(error: unknown): string[];
+/** True when any GraphQL error reachable from `error` carries one of `codes`. */
+export declare function hasGraphQLErrorCode(error: unknown, codes: ReadonlySet<string>): boolean;
 export {};

package/dist/bigconsole/utils/backendError.js

@@ -0,0 +1,42 @@
+//#region src/bigconsole/utils/backendError.ts
+function e(e) {
+	return typeof e == "object" && !!e;
+}
+var t = 4;
+function n(t) {
+	return Array.isArray(t) ? t.flatMap((t) => {
+		let n = e(t) && e(t.extensions) ? t.extensions.code : void 0;
+		return typeof n == "string" && n.length > 0 ? [n] : [];
+	}) : [];
+}
+function r(t) {
+	if (typeof t != "string" || t.length === 0) return [];
+	try {
+		let r = JSON.parse(t);
+		return e(r) ? n(r.errors) : [];
+	} catch {
+		return [];
+	}
+}
+function i(i) {
+	let a = /* @__PURE__ */ new Set(), o = (i, s) => {
+		if (!e(i) || s > t || a.has(i)) return [];
+		a.add(i);
+		let c = e(i.extensions) ? i.extensions.code : void 0;
+		return [
+			...n(i.errors),
+			...n(i.graphQLErrors),
+			...e(i.result) ? n(i.result.errors) : [],
+			...r(i.bodyText),
+			...typeof c == "string" && c.length > 0 ? [c] : [],
+			...o(i.cause, s + 1),
+			...o(i.error, s + 1)
+		];
+	};
+	return [...new Set(o(i, 0))];
+}
+function a(e, t) {
+	return i(e).some((e) => t.has(e));
+}
+//#endregion
+export { i as graphQLErrorCodes, a as hasGraphQLErrorCode };

package/dist/bigconsole/utils/dashboardList.d.ts

@@ -0,0 +1,28 @@
+import { ListSortValue } from './listSort';
+
+export interface DashboardRow {
+    name: string;
+    description?: string | null;
+    category?: string | null;
+    status?: string;
+    updatedAt: string;
+}
+export interface DashboardListQuery {
+    search: string;
+    /** '' = all categories. */
+    category: string;
+    /** '' = all statuses. */
+    status: string;
+    sort: ListSortValue;
+    /** 1-based. */
+    page: number;
+    pageSize: number;
+}
+export interface DashboardListResult<T> {
+    /** Every row that passes search and filters, in the chosen order. */
+    filtered: T[];
+    totalPages: number;
+    /** The rows on `page` (clamped to the available pages). */
+    pageItems: T[];
+}
+export declare function selectDashboards<T extends DashboardRow>(dashboards: readonly T[], query: DashboardListQuery): DashboardListResult<T>;

package/dist/bigconsole/utils/dashboardList.js

@@ -0,0 +1,15 @@
+import { sortList as e } from "./listSort.js";
+//#region src/bigconsole/utils/dashboardList.ts
+function t(t, n) {
+	let r = n.search.toLowerCase(), i = e(t.filter((e) => (!n.category || e.category === n.category) && (!n.status || e.status === n.status) && (e.name.toLowerCase().includes(r) || e.description?.toLowerCase().includes(r))), n.sort, {
+		name: (e) => e.name,
+		updatedAt: (e) => e.updatedAt
+	}), a = Math.max(1, Math.ceil(i.length / n.pageSize)), o = (Math.min(Math.max(1, n.page), a) - 1) * n.pageSize;
+	return {
+		filtered: i,
+		totalPages: a,
+		pageItems: i.slice(o, o + n.pageSize)
+	};
+}
+//#endregion
+export { t as selectDashboards };

package/dist/bigconsole/utils/dataSinkList.d.ts

@@ -0,0 +1,15 @@
+import { DataSink, DataSinkSetupState, DataSinkStatus } from '../types';
+import { ListSortValue } from './listSort';
+
+export interface DataSinkRow {
+    dataSink: DataSink;
+    setupState: DataSinkSetupState;
+}
+export interface DataSinkListQuery {
+    setupState: 'all' | 'in_progress' | 'completed';
+    status: DataSinkStatus | null;
+    active: boolean | null;
+    search: string;
+    sort: ListSortValue;
+}
+export declare function selectDataSinks<T extends DataSinkRow>(rows: readonly T[], query: DataSinkListQuery): T[];

package/dist/bigconsole/utils/dataSinkList.js

@@ -0,0 +1,15 @@
+import { sortList as e } from "./listSort.js";
+//#region src/bigconsole/utils/dataSinkList.ts
+function t(t, n) {
+	let r = [...t];
+	if (n.setupState === "in_progress" ? r = r.filter((e) => e.setupState !== "completed") : n.setupState === "completed" && (r = r.filter((e) => e.setupState === "completed")), n.status !== null && (r = r.filter((e) => e.dataSink.status === n.status)), n.active !== null && (r = r.filter((e) => e.dataSink.isActive === n.active)), n.search.trim()) {
+		let e = n.search.toLowerCase();
+		r = r.filter((t) => t.dataSink.name?.toLowerCase().includes(e) || t.dataSink.key.toLowerCase().includes(e) || t.dataSink.description?.toLowerCase().includes(e));
+	}
+	return e(r, n.sort, {
+		name: (e) => e.dataSink.name || e.dataSink.key,
+		updatedAt: (e) => e.dataSink.updatedAt
+	});
+}
+//#endregion
+export { t as selectDataSinks };

package/dist/bigconsole/utils/formDirty.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Form dirty helpers (BOFF-8060, N3 leave guard).
+ *
+ * Pure functions, no React, so the "is this editor holding an unsaved draft"
+ * decision is testable without a DOM. Each editor keeps a baseline of the
+ * values it seeded or last saved, and reports `isDirty(current, baseline)` to
+ * `useUnsavedChanges`.
+ *
+ * Two rules keep the signal honest:
+ * - A missing baseline (`null`/`undefined`) is CLEAN. An editor whose seed has
+ *   not landed yet has nothing to lose, and reporting dirty there would make a
+ *   freshly opened page refuse the assistant's navigation.
+ * - Comparison is by value (stable JSON, sorted keys, `undefined` dropped), so
+ *   object identity, key order and a refetch that returns equal data never
+ *   count as an edit.
+ */
+/** JSON with object keys sorted at every depth, so key order never matters. */
+export declare function stableStringify(value: unknown): string;
+/**
+ * True when `current` differs by value from `baseline`. A missing baseline is
+ * clean (see the module note).
+ */
+export declare function isDirty(current: unknown, baseline: unknown): boolean;
+/**
+ * Whether an edit form should be (re)seeded from the record the store now holds.
+ *
+ * A record can arrive twice: first as a partial list item (no expression, ttl, version), then as
+ * the full record after the detail fetch. The second arrival must refresh a form the person has
+ * not touched, otherwise the partial values would be saved over the stored ones. It must never
+ * overwrite an edit in progress.
+ *  - `seededId`: the id of the record the form was last seeded from (null = never seeded);
+ *  - `form` / `baseline`: the current form and the form as last seeded or saved.
+ * Seed when the record is a different one, or when the form still equals its baseline (a missing
+ * baseline counts as clean). Skip only when the same record is loaded and the form is dirty.
+ */
+export declare function shouldReseedForm(seededId: string | null, recordId: string, form: unknown, baseline: unknown): boolean;
+/** A grid item: react-grid-layout names the id `i`, our own widgets use `id`. */
+export type LayoutItem = {
+    readonly id: string;
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+} | {
+    readonly i: string;
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+};
+/** Item id to `x,y,w,h`, keys in sorted order. */
+export type NormalisedLayout = Readonly<Record<string, string>>;
+/**
+ * Reduces a layout to the four numbers per item that a person can change by
+ * dragging or resizing. Array order, extra grid bookkeeping fields (`moved`,
+ * `static`, min/max) and item order never matter.
+ */
+export declare function normaliseLayout(items: readonly LayoutItem[]): NormalisedLayout;
+type LayoutInput = readonly LayoutItem[] | NormalisedLayout;
+/** True when the layout differs by value from the baseline. No baseline is clean. */
+export declare function layoutDirty(current: LayoutInput, baseline: LayoutInput | null | undefined): boolean;
+/**
+ * react-grid-layout fires `onLayoutChange` on mount and again whenever it
+ * compacts, with no person involved, so "a change event happened" is not a
+ * dirty signal. The baseline therefore FLOATS (follows every layout change)
+ * until the first user gesture (drag or resize stop), then FREEZES; from then on
+ * `layoutDirty(current, tracker.baseline)` is the answer. Reloading the
+ * dashboard or a successful save starts a fresh tracker; a failed save keeps
+ * the old one, so the draft stays dirty.
+ */
+export interface LayoutTracker {
+    readonly baseline: NormalisedLayout | null;
+    readonly frozen: boolean;
+}
+export declare const EMPTY_LAYOUT_TRACKER: LayoutTracker;
+/** A fresh floating tracker, for after a load or a successful save. */
+export declare function resetLayoutTracker(items: readonly LayoutItem[]): LayoutTracker;
+/** A layout-change event: moves the baseline while floating, ignored once frozen. */
+export declare function trackLayoutChange(tracker: LayoutTracker, items: readonly LayoutItem[]): LayoutTracker;
+/** The first user gesture: stops the baseline following layout changes. */
+export declare function freezeLayoutTracker(tracker: LayoutTracker): LayoutTracker;
+export {};

package/dist/bigconsole/utils/formDirty.js

@@ -0,0 +1,21 @@
+//#region src/bigconsole/utils/formDirty.ts
+function e(e) {
+	return JSON.stringify(t(e));
+}
+function t(e) {
+	if (Array.isArray(e)) return e.map(t);
+	if (typeof e == "object" && e) {
+		let n = e, r = {};
+		for (let e of Object.keys(n).sort()) r[e] = t(n[e]);
+		return r;
+	}
+	return e;
+}
+function n(t, n) {
+	return n == null ? !1 : e(t) !== e(n);
+}
+function r(e, t, r, i) {
+	return e === t ? !n(r, i) : !0;
+}
+//#endregion
+export { n as isDirty, r as shouldReseedForm };

package/dist/bigconsole/utils/insightsDraft.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Does the Insights page hold a description the person has typed and not submitted?
+ * (BOFF-8060, N3/N4 leave guard.)
+ *
+ * The page has two draft textareas: the "Describe your dashboard" prompt and the refine
+ * modal's "What should change?". Both are cleared by the page itself when their
+ * submission is accepted (and when the refine modal is reopened), so the last submitted
+ * value is always the empty string and "unsubmitted" reads as "non-empty". Pure
+ * functions, no React, so the rule is testable without a DOM.
+ *
+ * - Whitespace-only text is clean: the page will not submit it, and nothing is lost.
+ * - Text being submitted right now is clean: it already left the page (the mutation
+ *   keeps running after the person navigates). If the submission fails the page keeps
+ *   the text and clears the in-flight flag, so the draft reads dirty again.
+ * - The refine text only counts while the refine modal is open.
+ */
+export interface InsightsDraftState {
+    /** The "Describe your dashboard" textarea. */
+    readonly promptText: string;
+    /** A generation request for `promptText` is in flight. */
+    readonly isGenerating: boolean;
+    /** The refine modal is open. */
+    readonly refineOpen: boolean;
+    /** The refine modal's "What should change?" textarea. */
+    readonly refineText: string;
+    /** A refine request for the open generation is in flight. */
+    readonly refineBusy: boolean;
+}
+export declare function isInsightsDraftDirty(state: InsightsDraftState): boolean;

package/dist/bigconsole/utils/insightsDraft.js

@@ -0,0 +1,8 @@
+//#region src/bigconsole/utils/insightsDraft.ts
+var e = (e) => e.trim() !== "";
+function t(t) {
+	let n = e(t.promptText) && !t.isGenerating, r = t.refineOpen && e(t.refineText) && !t.refineBusy;
+	return n || r;
+}
+//#endregion
+export { t as isInsightsDraftDirty };

package/dist/bigconsole/utils/layoutBaseline.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Dashboard layout baseline (BOFF-8060, N3/N4: the dashboard leave guard).
+ *
+ * The dashboard builder keeps moved and resized widgets only in the widget store
+ * until the toolbar Save runs (`DashboardBuilderPage.handleSave`, step 2). To tell
+ * the assistant "this editor holds unsaved work" the builder needs one honest
+ * boolean, and the store has none: `widgetStore.dirtyWidgetIds` is never marked and
+ * `dashboardStore.hasUnsavedChanges` is never cleared. This module is that boolean,
+ * as plain functions with no React, so it can be tested without a DOM.
+ *
+ * ★★ "A layout event happened" is NOT a dirty signal. Positions reach the store on
+ * load (`setWidgets`), when a widget is created or deleted, and when a save writes
+ * its own positions back, none of which is the person's work. Only a PERSON'S
+ * placement is. So the baseline FLOATS (it is re-taken on every observation)
+ * until the first placement by a person, and from then on it is FROZEN: it holds
+ * the last layout the server is known to have, and "dirty" means the current
+ * layout differs from it BY VALUE:
+ *
+ *   load / refetch / add / delete / save write-back  -> baseline follows, clean
+ *   first drag, resize, or typed placement           -> baseline freezes
+ *   a drag that moves and moves back                 -> equal again, clean
+ *   a successful save                                -> baseline = what was saved
+ *   a failed save                                    -> nothing happens, still dirty
+ *
+ * ★★ The "placement by a person" signal is `layoutEditRevision` on the widget
+ * store, a counter bumped by `updateWidgetPosition` and by nothing else. It is the
+ * ONE writer shared by the canvas (drag stop, resize stop) and the inspector's
+ * "Position & size" fields, so a placement typed into the inspector, which never
+ * touches the grid, freezes the baseline too. A signal taken from the grid alone
+ * would let a floating baseline silently absorb it.
+ *
+ * Every function here is pure. `useDashboardLayoutBaseline` is the React shell.
+ */
+/** One widget's grid cell, in grid units (columns / rows). */
+export interface LayoutRect {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+}
+export interface LayoutItem extends LayoutRect {
+    readonly id: string;
+}
+/**
+ * Widget id -> cell, keys in sorted order. A `Map` (not a plain object) so an
+ * id such as `"1"` or `"__proto__"` is only ever a key.
+ */
+export type NormalisedLayout = ReadonlyMap<string, LayoutRect>;
+interface PositionLike {
+    readonly x?: number | null;
+    readonly y?: number | null;
+    readonly width?: number | null;
+    readonly height?: number | null;
+}
+/**
+ * What a widget must carry for its cell to be read. Structural, so the store's
+ * `Widget` satisfies it and a test can pass a plain object.
+ */
+export interface LayoutSourceWidget {
+    readonly id: string;
+    readonly position?: PositionLike | null;
+    readonly positionX?: number | null;
+    readonly positionY?: number | null;
+    readonly positionWidth?: number | null;
+    readonly positionHeight?: number | null;
+}
+/**
+ * The cell a widget with no stored size falls back to. These mirror
+ * `DashboardGrid.widgetToLayout` exactly, so the baseline reads a widget the same
+ * way the grid draws it.
+ */
+export declare const DEFAULT_LAYOUT_CELL: LayoutRect;
+/**
+ * Items -> a sorted `id -> x,y,w,h` map. Order of the input does not matter, a
+ * repeated id keeps the last one, and a non-finite number becomes 0 so a stray
+ * `NaN` (which is never equal to itself) cannot make a layout permanently dirty.
+ */
+export declare function normaliseLayout(items: Iterable<LayoutItem>): NormalisedLayout;
+/** The widget store's widgets -> a normalised layout (every widget in the store, which is what Save sends). */
+export declare function layoutFromWidgets(widgets: Iterable<LayoutSourceWidget>): NormalisedLayout;
+/** The `{ id, position }` list `batchUpdatePositions` sends -> layout items (exactly what reached the server). */
+export declare function layoutItemsFromPositionUpdates(updates: ReadonlyArray<{
+    readonly id: string;
+    readonly position: PositionLike;
+}>): LayoutItem[];
+/** Same widgets in the same cells (by value; key order and object identity are irrelevant). */
+export declare function layoutEquals(a: NormalisedLayout, b: NormalisedLayout): boolean;
+/**
+ * Does `current` differ from `baseline`? Different cells, a widget present on only
+ * one side, or both, all count. With no baseline there is nothing to differ from,
+ * so the answer is no: this never claims unsaved work it cannot point to.
+ */
+export declare function layoutDirty(current: NormalisedLayout, baseline: NormalisedLayout | null): boolean;
+export interface LayoutBaselineState {
+    /** The layout the server is known to hold, or the last loaded one while floating. `null` until first observed. */
+    readonly baseline: NormalisedLayout | null;
+    /** True once a person has placed something since the baseline was taken. Frozen baselines do not follow the store. */
+    readonly frozen: boolean;
+    /** The last `layoutEditRevision` seen, to notice the next placement. `null` until first observed. */
+    readonly seenRevision: number | null;
+}
+export declare const INITIAL_LAYOUT_BASELINE: LayoutBaselineState;
+export type LayoutBaselineAction = 
+/** The store changed (or the page mounted): here is the layout and the placement counter now. */
+{
+    readonly type: 'observe';
+    readonly layout: NormalisedLayout;
+    readonly editRevision: number;
+}
+/**
+ * The positions reached the server. `layout` is exactly what was sent;
+ * `editRevision` is the counter read BEFORE the request started, so a
+ * placement made while it was in flight is not mistaken for saved.
+ */
+ | {
+    readonly type: 'saved';
+    readonly layout: NormalisedLayout;
+    readonly editRevision: number;
+}
+/** A different dashboard: forget everything. */
+ | {
+    readonly type: 'reset';
+};
+export declare function reduceLayoutBaseline(state: LayoutBaselineState, action: LayoutBaselineAction): LayoutBaselineState;
+/**
+ * The one boolean the builder reports. A floating baseline is never dirty by
+ * definition: it follows the store, so whatever differs is not the person's work.
+ */
+export declare function isLayoutBaselineDirty(state: LayoutBaselineState, current: NormalisedLayout): boolean;
+export {};