@burdenoff/microfe-bigconsole 2026.1006.1 → 2026.1007.11

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

@@ -0,0 +1,33 @@
+import { AssistantModeConfig } from '@burdenoff/fe-libs/shared/assistant/conversation';
+
+/** Keys longer than this get a hash suffix instead of the full slug (as fe-libs). */
+export declare const MAX_COPY_SLUG_LENGTH = 64;
+/**
+ * lower-camel ASCII of an English string, accents folded and every
+ * non-alphanumeric run a word break: `"What can I do on this screen?"` →
+ * `whatCanIDoOnThisScreen`. A slug over {@link MAX_COPY_SLUG_LENGTH} keeps a
+ * readable prefix plus a hash of the whole English.
+ *
+ * ★ The same function as fe-libs' `assistantCopySlug` (PR-I18N,
+ * `shared/assistant/productCopy.ts`), which derives the keys it looks up at
+ * display time. Replace this copy with the fe-libs import once that ships.
+ *
+ * @throws when nothing ASCII-alphanumeric is left — fe-libs shows such copy as
+ *   passed, so a key for it could never be asked for.
+ */
+export declare function assistantCopySlug(english: string): string;
+/** The part of a mode whose copy this module keys. */
+export type AssistantModeDisplaySource = Pick<AssistantModeConfig, 'id' | 'description' | 'suggestions'>;
+/**
+ * Relative key → English for each mode's description and suggestion chips, and
+ * for each page label.
+ *
+ * @throws when two different English strings would share a key.
+ */
+export declare function assistantDisplayCopy(args: {
+    modes: readonly AssistantModeDisplaySource[];
+    pageLabels: readonly string[];
+}): Record<string, string>;
+/** BigConsole's display copy as FULL keys (`bigconsole.assistant.…`), for the seed bundle. */
+export declare function bigconsoleAssistantDisplaySeedCopy(): Record<string, string>;
+//# sourceMappingURL=displayCopy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"displayCopy.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/displayCopy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kDAAkD,CAAC;AAO5F,qFAAqF;AACrF,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAcvC;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAYzD;AAED,sDAAsD;AACtD,MAAM,MAAM,0BAA0B,GAAG,IAAI,CAAC,mBAAmB,EAAE,IAAI,GAAG,aAAa,GAAG,aAAa,CAAC,CAAC;AAYzG;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE;IACzC,KAAK,EAAE,SAAS,0BAA0B,EAAE,CAAC;IAC7C,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/B,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAUzB;AAED,8FAA8F;AAC9F,wBAAgB,kCAAkC,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAQ3E"}

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

@@ -30,3 +30,4 @@ export { BIGCONSOLE_PRODUCT } from './product';
 export { API_CALLS_CONFIRM_PREAMBLE, API_CALLS_PROPOSAL_PREAMBLE, USER_REQUEST_DELIMITER, buildPromptForMode, } from './assistantPrompt';
 export { PROBE_RESOURCES, useWorkspaceWriteAccess, type WorkspaceWriteAccess } from './useWorkspaceWriteAccess';
 export { useBigConsoleAssistantPreview } from './previewController';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAC;AACjF,YAAY,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAG5E,OAAO,EAAE,kBAAkB,EAAE,MAAM,0CAA0C,CAAC;AAC9E,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,oCAAoC,EAAE,MAAM,eAAe,CAAC;AAC7G,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,YAAY,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAE7C;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,4BAA4B,EAAE,eAAe,EAAE,KAAK,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AACpH,OAAO,EAAE,GAAG,EAAE,0BAA0B,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EACL,0BAA0B,EAC1B,2BAA2B,EAC3B,sBAAsB,EACtB,kBAAkB,GACnB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,eAAe,EAAE,uBAAuB,EAAE,KAAK,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAChH,OAAO,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAC"}

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

@@ -252,3 +252,4 @@ declare const BUILD: {
  */
 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/modes.js

@@ -27,3 +27,5 @@ var e = {
 }, n = [e, t];
 //#endregion
 export { e as ASK, n as BIGCONSOLE_ASSISTANT_MODES, t as BUILD };
+
+//# sourceMappingURL=modes.js.map

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

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

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

@@ -39,6 +39,20 @@ export type PageContext = {
     timestamp: string;
 };
 export declare function gatherPageContext(): PageContext;
+/**
+ * Route segment → human label.
+ *
+ * ★ Every top-level segment BigConsole routes to (`BigConsoleRoutes.tsx`),
+ * except `/list`, which only redirects. Anything missing falls through to a
+ * title-cased segment, which is right far more often than a wrong
+ * label would be — and a wrong answer here is worse than none, because the panel
+ * states it as fact.
+ *
+ * Each label is also seeded as `bigconsole.assistant.page.<slug>`
+ * (`displayCopy.ts`) so the panel can SHOW it translated; the English here is
+ * what the model is told.
+ */
+export declare const BIGCONSOLE_PAGE_LABELS: Readonly<Record<string, string>>;
 /**
  * A human label for where the user is right now, for the shared panel.
  *
@@ -62,3 +76,4 @@ export declare function describeCurrentPage(): string;
  */
 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;AAKD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAcnE,CAAC;AAEF;;;;;;;;;;;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/pageContext.js

@@ -18,9 +18,14 @@ var n = "Home", r = {
 	home: n,
 	dashboards: "Dashboards",
 	datasinks: "Data sinks",
+	datasources: "Data sources",
+	insights: "Insights",
 	parsers: "Parsers",
 	pipelines: "Pipelines",
-	workflows: "Workflows"
+	settings: "Settings",
+	widgets: "Widgets",
+	workflows: "Workflows",
+	workflow: "Workflows"
 };
 function i() {
 	let { currentPage: e } = t(), i = e.split("/").filter(Boolean), a = (i[0] === "bigconsole" ? i[1] : i[0]) ?? "";
@@ -60,3 +65,5 @@ function s(e) {
 }
 //#endregion
 export { i as describeCurrentPage, t as gatherPageContext, o as resolveBigConsoleConversationContext };
+
+//# sourceMappingURL=pageContext.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pageContext.js","names":[],"sources":["../../../src/bigconsole/assistant/pageContext.ts"],"sourcesContent":["/**\n * Page context gathering for BigConsole — captures the user's current browser\n * context to be sent alongside every assistant prompt for better AI awareness.\n *\n * Mirrors microfe-vibecontrols' `utils/pageContext.ts`. The agent filters the\n * payload to an allow-list (`ai-assistant/src/context-loader.ts` →\n * `ALLOWED_CONTEXT_KEYS`), so the keys MUST be `currentUrl` (NOT `activeUrl`)\n * and the generic `entityType` / `entityId`, or the value is silently dropped.\n */\n\nimport { BIGCONSOLE_PRODUCT } from './product';\n\ninterface ConversationContextShape {\n  entityType?: string;\n  entityId?: string;\n  activeTab?: string;\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * ★★ A `type`, NOT an `interface`, and the difference is load-bearing.\n *\n * fe-libs' product seam declares `gatherPageContext?: () => PageContext` against\n * ITS OWN `PageContext`, which carries an index signature\n * (`[key: string]: unknown`) so a product may add keys of its own. TypeScript\n * gives a type alias an IMPLICIT index signature and an interface NONE —\n * an interface stays open to declaration merging, so the compiler cannot know\n * its full set of keys and refuses the assignment.\n *\n * So this exact shape, written as an interface, is not assignable to fe-libs'\n * parameter: `assistantProduct.ts` fails with TS2322 while the runtime value is\n * perfectly correct. Changing this back to `interface` re-breaks the seam.\n */\nexport type PageContext = {\n  // `currentUrl` (NOT `activeUrl`) — must match the agent's allowed-context-key\n  // contract, otherwise the agent filters it out.\n  currentUrl: string;\n  currentPage: string;\n  // The entity the user is currently looking at, resolved from the route. Lets\n  // the assistant act on \"this / current / here\" without asking for an id.\n  entityType?: string;\n  entityId?: string;\n  platform: string;\n  version: string;\n  viewportSize: string;\n  userAgent: string;\n  timestamp: string;\n};\n\nexport function gatherPageContext(): PageContext {\n  const url = window.location.href;\n  const pathSegments = window.location.pathname.split('/').filter(Boolean);\n  const currentPage = pathSegments.slice(0, 3).join('/') || 'home';\n  const entity = resolveBigConsoleConversationContext(window.location.pathname, window.location.search);\n\n  return {\n    currentUrl: url,\n    currentPage,\n    entityType: entity.entityType,\n    entityId: entity.entityId,\n    platform: BIGCONSOLE_PRODUCT,\n    version: import.meta.env.VITE_APP_VERSION ?? '2026.430.500',\n    viewportSize: `${window.innerWidth}x${window.innerHeight}`,\n    userAgent: navigator.userAgent,\n    timestamp: new Date().toISOString(),\n  };\n}\n\n/** Shown to the user as \"where you are\", e.g. in the panel's empty state. */\nconst HOME_LABEL = 'Home';\n\n/**\n * Route segment → human label.\n *\n * ★ Every top-level segment BigConsole routes to (`BigConsoleRoutes.tsx`),\n * except `/list`, which only redirects. Anything missing falls through to a\n * title-cased segment, which is right far more often than a wrong\n * label would be — and a wrong answer here is worse than none, because the panel\n * states it as fact.\n *\n * Each label is also seeded as `bigconsole.assistant.page.<slug>`\n * (`displayCopy.ts`) so the panel can SHOW it translated; the English here is\n * what the model is told.\n */\nexport const BIGCONSOLE_PAGE_LABELS: Readonly<Record<string, string>> = {\n  home: HOME_LABEL,\n  dashboards: 'Dashboards',\n  datasinks: 'Data sinks',\n  datasources: 'Data sources',\n  insights: 'Insights',\n  parsers: 'Parsers',\n  pipelines: 'Pipelines',\n  settings: 'Settings',\n  widgets: 'Widgets',\n  workflows: 'Workflows',\n  // `/workflow/:id/:version` is the workflow builder's legacy route; it is\n  // part of the Workflows area, not a page of its own.\n  workflow: 'Workflows',\n};\n\n/**\n * A human label for where the user is right now, for the shared panel.\n *\n * ★★ The `/bigconsole` MOUNT SEGMENT IS SKIPPED. This MFE mounts under\n * `/bigconsole` in the host shell, so the first segment is the product name on\n * every single page — without this, every location would be described as\n * \"Bigconsole\", which is both useless and wrong.\n *\n * ★ Derived from `gatherPageContext().currentPage` rather than reading\n * `window.location` a second time, so the label and the agent's structured\n * context can never disagree about which page they describe.\n */\nexport function describeCurrentPage(): string {\n  const { currentPage } = gatherPageContext();\n  const segments = currentPage.split('/').filter(Boolean);\n  const first = (segments[0] === BIGCONSOLE_PRODUCT ? segments[1] : segments[0]) ?? '';\n  if (!first || first === 'home') return HOME_LABEL;\n  return (\n    BIGCONSOLE_PAGE_LABELS[first] ??\n    first\n      .split('-')\n      .map((word) => (word ? word.charAt(0).toUpperCase() + word.slice(1) : word))\n      .join(' ')\n  );\n}\n\nfunction matchPath(pattern: RegExp, pathname: string): RegExpMatchArray | null {\n  return pathname.match(pattern);\n}\n\n/**\n * Maps the current BigConsole route to `{ entityType, entityId }`. The BigConsole\n * MFE mounts under the `/bigconsole` base path in the host shell, so detail\n * routes are matched as `/bigconsole/<collection>/:id`.\n *\n * More specific routes (e.g. dashboard-scoped parsers, builder/edit sub-routes)\n * are matched before their parent so the most relevant entity wins.\n */\nexport function resolveBigConsoleConversationContext(pathname: string, search: string): ConversationContextShape {\n  const params = new URLSearchParams(search);\n\n  const directMatches: Array<[RegExp, string]> = [\n    // Dashboard-scoped parser detail (more specific than the bare parser route).\n    [/^\\/bigconsole\\/dashboards\\/[^/]+\\/parsers\\/([^/]+)(?:\\/edit)?$/, 'BIGCONSOLE_PARSER'],\n    // Dashboard detail + builder.\n    [/^\\/bigconsole\\/dashboards\\/([^/]+)(?:\\/builder)?$/, 'BIGCONSOLE_DASHBOARD'],\n    // Data sinks.\n    [/^\\/bigconsole\\/datasinks\\/([^/]+)(?:\\/edit)?$/, 'BIGCONSOLE_DATASINK'],\n    // Parsers.\n    [/^\\/bigconsole\\/parsers\\/([^/]+)(?:\\/edit)?$/, 'BIGCONSOLE_PARSER'],\n    // Pipelines.\n    [/^\\/bigconsole\\/pipelines\\/([^/]+)(?:\\/edit)?$/, 'BIGCONSOLE_PIPELINE'],\n    // Workflows (BigConsole-native list/view; the SDK builder uses /workflow/...).\n    [/^\\/bigconsole\\/workflows\\/([^/]+)(?:\\/edit)?$/, 'BIGCONSOLE_WORKFLOW'],\n  ];\n\n  for (const [pattern, entityType] of directMatches) {\n    const match = matchPath(pattern, pathname);\n    if (match && match[1] && !isReservedSegment(match[1])) {\n      return {\n        entityType,\n        entityId: match[1],\n        metadata: {\n          routePattern: pattern.source,\n        },\n      };\n    }\n  }\n\n  const activeTab =\n    params.get('tab') ??\n    (() => {\n      const segments = pathname.split('/').filter(Boolean);\n      return segments.length > 2 ? segments[segments.length - 1] : undefined;\n    })();\n\n  return {\n    activeTab: activeTab ?? undefined,\n    metadata: {\n      ...(activeTab ? { activeTab } : {}),\n    },\n  };\n}\n\n/**\n * Static segments that share a route shape with `:id` detail routes\n * (e.g. `/bigconsole/datasinks/new`, `/bigconsole/parsers/new`). These are\n * pages, not entities, so they must not be reported as an `entityId`.\n */\nfunction isReservedSegment(segment: string): boolean {\n  return segment === 'new' || segment === 'builder' || segment === 'list';\n}\n"],"mappings":";;AAiDA,SAAgB,IAAiC;CAC/C,IAAM,IAAM,OAAO,SAAS,MAEtB,IADe,OAAO,SAAS,SAAS,MAAM,IAAI,CAAC,OAAO,QAAQ,CACvC,MAAM,GAAG,EAAE,CAAC,KAAK,IAAI,IAAI,QACpD,IAAS,EAAqC,OAAO,SAAS,UAAU,OAAO,SAAS,OAAO;AAErG,QAAO;EACL,YAAY;EACZ;EACA,YAAY,EAAO;EACnB,UAAU,EAAO;EACjB,UAAU;EACV,SAA6C;EAC7C,cAAc,GAAG,OAAO,WAAW,GAAG,OAAO;EAC7C,WAAW,UAAU;EACrB,4BAAW,IAAI,MAAM,EAAC,aAAa;EACpC;;AAIH,IAAM,IAAa,QAeN,IAA2D;CACtE,MAAM;CACN,YAAY;CACZ,WAAW;CACX,aAAa;CACb,UAAU;CACV,SAAS;CACT,WAAW;CACX,UAAU;CACV,SAAS;CACT,WAAW;CAGX,UAAU;CACX;AAcD,SAAgB,IAA8B;CAC5C,IAAM,EAAE,mBAAgB,GAAmB,EACrC,IAAW,EAAY,MAAM,IAAI,CAAC,OAAO,QAAQ,EACjD,KAAS,EAAS,OAAA,eAA4B,EAAS,KAAK,EAAS,OAAO;AAElF,QADI,CAAC,KAAS,MAAU,SAAe,IAErC,EAAuB,MACvB,EACG,MAAM,IAAI,CACV,KAAK,MAAU,KAAO,EAAK,OAAO,EAAE,CAAC,aAAa,GAAG,EAAK,MAAM,EAAE,CAAS,CAC3E,KAAK,IAAI;;AAIhB,SAAS,EAAU,GAAiB,GAA2C;AAC7E,QAAO,EAAS,MAAM,EAAQ;;AAWhC,SAAgB,EAAqC,GAAkB,GAA0C;CAC/G,IAAM,IAAS,IAAI,gBAAgB,EAAO;AAiB1C,MAAK,IAAM,CAAC,GAAS,MAf0B;EAE7C,CAAC,kEAAkE,oBAAoB;EAEvF,CAAC,qDAAqD,uBAAuB;EAE7E,CAAC,iDAAiD,sBAAsB;EAExE,CAAC,+CAA+C,oBAAoB;EAEpE,CAAC,iDAAiD,sBAAsB;EAExE,CAAC,iDAAiD,sBAAsB;EACzE,EAEkD;EACjD,IAAM,IAAQ,EAAU,GAAS,EAAS;AAC1C,MAAI,KAAS,EAAM,MAAM,CAAC,EAAkB,EAAM,GAAG,CACnD,QAAO;GACL;GACA,UAAU,EAAM;GAChB,UAAU,EACR,cAAc,EAAQ,QACvB;GACF;;CAIL,IAAM,IACJ,EAAO,IAAI,MAAM,WACV;EACL,IAAM,IAAW,EAAS,MAAM,IAAI,CAAC,OAAO,QAAQ;AACpD,SAAO,EAAS,SAAS,IAAI,EAAS,EAAS,SAAS,KAAK,KAAA;KAC3D;AAEN,QAAO;EACL,WAAW,KAAa,KAAA;EACxB,UAAU,EACR,GAAI,IAAY,EAAE,cAAW,GAAG,EAAE,EACnC;EACF;;AAQH,SAAS,EAAkB,GAA0B;AACnD,QAAO,MAAY,SAAS,MAAY,aAAa,MAAY"}

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

@@ -30,3 +30,4 @@ export type { PreviewRunAction };
  * 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

@@ -34,3 +34,5 @@ function c() {
 }
 //#endregion
 export { c as useBigConsoleAssistantPreview };
+
+//# sourceMappingURL=previewController.js.map

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

@@ -0,0 +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';\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

@@ -8,3 +8,4 @@ export interface PreviewMutationEntity {
 /** 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

@@ -55,3 +55,5 @@ function i(r) {
 }
 //#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

@@ -22,3 +22,4 @@ export type PreviewRunAction = 'start' | 'progress' | 'end' | 'ignore';
  * 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/previewRunAction.js

@@ -5,3 +5,5 @@ function t(t, n, r, i) {
 }
 //#endregion
 export { t as previewRunAction };
+
+//# sourceMappingURL=previewRunAction.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"previewRunAction.js","names":[],"sources":["../../../src/bigconsole/assistant/previewRunAction.ts"],"sourcesContent":["/**\n * Which bridge events may drive BigConsole's BUILD preview.\n *\n * ★★★ A MODULE OF ITS OWN, AND THAT IS NOT ORGANISATION — IT IS WHAT MAKES THIS\n * TESTABLE AT ALL.\n *\n * This rule started life inside `previewController.tsx`, next to the React\n * surface, described as \"pure, and separate from the wiring\". It was not\n * separate: that file imports `useAssistantStore` from fe-libs' assistant\n * BARREL, and the barrel pulls modules that touch `document` at load time. So\n * importing it from a `bun test` (no DOM) threw `ReferenceError: document is not\n * defined` before a single assertion ran.\n *\n * Here the only runtime import is `./modes`, whose own fe-libs import is\n * type-only and therefore erased. That keeps this file loadable anywhere — which\n * is the whole point of splitting a decision out from its wiring.\n */\nimport type { AssistantPreviewEvent } from '@burdenoff/fe-libs/shared/assistant';\n\nimport { BUILD } from './modes';\n\n/** What, if anything, a bridge event should do to the run store. */\nexport type PreviewRunAction = 'start' | 'progress' | 'end' | 'ignore';\n\n/**\n * ★★★ ASK TURNS MUST NOT DRIVE THE BUILD PREVIEW (Codex review, PR #154).\n *\n * BC3 is what introduces a second mode. Before it, `api-calls` was the ONLY mode\n * BigConsole offered, so forwarding every event unconditionally was correct.\n * Now the controller is registered panel-wide while Ask is read-only, and an\n * unfiltered `start` would mark the build store running, open the preview and\n * light the DataSink step for an ordinary question. Worse, `applyProgress`\n * harvests entity links out of PROSE — so an Ask answer that merely mentions\n * `/bigconsole/dashboards/abc` would be recorded as an entity a build had just\n * created. Every member who only has Ask would see that, on every question.\n *\n * ★★ ADOPTION IS KEYED ON THE RUN, and that is the subtle half. Re-checking \"is\n * the mode Build right now?\" on every event looks equivalent and is not: a run\n * that STARTS in Build whose conversation is switched to Ask mid-run would have\n * its `end` filtered out, leaving the store spinning on a build that had already\n * finished. The mode is consulted ONCE, at `start`; after that the run is\n * followed to its end — the same way fe-libs' own bridge keys runs.\n */\nexport function previewRunAction(\n  kind: AssistantPreviewEvent['kind'],\n  runId: string,\n  modeOfRun: string,\n  adoptedRuns: ReadonlySet<string>\n): PreviewRunAction {\n  if (kind === 'start') return modeOfRun === BUILD.id ? 'start' : 'ignore';\n  if (!adoptedRuns.has(runId)) return 'ignore';\n  return kind === 'snapshot' ? 'progress' : 'end';\n}\n"],"mappings":";;AA2CA,SAAgB,EACd,GACA,GACA,GACA,GACkB;AAGlB,QAFI,MAAS,UAAgB,MAAc,EAAM,KAAK,UAAU,WAC3D,EAAY,IAAI,EAAM,GACpB,MAAS,aAAa,aAAa,QADN"}

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

@@ -25,3 +25,4 @@
  * 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"}

package/dist/bigconsole/assistant/product.js

@@ -2,3 +2,5 @@
 var e = "bigconsole";
 //#endregion
 export { e as BIGCONSOLE_PRODUCT };
+
+//# sourceMappingURL=product.js.map

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

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

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

@@ -12,3 +12,4 @@ export interface RecordAdapterDeps {
 }
 export declare function createBigConsoleRecordAdapters(deps?: RecordAdapterDeps): readonly AssistantRecordAdapter[];
 export declare const BIGCONSOLE_RECORD_ADAPTERS: readonly AssistantRecordAdapter[];
+//# sourceMappingURL=recordAdapters.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recordAdapters.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/recordAdapters.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EACV,sBAAsB,EAEvB,MAAM,2DAA2D,CAAC;AACnE,OAAO,EAAwB,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAEvF,0FAA0F;AAC1F,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAE1C,eAAO,MAAM,uBAAuB,gNAMnC,CAAC;AAEF,eAAO,MAAM,uBAAuB,oMAMnC,CAAC;AAEF,gGAAgG;AAChG,MAAM,WAAW,iBAAiB;IAChC,YAAY,EAAE,OAAO,YAAY,CAAC;IAClC,cAAc,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;CACrC;AAuKD,wBAAgB,8BAA8B,CAAC,IAAI,GAAE,iBAA6B,GAAG,SAAS,sBAAsB,EAAE,CAuBrH;AAED,eAAO,MAAM,0BAA0B,EAAE,SAAS,sBAAsB,EAAqC,CAAC"}

package/dist/bigconsole/assistant/recordAdapters.js

@@ -1,19 +1,20 @@
 import { getStoredWorkspaceId as e, graphqlFetch as t } from "@burdenoff/fe-libs/shared/graphql";
-var n = "\n  query AssistantFindDashboards($search: String, $first: Int) {\n    listDashboards(search: $search, first: $first, includeArchived: false) {\n      edges { node { id name workspaceId } }\n    }\n  }\n", r = "\n  query AssistantFindDataSinks($search: String, $first: Int) {\n    listDataSinks(search: $search, first: $first) {\n      edges { node { id name key workspaceId deletedAt } }\n    }\n  }\n", i = {
+import { normaliseRecordName as n } from "@burdenoff/fe-libs/shared/assistant/uiActions/recordNames";
+var r = "\n  query AssistantFindDashboards($search: String, $first: Int) {\n    listDashboards(search: $search, first: $first, includeArchived: false) {\n      edges { node { id name workspaceId } }\n    }\n  }\n", i = "\n  query AssistantFindDataSinks($search: String, $first: Int) {\n    listDataSinks(search: $search, first: $first) {\n      edges { node { id name key workspaceId deletedAt } }\n    }\n  }\n", a = {
 	graphqlFetch: t,
 	getWorkspaceId: e
-}, a = (e) => e.normalize("NFKC").toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").replace(/\s+/g, " ").trim(), o = (e) => [...new Set(e.split(" ").filter((e) => e.length > 0))].sort((e, t) => [...t].length - [...e].length), s = (e) => {
-	let t = e.filter((e) => [...e].length >= 3);
-	return t.length > 0 ? t : e.filter((e) => [...e].length === 2);
+}, o = n, s = (e) => [...new Set(e.split(" ").filter((e) => e.length > 0))].sort((e, t) => [...t].length - [...e].length), c = "and", l = (e) => {
+	let t = e.filter((e) => [...e].length >= 3), n = [...t.filter((e) => e !== c), ...t.filter((e) => e === c)];
+	return n.length > 0 ? n : e.filter((e) => [...e].length === 2);
 };
-async function c(e, t, n, r, i, c, l) {
+async function u(e, t, n, r, i, a, c) {
 	let u = e.getWorkspaceId();
 	if (!u) return [];
-	let d = a(i), f = o(d);
+	let d = o(i), f = s(d);
 	if (f.length === 0) return [];
-	let [p, m] = s(f), h = async (i) => {
-		if (c.aborted) return null;
-		let a = await e.graphqlFetch({
+	let [p, m] = l(f), h = async (i) => {
+		if (a.aborted) return null;
+		let o = await e.graphqlFetch({
 			gateway: "workspace",
 			query: t,
 			operationName: n,
@@ -24,35 +25,35 @@ async function c(e, t, n, r, i, c, l) {
 			workspaceToken: !0,
 			workspaceId: u,
 			organizationId: !0,
-			signal: c,
+			signal: a,
 			suppressGlobalErrorEvent: !0
 		});
-		if (a.errors?.length) return null;
-		let o = a.data?.[r]?.edges;
-		if (!Array.isArray(o)) return null;
-		let s = [];
-		for (let e of o) {
+		if (o.errors?.length) return null;
+		let s = o.data?.[r]?.edges;
+		if (!Array.isArray(s)) return null;
+		let l = [];
+		for (let e of s) {
 			let t = e?.node;
 			if (!t || typeof t.id != "string" || t.id.length === 0 || typeof t.workspaceId == "string" && t.workspaceId !== u) continue;
-			let n = l(t);
-			n !== null && s.push({
+			let n = c(t);
+			n !== null && l.push({
 				params: { id: t.id },
 				name: n
 			});
 		}
 		return {
-			rows: o.length,
-			matches: s
+			rows: s.length,
+			matches: l
 		};
-	}, g = (e) => h(e).catch(() => null), _ = (e) => a(e.name) === d, [v, y] = await Promise.all([h(d), p !== void 0 && p !== d ? g(p) : null]);
+	}, g = (e) => h(e).catch(() => null), _ = (e) => o(e.name) === d, [v, y] = await Promise.all([h(d), p !== void 0 && p !== d ? g(p) : null]);
 	if (v === null) return [];
 	let b = [...v.matches], x = (e) => {
 		for (let t of e?.matches ?? []) _(t) && !b.some((e) => e.params.id === t.params.id) && b.push(t);
 	};
 	return x(y), y !== null && y.rows >= 10 && !b.some(_) && m !== void 0 && e.getWorkspaceId() === u && x(await g(m)), b;
 }
-var l = (e) => typeof e == "string" && e.trim().length > 0 ? e.trim() : null;
-function u(e = i) {
+var d = (e) => typeof e == "string" && e.trim().length > 0 ? e.trim() : null;
+function f(e = a) {
 	return [{
 		id: "bigconsole-dashboard",
 		nouns: ["dashboard", "dashboards"],
@@ -61,7 +62,7 @@ function u(e = i) {
 			fallback: "dashboard"
 		},
 		entityRouteId: "bigconsole-dashboard",
-		find: (t, r) => c(e, n, "AssistantFindDashboards", "listDashboards", t, r, (e) => l(e.name))
+		find: (t, n) => u(e, r, "AssistantFindDashboards", "listDashboards", t, n, (e) => d(e.name))
 	}, {
 		id: "bigconsole-datasink",
 		nouns: [
@@ -77,9 +78,11 @@ function u(e = i) {
 			fallback: "data source"
 		},
 		entityRouteId: "bigconsole-datasink",
-		find: (t, n) => c(e, r, "AssistantFindDataSinks", "listDataSinks", t, n, (e) => e.deletedAt ? null : l(e.name) ?? l(e.key))
+		find: (t, n) => u(e, i, "AssistantFindDataSinks", "listDataSinks", t, n, (e) => e.deletedAt ? null : d(e.name) ?? d(e.key))
 	}];
 }
-var d = u();
+var p = f();
 //#endregion
-export { d as BIGCONSOLE_RECORD_ADAPTERS };
+export { p as BIGCONSOLE_RECORD_ADAPTERS };
+
+//# sourceMappingURL=recordAdapters.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recordAdapters.js","names":[],"sources":["../../../src/bigconsole/assistant/recordAdapters.ts"],"sourcesContent":["/**\n * BigConsole's named-record adapters for the shared assistant (BOFF-8060 N1b):\n * \"open the Coffee Shop Sales dashboard\", \"open the Orders data source\".\n *\n * An adapter only LOOKS A RECORD UP BY NAME through the READ API the product's\n * own list pages already use (`listDashboards`, `listDataSinks`, with their\n * `search` argument), as the signed-in person: the workspace token is theirs and\n * the gateway's `@rbac` filters the list, so a record they may not read never\n * comes back. The adapter produces route params, never a path: fe-libs fills the\n * entity route declared in `assistantProduct.ts` (`ENTITY_ROUTES`) and re-validates\n * it, and only for a person who can see the route's sidebar entry.\n *\n * ★ Raw operation strings, as in `conversationHistoryApi.ts`: two tiny read-only\n * selections used only here. `tests/recordAdapters.test.ts` validates both against\n * the committed workspace schema, so a renamed field fails there, not in prod.\n *\n * ★ What the server is asked (BOFF-8060 F8). The shared planner hands over a\n * NORMALISED name (lower case, \"&\" as \"and\", every other punctuation mark a space) while the server's\n * `search` is a plain substring match on the RAW name. The WHOLE SENTENCE is what this\n * lookup has always asked, and what it answered stays the answer; but \"boff 7926 embed\n * all widgets prod check\" is not a substring of \"BOFF-7926 embed all widgets (prod\n * check)\", so a name with punctuation is never found by it. ONE WORD has no punctuation\n * or space in it, so it is a substring of the raw name: it is asked in parallel (and at\n * most once more), and ONLY a row whose normalised name equals the sentence exactly is\n * taken from it. The answer is therefore exactly what the old lookup answered, plus the\n * exact names it could not see: a partial row from a one-word page would give the\n * planner candidates the whole sentence never offered (\"an ambiguous name asks, never\n * guesses\"). The matching itself stays with the shared planner.\n *\n * ★ Nothing here writes, opens a form, or touches the DOM.\n */\nimport { normaliseRecordName } from '@burdenoff/fe-libs/shared/assistant/uiActions/recordNames';\nimport type {\n  AssistantRecordAdapter,\n  AssistantRecordMatch,\n} from '@burdenoff/fe-libs/shared/assistant/uiActions/recordNames';\nimport { getStoredWorkspaceId, graphqlFetch } from '@burdenoff/fe-libs/shared/graphql';\n\n/** More than a handful of candidates is never offered (the panel offers at most four). */\nexport const RECORD_LOOKUP_PAGE_SIZE = 10;\n\nexport const FIND_DASHBOARDS_BY_NAME = `\n  query AssistantFindDashboards($search: String, $first: Int) {\n    listDashboards(search: $search, first: $first, includeArchived: false) {\n      edges { node { id name workspaceId } }\n    }\n  }\n`;\n\nexport const FIND_DATA_SINKS_BY_NAME = `\n  query AssistantFindDataSinks($search: String, $first: Int) {\n    listDataSinks(search: $search, first: $first) {\n      edges { node { id name key workspaceId deletedAt } }\n    }\n  }\n`;\n\n/** The two things the adapters need from the app; injectable so tests run without a network. */\nexport interface RecordAdapterDeps {\n  graphqlFetch: typeof graphqlFetch;\n  getWorkspaceId: () => string | null;\n}\nconst LIVE_DEPS: RecordAdapterDeps = { graphqlFetch, getWorkspaceId: getStoredWorkspaceId };\n\ninterface RawNode {\n  id?: unknown;\n  name?: unknown;\n  key?: unknown;\n  workspaceId?: unknown;\n  deletedAt?: unknown;\n}\ntype ListData = Record<string, { edges?: Array<{ node?: RawNode | null } | null> | null } | null | undefined>;\n\n/**\n * ★ BOFF-8680: the shared planner's OWN normalisation, imported, never copied.\n * fe-libs `normaliseRecordName` (`canonical`) is applied to the request and to\n * every record name before they are compared, so the adapter reasons about names\n * exactly as the planner will: \"&\" reads as \"and\" (\"Sales & Marketing\" is \"sales\n * and marketing\"), a Hindi or Tamil word keeps its vowel signs (combining marks),\n * and a zero-width joiner or non-joiner inside an Indic word is dropped. The local\n * copy this replaces stripped combining marks and kept \"&\" a separator, so an\n * exact name with either was never recognised as exact. Idempotent, so a name\n * that arrives already normalised is unchanged.\n */\nconst normalise = normaliseRecordName;\n\n/**\n * The distinct words of a normalised request, best search term first: the longest\n * (it narrows the server's substring match the most), the earlier word on a tie.\n * `Array.prototype.sort` is stable, so the original order is the tie-break.\n */\nconst searchTerms = (wanted: string): string[] =>\n  [...new Set(wanted.split(' ').filter((word) => word.length > 0))].sort((a, b) => [...b].length - [...a].length);\n\n/** What the planner makes of \"&\" (`normaliseRecordName`): the word \"and\". */\nconst AND = 'and';\n\n/**\n * The words worth asking the server with on their own, best first (`terms` is longest first, earlier on a tie):\n * those of at least three characters; only if there are none, those of exactly two (\"HR-IT\" is typed \"hr it\").\n * A word of one character is in too many names, so it is never asked alone. A one-word page can only ADD exact\n * names, so a short word costs the planner nothing.\n */\nconst searchWords = (terms: readonly string[]): string[] => {\n  const long = terms.filter((word) => [...word].length >= 3);\n  // ★ BOFF-8680: \"and\" is asked LAST among them. The planner writes \"&\" as \"and\" (\"Q&A Hub\" arrives as\n  // \"q and a hub\"), and \"and\" is not a substring of a raw name spelt with \"&\", so asked first it would spend the\n  // one-word request on a page that cannot hold the record. Every other word keeps its place.\n  const ranked = [...long.filter((word) => word !== AND), ...long.filter((word) => word === AND)];\n  return ranked.length > 0 ? ranked : terms.filter((word) => [...word].length === 2);\n};\n\n/** One answer of the server: how many rows it sent, and its usable rows as matches, in the server's order. */\ninterface Page {\n  rows: number;\n  matches: AssistantRecordMatch[];\n}\n\n/**\n * Look a record up by name as the signed-in person and map its nodes to matches.\n *\n * ★ The answer is what the whole-sentence request alone has always answered, plus the\n * exact names it cannot see. The rows of the whole-sentence request are returned\n * unchanged and in order: ONE page of RECORD_LOOKUP_PAGE_SIZE rows, whose partial\n * matches the planner weighs as it always has. A one-word request can only ADD a row\n * whose normalised name equals the sentence exactly (a record that is not deleted and\n * is in this workspace, like any other row); it never adds a partial one.\n *\n * Failure (no workspace, a GraphQL error, a refusal, an abort) of the whole-sentence\n * request is \"no match\": the sentence then goes to the model exactly as it would have.\n * A one-word request that fails or is refused is ignored: it could only have added\n * exact names, and the answer the old lookup gave stands.\n *\n * At most THREE list requests in TWO round trips, usually ONE:\n *  Round 1, in parallel:\n *   (a) `search` = the whole normalised sentence, as ever;\n *   (b) `search` = the longest word, which has no punctuation or space in it, so it is\n *       a substring of the raw name whatever punctuation the name has. Only for a\n *       sentence of more than one word: its longest word of at least three characters or,\n *       if none is that long, its longest word of two (never a word of one character).\n *  Round 2, ONE request, only if no exact name has been found, (b) came back full (the\n *  exact record may be past it) and the workspace is still the one round 1 asked\n *  about: the next distinct word by the same rule.\n * No request is made without `search`, and none once the panel has stopped waiting.\n */\nasync function findByName(\n  deps: RecordAdapterDeps,\n  query: string,\n  operationName: string,\n  field: string,\n  name: string,\n  signal: AbortSignal,\n  pick: (node: RawNode) => string | null\n): Promise<readonly AssistantRecordMatch[]> {\n  const workspaceId = deps.getWorkspaceId();\n  if (!workspaceId) return [];\n  const wanted = normalise(name);\n  const terms = searchTerms(wanted);\n  // Nothing to match: the planner plans a request with no words as \"none\".\n  if (terms.length === 0) return [];\n  const [best, next] = searchWords(terms);\n\n  /** One list request for `search`; `null` is \"no usable answer\". */\n  const ask = async (search: string): Promise<Page | null> => {\n    // Once the panel has stopped waiting nothing is worth asking.\n    if (signal.aborted) return null;\n    const result = await deps.graphqlFetch<ListData>({\n      gateway: 'workspace',\n      query,\n      operationName,\n      variables: { search, first: RECORD_LOOKUP_PAGE_SIZE },\n      // The person's own workspace token, minted for THIS workspace.\n      workspaceToken: true,\n      workspaceId,\n      organizationId: true,\n      signal,\n      suppressGlobalErrorEvent: true,\n    });\n    if (result.errors?.length) return null;\n    const edges = result.data?.[field]?.edges;\n    if (!Array.isArray(edges)) return null;\n    const matches: AssistantRecordMatch[] = [];\n    for (const edge of edges) {\n      const node = edge?.node;\n      if (!node || typeof node.id !== 'string' || node.id.length === 0) continue;\n      // A list answered for another workspace (a switch mid-request) is not used.\n      if (typeof node.workspaceId === 'string' && node.workspaceId !== workspaceId) continue;\n      const label = pick(node);\n      if (label === null) continue;\n      matches.push({ params: { id: node.id }, name: label });\n    }\n    return { rows: edges.length, matches };\n  };\n  /** A one-word request never rejects: when it fails there is simply nothing to add. */\n  const askWord = (word: string): Promise<Page | null> => ask(word).catch(() => null);\n  const isExact = (match: AssistantRecordMatch): boolean => normalise(match.name) === wanted;\n\n  // Round 1, in parallel.\n  const [whole, word] = await Promise.all([ask(wanted), best !== undefined && best !== wanted ? askWord(best) : null]);\n  // As it always was: the whole-sentence request refused or failed is \"no match\".\n  if (whole === null) return [];\n\n  const answer = [...whole.matches];\n  /** Adds the exact names of a one-word page that the answer does not hold yet, and nothing else. */\n  const addExact = (page: Page | null): void => {\n    for (const match of page?.matches ?? []) {\n      if (isExact(match) && !answer.some((known) => known.params.id === match.params.id)) answer.push(match);\n    }\n  };\n  addExact(word);\n\n  // Round 2: ONE request, only while the exact record may still be past the one-word page.\n  if (\n    word !== null &&\n    word.rows >= RECORD_LOOKUP_PAGE_SIZE &&\n    !answer.some(isExact) &&\n    next !== undefined &&\n    // a workspace switch since round 1 would make this request (and its answer) about the wrong workspace\n    deps.getWorkspaceId() === workspaceId\n  ) {\n    addExact(await askWord(next));\n  }\n  return answer;\n}\n\nconst text = (value: unknown): string | null =>\n  typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;\n\nexport function createBigConsoleRecordAdapters(deps: RecordAdapterDeps = LIVE_DEPS): readonly AssistantRecordAdapter[] {\n  const dashboards: AssistantRecordAdapter = {\n    id: 'bigconsole-dashboard',\n    nouns: ['dashboard', 'dashboards'],\n    noun: { key: 'entity.dashboard', fallback: 'dashboard' },\n    entityRouteId: 'bigconsole-dashboard',\n    find: (name, signal) =>\n      findByName(deps, FIND_DASHBOARDS_BY_NAME, 'AssistantFindDashboards', 'listDashboards', name, signal, (node) =>\n        text(node.name)\n      ),\n  };\n  const dataSinks: AssistantRecordAdapter = {\n    id: 'bigconsole-datasink',\n    nouns: ['data source', 'data sources', 'data sink', 'data sinks', 'datasink', 'datasinks'],\n    noun: { key: 'entity.datasink', fallback: 'data source' },\n    entityRouteId: 'bigconsole-datasink',\n    find: (name, signal) =>\n      findByName(deps, FIND_DATA_SINKS_BY_NAME, 'AssistantFindDataSinks', 'listDataSinks', name, signal, (node) =>\n        // A deleted data source is not a page to open; an unnamed one is called by its key.\n        node.deletedAt ? null : (text(node.name) ?? text(node.key))\n      ),\n  };\n  return [dashboards, dataSinks];\n}\n\nexport const BIGCONSOLE_RECORD_ADAPTERS: readonly AssistantRecordAdapter[] = createBigConsoleRecordAdapters();\n"],"mappings":";;AAyCA,IAAa,IAA0B,+MAQ1B,IAA0B,mMAajC,IAA+B;CAAE;CAAc,gBAAgB;CAAsB,EAsBrF,IAAY,GAOZ,KAAe,MACnB,CAAC,GAAG,IAAI,IAAI,EAAO,MAAM,IAAI,CAAC,QAAQ,MAAS,EAAK,SAAS,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,MAAM,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,OAAO,EAG3G,IAAM,OAQN,KAAe,MAAuC;CAC1D,IAAM,IAAO,EAAM,QAAQ,MAAS,CAAC,GAAG,EAAK,CAAC,UAAU,EAAE,EAIpD,IAAS,CAAC,GAAG,EAAK,QAAQ,MAAS,MAAS,EAAI,EAAE,GAAG,EAAK,QAAQ,MAAS,MAAS,EAAI,CAAC;AAC/F,QAAO,EAAO,SAAS,IAAI,IAAS,EAAM,QAAQ,MAAS,CAAC,GAAG,EAAK,CAAC,WAAW,EAAE;;AAoCpF,eAAe,EACb,GACA,GACA,GACA,GACA,GACA,GACA,GAC0C;CAC1C,IAAM,IAAc,EAAK,gBAAgB;AACzC,KAAI,CAAC,EAAa,QAAO,EAAE;CAC3B,IAAM,IAAS,EAAU,EAAK,EACxB,IAAQ,EAAY,EAAO;AAEjC,KAAI,EAAM,WAAW,EAAG,QAAO,EAAE;CACjC,IAAM,CAAC,GAAM,KAAQ,EAAY,EAAM,EAGjC,IAAM,OAAO,MAAyC;AAE1D,MAAI,EAAO,QAAS,QAAO;EAC3B,IAAM,IAAS,MAAM,EAAK,aAAuB;GAC/C,SAAS;GACT;GACA;GACA,WAAW;IAAE;IAAQ,OAAA;IAAgC;GAErD,gBAAgB;GAChB;GACA,gBAAgB;GAChB;GACA,0BAA0B;GAC3B,CAAC;AACF,MAAI,EAAO,QAAQ,OAAQ,QAAO;EAClC,IAAM,IAAQ,EAAO,OAAO,IAAQ;AACpC,MAAI,CAAC,MAAM,QAAQ,EAAM,CAAE,QAAO;EAClC,IAAM,IAAkC,EAAE;AAC1C,OAAK,IAAM,KAAQ,GAAO;GACxB,IAAM,IAAO,GAAM;AAGnB,OAFI,CAAC,KAAQ,OAAO,EAAK,MAAO,YAAY,EAAK,GAAG,WAAW,KAE3D,OAAO,EAAK,eAAgB,YAAY,EAAK,gBAAgB,EAAa;GAC9E,IAAM,IAAQ,EAAK,EAAK;AACpB,SAAU,QACd,EAAQ,KAAK;IAAE,QAAQ,EAAE,IAAI,EAAK,IAAI;IAAE,MAAM;IAAO,CAAC;;AAExD,SAAO;GAAE,MAAM,EAAM;GAAQ;GAAS;IAGlC,KAAW,MAAuC,EAAI,EAAK,CAAC,YAAY,KAAK,EAC7E,KAAW,MAAyC,EAAU,EAAM,KAAK,KAAK,GAG9E,CAAC,GAAO,KAAQ,MAAM,QAAQ,IAAI,CAAC,EAAI,EAAO,EAAE,MAAS,KAAA,KAAa,MAAS,IAAS,EAAQ,EAAK,GAAG,KAAK,CAAC;AAEpH,KAAI,MAAU,KAAM,QAAO,EAAE;CAE7B,IAAM,IAAS,CAAC,GAAG,EAAM,QAAQ,EAE3B,KAAY,MAA4B;AAC5C,OAAK,IAAM,KAAS,GAAM,WAAW,EAAE,CACrC,CAAI,EAAQ,EAAM,IAAI,CAAC,EAAO,MAAM,MAAU,EAAM,OAAO,OAAO,EAAM,OAAO,GAAG,IAAE,EAAO,KAAK,EAAM;;AAgB1G,QAbA,EAAS,EAAK,EAIZ,MAAS,QACT,EAAK,QAAA,MACL,CAAC,EAAO,KAAK,EAAQ,IACrB,MAAS,KAAA,KAET,EAAK,gBAAgB,KAAK,KAE1B,EAAS,MAAM,EAAQ,EAAK,CAAC,EAExB;;AAGT,IAAM,KAAQ,MACZ,OAAO,KAAU,YAAY,EAAM,MAAM,CAAC,SAAS,IAAI,EAAM,MAAM,GAAG;AAExE,SAAgB,EAA+B,IAA0B,GAA8C;AAsBrH,QAAO,CArBoC;EACzC,IAAI;EACJ,OAAO,CAAC,aAAa,aAAa;EAClC,MAAM;GAAE,KAAK;GAAoB,UAAU;GAAa;EACxD,eAAe;EACf,OAAO,GAAM,MACX,EAAW,GAAM,GAAyB,2BAA2B,kBAAkB,GAAM,IAAS,MACpG,EAAK,EAAK,KAAK,CAChB;EACJ,EACyC;EACxC,IAAI;EACJ,OAAO;GAAC;GAAe;GAAgB;GAAa;GAAc;GAAY;GAAY;EAC1F,MAAM;GAAE,KAAK;GAAmB,UAAU;GAAe;EACzD,eAAe;EACf,OAAO,GAAM,MACX,EAAW,GAAM,GAAyB,0BAA0B,iBAAiB,GAAM,IAAS,MAElG,EAAK,YAAY,OAAQ,EAAK,EAAK,KAAK,IAAI,EAAK,EAAK,IAAI,CAC3D;EACJ,CAC6B;;AAGhC,IAAa,IAAgE,GAAgC"}

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

@@ -54,3 +54,4 @@ export interface AssistantSandboxAuthContext {
     userId?: string | null;
     organizationId?: string | null;
 }
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,WAAW,GAAG,cAAc,GAAG,WAAW,CAAC;AAEnF,MAAM,WAAW,uBAAuB;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE;QACN,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,GAAG,CAAC,EAAE,OAAO,CAAC;KACf,CAAC;CACH;AAED,MAAM,WAAW,mBAAmB;IAElC,IAAI,CAAC,EAAE;QACL,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC;QAC3C,IAAI,CAAC,EAAE;YACL,OAAO,CAAC,EAAE,MAAM,CAAC;YACjB,SAAS,CAAC,EAAE,MAAM,CAAC;SACpB,CAAC;KACH,CAAC;IACF,KAAK,CAAC,EAAE,uBAAuB,EAAE,CAAC;IAElC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC/B;AAED,qEAAqE;AACrE,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE;QACL,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED,MAAM,WAAW,2BAA2B;IAC1C,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC"}

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

@@ -14,3 +14,4 @@
  * ★ `|| null`: an empty string is "no workspace", not a workspace called "".
  */
 export declare function useAssistantRunWorkspace(): void;
+//# sourceMappingURL=useAssistantRunWorkspace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAssistantRunWorkspace.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/useAssistantRunWorkspace.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAQ/C"}

package/dist/bigconsole/assistant/useAssistantRunWorkspace.js

@@ -15,3 +15,5 @@ function i() {
 }
 //#endregion
 export { i as useAssistantRunWorkspace };
+
+//# sourceMappingURL=useAssistantRunWorkspace.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAssistantRunWorkspace.js","names":[],"sources":["../../../src/bigconsole/assistant/useAssistantRunWorkspace.ts"],"sourcesContent":["import { useEffect } from 'react';\nimport { useAuthToken } from '@burdenoff/fe-libs/shared/providers/shell';\nimport { useActiveContext } from '@burdenoff/fe-libs/shared/providers/shell/ActiveContextProvider';\n\nimport { useAssistantRunStore } from './assistantRunStore';\n\n/**\n * Binds the build-preview run store to the ACTIVE workspace (BOFF-7799).\n *\n * ★★ Called by both page surfaces, which is what makes a reload in the same tab\n * restore the preview under the breadcrumb and a workspace switch clear it.\n * Binding is idempotent, so the rich panel and the app-shell mini panel may\n * both call it on the same page.\n *\n * ★ From the REACTIVE context, as `BigConsoleAssistant` reads it, never from a\n * helper that reads storage once: the shell does not remount on a workspace\n * switch, so a one-shot read would keep the previous workspace's build on\n * screen.\n *\n * ★ `|| null`: an empty string is \"no workspace\", not a workspace called \"\".\n */\nexport function useAssistantRunWorkspace(): void {\n  const { workspaceId } = useActiveContext();\n  const { userId } = useAuthToken();\n  const bindWorkspace = useAssistantRunStore((state) => state.bindWorkspace);\n\n  useEffect(() => {\n    bindWorkspace(workspaceId || null);\n  }, [bindWorkspace, workspaceId, userId]);\n}\n"],"mappings":";;;;;AAqBA,SAAgB,IAAiC;CAC/C,IAAM,EAAE,mBAAgB,GAAkB,EACpC,EAAE,cAAW,GAAc,EAC3B,IAAgB,GAAsB,MAAU,EAAM,cAAc;AAE1E,SAAgB;AACd,IAAc,KAAe,KAAK;IACjC;EAAC;EAAe;EAAa;EAAO,CAAC"}

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

@@ -33,3 +33,4 @@ export declare const PROBE_RESOURCES: readonly ["bigconsole-datasink", "bigconso
  * first render's list forever.
  */
 export declare function useWorkspaceWriteAccess(actorId: string | null, workspaceId: string | null): import('@burdenoff/fe-libs/shared/assistant').WorkspaceWriteAccess;
+//# sourceMappingURL=useWorkspaceWriteAccess.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useWorkspaceWriteAccess.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/assistant/useWorkspaceWriteAccess.ts"],"names":[],"mappings":"AAUA,YAAY,EAAE,oBAAoB,EAAE,MAAM,6DAA6D,CAAC;AAExG;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,eAAe,oGAKlB,CAAC;AAEX;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,sEAEzF"}

package/dist/bigconsole/assistant/useWorkspaceWriteAccess.js

@@ -11,3 +11,5 @@ function n(n, r) {
 }
 //#endregion
 export { t as PROBE_RESOURCES, n as useWorkspaceWriteAccess };
+
+//# sourceMappingURL=useWorkspaceWriteAccess.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useWorkspaceWriteAccess.js","names":[],"sources":["../../../src/bigconsole/assistant/useWorkspaceWriteAccess.ts"],"sourcesContent":["/**\n * BigConsole's write-access probe.\n *\n * ★ The mechanism lives in `fe-libs/shared/assistant`; the RESOURCE TYPES stay\n * here, because which resources prove \"this user can write in this workspace\"\n * is the product's answer. The shared hook takes them with no default, so\n * another product cannot accidentally probe BigConsole's dashboards — or the\n * other way round.\n */\nimport { useWorkspaceWriteAccess as useShared } from '@burdenoff/fe-libs/shared/assistant/useWorkspaceWriteAccess';\nexport type { WorkspaceWriteAccess } from '@burdenoff/fe-libs/shared/assistant/useWorkspaceWriteAccess';\n\n/**\n * The resources a Build turn actually writes.\n *\n * ★★ READ OUT OF THE BACKEND, NOT INVENTED. These are the exact `resource:`\n * values on `@rbac` directives in `wspace-bigconsole-svc`, and they are\n * HYPHENATED — `bigconsole-datasink`, not `bigconsole_datasink`.\n *\n * ★★★ Do NOT copy HealthyBowl's `healthybowl_crop` underscore convention.\n * VibeControls did exactly that, probed `vibecontrols_vibe` and friends, matched\n * no resource type that exists, and so silently default-denied — its composer\n * warning said nothing about the permissions a write turn actually needs, and\n * nothing failed loudly enough to notice.\n *\n * ★ Scoped to the four the assistant ISSUES, not all 17 the service defines.\n * The agent's build path is `createDataSink` → `createBigConsoleDashboard` →\n * `createParser` → `createBigConsoleWidget`; probing `bigconsole-webhook` or\n * `bigconsole-rls-policy`, which the assistant never calls, would make\n * \"granted\" mean less than it does. All four carry `action: \"create\"` @rbac\n * entries, which is the only action the shared hook asks about.\n *\n * ★ Advisory, never a gate: it warns in the composer BEFORE a write turn is\n * spent rather than after, and self-corrects once workspace RBAC rows are\n * seeded. Gating on it would remove Build from the product entirely — at\n * workspace scope in prod the honest answer today is \"denied\" for everyone, org\n * owners included, because no roles are provisioned there yet.\n */\nexport const PROBE_RESOURCES = [\n  'bigconsole-datasink',\n  'bigconsole-dashboard',\n  'bigconsole-parser',\n  'bigconsole-widget',\n] as const;\n\n/**\n * ★ `PROBE_RESOURCES` is a module-level const, never an inline array. The shared\n * hook's effect deps are `[actorId, workspaceId]` only — `probeResources` is not\n * among them — so an array literal created during render would silently pin the\n * first render's list forever.\n */\nexport function useWorkspaceWriteAccess(actorId: string | null, workspaceId: string | null) {\n  return useShared(actorId, workspaceId, PROBE_RESOURCES);\n}\n"],"mappings":";;AAsCA,IAAa,IAAkB;CAC7B;CACA;CACA;CACA;CACD;AAQD,SAAgB,EAAwB,GAAwB,GAA4B;AAC1F,QAAO,EAAU,GAAS,GAAa,EAAgB"}

package/dist/bigconsole/components/DrilldownDashboardRenderer.d.ts

@@ -10,3 +10,4 @@ export interface DrilldownDashboardRendererProps {
 }
 export declare const DrilldownDashboardRenderer: FC<DrilldownDashboardRendererProps>;
 export default DrilldownDashboardRenderer;
+//# sourceMappingURL=DrilldownDashboardRenderer.d.ts.map

package/dist/bigconsole/components/DrilldownDashboardRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DrilldownDashboardRenderer.d.ts","sourceRoot":"","sources":["../../../src/bigconsole/components/DrilldownDashboardRenderer.tsx"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,KAAK,EAAE,EAA6B,MAAM,OAAO,CAAC;AAc3D,MAAM,WAAW,+BAA+B;IAC9C,oCAAoC;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mEAAmE;IACnE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AA8ED,eAAO,MAAM,0BAA0B,EAAE,EAAE,CAAC,+BAA+B,CAgQ1E,CAAC;AAmBF,eAAe,0BAA0B,CAAC"}

package/dist/bigconsole/components/DrilldownDashboardRenderer.js

@@ -252,3 +252,5 @@ var g = c(function({ dashboardId: i, params: o, live: c = !1, refreshRevision: g
 });
 //#endregion
 export { g as default };
+
+//# sourceMappingURL=DrilldownDashboardRenderer.js.map