@burdenoff/fe-libs 2026.926.5 → 2026.927.1

package/dist/shared/assistant/history/historyTypes.d.ts

@@ -0,0 +1,256 @@
+/**
+ * Server-backed assistant history (BOFF-7335): the shapes shared by the
+ * transport, the mapper, the persisted history store and the engine.
+ *
+ * ★★ The WIRE types mirror the wspace-conversations `my*` assistant-history
+ * fields as BUILT — `history/__fixtures__/assistantHistory.sdl.graphql` is a
+ * vendored copy of that SDL, and `historySdlContract.test.ts` validates every
+ * operation the client sends against it. When the two disagree, the server is
+ * right and this file changes.
+ *
+ * Product-neutral by construction: a product is only ever the string the
+ * product itself declared (`AssistantProductConfig.product`), passed through.
+ */
+/** Whose history a request reads or writes: one account, in one workspace, in one product. */
+export interface AssistantHistoryScope {
+    actorId: string;
+    workspaceId: string;
+    /** Sent to the server untouched as `productId`. */
+    product: string;
+}
+/** `${actorId}|${workspaceId}|${product}` — see {@link assistantHistoryScopeKey}. */
+export type AssistantHistoryScopeKey = string;
+/**
+ * A conversation's key in the history store: its `clientConversationId` (the
+ * local conversation id), or `legacy:<serverId>` for a conversation saved
+ * before v2, which has no client id.
+ */
+export type AssistantHistoryConvKey = string;
+export declare const LEGACY_HISTORY_KEY_PREFIX = "legacy:";
+export declare function assistantHistoryScopeKey(scope: AssistantHistoryScope): AssistantHistoryScopeKey;
+/** A complete scope, or null when any part is missing (history is then off, never "partly on"). */
+export declare function completeAssistantHistoryScope(actorId: string | null | undefined, workspaceId: string | null | undefined, product: string | null | undefined): AssistantHistoryScope | null;
+export declare function legacyHistoryConvKey(serverId: string): AssistantHistoryConvKey;
+export declare function isLegacyHistoryConvKey(key: AssistantHistoryConvKey): boolean;
+/** Exactly one of the two: a client-minted id, or a legacy row's server id. */
+export type AssistantHistoryConvRef = {
+    clientConversationId: string;
+} | {
+    conversationId: string;
+};
+export type AssistantHistoryEntryKind = "TURN" | "LOCAL_COMMAND" | "NOTE";
+export type AssistantHistoryRole = "USER" | "ASSISTANT" | "NOTE";
+export type AssistantHistorySaveOutcome = "APPLIED" | "ALREADY_APPLIED" | "CONVERSATION_DELETED";
+export type AssistantHistoryDeleteOutcome = "DELETED" | "ALREADY_DELETED" | "TOMBSTONED_UNSEEN" | "NOT_PRESENT";
+/** `AssistantHistoryConversation`, with its DateTimes normalised to ISO strings. */
+export interface AssistantHistoryServerConversation {
+    id: string;
+    /** Null for a conversation saved before v2 (read-only). */
+    clientConversationId: string | null;
+    /** The product as the request named it (a renamed product's alias is echoed back as sent). */
+    productId: string;
+    /** Null once the conversation is deleted: a deleted chat's title is never served. */
+    title: string | null;
+    legacy: boolean;
+    revision: number;
+    lastMessageSeq: number;
+    deleted: boolean;
+    deletedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/** `AssistantHistoryEntry`, with `createdAt` normalised to an ISO string. */
+export interface AssistantHistoryServerEntry {
+    id: string;
+    /** Null for a message saved before v2. */
+    clientMessageId: string | null;
+    kind: AssistantHistoryEntryKind | null;
+    role: AssistantHistoryRole;
+    content: string;
+    seq: number | null;
+    createdAt: string;
+    /** The client's own timestamp, exactly as it was sent (or null when the server clamped it away). */
+    clientCreatedAt: string | null;
+    /** The allow-listed metadata, verbatim. Untrusted input to `fromHistoryEntry`, never executed. */
+    metadata: Record<string, unknown> | null;
+}
+export interface AssistantHistoryPageInfo {
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    startCursor: string | null;
+    endCursor: string | null;
+}
+/** `myAssistantHistoryChanges`: every change in commit order, tombstones included. */
+export interface AssistantHistoryChangePage {
+    nodes: AssistantHistoryServerConversation[];
+    pageInfo: AssistantHistoryPageInfo;
+    /** The cursor predates retained tombstones: drop synced state and pull from the start. */
+    resetRequired: boolean;
+}
+/** `myAssistantConversations`: live conversations, most recently changed first. */
+export interface AssistantHistoryHeaderPage {
+    nodes: AssistantHistoryServerConversation[];
+    pageInfo: AssistantHistoryPageInfo;
+}
+/** `myAssistantConversationEntries`: nodes are always ascending by `seq`. */
+export interface AssistantHistoryEntryPage {
+    conversation: AssistantHistoryServerConversation;
+    nodes: AssistantHistoryServerEntry[];
+    pageInfo: AssistantHistoryPageInfo;
+}
+/** `AssistantHistoryEntryInput`. `metadata` is already allow-listed by `toHistoryEntries`. */
+export interface AssistantHistoryEntryInput {
+    clientMessageId: string;
+    role: AssistantHistoryRole;
+    content: string;
+    clientCreatedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+/** A save, minus `productId` — the transport takes that from the scope, never from the caller. */
+export interface AssistantHistorySaveInput {
+    clientConversationId: string;
+    kind: AssistantHistoryEntryKind;
+    entries: AssistantHistoryEntryInput[];
+}
+export interface AssistantHistorySavePayload {
+    outcome: AssistantHistorySaveOutcome;
+    conversation: AssistantHistoryServerConversation;
+    entries: AssistantHistoryServerEntry[];
+    /** `<entryIndex>.<key>` (or `<entryIndex>.<key>.<path>.pendingWrite`) for what the server did not store. */
+    droppedMetadataKeys: string[];
+}
+export interface AssistantHistoryDeletePayload {
+    outcome: AssistantHistoryDeleteOutcome;
+    conversation: AssistantHistoryServerConversation | null;
+}
+/** Paging for `myAssistantConversationEntries`: backward (`last`/`before`) OR forward (`first`/`after`/`sinceSeq`), never both. */
+export type AssistantHistoryEntryPaging = {
+    last?: number;
+    before?: string;
+} | {
+    first?: number;
+    after?: string;
+    sinceSeq?: number;
+};
+/** What the list shows for a server conversation that is not (yet) materialised locally. */
+export interface AssistantHistoryHeader {
+    serverId: string;
+    clientConversationId: string | null;
+    title: string | null;
+    legacy: boolean;
+    revision: number;
+    lastMessageSeq: number;
+    createdAt: string;
+    updatedAt: string;
+    /**
+     * The server answered NOT_FOUND for this conversation (it never had it in
+     * this scope), so the list hides it. NOT a delete: nothing is tombstoned,
+     * and a feed node with a HIGHER revision makes it visible again. At the same
+     * revision `gone` wins a merge, so another tab cannot quietly bring it back.
+     */
+    gone?: true;
+}
+export interface AssistantHistoryScopeState {
+    /**
+     * How many times this scope was reset (`resetRequired`). A merge keeps the
+     * cursor and headers of the HIGHER generation wholesale — a union would put
+     * back exactly what the reset threw away. Absent means 0.
+     */
+    gen?: number;
+    /** The feed's opaque `endCursor`, and the revision it reached (merges keep the higher). */
+    cursor: string | null;
+    cursorRev: number;
+    headers: Record<AssistantHistoryConvKey, AssistantHistoryHeader>;
+    /** Headers were dropped to the cache bound; "Show older conversations" pages the live list. */
+    hasOlderHeaders?: true;
+    pulledAt?: number;
+    /**
+     * Epoch ms of this generation's reset (`resetRequired`), kept after its
+     * re-pull finishes: everything held since was read after it, so for a
+     * while a further `resetRequired` cannot mean a missed delete (the engine's
+     * feed says how long). Absent for a scope never reset.
+     */
+    resetAt?: number;
+    /** That re-pull has pages still to read: after a reload it resumes, and still removes what it did not return. */
+    rescanning?: true;
+}
+export interface AssistantHistoryTombstone {
+    scopeKey: AssistantHistoryScopeKey;
+    /** Epoch ms it was recorded here. */
+    at: number;
+    /** The server has confirmed the delete (any outcome), or reported it deleted. */
+    confirmed: boolean;
+    serverId?: string;
+}
+/**
+ * A save carries a SNAPSHOT of the entries, built from the store at commit
+ * time — never message ids to look up later — so it survives the main store
+ * losing the conversation (another tab's last write wins there).
+ */
+export interface AssistantHistorySaveItem {
+    id: string;
+    type: "save";
+    scopeKey: AssistantHistoryScopeKey;
+    convKey: AssistantHistoryConvKey;
+    kind: AssistantHistoryEntryKind;
+    entries: AssistantHistoryEntryInput[];
+    attempts: number;
+    nextAttemptAt?: number;
+    parked?: "quota";
+}
+export interface AssistantHistoryDeleteItem {
+    id: string;
+    type: "delete";
+    scopeKey: AssistantHistoryScopeKey;
+    convKey: AssistantHistoryConvKey;
+    serverId?: string;
+    legacy: boolean;
+    attempts: number;
+    nextAttemptAt?: number;
+}
+export type AssistantHistoryOutboxItem = AssistantHistorySaveItem | AssistantHistoryDeleteItem;
+/**
+ * ★★ `v` is this build's FORMAT. A later build keeps it at 1 only for ADDITIVE
+ * changes; anything else takes a higher `v`, and this build then never writes
+ * the key (nor reads it). At `v: 1`, what this build does with what it does
+ * not read (see historyStore):
+ *
+ * PRESERVED, exactly as the key holds it at each write:
+ *   - a new top-level key;
+ *   - an outbox item of a new type or save kind, in its place in the queue,
+ *     until that build finishes it (`doneItemIds`);
+ *   - a new field on a scope, a tombstone, a header or a known outbox item.
+ *     Wherever the key holds that record, the field is the key's — at every
+ *     write and every read of another tab's write — so a value the later
+ *     build changes stays changed and a field it deletes stays deleted, even
+ *     in a tab of this build that read the old ones. This build never writes
+ *     such a field the key does not hold, except on a record the key no
+ *     longer holds at all, which it writes back as it last read it.
+ *
+ * NOT preserved:
+ *   - a new field on a header this build replaces with a higher revision (a
+ *     newer copy of the server's record replaces the old one whole, and this
+ *     build's own pulls carry none) — so a header's new fields must describe
+ *     that revision only;
+ *   - a new field on a scope this build resets (`resetRequired` starts it
+ *     again from nothing), or on a scope a copy of a higher `gen` replaces;
+ *   - a record merely left out of the key: this build keeps what it holds
+ *     (a union), so a later build removes one only by the facts this build
+ *     reads — `doneItemIds`, a tombstone, a higher `gen`, `gone`;
+ *   - a new field NESTED inside a field this build reads (inside a save's
+ *     `entries`, say): it goes with that field's value, which this build's
+ *     rules choose (the more-tried copy; at equal attempts, this tab's);
+ *   - a field this build reads, given another type or meaning: it is read
+ *     as it always was — a scope's or tombstone's field of another type is
+ *     dropped, a tombstone or header lacking a required one is dropped whole,
+ *     and an outbox item lacking one is carried as an item of unknown type.
+ */
+export interface AssistantHistoryPersisted {
+    v: 1;
+    scopes: Record<AssistantHistoryScopeKey, AssistantHistoryScopeState>;
+    outbox: AssistantHistoryOutboxItem[];
+    /** Outbox item id -> epoch ms it was acknowledged. Kept so a merge from a stale tab cannot revive it. */
+    doneItemIds: Record<string, number>;
+    tombstones: Record<AssistantHistoryConvKey, AssistantHistoryTombstone>;
+}
+//# sourceMappingURL=historyTypes.d.ts.map

package/dist/shared/assistant/history/historyTypes.d.ts.map

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

package/dist/shared/assistant/history/historyTypes.js

@@ -0,0 +1,20 @@
+//#region src/shared/assistant/history/historyTypes.ts
+var e = "legacy:";
+function t(e) {
+	return `${e.actorId}|${e.workspaceId}|${e.product}`;
+}
+function n(e, t, n) {
+	return !e || !t || !n ? null : {
+		actorId: e,
+		workspaceId: t,
+		product: n
+	};
+}
+function r(t) {
+	return `${e}${t}`;
+}
+function i(t) {
+	return t.startsWith(e);
+}
+//#endregion
+export { e as LEGACY_HISTORY_KEY_PREFIX, t as assistantHistoryScopeKey, n as completeAssistantHistoryScope, i as isLegacyHistoryConvKey, r as legacyHistoryConvKey };

package/dist/shared/assistant/history/profileBoundStorage.d.ts

@@ -0,0 +1,36 @@
+import { StateStorage } from 'zustand/middleware';
+export interface ProfileBoundStorage extends StateStorage {
+    /** Synchronous: binds to the active profile's key (see the module docblock). */
+    getItem(name: string): string | null;
+    /** Forget the bound key: writes are refused until the next read binds one (the only way to change profile). */
+    unbind(): void;
+    /** The storage key the state was read from, or null while unbound. */
+    boundKey(): string | null;
+    /**
+     * What the bound key holds right now, WITHOUT binding: null while unbound or
+     * once the profile has changed. A write merges with this first, so another
+     * tab's write that this one has not folded in yet is never overwritten.
+     */
+    peekItem(name: string): string | null;
+    /** Bound, and `name` still resolves to the bound key (the active profile has not changed). */
+    isCurrent(name: string): boolean;
+    /** The key `name` would bind to right now, or null with no active profile. Reads nothing. */
+    activeKey(name: string): string | null;
+    /**
+     * The browser refused the latest write (a full or blocked storage): what is
+     * in memory is not saved on this device. False again once a write succeeds.
+     * A write refused for the profile (unbound, or changed) is not counted — it
+     * was never meant to land.
+     */
+    lastWriteFailed(): boolean;
+}
+export interface ProfileBoundStorageOptions {
+    /** Resolve the profile-scoped key for a base name (default: the app's active profile). */
+    resolveKey?: (name: string) => string;
+    /** The storage to use (default: `window.localStorage`, when there is one). */
+    storage?: () => Pick<Storage, "getItem" | "setItem" | "removeItem"> | null;
+    /** Told once per refusal streak, and about every failed write. */
+    onRefused?: (reason: "unbound" | "profile-changed" | "write-failed", error?: unknown) => void;
+}
+export declare function createProfileBoundStorage(options?: ProfileBoundStorageOptions): ProfileBoundStorage;
+//# sourceMappingURL=profileBoundStorage.d.ts.map

package/dist/shared/assistant/history/profileBoundStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profileBoundStorage.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/history/profileBoundStorage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAIvD,MAAM,WAAW,mBAAoB,SAAQ,YAAY;IACvD,gFAAgF;IAChF,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACrC,+GAA+G;IAC/G,MAAM,IAAI,IAAI,CAAC;IACf,sEAAsE;IACtE,QAAQ,IAAI,MAAM,GAAG,IAAI,CAAC;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACtC,8FAA8F;IAC9F,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACjC,6FAA6F;IAC7F,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACvC;;;;;OAKG;IACH,eAAe,IAAI,OAAO,CAAC;CAC5B;AAED,MAAM,WAAW,0BAA0B;IACzC,0FAA0F;IAC1F,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACtC,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC,OAAO,EAAE,SAAS,GAAG,SAAS,GAAG,YAAY,CAAC,GAAG,IAAI,CAAC;IAC3E,kEAAkE;IAClE,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,GAAG,iBAAiB,GAAG,cAAc,EAAE,KAAK,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;CAC/F;AAUD,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,0BAA+B,GACvC,mBAAmB,CAyGrB"}

package/dist/shared/assistant/history/profileBoundStorage.js

@@ -0,0 +1,74 @@
+import { getProfileScopedKey as e } from "../../utils/profileScopedStorage.js";
+//#region src/shared/assistant/history/profileBoundStorage.ts
+function t() {
+	try {
+		return typeof localStorage > "u" ? null : localStorage;
+	} catch {
+		return null;
+	}
+}
+function n(n = {}) {
+	let r = n.resolveKey ?? e, i = n.storage ?? t, a = null, o = !1, s = !1, c = (e, t) => {
+		(e === "write-failed" || !o) && (o = !0, n.onRefused?.(e, t));
+	}, l = (e) => {
+		try {
+			let t = r(e);
+			return t === e ? null : t;
+		} catch {
+			return null;
+		}
+	}, u = (e) => a === null ? (c("unbound"), null) : l(e) === a ? a : (c("profile-changed"), null);
+	return {
+		getItem(e) {
+			let t = l(e);
+			if (a !== null && t !== a) return c("profile-changed"), null;
+			if (a = t, o = !1, t === null) return null;
+			try {
+				return i()?.getItem(t) ?? null;
+			} catch {
+				return null;
+			}
+		},
+		setItem(e, t) {
+			let n = u(e);
+			if (n !== null) try {
+				i()?.setItem(n, t), s = !1;
+			} catch (e) {
+				s = !0, c("write-failed", e);
+			}
+		},
+		removeItem(e) {
+			let t = u(e);
+			if (t !== null) try {
+				i()?.removeItem(t), s = !1;
+			} catch (e) {
+				s = !0, c("write-failed", e);
+			}
+		},
+		peekItem(e) {
+			if (a === null || l(e) !== a) return null;
+			try {
+				return i()?.getItem(a) ?? null;
+			} catch {
+				return null;
+			}
+		},
+		isCurrent(e) {
+			return a !== null && l(e) === a;
+		},
+		activeKey(e) {
+			return l(e);
+		},
+		unbind() {
+			a = null, s = !1;
+		},
+		lastWriteFailed() {
+			return s;
+		},
+		boundKey() {
+			return a;
+		}
+	};
+}
+//#endregion
+export { n as createProfileBoundStorage };

package/dist/shared/assistant/history/stampRegistry.d.ts

@@ -0,0 +1,84 @@
+/**
+ * The seams between the main assistant store and server history (BOFF-7335).
+ *
+ * ★★ A LEAF: this module imports nothing. The main store (`../store`) reads
+ * it and the history engine writes it, so neither has to import the other —
+ * the store stays loadable in every product, and in every test, without the
+ * engine, its transport or its persisted store.
+ *
+ * Four seams, each empty until the engine is enabled — so with server history
+ * off (every product that has not opted in) the store behaves exactly as it
+ * did before this module existed:
+ *
+ * - the STAMP: who a conversation created right now belongs to. The store
+ *   stamps a new conversation with it (`Conversation.sync`), and only then is
+ *   that conversation ever saved. No source, or a source that cannot name the
+ *   product, the account AND the workspace, means device-only.
+ * - STORAGE FULL: the main store's persisted write was refused for space. The
+ *   engine frees space by evicting server-backed conversations it can load
+ *   again; the eviction's own write is the retry.
+ * - BUSY: a conversation that must not be rewritten under the person right now
+ *   (a live voice session in it). The panel registers this; the engine checks
+ *   it, together with the turn-in-flight state it reads from the store, before
+ *   it merges loaded messages or evicts.
+ * - OPEN IN PLACE: which conversation may open when the open one leaves the
+ *   store (deleted here or elsewhere). The store used to open the first one
+ *   left, whoever it belonged to — another workspace's, which the list hides
+ *   and whose turns would then be sent from this workspace.
+ */
+/** The owner a conversation created now is stamped with. */
+export interface AssistantHistoryStamp {
+    product: string;
+    workspaceId: string;
+    actorId: string;
+}
+/** Install (or, with null, remove) where new conversations' stamps come from. */
+export declare function setHistoryStampSource(source: (() => AssistantHistoryStamp | null) | null): void;
+/**
+ * The stamp for a conversation created now, or null: history off, or any part
+ * of the owner unknown. Never throws — a source that fails means device-only.
+ */
+export declare function getHistoryStamp(): AssistantHistoryStamp | null;
+/**
+ * Told when the main store's write was refused. `stillFailing` reports whether
+ * the most recent write attempt (including one the handler itself caused) was
+ * refused too.
+ */
+export type AssistantStorageFullHandler = (stillFailing: () => boolean) => void;
+export declare function setAssistantStorageFullHandler(handler: AssistantStorageFullHandler | null): void;
+/** Called by the main store's guarded storage; a no-op while history is off. */
+export declare function notifyAssistantStorageFull(stillFailing: () => boolean): void;
+/**
+ * The panel's answer to "is something live in this conversation right now" (a
+ * voice session). Returns its release, which clears the probe only while it is
+ * still this one — a panel unmounting after another mounted leaves the newer
+ * panel's probe in place.
+ */
+export declare function setHistoryBusyProbe(probe: ((conversationId: string) => boolean) | null): () => void;
+/** True when the registered probe says so. A probe that throws answers "busy" — the safe side. */
+export declare function isHistoryConversationBusy(conversationId: string): boolean;
+/** What the store knows of a conversation when it asks whether that one may open. */
+export interface AssistantHistoryOpenCandidate {
+    readonly id: string;
+    readonly sync?: {
+        readonly product: string;
+        readonly workspaceId: string;
+        readonly actorId: string;
+    };
+}
+/** Decides, for one removal, which conversations may open in place of the one that went. */
+export type AssistantHistoryOpenFilter = (candidate: AssistantHistoryOpenCandidate) => boolean;
+/**
+ * Install (or, with null, remove) the rule for what may open in place of a
+ * removed conversation. A source, not a filter: it is asked once per removal,
+ * so it can read the active scope once rather than once per conversation.
+ */
+export declare function setHistoryOpenFilterSource(source: (() => AssistantHistoryOpenFilter) | null): void;
+/**
+ * The rule for this removal: any conversation with history off (as before),
+ * otherwise the source's. A source or filter that throws leaves only the
+ * device's own conversations — never another workspace's, at worst an empty
+ * panel.
+ */
+export declare function historyOpenFilter(): AssistantHistoryOpenFilter;
+//# sourceMappingURL=stampRegistry.d.ts.map

package/dist/shared/assistant/history/stampRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stampRegistry.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/history/stampRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,4DAA4D;AAC5D,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAID,iFAAiF;AACjF,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,CAAC,MAAM,qBAAqB,GAAG,IAAI,CAAC,GAAG,IAAI,GAAG,IAAI,CAE/F;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,qBAAqB,GAAG,IAAI,CAQ9D;AAED;;;;GAIG;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,YAAY,EAAE,MAAM,OAAO,KAAK,IAAI,CAAC;AAIhF,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,2BAA2B,GAAG,IAAI,GAAG,IAAI,CAEhG;AAED,gFAAgF;AAChF,wBAAgB,0BAA0B,CAAC,YAAY,EAAE,MAAM,OAAO,GAAG,IAAI,CAE5E;AAID;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,CAAC,CAAC,cAAc,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,IAAI,GAClD,MAAM,IAAI,CAKZ;AAED,kGAAkG;AAClG,wBAAgB,yBAAyB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAOzE;AAED,qFAAqF;AACrF,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,CAAC,EAAE;QACd,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;QAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;KAC1B,CAAC;CACH;AAED,4FAA4F;AAC5F,MAAM,MAAM,0BAA0B,GAAG,CAAC,SAAS,EAAE,6BAA6B,KAAK,OAAO,CAAC;AAI/F;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,CAAC,MAAM,0BAA0B,CAAC,GAAG,IAAI,GAAG,IAAI,CAElG;AAKD;;;;;GAKG;AACH,wBAAgB,iBAAiB,IAAI,0BAA0B,CAe9D"}

package/dist/shared/assistant/history/stampRegistry.js

@@ -0,0 +1,58 @@
+//#region src/shared/assistant/history/stampRegistry.ts
+var e = null;
+function t(t) {
+	e = t;
+}
+function n() {
+	if (!e) return null;
+	try {
+		let t = e();
+		return t && t.product && t.workspaceId && t.actorId ? t : null;
+	} catch {
+		return null;
+	}
+}
+var r = null;
+function i(e) {
+	r = e;
+}
+function a(e) {
+	r?.(e);
+}
+var o = null;
+function s(e) {
+	return o = e, () => {
+		o === e && (o = null);
+	};
+}
+function c(e) {
+	if (!o) return !1;
+	try {
+		return o(e);
+	} catch {
+		return !0;
+	}
+}
+var l = null;
+function u(e) {
+	l = e;
+}
+var d = () => !0, f = (e) => !e.sync;
+function p() {
+	if (!l) return d;
+	let e;
+	try {
+		e = l();
+	} catch {
+		return f;
+	}
+	return (t) => {
+		try {
+			return e(t);
+		} catch {
+			return f(t);
+		}
+	};
+}
+//#endregion
+export { n as getHistoryStamp, p as historyOpenFilter, c as isHistoryConversationBusy, a as notifyAssistantStorageFull, i as setAssistantStorageFullHandler, s as setHistoryBusyProbe, u as setHistoryOpenFilterSource, t as setHistoryStampSource };

package/dist/shared/assistant/history/useAssistantServerHistory.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Opt this product's panel into server-backed history (BOFF-7335, contract §6).
+ *
+ * ★★ OFF unless asked. A product turns it on with the panel's `serverHistory`
+ * prop; with it off (the default) nothing is stamped, queued, pulled or read,
+ * and the panel behaves exactly as it did before server history existed.
+ *
+ * The engine is a module-level singleton, and this only holds it on: enabling
+ * is ref-counted, so the overlay (which keeps it on while the panel is closed)
+ * and the panel itself can both ask, and it switches off when the last one
+ * lets go. The engine watches the account, workspace and profile itself.
+ *
+ * ★ The product id is the one the product provider already gives — the same
+ * string the server stores as `productId` — so no product names itself twice.
+ * With no product there is nothing to scope the history to, and it stays off.
+ */
+export declare function useAssistantServerHistory(enabled: boolean): void;
+//# sourceMappingURL=useAssistantServerHistory.d.ts.map

package/dist/shared/assistant/history/useAssistantServerHistory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAssistantServerHistory.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/history/useAssistantServerHistory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAOH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAMhE"}

package/dist/shared/assistant/history/useAssistantServerHistory.js

@@ -0,0 +1,12 @@
+import { useAssistantProductOrNull as e } from "../product.js";
+import { assistantHistory as t } from "./historyEngine.js";
+import { useEffect as n } from "react";
+//#region src/shared/assistant/history/useAssistantServerHistory.ts
+function r(r) {
+	let i = e()?.product ?? "";
+	n(() => {
+		if (!(!r || !i)) return t.enable(i);
+	}, [r, i]);
+}
+//#endregion
+export { r as useAssistantServerHistory };

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

@@ -180,6 +180,24 @@ export declare const ASSISTANT_I18N_LITERAL_COPY: {
     readonly "header.preview": "Preview";
     readonly "header.ready": "Ready";
     readonly "header.title": "AI Assistant";
+    readonly "history.badgeLoading": "Loading…";
+    readonly "history.badgeNotSaved": "Not saved";
+    readonly "history.badgeReadOnly": "Read-only";
+    readonly "history.deleteNotSaved": "This device's storage is full, so that delete isn't saved here yet. Keep this page open until it reaches the server.";
+    readonly "history.deletedElsewhere": "The conversation you had open was deleted on another device.";
+    readonly "history.dismiss": "Dismiss";
+    readonly "history.groupDevice": "On this device";
+    readonly "history.groupWorkspace": "This workspace";
+    readonly "history.legacyReadOnly": "This conversation was saved by an earlier version of the assistant. You can read it, but it can't be continued.";
+    readonly "history.loadFailed": "Couldn't load this conversation.";
+    readonly "history.loading": "Loading conversation…";
+    readonly "history.notSavedInvalid": "Part of this conversation couldn't be saved. It stays on this device.";
+    readonly "history.notSavedQuota": "Not saved yet: this workspace has reached its conversation limit. It will be saved when there is room.";
+    readonly "history.notSavedScope": "Some turns were sent from another workspace. They stay on this device.";
+    readonly "history.showEarlier": "Show earlier messages";
+    readonly "history.showOlder": "Show older conversations";
+    readonly "history.tryAgain": "Try again";
+    readonly "history.untitled": "Untitled conversation";
     readonly "language.inputLabel": "Language";
     readonly "language.replyLabel": "Assistant replies in";
     readonly "language.replyMatch": "Match my language";

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

@@ -1 +1 @@
-{"version":3,"file":"i18nManifest.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/i18nManifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAU1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0GG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4OG,CAAC;AAE5C,mDAAmD;AACnD,MAAM,MAAM,uBAAuB,GAAG,MAAM,OAAO,2BAA2B,CAAC;AAW/E;;;GAGG;AACH,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAsBtE,CAAC;AAEL;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAIjE,CAAC;AAEL,kEAAkE;AAClE,MAAM,MAAM,uBAAuB,GAAG,IAAI,CACxC,mBAAmB,EACnB,IAAI,GAAG,OAAO,GAAG,mBAAmB,CACrC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,uBAAuB,EAAE,GACxC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAexB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,SAAS,uBAAuB,EAAE,CAAC;IAC1C,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC9C,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAiCzB"}
+{"version":3,"file":"i18nManifest.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/i18nManifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAU1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0GG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoQG,CAAC;AAE5C,mDAAmD;AACnD,MAAM,MAAM,uBAAuB,GAAG,MAAM,OAAO,2BAA2B,CAAC;AAW/E;;;GAGG;AACH,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAsBtE,CAAC;AAEL;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAIjE,CAAC;AAEL,kEAAkE;AAClE,MAAM,MAAM,uBAAuB,GAAG,IAAI,CACxC,mBAAmB,EACnB,IAAI,GAAG,OAAO,GAAG,mBAAmB,CACrC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,uBAAuB,EAAE,GACxC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAexB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,SAAS,uBAAuB,EAAE,CAAC;IAC1C,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC9C,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAiCzB"}

package/dist/shared/assistant/i18nManifest.js

@@ -75,6 +75,24 @@ var u = {
 	"header.preview": "Preview",
 	"header.ready": "Ready",
 	"header.title": "AI Assistant",
+	"history.badgeLoading": "Loading…",
+	"history.badgeNotSaved": "Not saved",
+	"history.badgeReadOnly": "Read-only",
+	"history.deleteNotSaved": "This device's storage is full, so that delete isn't saved here yet. Keep this page open until it reaches the server.",
+	"history.deletedElsewhere": "The conversation you had open was deleted on another device.",
+	"history.dismiss": "Dismiss",
+	"history.groupDevice": "On this device",
+	"history.groupWorkspace": "This workspace",
+	"history.legacyReadOnly": "This conversation was saved by an earlier version of the assistant. You can read it, but it can't be continued.",
+	"history.loadFailed": "Couldn't load this conversation.",
+	"history.loading": "Loading conversation…",
+	"history.notSavedInvalid": "Part of this conversation couldn't be saved. It stays on this device.",
+	"history.notSavedQuota": "Not saved yet: this workspace has reached its conversation limit. It will be saved when there is room.",
+	"history.notSavedScope": "Some turns were sent from another workspace. They stay on this device.",
+	"history.showEarlier": "Show earlier messages",
+	"history.showOlder": "Show older conversations",
+	"history.tryAgain": "Try again",
+	"history.untitled": "Untitled conversation",
 	"language.inputLabel": "Language",
 	"language.replyLabel": "Assistant replies in",
 	"language.replyMatch": "Match my language",