@burdenoff/fe-libs 2026.904.2 → 2026.904.4

package/dist/shared/assistant/documentText.d.ts

@@ -0,0 +1,261 @@
+/**
+ * Turning a PDF / DOCX / XLSX into plain text — the PURE half (BOFF-6291).
+ *
+ * Everything in this file is a string-in/string-out function with no imports,
+ * no DOM and no parser dependency, which is what makes it testable under the
+ * repo's `environment: 'node'` vitest config. The browser-only half — reading
+ * the File, lazily importing pdf.js / fflate, unzipping — lives in
+ * `documentExtract.ts` and calls into here.
+ *
+ * ## Why regex and not DOMParser
+ *
+ * DOCX and XLSX are ZIPs of XML, and the obvious tool is `DOMParser`. It is
+ * browser-only, so every one of these functions would then be untestable here
+ * and the extraction logic would ship unverified. We are pulling *text* out of
+ * a machine-generated, schema-fixed document part — not rendering untrusted
+ * markup — so a targeted scan over the tags Word/Excel actually emit is both
+ * sufficient and checkable. The output is inlined into a prompt as text; it is
+ * never interpreted as markup, so a mis-parse costs fidelity, not safety.
+ */
+/** Upper bound on characters pulled out of one document before we stop. */
+export declare const MAX_EXTRACTED_CHARS = 200000;
+/** Upper bound on PDF pages we will even look at, however long the document. */
+export declare const MAX_PDF_PAGES_SCANNED = 100;
+/**
+ * How many characters of PAGE-SPECIFIC text a page must yield before we are
+ * willing to say we read it.
+ *
+ * A scanned page is not empty — its scanner stamps a footer on every page, and
+ * `page.trim() !== ''` is therefore true for a document containing no readable
+ * content whatsoever. 24 characters is below any real page of a soil report or
+ * an audit (those run to thousands) and above the watermarks that defeat an
+ * all-or-nothing check.
+ */
+export declare const MIN_PAGE_TEXT_CHARS = 24;
+/**
+ * A line repeated on at least this share of pages is a running head/footer or a
+ * scanner watermark, not content.
+ *
+ * Used ONLY to judge whether a page carries its own text; the line is never
+ * removed from the text handed to the model. So a false positive here costs
+ * nothing but a slightly more cautious disclosure, while a false negative is the
+ * failure this whole notion exists to stop.
+ */
+export declare const BOILERPLATE_PAGE_SHARE = 0.6;
+/**
+ * Boilerplate detection only ever applies to short lines, never to content.
+ *
+ * Named trade-off: a running footer LONGER than this — a full confidentiality
+ * paragraph stamped on every page of a scan — is not recognised, and the scan
+ * is then treated as readable. That is the safe direction to be wrong in only
+ * because the model still sees exactly the text the file contains; it is not a
+ * claim the heuristic is exact.
+ */
+export declare const MAX_BOILERPLATE_LINE_CHARS = 80;
+/**
+ * Below this share of pages carrying a text layer, a document is "mostly
+ * images" and must be presented as unread rather than as extracted.
+ */
+export declare const MIN_TEXT_PAGE_SHARE = 0.5;
+/**
+ * What happened when we tried to read a document.
+ *
+ * Every value other than `ok` MUST reach the model as a sentence — a document
+ * we could not read has to look different from a document that was empty, and
+ * both have to look different from one we never tried. Silence here is what
+ * makes an assistant answer confidently about a file it never saw.
+ */
+export type DocumentExtractionStatus = "ok" | "no-text" | "encrypted" | "corrupt"
+/** No extractor for this type — we did not even try. */
+ | "unsupported";
+/** Document formats we can turn into text in the browser. */
+export type DocumentFormat = "pdf" | "docx" | "xlsx";
+export interface DocumentExtraction {
+    status: DocumentExtractionStatus;
+    /**
+     * Which extractor produced this. Carried so the failure wording can be
+     * true rather than merely plausible: "appears to be scanned images" is the
+     * right sentence for a PDF and a wrong one for an empty .docx.
+     */
+    format?: DocumentFormat;
+    /** Total pages in a PDF (not how many we read — see `pagesScanned`). */
+    pageCount?: number;
+    /** How many pages we actually looked at; capped by MAX_PDF_PAGES_SCANNED. */
+    pagesScanned?: number;
+    /** How far into the document `textContent` reaches: pages 1..N were processed. */
+    pagesIncluded?: number;
+    /**
+     * The 1-indexed pages whose text is ACTUALLY in `textContent`.
+     *
+     * Distinct from `pagesIncluded` on purpose: a 40-page certificate with 3 text
+     * pages and 37 image pages processes all 40 and reads 3, and saying "40 pages"
+     * there is the exact falsehood this feature must not tell.
+     */
+    pageNumbers?: number[];
+    /**
+     * The 1-indexed pages within `pagesScanned` that yielded no page-specific
+     * text — image or blank pages. Counted so they can be DISCLOSED rather than
+     * silently folded into a page total.
+     */
+    imagePages?: number[];
+    /** How many scanned pages carried a text layer at all. */
+    textPageCount?: number;
+    /** Characters of text the document yielded before the inline budget cut it. */
+    sourceChars?: number;
+    /** Worksheet names, in workbook order. XLSX only. */
+    sheetNames?: string[];
+    /** Parser detail for the `corrupt` case — shown to the model verbatim. */
+    detail?: string;
+}
+/** Resolve the five XML entities plus numeric character references. */
+export declare function decodeXmlEntities(value: string): string;
+/**
+ * `word/document.xml` → plain text.
+ *
+ * Word's body is a flat list of `<w:p>` paragraphs holding `<w:t>` runs, with
+ * `<w:tab/>` and `<w:br/>` as explicit whitespace. Table cells are paragraphs
+ * too, so a table comes out one cell per line — lossy for layout, faithful for
+ * content, and the model reads it fine.
+ *
+ * `<w:instrText>` (field codes such as a HYPERLINK target or a MERGEFIELD name)
+ * is deliberately skipped: it is markup the reader never sees, and inlining it
+ * puts strings in front of the model that are not in the document.
+ */
+export declare function docxXmlToText(xml: string): string;
+/** `xl/sharedStrings.xml` → the string table, indexed as the sheets index it. */
+export declare function parseSharedStrings(xml: string): string[];
+/** `A` → 0, `Z` → 25, `AA` → 26. Returns -1 for anything that is not a column. */
+export declare function columnLetterToIndex(reference: string): number;
+/**
+ * One worksheet's XML → CSV-ish rows.
+ *
+ * Sparse cells are padded from their `r="C7"` reference so column alignment
+ * survives, which is the whole reason a spreadsheet is worth inlining at all.
+ * Numbers come out exactly as stored — an Excel date is a serial number, and
+ * guessing at a display format would put dates in front of the model that the
+ * file does not contain.
+ */
+export declare function sheetXmlToRows(xml: string, sharedStrings: string[]): string[];
+/**
+ * `xl/workbook.xml` (+ its rels) → the sheets in workbook order.
+ *
+ * The rels file is what maps `r:id="rId3"` to `worksheets/sheet1.xml`; the
+ * common assumption that `sheetN.xml` matches tab order is simply false in any
+ * workbook whose sheets have been reordered or deleted.
+ */
+export declare function parseWorkbookSheets(workbookXml: string, relsXml: string): {
+    name: string;
+    path: string | null;
+}[];
+/** Stitch the parsed sheets into one document, headed by the sheet name. */
+export declare function joinSheets(sheets: {
+    name: string;
+    rows: string[];
+}[]): string;
+/**
+ * pdf.js text items → one page of text.
+ *
+ * `hasEOL` is pdf.js' own end-of-line marker, so line structure comes from the
+ * library rather than from us guessing at coordinates. Marked-content items
+ * carry no `str` and are skipped.
+ */
+export declare function pdfTextItemsToPage(items: {
+    str?: string;
+    hasEOL?: boolean;
+}[]): string;
+/** Header a page gets when several of them are inlined together. */
+export declare function pageMarker(pageNumber: number): string;
+/**
+ * Which pages of a PDF actually carry text, and which are images.
+ *
+ * ## Why an all-or-nothing check is not enough
+ *
+ * The obvious test — "did ANY page yield a non-empty string" — is defeated by
+ * every scanner on the market, because scanners stamp a text footer onto each
+ * page image. A 12-page scanned soil report whose only text layer is
+ * `Scanned with CamScanner  1` passes that test, and the document is then handed
+ * to the model as `Extracted text (12 pages):` with no hint that not one word of
+ * the report is in it. The model answers confidently about a file nobody read.
+ *
+ * So the unit of judgement is the PAGE, and the question per page is whether it
+ * holds text SPECIFIC TO IT. Two signals, deliberately both cheap and pure:
+ *
+ * 1. **Repetition.** A line that appears on most pages, once digits are
+ *    normalised away so page numbers compare equal, is a running head/footer or
+ *    a scan watermark. Only short lines are eligible, so this can never strike
+ *    out a paragraph of content.
+ * 2. **Volume.** What is left after (1) must reach `MIN_PAGE_TEXT_CHARS`.
+ *
+ * Boilerplate is subtracted only for this JUDGEMENT — the text handed to the
+ * model is untouched, so mis-classifying a sparse page costs a more cautious
+ * sentence rather than lost content.
+ */
+export interface PageTextSummary {
+    /** 1-indexed pages carrying page-specific text. */
+    textPages: number[];
+    /** 1-indexed pages carrying nothing but blanks or repeated boilerplate. */
+    imagePages: number[];
+    /** The normalised lines judged to be running heads/footers or watermarks. */
+    boilerplate: string[];
+}
+export declare function summarisePageText(pages: string[]): PageTextSummary;
+/**
+ * Is this document mostly images — i.e. must it be presented as UNREAD?
+ *
+ * Takes the counts rather than the extraction so it stays pure and is the same
+ * function whether it is asked at extraction time or at prompt-building time.
+ */
+export declare function isMostlyImagePages(textPageCount: number, pagesScanned: number): boolean;
+/**
+ * Everything `extractPdf` does once pdf.js has handed over the page strings.
+ *
+ * Pulled out of the browser half deliberately: pdf.js needs a DOM and this
+ * repo's vitest is `environment: 'node'`, so leaving the scanned-vs-read
+ * decision inside `extractPdf` left the most dangerous logic in the feature —
+ * "may the model treat this document as read" — with no test that could reach
+ * it. Here it is a string-array-in, extraction-out function.
+ */
+export interface PdfPageFit {
+    extraction: DocumentExtraction;
+    textContent?: string;
+    documentPages?: string[];
+    textTruncated?: boolean;
+}
+export declare function fitPdfPages(pages: string[], pageCount: number, pagesScanned: number, limit: number): PdfPageFit;
+/** `[1,2,3,7,9,10]` → `"1-3, 7, 9-10"`. Empty in, empty out. */
+export declare function formatPageRanges(pages: number[]): string;
+export interface FittedPages {
+    text: string;
+    truncated: boolean;
+    /** How far into the document `text` reaches: pages 1..N were processed. */
+    pagesIncluded: number;
+    /** The 1-indexed pages whose text is actually in `text`. */
+    pageNumbers: number[];
+    /** Rendered length of every page that HAS text, before the cut. */
+    sourceChars: number;
+    /**
+     * `pages` trimmed to exactly what `text` holds, indices preserved.
+     *
+     * This is what makes the per-file cap an INVARIANT rather than a hope: the
+     * caller stores this array, so a later re-fit against the shared budget can
+     * only ever shrink it. Storing the untruncated pages instead let the shared
+     * pass re-expand a document to 20,000 characters — 2.5x the per-file cap —
+     * and starve the file attached beside it.
+     */
+    pages: string[];
+}
+/**
+ * Fit whole PDF pages into a character budget, preferring a PAGE boundary.
+ *
+ * A page is the unit a reader — and a citation — thinks in, so cutting mid-page
+ * is a worse lie than dropping the tail entirely. Falls back to a hard character
+ * cut only when the first page with text will not fit on its own, because
+ * "0 pages included" is useless to the model.
+ *
+ * Blank entries are pages the caller has judged to carry no text (see
+ * `summarisePageText`). They are skipped rather than rendered as an empty
+ * `[page N]`, which would both waste budget and read to the model as a page it
+ * had seen and found empty.
+ */
+export declare function truncatePagesForInline(pages: string[], limit: number): FittedPages;
+//# sourceMappingURL=documentText.d.ts.map

package/dist/shared/assistant/documentText.d.ts.map

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

package/dist/shared/assistant/documentText.js

@@ -0,0 +1,235 @@
+//#region src/shared/assistant/documentText.ts
+var e = 2e5, t = 100, n = 24, r = .6, i = 80, a = .5, o = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'"
+};
+function s(e) {
+	return e.replace(/&(#x?[0-9a-fA-F]+|[a-zA-Z]+);/g, (e, t) => {
+		if (t.startsWith("#x") || t.startsWith("#X")) {
+			let n = Number.parseInt(t.slice(2), 16);
+			return Number.isFinite(n) ? String.fromCodePoint(n) : e;
+		}
+		if (t.startsWith("#")) {
+			let n = Number.parseInt(t.slice(1), 10);
+			return Number.isFinite(n) ? String.fromCodePoint(n) : e;
+		}
+		return o[t] ?? e;
+	});
+}
+function c(e) {
+	return e.split("\n").map((e) => e.replace(/[ \t]+$/, "")).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function l(e) {
+	let t = e.replace(/<w:instrText[\s\S]*?<\/w:instrText>/g, ""), n = [], r = "", i = /<w:t(?:\s[^>]*)?>([\s\S]*?)<\/w:t>|<w:tab\b[^>]*\/?>|<w:br\b[^>]*\/?>|<\/w:p>/g, a;
+	for (; (a = i.exec(t)) !== null;) {
+		let [e, t] = a;
+		t === void 0 ? e.startsWith("<w:tab") ? r += "	" : (e.startsWith("<w:br"), n.push(r), r = "") : r += s(t);
+	}
+	return r && n.push(r), c(n.join("\n"));
+}
+function u(e) {
+	return (e.match(/<si\b[^>]*\/>|<si\b[^>]*>[\s\S]*?<\/si>/g) ?? []).map((e) => (e.match(/<t(?:\s[^>]*)?>([\s\S]*?)<\/t>/g) ?? []).map((e) => s(e.replace(/<t(?:\s[^>]*)?>|<\/t>/g, ""))).join(""));
+}
+function d(e) {
+	let t = /^([A-Z]+)/.exec(e.toUpperCase());
+	if (!t) return -1;
+	let n = 0;
+	for (let e of t[1]) n = n * 26 + (e.charCodeAt(0) - 64);
+	return n - 1;
+}
+function f(e) {
+	return /[",\n]/.test(e) ? `"${e.replace(/"/g, "\"\"")}"` : e;
+}
+function p(e, t) {
+	let n = [], r = /<row\b[^>]*\/>|<row\b[^>]*>([\s\S]*?)<\/row>/g, i;
+	for (; (i = r.exec(e)) !== null;) {
+		let e = i[1] ?? "", r = [], a = /<c\b([^>]*?)(?:\/>|>([\s\S]*?)<\/c>)/g, o;
+		for (; (o = a.exec(e)) !== null;) {
+			let e = o[1] ?? "", n = o[2] ?? "", i = /\bt="([^"]+)"/.exec(e)?.[1] ?? "n", a = /\br="([^"]+)"/.exec(e)?.[1] ?? "", c;
+			if (i === "s") {
+				let e = /<v(?:\s[^>]*)?>([\s\S]*?)<\/v>/.exec(n)?.[1] ?? "";
+				c = t[Number.parseInt(e, 10)] ?? "";
+			} else if (i === "inlineStr") c = (n.match(/<t(?:\s[^>]*)?>([\s\S]*?)<\/t>/g) ?? []).map((e) => s(e.replace(/<t(?:\s[^>]*)?>|<\/t>/g, ""))).join("");
+			else {
+				let e = /<v(?:\s[^>]*)?>([\s\S]*?)<\/v>/.exec(n)?.[1] ?? "";
+				c = i === "b" ? e === "1" ? "TRUE" : e === "0" ? "FALSE" : "" : s(e);
+			}
+			let l = d(a);
+			if (l >= 0) {
+				for (; r.length < l;) r.push("");
+				r[l] = c;
+			} else r.push(c);
+		}
+		for (; r.length > 0 && r[r.length - 1] === "";) r.pop();
+		n.push(r.map(f).join(","));
+	}
+	for (; n.length > 0 && n[n.length - 1] === "";) n.pop();
+	return n;
+}
+function m(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let e of t.match(/<Relationship\b[^>]*\/?>/g) ?? []) {
+		let t = /\bId="([^"]+)"/.exec(e)?.[1], r = /\bTarget="([^"]+)"/.exec(e)?.[1];
+		if (!t || !r) continue;
+		let i = r.replace(/^\/xl\//, "").replace(/^\.\//, "");
+		n.set(t, i.startsWith("xl/") ? i : `xl/${i}`);
+	}
+	return (e.match(/<sheet\b[^>]*\/?>/g) ?? []).map((e) => {
+		let t = s(/\bname="([^"]*)"/.exec(e)?.[1] ?? "Sheet"), r = /\br:id="([^"]+)"/.exec(e)?.[1] ?? "";
+		return {
+			name: t,
+			path: n.get(r) ?? null
+		};
+	});
+}
+function h(e) {
+	return c(e.filter((e) => e.rows.length > 0).map((e) => `## Sheet: ${e.name}\n${e.rows.join("\n")}`).join("\n\n"));
+}
+function g(e) {
+	let t = "";
+	for (let n of e) typeof n.str == "string" && (t += n.str, n.hasEOL && (t += "\n"));
+	return c(t);
+}
+function _(e) {
+	return `[page ${e}]`;
+}
+var v = /^\s*(?:page|p\.?|pg\.?)?\s*\d+(?:\s*(?:of|\/)\s*\d+)?\s*(?:[-–—|]\s*)?/i, y = /\s*(?:[-–—|]\s*)?(?:page|p\.?|pg\.?)?\s*\d+(?:\s*(?:of|\/)\s*\d+)?\s*$/i;
+function b(e) {
+	let t = e.replace(/\s+/g, " ").trim().toLowerCase();
+	return (t.replace(v, "") || t).replace(y, "").trim();
+}
+function x(e) {
+	let t = e.map((e) => {
+		let t = /* @__PURE__ */ new Set();
+		for (let n of e.split("\n")) {
+			let e = b(n);
+			e !== "" && t.add(e);
+		}
+		return t;
+	}), n = /* @__PURE__ */ new Map();
+	for (let e of t) for (let t of e) n.set(t, (n.get(t) ?? 0) + 1);
+	let i = Math.max(2, Math.ceil(e.length * r)), a = /* @__PURE__ */ new Set();
+	for (let [e, t] of n) t >= i && e.length <= 80 && a.add(e);
+	let o = [], s = [];
+	return e.forEach((e, t) => {
+		(e.split("\n").filter((e) => {
+			let t = b(e);
+			return t !== "" && !a.has(t);
+		}).join("\n").trim().length >= 24 ? o : s).push(t + 1);
+	}), {
+		textPages: o,
+		imagePages: s,
+		boilerplate: [...a]
+	};
+}
+function S(e, t) {
+	return t <= 0 ? !1 : e < t * a;
+}
+function C(e, t, n, r) {
+	let i = x(e);
+	if (i.textPages.length === 0) return { extraction: {
+		status: "no-text",
+		pageCount: t,
+		pagesScanned: n
+	} };
+	let a = new Set(i.textPages), o = T(e.map((e, t) => a.has(t + 1) ? e : ""), r);
+	return o.text === "" ? { extraction: {
+		status: "no-text",
+		pageCount: t,
+		pagesScanned: n
+	} } : {
+		extraction: {
+			status: "ok",
+			pageCount: t,
+			pagesScanned: n,
+			pagesIncluded: o.pagesIncluded,
+			pageNumbers: o.pageNumbers,
+			imagePages: i.imagePages,
+			textPageCount: i.textPages.length,
+			sourceChars: o.sourceChars
+		},
+		textContent: o.text,
+		documentPages: o.pages,
+		textTruncated: o.truncated || n < t
+	};
+}
+function w(e) {
+	let t = [...new Set(e)].sort((e, t) => e - t), n = [], r = null, i = 0, a = () => {
+		r !== null && n.push(r === i ? `${r}` : `${r}-${i}`);
+	};
+	for (let e of t) {
+		if (r === null) {
+			r = i = e;
+			continue;
+		}
+		if (e === i + 1) {
+			i = e;
+			continue;
+		}
+		a(), r = i = e;
+	}
+	return a(), n.join(", ");
+}
+function T(e, t) {
+	let n = (e, t) => `${_(t + 1)}\n${e}`, r = e.map((e, t) => ({
+		index: t,
+		page: e,
+		rendered: n(e, t)
+	})).filter((e) => e.page.trim() !== ""), i = r.map((e) => e.rendered).join("\n\n").length;
+	if (r.length === 0) return {
+		text: "",
+		truncated: !1,
+		pagesIncluded: e.length,
+		pageNumbers: [],
+		sourceChars: 0,
+		pages: []
+	};
+	let a = [], o = 0, s = 0, c = !1;
+	for (let r = 0; r < e.length; r += 1) {
+		if (e[r].trim() === "") {
+			s = r + 1;
+			continue;
+		}
+		let i = n(e[r], r), l = a.length === 0 ? i.length : i.length + 2;
+		if (o + l > t) {
+			c = !0;
+			break;
+		}
+		a.push({
+			index: r,
+			page: e[r],
+			rendered: i
+		}), o += l, s = r + 1;
+	}
+	if (a.length > 0) return {
+		text: a.map((e) => e.rendered).join("\n\n"),
+		truncated: c,
+		pagesIncluded: s,
+		pageNumbers: a.map((e) => e.index + 1),
+		sourceChars: i,
+		pages: e.slice(0, s)
+	};
+	let l = r[0], u = l.rendered.slice(0, Math.max(0, t)), d = u.lastIndexOf("\n"), f = d > t * .5 ? u.slice(0, d) : u, p = f.slice(_(l.index + 1).length + 1);
+	if (p.trim() === "") return {
+		text: "",
+		truncated: !0,
+		pagesIncluded: 0,
+		pageNumbers: [],
+		sourceChars: i,
+		pages: []
+	};
+	let m = e.slice(0, l.index + 1);
+	return m[l.index] = p, {
+		text: f,
+		truncated: !0,
+		pagesIncluded: l.index + 1,
+		pageNumbers: [l.index + 1],
+		sourceChars: i,
+		pages: m
+	};
+}
+//#endregion
+export { r as BOILERPLATE_PAGE_SHARE, i as MAX_BOILERPLATE_LINE_CHARS, e as MAX_EXTRACTED_CHARS, t as MAX_PDF_PAGES_SCANNED, n as MIN_PAGE_TEXT_CHARS, a as MIN_TEXT_PAGE_SHARE, d as columnLetterToIndex, s as decodeXmlEntities, l as docxXmlToText, C as fitPdfPages, w as formatPageRanges, S as isMostlyImagePages, h as joinSheets, _ as pageMarker, u as parseSharedStrings, m as parseWorkbookSheets, g as pdfTextItemsToPage, p as sheetXmlToRows, x as summarisePageText, T as truncatePagesForInline };

package/dist/shared/assistant/gatewayLimits.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Hard limits imposed by the gateways this app talks to.
+ *
+ * These are not our numbers — they are deployment facts, and getting them wrong
+ * is expensive because the failure is opaque. `wspace-public-gateway` sets
+ * `MAX_REQUEST_BODY_SIZE: 256kb` in BOTH environments (burdenoff-gitops,
+ * `apps/config-workspace/wspace-public-gateway-config.yaml:21` and
+ * `apps/config-workspace-prod/…:21`). It compares Content-Length and answers
+ * 413 *before* authenticating and before forwarding, and fe-libs' `graphqlFetch`
+ * discards the status — so the user is told "The request could not be processed.
+ * Please refresh and try again." with nothing in it to suggest the payload was
+ * simply too big.
+ *
+ * Anything that POSTs base64 from the browser has to be sized against this.
+ */
+export declare const MAX_REQUEST_BODY_BYTES = 262144;
+/**
+ * What is left for a base64 image once the rest of a GraphQL request is paid
+ * for: the query document, operation name, variables, and the workspace/org
+ * context envelope. 32 KB is deliberately generous — the point is to fail in
+ * OUR code with a sentence the user can act on, rather than at the gateway with
+ * one they cannot.
+ */
+export declare const MAX_INLINE_IMAGE_BASE64_BYTES: number;
+//# sourceMappingURL=gatewayLimits.d.ts.map

package/dist/shared/assistant/gatewayLimits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gatewayLimits.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/gatewayLimits.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,sBAAsB,SAAU,CAAC;AAE9C;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,QAAkC,CAAC"}

package/dist/shared/assistant/gatewayLimits.js

@@ -0,0 +1,4 @@
+//#region src/shared/assistant/gatewayLimits.ts
+var e = 262144, t = e - 32768;
+//#endregion
+export { t as MAX_INLINE_IMAGE_BASE64_BYTES, e as MAX_REQUEST_BODY_BYTES };

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

@@ -63,4 +63,10 @@ export * from './i18n';
 export * from './voice/speechLabels';
 export * from './voice/replyLanguage';
 export * from './voice/speechPlayback';
+export * from './conversation';
+export * from './attachments';
+export * from './store';
+export * from './turnState';
+export * from './gatewayLimits';
+export * from './documentText';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mCAAmC,CAAC;AAClD,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,OAAO,CAAC;AACtB,cAAc,SAAS,CAAC;AAGxB,cAAc,wBAAwB,CAAC;AAKvC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,+BAA+B,CAAC;AAG9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAGlC,cAAc,gBAAgB,CAAC;AAK/B,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,4BAA4B,CAAC;AAG3C,cAAc,QAAQ,CAAC;AAEvB,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mCAAmC,CAAC;AAClD,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,OAAO,CAAC;AACtB,cAAc,SAAS,CAAC;AAGxB,cAAc,wBAAwB,CAAC;AAKvC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,+BAA+B,CAAC;AAG9C,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAGlC,cAAc,gBAAgB,CAAC;AAK/B,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,4BAA4B,CAAC;AAG3C,cAAc,QAAQ,CAAC;AAEvB,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AAGvC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC"}

package/dist/shared/assistant/store.d.ts

@@ -0,0 +1,114 @@
+import { AssistantConversationProcessing, AssistantConversationStatus, AssistantMessageMetadata, AssistantSandboxRuntime, AssistantSandboxStatus, Conversation, Message } from './conversation';
+import { AssistantMode } from './types';
+interface AssistantState {
+    conversations: Conversation[];
+    activeConversationId: string | null;
+    mode: AssistantMode;
+    processingByConversationId: Record<string, AssistantConversationProcessing>;
+    conversationListOpen: boolean;
+    /** Active sandboxes keyed by assistant mode */
+    sandboxesByMode: Partial<Record<AssistantMode, AssistantSandboxRuntime>>;
+    /**
+     * A prompt queued up for auto-submit by the chat area. Used by the
+     * `GetHelpButton` / `useOpenAssistantHelp` hook so pages can prompt the
+     * assistant contextually from an empty state button without coupling to
+     * the chat area internals.
+     */
+    pendingPrompt: string | null;
+    /**
+     * Whether the user has acknowledged the api-calls (write) mode consent
+     * dialog. Persisted per-profile so the warning shows once, not every switch.
+     */
+    apiCallsAcknowledged: boolean;
+    /**
+     * Read every assistant reply aloud as it settles (BOFF-6290).
+     *
+     * Persisted per-profile and **false by default**: speech is opt-in, and the
+     * assistant must never start talking without an explicit prior choice. A
+     * one-off "read this message" needs no preference at all — it is the speak
+     * button on the message.
+     */
+    autoSpeakEnabled: boolean;
+    /**
+     * The language the user speaks TO the assistant, independent of the interface
+     * language (BOFF-7108). `null` means "follow the app locale", which is what
+     * every user gets until they choose otherwise — and is exactly the behaviour
+     * that existed before this preference did.
+     */
+    assistantLanguage: string | null;
+    /**
+     * The language the assistant ANSWERS in. `null` means "match my language" —
+     * i.e. follow `assistantLanguage` — which is the default and what shipped
+     * before the two were separated.
+     */
+    replyLanguage: string | null;
+    /**
+     * The voice the user picked, keyed by language code (BOFF-7110).
+     *
+     * Per language, because a voice only reads one: picking "Google US English"
+     * says nothing about which Tamil voice to use. Stored by NAME because that is
+     * the only identifier stable across page loads — voice objects are recreated
+     * each time and `voiceURI` is not reliably unique across platforms.
+     *
+     * A name saved on one device will not resolve on another; that is handled by
+     * falling back to the ranking rather than by trying to sync it.
+     */
+    preferredVoices: Record<string, string>;
+    createConversation: (title?: string, mode?: AssistantMode) => string;
+    deleteConversation: (id: string) => void;
+    renameConversation: (id: string, title: string) => void;
+    setActiveConversation: (id: string | null) => void;
+    setMode: (mode: AssistantMode) => void;
+    setConversationMode: (conversationId: string, mode: AssistantMode) => void;
+    addMessage: (conversationId: string, message: Message) => void;
+    updateMessage: (conversationId: string, messageId: string, content: string) => void;
+    patchMessage: (conversationId: string, messageId: string, patch: Partial<Message>) => void;
+    /**
+     * MERGE into a message's metadata, leaving untouched keys alone.
+     *
+     * ★ The counterpart to `patchMessage`, which REPLACES `metadata` wholesale
+     * (`{...m, ...patch}`). That has already shipped one defect: a write which
+     * rebuilt the object dropped `voice`, so a spoken reply silently became a
+     * typed one. Anything adding a SINGLE metadata key should use this, or it
+     * takes `lang` and `voice` down with it.
+     */
+    mergeMessageMetadata: (conversationId: string, messageId: string, patch: Partial<AssistantMessageMetadata>) => void;
+    setConversationProcessing: (conversationId: string, status: AssistantConversationStatus, messageId?: string | null, error?: string | null) => void;
+    clearConversationProcessing: (conversationId: string) => void;
+    toggleConversationList: () => void;
+    setConversationListOpen: (open: boolean) => void;
+    clearConversation: (id: string) => void;
+    setBackendSessionId: (conversationId: string, sessionId: string) => void;
+    clearBackendSessionId: (conversationId: string) => void;
+    setSandbox: (mode: AssistantMode, sandboxId: string | null, status: AssistantSandboxStatus) => void;
+    clearSandbox: (mode: AssistantMode) => void;
+    resetStore: () => void;
+    /** Queue a prompt for the chat area to auto-send on next render. */
+    submitPrompt: (text: string) => void;
+    /** Returns and clears any queued prompt. */
+    consumePendingPrompt: () => string | null;
+    /** Mark the api-calls write-mode consent as acknowledged (persisted). */
+    acknowledgeApiCalls: () => void;
+    /** Turn automatic read-aloud of new replies on or off (persisted). */
+    setAutoSpeak: (enabled: boolean) => void;
+    /** Choose the language spoken to the assistant; `null` follows the app locale (persisted). */
+    setAssistantLanguage: (code: string | null) => void;
+    setReplyLanguage: (code: string | null) => void;
+    /** `null` clears the pick for that language, restoring the ranked default. */
+    setPreferredVoice: (languageCode: string, voiceName: string | null) => void;
+}
+export declare const useAssistantStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<AssistantState>, "setState" | "persist"> & {
+    setState(partial: AssistantState | Partial<AssistantState> | ((state: AssistantState) => AssistantState | Partial<AssistantState>), replace?: false | undefined): unknown;
+    setState(state: AssistantState | ((state: AssistantState) => AssistantState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<AssistantState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: AssistantState) => void) => () => void;
+        onFinishHydration: (fn: (state: AssistantState) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<AssistantState, unknown, unknown>>;
+    };
+}>;
+export {};
+//# sourceMappingURL=store.d.ts.map