@burdenoff/microfe-bigconsole 2026.930.2 → 2026.1001.2

package/dist/bigconsole/assistant/modes.d.ts

@@ -0,0 +1,255 @@
+import { AssistantModeConfig } from '@burdenoff/fe-libs/shared/assistant/conversation';
+
+/**
+ * Read-only. The ONLY mode fe-libs ever forwards the user's tokens to, and the
+ * only one whose sandbox boots with `AI_ASSISTANT_READONLY=1`.
+ *
+ * ★ This is the user-visible point of the migration. Today BigConsole's
+ * assistant is Owner/Admin-only in its entirety, because the legacy
+ * `AssistantWidget` has exactly one mode and that mode writes. A member who
+ * previously saw NO assistant at all gets read-only Ask, while `Build` stays
+ * hidden from them — fe-libs does that filtering itself
+ * (`AssistantChatArea` keeps `!mode.requiresAdmin || canUseAdminModes`).
+ */
+declare const ASK: {
+    readonly id: "assistant";
+    readonly label: "Ask";
+    readonly description: string;
+    readonly suggestions: readonly ["What can I do on this screen?", "What is in this data sink?", "Which widgets are on this dashboard?", "Why is my parser returning no rows?"];
+};
+/**
+ * The write mode. `api-calls` is the only id whose sandbox boots with
+ * `AI_ASSISTANT_CONFIRM_WRITES=1`, which is why the label may change and the id
+ * may not.
+ */
+declare const BUILD: {
+    readonly id: "api-calls";
+    readonly label: "Build";
+    readonly description: string;
+    readonly suggestions: readonly ["Build a school attendance dashboard from this CSV", "Add a bar chart of monthly totals to this dashboard", "Create a parser that splits the address column", "Show me what this data sink contains"];
+    readonly writeCapable: true;
+    /**
+     * 420s, matching the legacy transport's `STREAM_BUDGET_MS` exactly, so this
+     * introduces no behavioural change.
+     *
+     * ★★ NOT cosmetic, and not a round number picked for comfort. The default is
+     * 180s, which was SHORTER THAN THE WORK: a full build — data sink → dashboard
+     * → parser → widget, each a separate gateway call preceded by a model
+     * round-trip — measured 229s in prod. The agent finished, the dashboard
+     * genuinely existed, and the user was told the assistant timed out. People
+     * then retried and ended up with duplicate dashboards.
+     *
+     * Finite, positive and under `MAX_ASSISTANT_STREAM_BUDGET_MS`, so fe-libs
+     * honours it (`resolveAssistantModeCapabilities`) instead of silently falling
+     * back to 180_000 — which is why this seam needs fe-libs >= 2026.916.1.
+     */
+    readonly streamBudgetMs: 420000;
+    /**
+     * Report the WHOLE run's narration, joined oldest first, instead of only the
+     * newest sandbox message (BC1, BOFF-7334).
+     *
+     * ★★ Legacy PARITY, not a new behaviour. `createSandboxAssistantTransport`'s
+     * `buildProgress` already joins every assistant message of the run — its own
+     * comment reads "ACCUMULATE the run, don't just show its last line" — and it
+     * does so for a reason that has not changed: the agent opens a NEW message per
+     * step and prints a link the moment a create lands ("✅ Data sink created —
+     * [Open …](/…)"). Rendering only the newest message threw all of that away on
+     * the following poll; the user saw a lone "Thinking…" and none of the links
+     * they had been promised. Without this flag the shared panel would reintroduce
+     * the bug BigConsole already fixed.
+     *
+     * ★★ It changes what is STORED, not only what is displayed: the completed turn
+     * persists the joined account as its answer, so Copy, Export and read-aloud
+     * carry it too. That is correct HERE — the build log IS the answer, and it is
+     * where the links to the new data sink and dashboard live — and wrong for Ask,
+     * which is why Ask does not set it.
+     *
+     * Honoured by `resolveAssistantModeCapabilities`, which defaults it to `false`
+     * for every mode including the built-ins, so this seam needs fe-libs
+     * >= 2026.917.2 (fe-libs #233).
+     */
+    readonly accumulatesNarration: true;
+    /**
+     * 15,155 characters of ONE attached file's text, against fe-libs' 8,000
+     * default (BOFF-7334; fe-libs #242, so this seam needs >= 2026.920.2).
+     *
+     * ★★★ DERIVED FROM THE BYTE ENVELOPE, BECAUSE THAT IS THE ONE THAT BINDS:
+     *
+     *     floor((MAX_INLINE_TURN_BODY_BYTES - PROMPT_ENVELOPE_RESERVE_BYTES)
+     *           / MAX_UTF8_BYTES_PER_JS_CHAR / MAX_ATTACHMENTS)
+     *   = floor(227,328 / 3 / 5) = 15,155
+     *
+     * and 5 x 15,155 x 3 = 227,325 <= 227,328, so this is the LARGEST value that
+     * derivation allows — three bytes of slack. Two properties follow, and
+     * `tests/assistantSeam.test.ts` guards both rather than the literal:
+     *   1. the attachment TEXT can never exhaust the CHARACTER total
+     *      (5 x 15,155 = 75,775 <= MAX_CONFIGURABLE_INLINE_CHARS), and
+     *   2. its RAW UTF-8 BYTES can never exhaust the envelope `capTextToBody`
+     *      cuts to (5 x 15,155 x 3 = 227,325 <= 227,328), whatever script the
+     *      files are written in.
+     *
+     * ★★★ (2) BOUNDS THE PAYLOAD, NOT THE RENDERED TURN. An earlier revision of
+     * this docblock claimed the stronger thing — "it can never exhaust the BYTE
+     * envelope, whatever script the files are written in" — and that is FALSE.
+     * `capTextToBody` weighs `JSON.stringify({prompt, parts})` over the RENDERED
+     * block, and that block indents every line by four spaces, writes every
+     * newline as a two-byte escape, and adds an `[n] file — mime, size` header, a
+     * `Contents (...)` line and a pair of fences per file plus one
+     * `--- Attachments (N) ---` frame per turn. Where the lines are short and
+     * multibyte that is over 4 bytes per attachment character, not 3, so the
+     * envelope CAN still bind and fe-libs then cuts the turn total until it
+     * fits. Measured through `buildPromptWithAttachments` on the installed
+     * 2026.920.4, over the fixture the test carries — five 120 K-character
+     * all-CJK files of 1-3 characters a line — characters of each file that
+     * reached the agent:
+     *
+     *   15,155/200,000     15,151  15,151  15,151  11,179  3
+     *   8k/20k (today)      7,996   7,996   4,006       2  omitted
+     *
+     * 56,635 characters served for 227,326 of the 227,328 bytes, i.e. 4.01 bytes
+     * a character where the derivation budgets 3, and the fifth file arrives as
+     * a THREE-CHARACTER sliver announced as a sample.
+     * That is NOT a reason to lower this number, and the alternative is worse:
+     * on that same turn it still serves at least as much of every file as the
+     * shared default it raises (the second row IS the comparison); on the
+     * ordinary Build turn — three CJK fact tables and two Devanagari lookups —
+     * it hands BOTH lookups over WHOLE where the default cuts them to 77 and 3
+     * characters; and no per-file value can repair a slice fe-libs spends IN
+     * ATTACHMENT ORDER out of a total it has already cut. That last part is fe-libs' to fix — BOFF-7532 — and the
+     * residual is pinned by the test named "the byte envelope STILL binds".
+     *
+     * ★★★ WHY 3 IS A BOUND, NOT A GUESS. fe-libs budgets in JS string LENGTH and
+     * enforces in UTF-8 BYTES. Every UTF-16 code unit encodes to at most 3 bytes:
+     * <= U+007F is 1, <= U+07FF is 2, the rest of the BMP is 3, and an astral
+     * character is 4 bytes across TWO units — 2 bytes a unit. So
+     * `utf8Bytes(s) <= 3 * s.length` holds for every string, with equality from
+     * U+0800 (CJK, Devanagari, Thai). The test proves that over the whole BMP
+     * instead of asserting it.
+     *
+     * ★★★ THIS SEAM'S FIRST TWO ANSWERS WERE BOTH WRONG, and the second was wrong
+     * in a way ASCII tests could not see. 100,000 let two files eat the turn.
+     * 40,000 — `MAX_CONFIGURABLE_INLINE_CHARS / MAX_ATTACHMENTS` — was defended
+     * here as "the largest per-file limit that cannot starve a later attachment";
+     * that claim was FALSE for any non-ASCII file, because the character total is
+     * not what binds. `capTextToBody` lowers the turn total until the prompt fits
+     * 227,328 BYTES, and `applyInlineBudget` then still spends
+     * `min(remainingTotal, perFileChars)` IN ATTACHMENT ORDER. Measured against
+     * the installed 2026.920.4 dist with the fixtures the tests now carry — a
+     * 2,000-row all-CJK fact CSV (186 K characters, 506 KB, 2.78 bytes a
+     * character) and a 40-row Devanagari dimension CSV — rows of each file that
+     * reached the agent:
+     *
+     *                      8k/20k (today)      40k/200k           15,155/200,000
+     *   2 big + 1 small    85, 85, 40w         429, 429, 0        162, 162, 40w
+     *   3 big + 2 small    85, 85, 43, 1, 0    429, 427, 0, 0, 0  162 x3, 40w, 40w
+     *   5 big              85, 85, 43, 1, —    429, 427, 0, 0, —  162 x5
+     *
+     * ("w" is a table that arrived WHOLE; "—" is the honest `contents omitted`
+     * note; every other zero is a header fragment announced as a truncation.) At
+     * 40,000 the dimension tables arrive as SLIVERS ANNOUNCED AS SAMPLES —
+     * "Contents (first 50 characters of 5.7 KB; truncated)" — which is the
+     * failure this mode's docblocks keep naming: the agent believes it sampled
+     * the dimension, joins against values it never saw, and the dashboard it then
+     * builds looks right. Worse, on the ordinary two-fact-tables-and-a-lookup
+     * turn 40,000 was BEATEN BY THE SHARED DEFAULT it replaces, which hands that
+     * lookup table over WHOLE.
+     *
+     * ★★ WHAT THE DERIVATION COSTS, in the ASCII case where 40,000 was safe —
+     * same measurement, a 2,200-row / 144 KB fact CSV and a 40-row dimension CSV:
+     *
+     *                      8k/20k (today)      40k/200k          15,155/200,000
+     *   1 big              118                 596               225
+     *   3 big + 2 small    118, 118, 59, 0, 0  596 x3, 40w, 40w  225 x3, 40w, 40w
+     *
+     * 225 rows of a fact table instead of 596. Still 1.9x fe-libs' default, and
+     * still more than the legacy widget ever sent: `attachmentExtract.ts` cuts at
+     * `MAX_ROWS` = 200 rows *or* `MAX_INLINE_CHARS_PER_FILE` = 100,000, whichever
+     * comes first, and for a row-oriented CSV the row cap almost always wins — so
+     * its 100,000 was a ceiling that never bound. Build stays a strict
+     * improvement on both paths it replaces, in every script, which matching a
+     * ceiling was never worth breaking.
+     *
+     * ★ What this does NOT fix, because it cannot be fixed from a mode config:
+     * the user's own message shares that same 227,328-byte envelope, and opting
+     * above fe-libs' defaults is what turns `capTextToBody` on at all. See
+     * `maxInlineCharsTotal` below for the measured window. The real fix is a
+     * per-attachment floor or a smallest-first spending pass IN FE-LIBS —
+     * BOFF-7532. Raise this number only once that lands.
+     */
+    readonly maxInlineCharsPerFile: 15155;
+    /**
+     * 200,000 characters of attached text across the whole turn — fe-libs'
+     * `MAX_CONFIGURABLE_INLINE_CHARS`, i.e. "as much as a 256 KB body can carry".
+     *
+     * ★★★ SET EXPLICITLY BECAUSE LEAVING IT OUT IS NOT NEUTRAL. fe-libs raises
+     * the turn total to match the per-file limit only when that is LARGER, so
+     * omitting this resolves `{perFileChars: 15_155, totalChars: 20_000}` — the
+     * 8,000/20,000 default's total, one and a third files' worth of budget for a
+     * five-file turn, spent GREEDILY IN ATTACHMENT ORDER. At 200,000 the
+     * character total never binds before the per-file limit does
+     * (5 x 15,155 = 75,775), which is the point: the per-file limit is the only
+     * thing rationing the turn, and it is derived from the envelope.
+     *
+     * ★★ RAISING EITHER FIELD ABOVE fe-libs' DEFAULTS ARMS A SECOND, TIGHTER
+     * CEILING, and that is a measured cost rather than a theoretical one.
+     * `buildInlineBudget` runs `capTextToBody` only when
+     * `perFileChars > 8,000 || totalChars > 20,000`, and `capTextToBody` fits the
+     * prompt into `MAX_INLINE_TURN_BODY_BYTES - PROMPT_ENVELOPE_RESERVE_BYTES` =
+     * 227,328 bytes. The un-opted path has no such pass — its only ceiling is
+     * `buildBoundedAttachmentTurn`'s `MAX_TURN_BODY_BYTES` = 262,144, roughly
+     * 35 KB more room — so for a very large USER MESSAGE this mode delivers less
+     * than it would have unconfigured. Measured, 3 big + 2 small ASCII CSVs, rows
+     * that reached the agent:
+     *
+     *   user message chars   this mode              fe-libs defaults
+     *   <= 189,000           225, 225, 225, 40, 40  118, 118, 59, 0, 0
+     *   190,000              225, 225, 53, 1, 0     118, 118, 59, 0, 0
+     *   210,000              222, 0, 0, 0, 0        118, 118, 59, 0, 0
+     *   >= 226,000           nothing at all         118, 118, 59, 0, 0
+     *
+     * The threshold is 190,000 characters TYPED OR PASTED INTO THE COMPOSER, so
+     * the window is narrow — but it is reachable (a pasted CSV under "build me a
+     * dashboard from this"), it is pinned by a test, and it is one more reason
+     * the per-file limit is not raised: at 40,000 the same crossover sat at
+     * 137,000 characters, and by 150,000 it had already lost three of the five
+     * files this value still serves whole. BOFF-7532 asks fe-libs to measure
+     * `capTextToBody` against the envelope the send path actually enforces, and
+     * to spend the remainder fairly instead of in attachment order.
+     *
+     * ★★ AND IT IS NOT "cut, never rejected", which an earlier draft of this
+     * docblock claimed. `buildBoundedAttachmentTurn` cuts the attachment TEXT,
+     * then drops the attachment block entirely with an explicit disclosure ("N
+     * attachment(s) omitted from this turn to fit the request-size limit"), and
+     * if even that text-only turn still exceeds `MAX_TURN_BODY_BYTES` it ends in
+     * `throw new Error(REQUEST_TOO_LARGE_REFUSAL)`. The path is narrow — the
+     * user's own message has to overflow a 256 KB body on its own — but it is
+     * real, and it is the one case where nothing is sent at all.
+     *
+     * ★ Read at PREPARE time as well as at send time: fe-libs keeps
+     * `largestInlineCharsPerFile(modes)` characters of a file when it is attached,
+     * so a CSV attached while in Ask is not already cut to 8,000 by the time the
+     * user switches to Build. The send then cuts to the SENDING mode's limits.
+     *
+     * ★★★ NONE OF THIS RUNS UNTIL THE APP MOVES ITS OWN fe-libs PIN. fe-libs is
+     * `external` in this package's Vite build, so the HOST APP's copy is what
+     * executes here, and `bigconsole-app` pins it in `dependencies` AND in
+     * `overrides` — an `overrides` entry is not satisfied by this package's
+     * `peerDependencies`. At the app's `2026.917.2`, `resolveAssistantInlineLimits`
+     * does not exist at all, so both fields above are read by nobody, with no
+     * error and no warning, and the panel keeps the fixed 8,000/20,000 path.
+     * `accumulatesNarration` DOES exist there, so half of BOFF-7334 would ship
+     * and half would not. Bump the app's fe-libs to >= 2026.920.2 in both places
+     * in the same PR as the microfe bump — BOFF-7533.
+     */
+    readonly maxInlineCharsTotal: 200000;
+};
+/**
+ * The list handed to `AssistantProductProvider`, in display order.
+ *
+ * ★ Exported as ONE array and consumed by identity. The seam guard asserts
+ * `toBe`, not deep equality, because any `.map()` or rebuild on the way to the
+ * provider is exactly how `requiresAdmin` and `writeCapable` get dropped.
+ */
+export declare const BIGCONSOLE_ASSISTANT_MODES: readonly AssistantModeConfig[];
+export { ASK, BUILD };
+//# sourceMappingURL=modes.d.ts.map

package/dist/bigconsole/assistant/modes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modes.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/modes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kDAAkD,CAAC;AAE5F;;;;;;;;;;GAUG;AACH,QAAA,MAAM,GAAG;;;;;CAc+B,CAAC;AAEzC;;;;GAIG;AACH,QAAA,MAAM,KAAK;;;;;;IAqBT;;;;;;;;;;;;;;OAcG;;IAEH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;;IAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0GG;;IAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+DG;;CAEmC,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,EAAE,SAAS,mBAAmB,EAAiB,CAAC;AAEvF,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC"}

package/dist/bigconsole/assistant/pageContext.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Page context gathering for BigConsole — captures the user's current browser
+ * context to be sent alongside every assistant prompt for better AI awareness.
+ *
+ * Mirrors microfe-vibecontrols' `utils/pageContext.ts`. The agent filters the
+ * payload to an allow-list (`ai-assistant/src/context-loader.ts` →
+ * `ALLOWED_CONTEXT_KEYS`), so the keys MUST be `currentUrl` (NOT `activeUrl`)
+ * and the generic `entityType` / `entityId`, or the value is silently dropped.
+ */
+interface ConversationContextShape {
+    entityType?: string;
+    entityId?: string;
+    activeTab?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * ★★ A `type`, NOT an `interface`, and the difference is load-bearing.
+ *
+ * fe-libs' product seam declares `gatherPageContext?: () => PageContext` against
+ * ITS OWN `PageContext`, which carries an index signature
+ * (`[key: string]: unknown`) so a product may add keys of its own. TypeScript
+ * gives a type alias an IMPLICIT index signature and an interface NONE —
+ * an interface stays open to declaration merging, so the compiler cannot know
+ * its full set of keys and refuses the assignment.
+ *
+ * So this exact shape, written as an interface, is not assignable to fe-libs'
+ * parameter: `assistantProduct.ts` fails with TS2322 while the runtime value is
+ * perfectly correct. Changing this back to `interface` re-breaks the seam.
+ */
+export type PageContext = {
+    currentUrl: string;
+    currentPage: string;
+    entityType?: string;
+    entityId?: string;
+    platform: string;
+    version: string;
+    viewportSize: string;
+    userAgent: string;
+    timestamp: string;
+};
+export declare function gatherPageContext(): PageContext;
+/**
+ * A human label for where the user is right now, for the shared panel.
+ *
+ * ★★ The `/bigconsole` MOUNT SEGMENT IS SKIPPED. This MFE mounts under
+ * `/bigconsole` in the host shell, so the first segment is the product name on
+ * every single page — without this, every location would be described as
+ * "Bigconsole", which is both useless and wrong.
+ *
+ * ★ Derived from `gatherPageContext().currentPage` rather than reading
+ * `window.location` a second time, so the label and the agent's structured
+ * context can never disagree about which page they describe.
+ */
+export declare function describeCurrentPage(): string;
+/**
+ * Maps the current BigConsole route to `{ entityType, entityId }`. The BigConsole
+ * MFE mounts under the `/bigconsole` base path in the host shell, so detail
+ * routes are matched as `/bigconsole/<collection>/:id`.
+ *
+ * More specific routes (e.g. dashboard-scoped parsers, builder/edit sub-routes)
+ * are matched before their parent so the most relevant entity wins.
+ */
+export declare function resolveBigConsoleConversationContext(pathname: string, search: string): ConversationContextShape;
+export {};
+//# sourceMappingURL=pageContext.d.ts.map

package/dist/bigconsole/assistant/pageContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pageContext.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/pageContext.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,UAAU,wBAAwB;IAChC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,WAAW,GAAG;IAGxB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IAGpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,wBAAgB,iBAAiB,IAAI,WAAW,CAiB/C;AAsBD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAY5C;AAMD;;;;;;;GAOG;AACH,wBAAgB,oCAAoC,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,wBAAwB,CA4C/G"}

package/dist/bigconsole/assistant/previewController.d.ts

@@ -0,0 +1,33 @@
+import { AssistantPreviewController } from '@burdenoff/fe-libs/shared/assistant';
+import { previewRunAction, PreviewRunAction } from './previewRunAction';
+
+/**
+ * ★ Re-exported so consumers keep ONE import path, while the RULE itself lives
+ * in a module that loads without a DOM. Importing THIS file pulls fe-libs'
+ * assistant barrel, which touches `document` at load time — so the decision had
+ * to move out before it could be tested. See `previewRunAction.ts`.
+ *
+ * ★ Local bindings, not `export … from`: a bare re-export creates no local name,
+ * so `applyPreviewEvent` below would be calling something this module does not
+ * actually have.
+ */
+export { previewRunAction };
+export type { PreviewRunAction };
+/**
+ * BigConsole's preview controller, stable across renders.
+ *
+ * ★★★ THE MEMO IS LOAD-BEARING, not tidiness. fe-libs' bridge deliberately does
+ * NOT reset its run state when the controller identity changes — precisely so
+ * that the natural `preview={{ render, onEvent }}` object literal does not
+ * re-announce `start` on every poll tick. The cost of that choice is that
+ * REPLACING a controller mid-run leaves the newcomer without a `start` for the
+ * run already in flight. An empty dependency list is what guarantees one
+ * controller for the life of the mount.
+ *
+ * ★★ NO `render` AND NO `label`, and never add them back conditionally.
+ * fe-libs asks a product to decide once whether its controller is headless:
+ * adding `render` later swaps the panel's hook layout mid-mount. A `label`
+ * would be dead weight, because a headless controller has no toggle to name.
+ */
+export declare function useBigConsoleAssistantPreview(): AssistantPreviewController;
+//# sourceMappingURL=previewController.d.ts.map

package/dist/bigconsole/assistant/previewController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"previewController.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/previewController.tsx"],"names":[],"mappings":"AAkCA,OAAO,EAEL,KAAK,0BAA0B,EAEhC,MAAM,qCAAqC,CAAC;AAG7C,OAAO,EAAE,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAG7E;;;;;;;;;GASG;AACH,OAAO,EAAE,gBAAgB,EAAE,CAAC;AAC5B,YAAY,EAAE,gBAAgB,EAAE,CAAC;AAuHjC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,6BAA6B,IAAI,0BAA0B,CAE1E"}

package/dist/bigconsole/assistant/previewController.js

@@ -1,29 +1,38 @@
-import { runBelongsToWorkspace as e, useAssistantRunStore as t } from "./assistantRunStore.js";
-import { previewRunAction as n } from "./previewRunAction.js";
-import { useMemo as r } from "react";
-import { useAssistantStore as i } from "@burdenoff/fe-libs/shared/assistant";
+import { normalizePreviewActionResult as e } from "./previewMutationResult.js";
+import { runBelongsToWorkspace as t, useAssistantRunStore as n } from "./assistantRunStore.js";
+import { previewRunAction as r } from "./previewRunAction.js";
+import { useMemo as i } from "react";
+import { useAssistantStore as a } from "@burdenoff/fe-libs/shared/assistant";
 //#region src/bigconsole/assistant/previewController.tsx
-var a = /* @__PURE__ */ new Set();
-function o(r) {
-	let o = i.getState(), s = o.conversations.find((e) => e.id === r.run.conversationId)?.mode ?? o.mode;
-	if (n(r.kind, r.run.runId, s, a) === "ignore") return;
-	let c = t.getState(), l = e(r.run.workspaceId, c.workspaceId);
-	if (r.kind === "start") {
-		if (!l) return;
-		a.add(r.run.runId), c.startRun("");
+var o = /* @__PURE__ */ new Set();
+function s(i) {
+	let s = a.getState(), c = s.conversations.find((e) => e.id === i.run.conversationId)?.mode ?? s.mode;
+	if (i.kind === "action-result") {
+		let r = n.getState();
+		if (!t(i.run.workspaceId, r.workspaceId) || i.run.actorId !== null && r.actorId !== null && i.run.actorId !== r.actorId || s.activeConversationId !== i.run.conversationId) return;
+		r.conversationId !== i.run.conversationId && (r.startRun("", i.run.conversationId), n.getState().finishRun(null));
+		let a = s.conversations.find((e) => e.id === i.run.conversationId)?.messages.findIndex((e) => e.id === i.run.messageId);
+		r.applyResult(i.action.id, e(i.action.operation, i.action.responseKey, i.action.result, i.action.arguments), a !== void 0 && a >= 0 ? a : void 0);
 		return;
 	}
-	if (r.kind === "snapshot") {
-		if (!l) return;
-		c.applyProgress(r.content);
+	if (r(i.kind, i.run.runId, c, o) === "ignore") return;
+	let l = n.getState(), u = t(i.run.workspaceId, l.workspaceId);
+	if (i.kind === "start") {
+		if (!u || s.activeConversationId !== i.run.conversationId) return;
+		o.add(i.run.runId), l.startRun("", i.run.conversationId);
 		return;
 	}
-	a.delete(r.run.runId), l && c.finishRun(r.outcome === "error" ? r.error ?? "The build stopped." : null);
+	if (i.kind === "snapshot") {
+		if (!u || l.conversationId !== i.run.conversationId) return;
+		l.applyProgress(i.content);
+		return;
+	}
+	o.delete(i.run.runId), !(!u || l.conversationId !== i.run.conversationId) && l.finishRun(i.outcome === "error" ? i.error ?? "The build stopped." : null);
 }
-function s() {
-	return r(() => ({ onEvent: o }), []);
+function c() {
+	return i(() => ({ onEvent: s }), []);
 }
 //#endregion
-export { s as useBigConsoleAssistantPreview };
+export { c as useBigConsoleAssistantPreview };
 
 //# sourceMappingURL=previewController.js.map

package/dist/bigconsole/assistant/previewController.js.map

@@ -1 +1 @@
-{"version":3,"file":"previewController.js","names":[],"sources":["../../../src/bigconsole/assistant/previewController.tsx"],"sourcesContent":["/**\n * BigConsole's preview capability for the shared assistant panel (BC3).\n *\n * ★★★ THIS IS WHAT REPLACES THE TRANSPORT AS THE RUN STORE'S DRIVER.\n *\n * Today `createSandboxAssistantTransport` calls `startRun` / `applyProgress` /\n * `finishRun` itself, because it owns the turn. The shared panel consumes NO\n * transport at all — `AssistantChatArea` calls fe-libs' own `assistant/api`\n * directly — so once BC4 mounts the panel there is nothing left to drive the\n * store, and the live build preview would simply stop moving.\n *\n * fe-libs' preview capability is that missing wire: the bridge announces\n * `start` / `snapshot` / `end` for the run in flight, and this controller\n * forwards them to the same three store actions the transport used to call. The\n * store, both preview panels, and everything downstream are untouched.\n *\n * ★★★ HEADLESS (BOFF-7799). The controller carries `onEvent` and nothing else.\n * It used to also `render` a copy of the preview INSIDE the panel, behind a\n * \"Build preview\" toggle. That copy was offered even with no run in the tab\n * (an empty rail captioned \"Done\"), and opening it made the page preview under\n * the breadcrumb stand down, so users saw the build only as an overlay in the\n * chat. fe-libs 2026.930.3 made `render` optional: with no `render` the panel\n * shows no toggle, never opens the overlay and never publishes\n * `data-assistant-overlay=\"preview\"`, while the bridge still delivers `start`,\n * `snapshot` and `end`. The page surfaces (`AiPreviewPanel`,\n * `AiPreviewMiniPanel`) are now the only surfaces, and they stay beside the\n * chat by reading `DOCK_CLEARANCE`.\n *\n * ★★ ABSENCE IS STILL THE OFF-SWITCH for the events. A product that supplies no\n * controller gets no events; there is deliberately no second `enablePreview`\n * flag. So this hook always returns a controller — gating belongs at the mount\n * site (BC4), not here.\n */\nimport { useMemo } from 'react';\nimport {\n  useAssistantStore,\n  type AssistantPreviewController,\n  type AssistantPreviewEvent,\n} from '@burdenoff/fe-libs/shared/assistant';\n\nimport { runBelongsToWorkspace, useAssistantRunStore } from './assistantRunStore';\nimport { previewRunAction, type PreviewRunAction } from './previewRunAction';\n\n/**\n * ★ Re-exported so consumers keep ONE import path, while the RULE itself lives\n * in a module that loads without a DOM. Importing THIS file pulls fe-libs'\n * assistant barrel, which touches `document` at load time — so the decision had\n * to move out before it could be tested. See `previewRunAction.ts`.\n *\n * ★ Local bindings, not `export … from`: a bare re-export creates no local name,\n * so `applyPreviewEvent` below would be calling something this module does not\n * actually have.\n */\nexport { previewRunAction };\nexport type { PreviewRunAction };\n\n/**\n * The runs this controller has adopted — Build runs only.\n *\n * ★ Module-level, like the handler itself: it must outlive the controller memo\n * and every re-render, and nothing renders it.\n */\nconst adoptedRuns = new Set<string>();\n\n/**\n * Forward one bridge event to the run store.\n *\n * ★ Module-level and imperative (`getState()`), NOT a hook: the bridge calls\n * this from an effect, and reading the store through a selector here would make\n * the controller depend on state it never renders.\n */\nfunction applyPreviewEvent(event: AssistantPreviewEvent): void {\n  /**\n   * ★ The mode of THIS RUN's conversation, never the panel's. The panel's `mode`\n   * is whatever the user last selected, which need not be the mode the run in\n   * flight was started in. Falls back to the panel mode only when the\n   * conversation is gone.\n   */\n  const assistant = useAssistantStore.getState();\n  const modeOfRun = assistant.conversations.find((c) => c.id === event.run.conversationId)?.mode ?? assistant.mode;\n\n  if (previewRunAction(event.kind, event.run.runId, modeOfRun, adoptedRuns) === 'ignore') {\n    return;\n  }\n\n  const store = useAssistantRunStore.getState();\n  /**\n   * ★★ A run drives only the workspace it started in. A workspace switch clears\n   * the store (`bindWorkspace`), but the previous workspace's turn keeps\n   * streaming; its snapshots must not refill the cleared store, or the refill\n   * is kept under the new workspace's key.\n   */\n  const belongs = runBelongsToWorkspace(event.run.workspaceId, store.workspaceId);\n\n  if (event.kind === 'start') {\n    if (!belongs) return;\n    adoptedRuns.add(event.run.runId);\n    /**\n     * ★★ THE PROMPT IS NOT AVAILABLE, and that is a real gap rather than an\n     * oversight. `AssistantPreviewRun` carries `runId`, `conversationId`,\n     * `messageId`, `workspaceId` and `actorId` — no turn text — so the store's\n     * `prompt` (which only feeds an informational line) is left empty. The\n     * transport could pass it because it owned the turn; the bridge cannot,\n     * because it observes one. Everything the preview actually draws comes from\n     * `applyProgress`, so nothing visible depends on this.\n     */\n    store.startRun('');\n    return;\n  }\n\n  if (event.kind === 'snapshot') {\n    if (!belongs) return;\n    /**\n     * ★ `content` is the PROSE with the tool-activity lines already removed by\n     * fe-libs. That is what this store wants: it harvests entity links, raw\n     * mutation ids and the newest `⏳ …` caption out of the agent's narration,\n     * all of which live in the prose. The structured `event.steps` describe TOOL\n     * calls, which are a different rail from BigConsole's four build steps.\n     */\n    store.applyProgress(event.content);\n    return;\n  }\n\n  /**\n   * ★★ `abandoned` is neither success nor failure — it is a run the bridge can\n   * no longer follow (cancelled, superseded, or navigated away from mid-turn),\n   * and the turn may well still be executing. Passing its text as an error would\n   * paint a red \"Build stopped\" banner over a build that is very likely still\n   * running; passing nothing at all would leave the spinner going forever. So it\n   * ends the run WITHOUT an error, which stops the spinner and leaves every step\n   * already marked `done` exactly as it was.\n   */\n  /**\n   * ★ Released here, and only here. Run ids are `conversationId:messageId`, so\n   * they are never reused and this is a leak rather than a correctness bug — but\n   * an unbounded set that grows for the life of the tab is still a leak, and\n   * `end` is the one event guaranteed to arrive for every adopted run\n   * (`abandoned` included — that outcome exists precisely so a run the bridge\n   * can no longer follow still terminates).\n   */\n  adoptedRuns.delete(event.run.runId);\n  if (!belongs) return;\n  store.finishRun(event.outcome === 'error' ? (event.error ?? 'The build stopped.') : null);\n}\n\n/**\n * BigConsole's preview controller, stable across renders.\n *\n * ★★★ THE MEMO IS LOAD-BEARING, not tidiness. fe-libs' bridge deliberately does\n * NOT reset its run state when the controller identity changes — precisely so\n * that the natural `preview={{ render, onEvent }}` object literal does not\n * re-announce `start` on every poll tick. The cost of that choice is that\n * REPLACING a controller mid-run leaves the newcomer without a `start` for the\n * run already in flight. An empty dependency list is what guarantees one\n * controller for the life of the mount.\n *\n * ★★ NO `render` AND NO `label`, and never add them back conditionally.\n * fe-libs asks a product to decide once whether its controller is headless:\n * adding `render` later swaps the panel's hook layout mid-mount. A `label`\n * would be dead weight, because a headless controller has no toggle to name.\n */\nexport function useBigConsoleAssistantPreview(): AssistantPreviewController {\n  return useMemo<AssistantPreviewController>(() => ({ onEvent: applyPreviewEvent }), []);\n}\n"],"mappings":";;;;;AA8DA,IAAM,oBAAc,IAAI,KAAa;AASrC,SAAS,EAAkB,GAAoC;CAO7D,IAAM,IAAY,EAAkB,UAAU,EACxC,IAAY,EAAU,cAAc,MAAM,MAAM,EAAE,OAAO,EAAM,IAAI,eAAe,EAAE,QAAQ,EAAU;AAE5G,KAAI,EAAiB,EAAM,MAAM,EAAM,IAAI,OAAO,GAAW,EAAY,KAAK,SAC5E;CAGF,IAAM,IAAQ,EAAqB,UAAU,EAOvC,IAAU,EAAsB,EAAM,IAAI,aAAa,EAAM,YAAY;AAE/E,KAAI,EAAM,SAAS,SAAS;AAC1B,MAAI,CAAC,EAAS;AAWd,EAVA,EAAY,IAAI,EAAM,IAAI,MAAM,EAUhC,EAAM,SAAS,GAAG;AAClB;;AAGF,KAAI,EAAM,SAAS,YAAY;AAC7B,MAAI,CAAC,EAAS;AAQd,IAAM,cAAc,EAAM,QAAQ;AAClC;;AAoBF,GAAY,OAAO,EAAM,IAAI,MAAM,EAC9B,KACL,EAAM,UAAU,EAAM,YAAY,UAAW,EAAM,SAAS,uBAAwB,KAAK;;AAmB3F,SAAgB,IAA4D;AAC1E,QAAO,SAA2C,EAAE,SAAS,GAAmB,GAAG,EAAE,CAAC"}
+{"version":3,"file":"previewController.js","names":[],"sources":["../../../src/bigconsole/assistant/previewController.tsx"],"sourcesContent":["/**\n * BigConsole's preview capability for the shared assistant panel (BC3).\n *\n * ★★★ THIS IS WHAT REPLACES THE TRANSPORT AS THE RUN STORE'S DRIVER.\n *\n * Today `createSandboxAssistantTransport` calls `startRun` / `applyProgress` /\n * `finishRun` itself, because it owns the turn. The shared panel consumes NO\n * transport at all — `AssistantChatArea` calls fe-libs' own `assistant/api`\n * directly — so once BC4 mounts the panel there is nothing left to drive the\n * store, and the live build preview would simply stop moving.\n *\n * fe-libs' preview capability is that missing wire: the bridge announces\n * `start` / `snapshot` / `end` for the run in flight, and this controller\n * forwards them to the same three store actions the transport used to call. The\n * store, both preview panels, and everything downstream are untouched.\n *\n * ★★★ HEADLESS (BOFF-7799). The controller carries `onEvent` and nothing else.\n * It used to also `render` a copy of the preview INSIDE the panel, behind a\n * \"Build preview\" toggle. That copy was offered even with no run in the tab\n * (an empty rail captioned \"Done\"), and opening it made the page preview under\n * the breadcrumb stand down, so users saw the build only as an overlay in the\n * chat. fe-libs 2026.930.3 made `render` optional: with no `render` the panel\n * shows no toggle, never opens the overlay and never publishes\n * `data-assistant-overlay=\"preview\"`, while the bridge still delivers `start`,\n * `snapshot` and `end`. The page surfaces (`AiPreviewPanel`,\n * `AiPreviewMiniPanel`) are now the only surfaces, and they stay beside the\n * chat by reading `DOCK_CLEARANCE`.\n *\n * ★★ ABSENCE IS STILL THE OFF-SWITCH for the events. A product that supplies no\n * controller gets no events; there is deliberately no second `enablePreview`\n * flag. So this hook always returns a controller — gating belongs at the mount\n * site (BC4), not here.\n */\nimport { useMemo } from 'react';\nimport {\n  useAssistantStore,\n  type AssistantPreviewController,\n  type AssistantPreviewEvent,\n} from '@burdenoff/fe-libs/shared/assistant';\n\nimport { runBelongsToWorkspace, useAssistantRunStore } from './assistantRunStore';\nimport { previewRunAction, type PreviewRunAction } from './previewRunAction';\nimport { normalizePreviewActionResult } from './previewMutationResult';\n\n/**\n * ★ Re-exported so consumers keep ONE import path, while the RULE itself lives\n * in a module that loads without a DOM. Importing THIS file pulls fe-libs'\n * assistant barrel, which touches `document` at load time — so the decision had\n * to move out before it could be tested. See `previewRunAction.ts`.\n *\n * ★ Local bindings, not `export … from`: a bare re-export creates no local name,\n * so `applyPreviewEvent` below would be calling something this module does not\n * actually have.\n */\nexport { previewRunAction };\nexport type { PreviewRunAction };\n\n/**\n * The runs this controller has adopted — Build runs only.\n *\n * ★ Module-level, like the handler itself: it must outlive the controller memo\n * and every re-render, and nothing renders it.\n */\nconst adoptedRuns = new Set<string>();\n\n/**\n * Forward one bridge event to the run store.\n *\n * ★ Module-level and imperative (`getState()`), NOT a hook: the bridge calls\n * this from an effect, and reading the store through a selector here would make\n * the controller depend on state it never renders.\n */\nfunction applyPreviewEvent(event: AssistantPreviewEvent): void {\n  /**\n   * ★ The mode of THIS RUN's conversation, never the panel's. The panel's `mode`\n   * is whatever the user last selected, which need not be the mode the run in\n   * flight was started in. Falls back to the panel mode only when the\n   * conversation is gone.\n   */\n  const assistant = useAssistantStore.getState();\n  const modeOfRun = assistant.conversations.find((c) => c.id === event.run.conversationId)?.mode ?? assistant.mode;\n\n  if (event.kind === 'action-result') {\n    const store = useAssistantRunStore.getState();\n    if (!runBelongsToWorkspace(event.run.workspaceId, store.workspaceId)) return;\n    if (event.run.actorId !== null && store.actorId !== null && event.run.actorId !== store.actorId) return;\n    // Approved writes can finish after the model turn settles. They remain real\n    // results. Replayed history restores the selected conversation, while\n    // inactive background results cannot replace its preview.\n    if (assistant.activeConversationId !== event.run.conversationId) return;\n    if (store.conversationId !== event.run.conversationId) {\n      store.startRun('', event.run.conversationId);\n      useAssistantRunStore.getState().finishRun(null);\n    }\n    const messageOrder = assistant.conversations\n      .find((conversation) => conversation.id === event.run.conversationId)\n      ?.messages.findIndex((message) => message.id === event.run.messageId);\n    store.applyResult(\n      event.action.id,\n      normalizePreviewActionResult(\n        event.action.operation,\n        event.action.responseKey,\n        event.action.result,\n        event.action.arguments\n      ),\n      messageOrder !== undefined && messageOrder >= 0 ? messageOrder : undefined\n    );\n    return;\n  }\n\n  if (previewRunAction(event.kind, event.run.runId, modeOfRun, adoptedRuns) === 'ignore') {\n    return;\n  }\n\n  const store = useAssistantRunStore.getState();\n  /**\n   * ★★ A run drives only the workspace it started in. A workspace switch clears\n   * the store (`bindWorkspace`), but the previous workspace's turn keeps\n   * streaming; its snapshots must not refill the cleared store, or the refill\n   * is kept under the new workspace's key.\n   */\n  const belongs = runBelongsToWorkspace(event.run.workspaceId, store.workspaceId);\n\n  if (event.kind === 'start') {\n    if (!belongs || assistant.activeConversationId !== event.run.conversationId) return;\n    adoptedRuns.add(event.run.runId);\n    /**\n     * ★★ THE PROMPT IS NOT AVAILABLE, and that is a real gap rather than an\n     * oversight. `AssistantPreviewRun` carries `runId`, `conversationId`,\n     * `messageId`, `workspaceId` and `actorId` — no turn text — so the store's\n     * `prompt` (which only feeds an informational line) is left empty. The\n     * transport could pass it because it owned the turn; the bridge cannot,\n     * because it observes one. Everything the preview actually draws comes from\n     * `applyProgress`, so nothing visible depends on this.\n     */\n    store.startRun('', event.run.conversationId);\n    return;\n  }\n\n  if (event.kind === 'snapshot') {\n    if (!belongs || store.conversationId !== event.run.conversationId) return;\n    /**\n     * ★ `content` is the PROSE with the tool-activity lines already removed by\n     * fe-libs. That is what this store wants: it harvests entity links, raw\n     * mutation ids and the newest `⏳ …` caption out of the agent's narration,\n     * all of which live in the prose. The structured `event.steps` describe TOOL\n     * calls, which are a different rail from BigConsole's four build steps.\n     */\n    store.applyProgress(event.content);\n    return;\n  }\n\n  /**\n   * ★★ `abandoned` is neither success nor failure — it is a run the bridge can\n   * no longer follow (cancelled, superseded, or navigated away from mid-turn),\n   * and the turn may well still be executing. Passing its text as an error would\n   * paint a red \"Build stopped\" banner over a build that is very likely still\n   * running; passing nothing at all would leave the spinner going forever. So it\n   * ends the run WITHOUT an error, which stops the spinner and leaves every step\n   * already marked `done` exactly as it was.\n   */\n  /**\n   * ★ Released here, and only here. Run ids are `conversationId:messageId`, so\n   * they are never reused and this is a leak rather than a correctness bug — but\n   * an unbounded set that grows for the life of the tab is still a leak, and\n   * `end` is the one event guaranteed to arrive for every adopted run\n   * (`abandoned` included — that outcome exists precisely so a run the bridge\n   * can no longer follow still terminates).\n   */\n  adoptedRuns.delete(event.run.runId);\n  if (!belongs || store.conversationId !== event.run.conversationId) return;\n  store.finishRun(event.outcome === 'error' ? (event.error ?? 'The build stopped.') : null);\n}\n\n/**\n * BigConsole's preview controller, stable across renders.\n *\n * ★★★ THE MEMO IS LOAD-BEARING, not tidiness. fe-libs' bridge deliberately does\n * NOT reset its run state when the controller identity changes — precisely so\n * that the natural `preview={{ render, onEvent }}` object literal does not\n * re-announce `start` on every poll tick. The cost of that choice is that\n * REPLACING a controller mid-run leaves the newcomer without a `start` for the\n * run already in flight. An empty dependency list is what guarantees one\n * controller for the life of the mount.\n *\n * ★★ NO `render` AND NO `label`, and never add them back conditionally.\n * fe-libs asks a product to decide once whether its controller is headless:\n * adding `render` later swaps the panel's hook layout mid-mount. A `label`\n * would be dead weight, because a headless controller has no toggle to name.\n */\nexport function useBigConsoleAssistantPreview(): AssistantPreviewController {\n  return useMemo<AssistantPreviewController>(() => ({ onEvent: applyPreviewEvent }), []);\n}\n"],"mappings":";;;;;;AA+DA,IAAM,oBAAc,IAAI,KAAa;AASrC,SAAS,EAAkB,GAAoC;CAO7D,IAAM,IAAY,EAAkB,UAAU,EACxC,IAAY,EAAU,cAAc,MAAM,MAAM,EAAE,OAAO,EAAM,IAAI,eAAe,EAAE,QAAQ,EAAU;AAE5G,KAAI,EAAM,SAAS,iBAAiB;EAClC,IAAM,IAAQ,EAAqB,UAAU;AAM7C,MALI,CAAC,EAAsB,EAAM,IAAI,aAAa,EAAM,YAAY,IAChE,EAAM,IAAI,YAAY,QAAQ,EAAM,YAAY,QAAQ,EAAM,IAAI,YAAY,EAAM,WAIpF,EAAU,yBAAyB,EAAM,IAAI,eAAgB;AACjE,EAAI,EAAM,mBAAmB,EAAM,IAAI,mBACrC,EAAM,SAAS,IAAI,EAAM,IAAI,eAAe,EAC5C,EAAqB,UAAU,CAAC,UAAU,KAAK;EAEjD,IAAM,IAAe,EAAU,cAC5B,MAAM,MAAiB,EAAa,OAAO,EAAM,IAAI,eAAe,EACnE,SAAS,WAAW,MAAY,EAAQ,OAAO,EAAM,IAAI,UAAU;AACvE,IAAM,YACJ,EAAM,OAAO,IACb,EACE,EAAM,OAAO,WACb,EAAM,OAAO,aACb,EAAM,OAAO,QACb,EAAM,OAAO,UACd,EACD,MAAiB,KAAA,KAAa,KAAgB,IAAI,IAAe,KAAA,EAClE;AACD;;AAGF,KAAI,EAAiB,EAAM,MAAM,EAAM,IAAI,OAAO,GAAW,EAAY,KAAK,SAC5E;CAGF,IAAM,IAAQ,EAAqB,UAAU,EAOvC,IAAU,EAAsB,EAAM,IAAI,aAAa,EAAM,YAAY;AAE/E,KAAI,EAAM,SAAS,SAAS;AAC1B,MAAI,CAAC,KAAW,EAAU,yBAAyB,EAAM,IAAI,eAAgB;AAW7E,EAVA,EAAY,IAAI,EAAM,IAAI,MAAM,EAUhC,EAAM,SAAS,IAAI,EAAM,IAAI,eAAe;AAC5C;;AAGF,KAAI,EAAM,SAAS,YAAY;AAC7B,MAAI,CAAC,KAAW,EAAM,mBAAmB,EAAM,IAAI,eAAgB;AAQnE,IAAM,cAAc,EAAM,QAAQ;AAClC;;AAoBF,GAAY,OAAO,EAAM,IAAI,MAAM,EAC/B,GAAC,KAAW,EAAM,mBAAmB,EAAM,IAAI,mBACnD,EAAM,UAAU,EAAM,YAAY,UAAW,EAAM,SAAS,uBAAwB,KAAK;;AAmB3F,SAAgB,IAA4D;AAC1E,QAAO,SAA2C,EAAE,SAAS,GAAmB,GAAG,EAAE,CAAC"}

package/dist/bigconsole/assistant/previewMutationResult.d.ts

@@ -0,0 +1,11 @@
+/** Entity identities from successful GraphQL responses, independent of narration. */
+export interface PreviewMutationEntity {
+    step: 'datasink' | 'dashboard' | 'parser' | 'widget';
+    id: string;
+    dashboardId?: string;
+    parserId?: string;
+}
+/** Accept a parsed response or tool output containing a JSON response. Never read request input. */
+export declare function normalizePreviewActionResult(operation: string, responseKey: string, result: unknown, args?: Readonly<Record<string, unknown>>): unknown;
+export declare function previewMutationEntities(output: unknown): PreviewMutationEntity[];
+//# sourceMappingURL=previewMutationResult.d.ts.map

package/dist/bigconsole/assistant/previewMutationResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"previewMutationResult.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/previewMutationResult.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,UAAU,GAAG,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACrD,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAqBD,oGAAoG;AACpG,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,OAAO,EACf,IAAI,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAM,GAC3C,OAAO,CAYT;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,OAAO,GAAG,qBAAqB,EAAE,CA6ChF"}

package/dist/bigconsole/assistant/previewMutationResult.js

@@ -0,0 +1,59 @@
+//#region src/bigconsole/assistant/previewMutationResult.ts
+var e = {
+	createDataSink: "datasink",
+	createBigConsoleDashboard: "dashboard",
+	createParser: "parser",
+	createBigConsoleWidget: "widget",
+	updateDataSink: "datasink",
+	updateBigConsoleDashboard: "dashboard",
+	updateParser: "parser",
+	updateBigConsoleWidget: "widget"
+}, t = /^[A-Za-z0-9_-]{1,128}$/;
+function n(e) {
+	return typeof e == "object" && e && !Array.isArray(e) ? e : null;
+}
+function r(e, t, r, i = {}) {
+	let a = n(r);
+	if (Array.isArray(a?.errors) && a.errors.length > 0) return r;
+	let o = n(a?.data) ?? a, s = n(o?.[t] ?? o?.[e]);
+	if (e === "executeParser" && s?.success === !0) return { executeParser: s };
+	if (!s || typeof s.id != "string") return r;
+	let c = n(i.input) ?? n(i.i) ?? i;
+	return { [e]: {
+		...c,
+		...s
+	} };
+}
+function i(r) {
+	if (typeof r == "string") try {
+		return i(JSON.parse(r));
+	} catch {
+		let e = r.indexOf("{"), t = r.lastIndexOf("}");
+		if (e < 0 || t <= e) return [];
+		try {
+			return i(JSON.parse(r.slice(e, t + 1)));
+		} catch {
+			return [];
+		}
+	}
+	let a = n(r);
+	if (!a || Array.isArray(a.errors) && a.errors.length > 0) return [];
+	let o = [];
+	for (let [r, s] of Object.entries(a)) {
+		let a = e[r], c = n(s);
+		r === "executeParser" && c?.success === !0 && typeof c.parserId == "string" && t.test(c.parserId) ? o.push({
+			step: "parser",
+			id: c.parserId
+		}) : a && c && typeof c.id == "string" && t.test(c.id) ? o.push({
+			step: a,
+			id: c.id,
+			...typeof c.dashboardId == "string" && t.test(c.dashboardId) ? { dashboardId: c.dashboardId } : {},
+			...typeof c.parserId == "string" && t.test(c.parserId) ? { parserId: c.parserId } : {}
+		}) : (r === "data" || r === "result" || r === "output" || r === "body") && o.push(...i(s));
+	}
+	return o;
+}
+//#endregion
+export { r as normalizePreviewActionResult, i as previewMutationEntities };
+
+//# sourceMappingURL=previewMutationResult.js.map

package/dist/bigconsole/assistant/previewMutationResult.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"previewMutationResult.js","names":[],"sources":["../../../src/bigconsole/assistant/previewMutationResult.ts"],"sourcesContent":["/** Entity identities from successful GraphQL responses, independent of narration. */\nexport interface PreviewMutationEntity {\n  step: 'datasink' | 'dashboard' | 'parser' | 'widget';\n  id: string;\n  dashboardId?: string;\n  parserId?: string;\n}\n\nconst OPERATIONS: Record<string, PreviewMutationEntity['step']> = {\n  createDataSink: 'datasink',\n  createBigConsoleDashboard: 'dashboard',\n  createParser: 'parser',\n  createBigConsoleWidget: 'widget',\n  updateDataSink: 'datasink',\n  updateBigConsoleDashboard: 'dashboard',\n  updateParser: 'parser',\n  updateBigConsoleWidget: 'widget',\n};\n\nconst ENTITY_ID = /^[A-Za-z0-9_-]{1,128}$/;\n\nfunction record(value: unknown): Record<string, unknown> | null {\n  return typeof value === 'object' && value !== null && !Array.isArray(value)\n    ? (value as Record<string, unknown>)\n    : null;\n}\n\n/** Accept a parsed response or tool output containing a JSON response. Never read request input. */\nexport function normalizePreviewActionResult(\n  operation: string,\n  responseKey: string,\n  result: unknown,\n  args: Readonly<Record<string, unknown>> = {}\n): unknown {\n  const envelope = record(result);\n  if (Array.isArray(envelope?.errors) && envelope.errors.length > 0) return result;\n  const data = record(envelope?.data) ?? envelope;\n  const entity = data?.[responseKey] ?? data?.[operation];\n  const confirmed = record(entity);\n  if (operation === 'executeParser' && confirmed?.success === true) return { executeParser: confirmed };\n  if (!confirmed || typeof confirmed.id !== 'string') return result;\n  // Relationships may be omitted from the selection. Approved arguments are\n  // usable only once the response confirms that an entity actually exists.\n  const input = record(args.input) ?? record(args.i) ?? args;\n  return { [operation]: { ...input, ...confirmed } };\n}\n\nexport function previewMutationEntities(output: unknown): PreviewMutationEntity[] {\n  if (typeof output === 'string') {\n    try {\n      return previewMutationEntities(JSON.parse(output));\n    } catch {\n      // Tool output can wrap the response in status lines or a fenced code block.\n      const first = output.indexOf('{');\n      const last = output.lastIndexOf('}');\n      if (first < 0 || last <= first) return [];\n      try {\n        return previewMutationEntities(JSON.parse(output.slice(first, last + 1)));\n      } catch {\n        return [];\n      }\n    }\n  }\n  const envelope = record(output);\n  if (!envelope || (Array.isArray(envelope.errors) && envelope.errors.length > 0)) return [];\n  const result: PreviewMutationEntity[] = [];\n  for (const [key, value] of Object.entries(envelope)) {\n    const step = OPERATIONS[key];\n    const entity = record(value);\n    if (\n      key === 'executeParser' &&\n      entity?.success === true &&\n      typeof entity.parserId === 'string' &&\n      ENTITY_ID.test(entity.parserId)\n    ) {\n      result.push({ step: 'parser', id: entity.parserId });\n    } else if (step && entity && typeof entity.id === 'string' && ENTITY_ID.test(entity.id)) {\n      result.push({\n        step,\n        id: entity.id,\n        ...(typeof entity.dashboardId === 'string' && ENTITY_ID.test(entity.dashboardId)\n          ? { dashboardId: entity.dashboardId }\n          : {}),\n        ...(typeof entity.parserId === 'string' && ENTITY_ID.test(entity.parserId)\n          ? { parserId: entity.parserId }\n          : {}),\n      });\n    } else if (key === 'data' || key === 'result' || key === 'output' || key === 'body') {\n      result.push(...previewMutationEntities(value));\n    }\n  }\n  return result;\n}\n"],"mappings":";AAQA,IAAM,IAA4D;CAChE,gBAAgB;CAChB,2BAA2B;CAC3B,cAAc;CACd,wBAAwB;CACxB,gBAAgB;CAChB,2BAA2B;CAC3B,cAAc;CACd,wBAAwB;CACzB,EAEK,IAAY;AAElB,SAAS,EAAO,GAAgD;AAC9D,QAAO,OAAO,KAAU,YAAY,KAAkB,CAAC,MAAM,QAAQ,EAAM,GACtE,IACD;;AAIN,SAAgB,EACd,GACA,GACA,GACA,IAA0C,EAAE,EACnC;CACT,IAAM,IAAW,EAAO,EAAO;AAC/B,KAAI,MAAM,QAAQ,GAAU,OAAO,IAAI,EAAS,OAAO,SAAS,EAAG,QAAO;CAC1E,IAAM,IAAO,EAAO,GAAU,KAAK,IAAI,GAEjC,IAAY,EADH,IAAO,MAAgB,IAAO,GACb;AAChC,KAAI,MAAc,mBAAmB,GAAW,YAAY,GAAM,QAAO,EAAE,eAAe,GAAW;AACrG,KAAI,CAAC,KAAa,OAAO,EAAU,MAAO,SAAU,QAAO;CAG3D,IAAM,IAAQ,EAAO,EAAK,MAAM,IAAI,EAAO,EAAK,EAAE,IAAI;AACtD,QAAO,GAAG,IAAY;EAAE,GAAG;EAAO,GAAG;EAAW,EAAE;;AAGpD,SAAgB,EAAwB,GAA0C;AAChF,KAAI,OAAO,KAAW,SACpB,KAAI;AACF,SAAO,EAAwB,KAAK,MAAM,EAAO,CAAC;SAC5C;EAEN,IAAM,IAAQ,EAAO,QAAQ,IAAI,EAC3B,IAAO,EAAO,YAAY,IAAI;AACpC,MAAI,IAAQ,KAAK,KAAQ,EAAO,QAAO,EAAE;AACzC,MAAI;AACF,UAAO,EAAwB,KAAK,MAAM,EAAO,MAAM,GAAO,IAAO,EAAE,CAAC,CAAC;UACnE;AACN,UAAO,EAAE;;;CAIf,IAAM,IAAW,EAAO,EAAO;AAC/B,KAAI,CAAC,KAAa,MAAM,QAAQ,EAAS,OAAO,IAAI,EAAS,OAAO,SAAS,EAAI,QAAO,EAAE;CAC1F,IAAM,IAAkC,EAAE;AAC1C,MAAK,IAAM,CAAC,GAAK,MAAU,OAAO,QAAQ,EAAS,EAAE;EACnD,IAAM,IAAO,EAAW,IAClB,IAAS,EAAO,EAAM;AAC5B,EACE,MAAQ,mBACR,GAAQ,YAAY,MACpB,OAAO,EAAO,YAAa,YAC3B,EAAU,KAAK,EAAO,SAAS,GAE/B,EAAO,KAAK;GAAE,MAAM;GAAU,IAAI,EAAO;GAAU,CAAC,GAC3C,KAAQ,KAAU,OAAO,EAAO,MAAO,YAAY,EAAU,KAAK,EAAO,GAAG,GACrF,EAAO,KAAK;GACV;GACA,IAAI,EAAO;GACX,GAAI,OAAO,EAAO,eAAgB,YAAY,EAAU,KAAK,EAAO,YAAY,GAC5E,EAAE,aAAa,EAAO,aAAa,GACnC,EAAE;GACN,GAAI,OAAO,EAAO,YAAa,YAAY,EAAU,KAAK,EAAO,SAAS,GACtE,EAAE,UAAU,EAAO,UAAU,GAC7B,EAAE;GACP,CAAC,IACO,MAAQ,UAAU,MAAQ,YAAY,MAAQ,YAAY,MAAQ,WAC3E,EAAO,KAAK,GAAG,EAAwB,EAAM,CAAC;;AAGlD,QAAO"}

package/dist/bigconsole/assistant/previewRunAction.d.ts

@@ -0,0 +1,25 @@
+import { AssistantPreviewEvent } from '@burdenoff/fe-libs/shared/assistant';
+
+/** What, if anything, a bridge event should do to the run store. */
+export type PreviewRunAction = 'start' | 'progress' | 'end' | 'ignore';
+/**
+ * ★★★ ASK TURNS MUST NOT DRIVE THE BUILD PREVIEW (Codex review, PR #154).
+ *
+ * BC3 is what introduces a second mode. Before it, `api-calls` was the ONLY mode
+ * BigConsole offered, so forwarding every event unconditionally was correct.
+ * Now the controller is registered panel-wide while Ask is read-only, and an
+ * unfiltered `start` would mark the build store running, open the preview and
+ * light the DataSink step for an ordinary question. Worse, `applyProgress`
+ * harvests entity links out of PROSE — so an Ask answer that merely mentions
+ * `/bigconsole/dashboards/abc` would be recorded as an entity a build had just
+ * created. Every member who only has Ask would see that, on every question.
+ *
+ * ★★ ADOPTION IS KEYED ON THE RUN, and that is the subtle half. Re-checking "is
+ * the mode Build right now?" on every event looks equivalent and is not: a run
+ * that STARTS in Build whose conversation is switched to Ask mid-run would have
+ * its `end` filtered out, leaving the store spinning on a build that had already
+ * finished. The mode is consulted ONCE, at `start`; after that the run is
+ * followed to its end — the same way fe-libs' own bridge keys runs.
+ */
+export declare function previewRunAction(kind: AssistantPreviewEvent['kind'], runId: string, modeOfRun: string, adoptedRuns: ReadonlySet<string>): PreviewRunAction;
+//# sourceMappingURL=previewRunAction.d.ts.map

package/dist/bigconsole/assistant/previewRunAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"previewRunAction.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/previewRunAction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAIjF,oEAAoE;AACpE,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG,UAAU,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEvE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,qBAAqB,CAAC,MAAM,CAAC,EACnC,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,GAC/B,gBAAgB,CAIlB"}

package/dist/bigconsole/assistant/product.d.ts

@@ -0,0 +1,28 @@
+/**
+ * BigConsole's product id, in one place.
+ *
+ * ★★ This single string answers three different questions, and they must never
+ * be allowed to drift apart:
+ *
+ *   1. `AI_ASSISTANT_PRODUCT` — the env the sandbox is created with, which
+ *      selects the agent's product guide.
+ *   2. `metadata.assistantProduct` — the reuse stamp (BOFF-7312). A sandbox
+ *      stamped with another product's id is never reused for this one. That is
+ *      not bookkeeping: adopting another product's container inherits its
+ *      persona and docs corpus, which is the production incident pinned in
+ *      fe-libs' `sandboxProductIsolation.test.ts` — a HealthyBowl user greeted
+ *      by "I am the AI assistant for the Burdenoff platform".
+ *   3. The i18n namespace prefix: every shared-panel string resolves as
+ *      `bigconsole.assistant.<relative key>`.
+ *
+ * A second literal spelled the same way would satisfy all three today and
+ * silently stop doing so the moment one of them is edited.
+ * `assistantSeamWiring.test.ts` asserts that no other production file in this
+ * folder contains the bare quoted literal.
+ *
+ * ★ Deliberately a module with NO other imports: the id is read by the seam, by
+ * the i18n namespace and by the sandbox stamp, and none of them should have to
+ * load anything else to get it.
+ */
+export declare const BIGCONSOLE_PRODUCT = "bigconsole";
+//# sourceMappingURL=product.d.ts.map

package/dist/bigconsole/assistant/product.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"product.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/product.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,kBAAkB,eAAe,CAAC"}