@burdenoff/microfe-bigconsole 2026.1008.11 → 2026.1008.13

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

@@ -0,0 +1,131 @@
+/**
+ * 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 {};
+//# sourceMappingURL=layoutBaseline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layoutBaseline.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/utils/layoutBaseline.ts"],"names":[],"mappings":"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"}

package/dist/bigconsole/utils/layoutBaseline.js

@@ -0,0 +1,98 @@
+//#region src/bigconsole/utils/layoutBaseline.ts
+var e = {
+	x: 0,
+	y: 0,
+	w: 4,
+	h: 4
+}, t = (e) => typeof e == "number" && Number.isFinite(e) ? e : void 0, n = (e) => Number.isFinite(e) ? e : 0;
+function r(e, n, r) {
+	return t(e) ?? t(n) ?? r;
+}
+var i = (e, t) => e < t ? -1 : +(e > t);
+function a(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let r of e) t.set(r.id, {
+		x: n(r.x),
+		y: n(r.y),
+		w: n(r.w),
+		h: n(r.h)
+	});
+	return new Map([...t.entries()].sort(([e], [t]) => i(e, t)));
+}
+function o(t) {
+	let n = [];
+	for (let i of t) n.push({
+		id: i.id,
+		x: r(i.position?.x, i.positionX, e.x),
+		y: r(i.position?.y, i.positionY, e.y),
+		w: r(i.position?.width, i.positionWidth, e.w),
+		h: r(i.position?.height, i.positionHeight, e.h)
+	});
+	return a(n);
+}
+function s(t) {
+	return t.map((t) => ({
+		id: t.id,
+		x: r(t.position.x, void 0, e.x),
+		y: r(t.position.y, void 0, e.y),
+		w: r(t.position.width, void 0, e.w),
+		h: r(t.position.height, void 0, e.h)
+	}));
+}
+function c(e, t) {
+	if (e.size !== t.size) return !1;
+	for (let [n, r] of e) {
+		let e = t.get(n);
+		if (!e || r.x !== e.x || r.y !== e.y || r.w !== e.w || r.h !== e.h) return !1;
+	}
+	return !0;
+}
+function l(e, t) {
+	return t !== null && !c(e, t);
+}
+var u = {
+	baseline: null,
+	frozen: !1,
+	seenRevision: null
+};
+function d(e, t) {
+	switch (t.type) {
+		case "reset": return u;
+		case "observe": {
+			if (e.baseline === null) return {
+				baseline: t.layout,
+				frozen: !1,
+				seenRevision: t.editRevision
+			};
+			let n = t.editRevision !== e.seenRevision;
+			return e.frozen ? n ? {
+				...e,
+				seenRevision: t.editRevision
+			} : e : n ? {
+				baseline: e.baseline,
+				frozen: !0,
+				seenRevision: t.editRevision
+			} : c(t.layout, e.baseline) ? e : {
+				baseline: t.layout,
+				frozen: !1,
+				seenRevision: t.editRevision
+			};
+		}
+		case "saved": return e.baseline === null ? {
+			baseline: t.layout,
+			frozen: !1,
+			seenRevision: t.editRevision
+		} : {
+			baseline: t.layout,
+			frozen: e.seenRevision !== null && e.seenRevision > t.editRevision,
+			seenRevision: e.seenRevision
+		};
+	}
+}
+function f(e, t) {
+	return e.frozen && l(t, e.baseline);
+}
+//#endregion
+export { u as INITIAL_LAYOUT_BASELINE, f as isLayoutBaselineDirty, o as layoutFromWidgets, s as layoutItemsFromPositionUpdates, a as normaliseLayout, d as reduceLayoutBaseline };
+
+//# sourceMappingURL=layoutBaseline.js.map

package/dist/bigconsole/utils/layoutBaseline.js.map

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

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

@@ -0,0 +1,17 @@
+/** True when `form` differs by value from `baseline`. Either side missing is clean. */
+export declare function isWidgetFormEdited<T>(form: T | null | undefined, baseline: T | null | undefined): boolean;
+/**
+ * Adds an inferred DataSink binding to a form that is bound to `parserId` and has none.
+ *
+ * The widget inspector infers an absent `dataSinkId` from the parser's input sink key once the
+ * parser resolves (AI-created widgets bind a parser without duplicating its input sink id). That
+ * is the panel filling in what the widget already means, not an edit by the person. It is
+ * applied to the form AND to the baseline with this one function, so the value compare of
+ * `isWidgetFormEdited` reads clean. Returns the same object when nothing applies, so a state
+ * updater using it does not trigger a re-render.
+ */
+export declare function withInferredDataSink<T extends {
+    parserId?: string | null;
+    dataSinkId?: string | null;
+}>(form: T | null | undefined, parserId: string, dataSinkId: string): T | null;
+//# sourceMappingURL=widgetFormDirty.d.ts.map

package/dist/bigconsole/utils/widgetFormDirty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widgetFormDirty.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/utils/widgetFormDirty.ts"],"names":[],"mappings":"AAsBA,uFAAuF;AACvF,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAKzG;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS;IAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACrG,IAAI,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,CAAC,GAAG,IAAI,CAIV"}

package/dist/bigconsole/utils/widgetFormDirty.js

@@ -0,0 +1,15 @@
+import { isDirty as e } from "./formDirty.js";
+//#region src/bigconsole/utils/widgetFormDirty.ts
+function t(t, n) {
+	return t == null || n == null ? !1 : e(t, n);
+}
+function n(e, t, n) {
+	return e == null ? null : e.parserId !== t || e.dataSinkId ? e : {
+		...e,
+		dataSinkId: n
+	};
+}
+//#endregion
+export { t as isWidgetFormEdited, n as withInferredDataSink };
+
+//# sourceMappingURL=widgetFormDirty.js.map

package/dist/bigconsole/utils/widgetFormDirty.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"widgetFormDirty.js","names":[],"sources":["../../../src/bigconsole/utils/widgetFormDirty.ts"],"sourcesContent":["/**\n * Widget inspector edit signal for the assistant's leave guard (BOFF-8060, N3/N4).\n *\n * The properties panel keeps a sticky boolean (`hasUnsavedChanges`) that every edit\n * handler sets and only a save, a discard or a widget switch clears. It drives the\n * panel's own prompts (the \"unsaved\" pill, the Save buttons, the re-seed bail-out)\n * and stays as it is. It is the wrong signal for the leave guard: typing a title and\n * then typing the original title back leaves it set, so the assistant would refuse a\n * navigation over a form that equals what is saved.\n *\n * The leave guard therefore asks a different question, by value: does the form the\n * person is editing differ from the baseline of the widget as it was opened (or as it\n * was last saved or discarded)? Pure functions, no React, so it is testable without a\n * DOM. Comparison is the stable JSON of `formDirty.isDirty` (sorted keys, `undefined`\n * dropped), so key order, object identity and an `undefined` that reads as missing\n * never count as an edit.\n *\n * A missing form (nothing selected) or a missing baseline (the seed has not landed)\n * is CLEAN: there is nothing the person could lose.\n */\nimport { isDirty } from './formDirty';\n\n/** True when `form` differs by value from `baseline`. Either side missing is clean. */\nexport function isWidgetFormEdited<T>(form: T | null | undefined, baseline: T | null | undefined): boolean {\n  if (form === null || form === undefined || baseline === null || baseline === undefined) {\n    return false;\n  }\n  return isDirty(form, baseline);\n}\n\n/**\n * Adds an inferred DataSink binding to a form that is bound to `parserId` and has none.\n *\n * The widget inspector infers an absent `dataSinkId` from the parser's input sink key once the\n * parser resolves (AI-created widgets bind a parser without duplicating its input sink id). That\n * is the panel filling in what the widget already means, not an edit by the person. It is\n * applied to the form AND to the baseline with this one function, so the value compare of\n * `isWidgetFormEdited` reads clean. Returns the same object when nothing applies, so a state\n * updater using it does not trigger a re-render.\n */\nexport function withInferredDataSink<T extends { parserId?: string | null; dataSinkId?: string | null }>(\n  form: T | null | undefined,\n  parserId: string,\n  dataSinkId: string\n): T | null {\n  if (form === null || form === undefined) return null;\n  if (form.parserId !== parserId || form.dataSinkId) return form;\n  return { ...form, dataSinkId };\n}\n"],"mappings":";;AAuBA,SAAgB,EAAsB,GAA4B,GAAyC;AAIzG,QAHI,KAAS,QAA8B,KAAa,OAC/C,KAEF,EAAQ,GAAM,EAAS;;AAahC,SAAgB,EACd,GACA,GACA,GACU;AAGV,QAFI,KAAS,OAAmC,OAC5C,EAAK,aAAa,KAAY,EAAK,aAAmB,IACnD;EAAE,GAAG;EAAM;EAAY"}

package/dist/translations/en.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../src/translations/en.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAqvEjD,CAAC;AAEF,eAAe,cAAc,CAAC"}
+{"version":3,"file":"en.d.ts","sourceRoot":"","sources":["../../src/translations/en.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAgwEjD,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@burdenoff/microfe-bigconsole",
-  "version": "2026.1008.11",
+  "version": "2026.1008.13",
   "description": "BigConsole - AI-powered analytics and dashboard platform",
   "type": "module",
   "files": [