@case-framework/survey-assistant 0.6.0 → 0.8.0

package/dist/react-C_GY-Fsc.mjs

@@ -0,0 +1,1727 @@
+import { F as surveyAssistantThreadTranscriptSchema, Ht as isSurveyAssistantSensitiveMetadataKey, It as parseSurveyAssistantError, N as surveyAssistantThreadListSchema, P as surveyAssistantThreadSchema, Ut as redactSurveyAssistantDiagnosticSecrets, Vt as getSurveyAssistantEmbeddedBinaryMarker, W as surveyDocumentVersionSchema, f as surveyChangeSetSchema, l as surveyAssistantTurnFinalSchema, n as SURVEY_ASSISTANT_TURN_FINAL_PART_TYPE, o as surveyAssistantApplyOutcomeSchema, p as surveyAssistantModelCatalogSchema, r as applyReceiptSchema } from "./protocol-CF4Bh_Ch.mjs";
+import { hashString } from "./digest.mjs";
+import { c as readSurveyAssistantJson, i as applySurveyAssistantLaunchUIContext } from "./controller-proxy-DEeFl9IA.mjs";
+import { DefaultChatTransport } from "ai";
+import { Zip, ZipPassThrough } from "fflate";
+import { useCallback, useEffect, useEffectEvent, useLayoutEffect, useMemo, useReducer, useRef, useState } from "react";
+import { useChat } from "@ai-sdk/react";
+//#region src/react/session-state.ts
+const isSurveyAssistantTurnActive = ({ isStreaming, state }) => state !== "aborted" && (isStreaming || state === "submitting" || state === "streaming" || state === "applying");
+const reduceSurveyAssistantSessionState = (_state, event) => {
+	switch (event.type) {
+		case "submit": return "submitting";
+		case "stream-started": return "streaming";
+		case "completed": return "completed";
+		case "apply-started": return "applying";
+		case "applied": return "applied";
+		case "failed": return "failed";
+		case "aborted": return "aborted";
+		case "reset": return event.hasTranscript ? "completed" : "idle";
+	}
+};
+//#endregion
+//#region src/react/turn-authorization.ts
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isCompletedToolPart = (part) => (part.type === "dynamic-tool" || part.type.startsWith("tool-")) && "state" in part && part.state === "output-available" && "output" in part;
+const unwrapSurveyAssistantToolOutput = (output) => {
+	if (isRecord(output) && "output" in output && output.output !== void 0) return output.output;
+	return output;
+};
+const parseSurveyChangeSet = (output) => {
+	const parsed = surveyChangeSetSchema.safeParse(unwrapSurveyAssistantToolOutput(output));
+	return parsed.success ? parsed.data : null;
+};
+const collectSurveyChangeSets = (messages) => {
+	const changes = [];
+	for (const message of messages) for (const part of message.parts) {
+		if (!isCompletedToolPart(part)) continue;
+		const change = parseSurveyChangeSet(part.output);
+		if (change) changes.push(change);
+	}
+	return changes;
+};
+const findLastUserMessageIndex$1 = (messages) => {
+	for (let index = messages.length - 1; index >= 0; index -= 1) if (messages[index]?.role === "user") return index;
+	return -1;
+};
+const resolveLatestSurveyTurnAuthorization = (messages) => {
+	const lastUserIndex = findLastUserMessageIndex$1(messages);
+	if (lastUserIndex < 0) return { status: "pending" };
+	const turnMessages = messages.slice(lastUserIndex + 1);
+	const finalParts = turnMessages.flatMap((message) => message.parts).filter((part) => part.type === SURVEY_ASSISTANT_TURN_FINAL_PART_TYPE);
+	if (finalParts.length === 0) return { status: "pending" };
+	if (finalParts.length !== 1) return {
+		status: "invalid",
+		reason: "The assistant returned multiple turn finals."
+	};
+	const finalPart = finalParts[0];
+	const finalParse = surveyAssistantTurnFinalSchema.safeParse(finalPart && "data" in finalPart ? finalPart.data : void 0);
+	if (!finalParse.success) return {
+		status: "invalid",
+		reason: "The assistant returned an invalid turn final."
+	};
+	const turnFinal = finalParse.data;
+	if (turnFinal.status !== "completed") return {
+		status: turnFinal.status,
+		turnFinal,
+		changeSets: []
+	};
+	const candidates = collectSurveyChangeSets(turnMessages).filter((change) => change.turnId === turnFinal.turnId);
+	const candidatesById = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) {
+		if (candidatesById.has(candidate.id)) return {
+			status: "invalid",
+			turnId: turnFinal.turnId,
+			reason: `The assistant returned duplicate change set "${candidate.id}".`
+		};
+		candidatesById.set(candidate.id, candidate);
+	}
+	for (const blockedChangeSetId of turnFinal.blockedChangeSetIds ?? []) {
+		const candidate = candidatesById.get(blockedChangeSetId);
+		if (!candidate || candidate.status !== "rejected" || candidate.validation.valid) return {
+			status: "invalid",
+			turnId: turnFinal.turnId,
+			reason: `The assistant did not provide blocked change set "${blockedChangeSetId}".`
+		};
+	}
+	const changeSets = [];
+	for (const changeSetId of turnFinal.executableChangeSetIds) {
+		const candidate = candidatesById.get(changeSetId);
+		if (!candidate || candidate.status !== "validated" || !candidate.validation.valid) return {
+			status: "invalid",
+			turnId: turnFinal.turnId,
+			reason: `The assistant did not provide authorized change set "${changeSetId}".`
+		};
+		changeSets.push(candidate);
+	}
+	return {
+		status: "completed",
+		turnFinal,
+		changeSets
+	};
+};
+const resolveSurveyTurnOutcome = ({ applyResultsByChangeId, authorization }) => {
+	if (authorization.status === "failed" || authorization.status === "aborted") return {
+		status: authorization.status,
+		terminationReason: authorization.turnFinal.terminationReason
+	};
+	if (authorization.status !== "completed") return null;
+	const blockedChangeSetCount = authorization.turnFinal.blockedChangeSetIds?.length ?? 0;
+	if (blockedChangeSetCount > 0) return {
+		status: "blocked",
+		blockedChangeSetCount
+	};
+	if (authorization.changeSets.length === 0) return null;
+	const results = authorization.changeSets.map((change) => applyResultsByChangeId[change.id]);
+	if (results.some((result) => result === void 0)) return null;
+	const failedChangeSetCount = results.filter((result) => result.status !== "applied").length;
+	if (failedChangeSetCount === 0) return null;
+	return {
+		status: "apply-failed",
+		appliedChangeSetCount: results.length - failedChangeSetCount,
+		failedChangeSetCount
+	};
+};
+const getSurveyDocumentVersionFromSnapshot = (snapshot) => ({ ...snapshot.version });
+const createApplyReceipts = ({ afterSnapshot, beforeSnapshot, changeSets, results, turnFinal, createdAt = (/* @__PURE__ */ new Date()).toISOString() }) => {
+	const beforeVersion = getSurveyDocumentVersionFromSnapshot(beforeSnapshot);
+	const afterVersion = afterSnapshot ? getSurveyDocumentVersionFromSnapshot(afterSnapshot) : void 0;
+	const resultsByChangeId = new Map(results.map((result) => [result.changeId, result]));
+	return changeSets.map((changeSet) => {
+		const result = resultsByChangeId.get(changeSet.id);
+		const status = result?.status ?? "failed";
+		return applyReceiptSchema.parse({
+			protocolVersion: 1,
+			turnId: turnFinal.turnId,
+			changeSetId: changeSet.id,
+			beforeVersion,
+			...status === "applied" && afterVersion ? { afterVersion } : {},
+			status,
+			operationCount: changeSet.operations.length,
+			...status === "applied" && afterVersion?.historyIndex !== void 0 ? { commit: { index: afterVersion.historyIndex } } : {},
+			...result?.issues ? { issues: result.issues } : {},
+			createdAt
+		});
+	});
+};
+//#endregion
+//#region src/react/transport.ts
+const findLastUserMessage = (messages) => {
+	for (let index = messages.length - 1; index >= 0; index -= 1) if (messages[index]?.role === "user") return messages[index];
+};
+const fetchSurveyAssistantChat = async (input, init) => {
+	const response = await globalThis.fetch(input, init);
+	if (!response.ok) await readSurveyAssistantJson(response);
+	return response;
+};
+const createSurveyAssistantTransport = ({ api = "/api/survey-assistant/chat", resourceId, surveyId, threadId }) => new DefaultChatTransport({
+	api,
+	body: {
+		resourceId,
+		...surveyId ? { surveyId } : {},
+		threadId
+	},
+	fetch: fetchSurveyAssistantChat,
+	prepareSendMessagesRequest: ({ api, body, credentials, headers, id, messageId, messages, trigger }) => {
+		const latestUserMessage = findLastUserMessage(messages);
+		return {
+			api,
+			credentials,
+			headers,
+			body: {
+				...body,
+				id,
+				messages: latestUserMessage ? [latestUserMessage] : [],
+				trigger,
+				messageId
+			}
+		};
+	}
+});
+//#endregion
+//#region src/react/thread-client.ts
+const createSurveyAssistantThreadClient = (api = "/api/survey-assistant/threads") => ({
+	async delete(threadId) {
+		const response = await fetch(`${api}/${encodeURIComponent(threadId)}`, { method: "DELETE" });
+		if (!response.ok) await readSurveyAssistantJson(response);
+	},
+	async create(title) {
+		const body = await readSurveyAssistantJson(await fetch(api, {
+			body: JSON.stringify(title ? { title } : {}),
+			headers: { "content-type": "application/json" },
+			method: "POST"
+		}));
+		return surveyAssistantThreadSchema.parse(body.thread);
+	},
+	async listPage(options) {
+		const search = new URLSearchParams();
+		if (options?.cursor) search.set("cursor", options.cursor);
+		const body = await readSurveyAssistantJson(await fetch(`${api}${search.size ? `?${search}` : ""}`, { cache: "no-store" }));
+		return surveyAssistantThreadListSchema.parse(body);
+	},
+	async read(threadId, cursor, options) {
+		const search = cursor ? `?cursor=${encodeURIComponent(cursor)}` : "";
+		const body = await readSurveyAssistantJson(await fetch(`${api}/${encodeURIComponent(threadId)}${search}`, {
+			cache: "no-store",
+			signal: options?.signal
+		}));
+		return surveyAssistantThreadTranscriptSchema.parse(body);
+	},
+	async rename(threadId, title) {
+		const body = await readSurveyAssistantJson(await fetch(`${api}/${encodeURIComponent(threadId)}`, {
+			body: JSON.stringify({
+				mode: "manual",
+				title
+			}),
+			headers: { "content-type": "application/json" },
+			method: "PATCH"
+		}));
+		return surveyAssistantThreadSchema.parse(body.thread);
+	},
+	async setAutomaticTitle(threadId, title) {
+		const body = await readSurveyAssistantJson(await fetch(`${api}/${encodeURIComponent(threadId)}`, {
+			body: JSON.stringify({
+				mode: "automatic",
+				...title ? { title } : {}
+			}),
+			headers: { "content-type": "application/json" },
+			method: "PATCH"
+		}));
+		return surveyAssistantThreadSchema.parse(body.thread);
+	}
+});
+//#endregion
+//#region src/react/support-bundle-limits.ts
+const MEBIBYTE = 1048576;
+const SURVEY_ASSISTANT_DEFAULT_SUPPORT_BUNDLE_LIMITS = {
+	attemptEvents: 200,
+	attemptStoreBytes: 48 * MEBIBYTE,
+	bundleBytes: 64 * MEBIBYTE,
+	emailWarningBytes: 15 * MEBIBYTE,
+	retainedAttempts: 5,
+	transcriptBytes: 24 * MEBIBYTE,
+	transcriptMessages: 2e3,
+	transcriptPages: 20,
+	zipEntryBytes: 32 * MEBIBYTE
+};
+const resolveSurveyAssistantSupportBundleLimits = (overrides) => {
+	const limits = {
+		...SURVEY_ASSISTANT_DEFAULT_SUPPORT_BUNDLE_LIMITS,
+		...overrides
+	};
+	for (const [name, value] of Object.entries(limits)) if (!Number.isSafeInteger(value) || value <= 0) throw new Error(`Survey assistant support-bundle limit "${name}" must be a positive integer.`);
+	if (limits.transcriptBytes > limits.zipEntryBytes) throw new Error("The transcript limit cannot exceed the individual ZIP-entry limit.");
+	if (limits.zipEntryBytes > limits.bundleBytes) throw new Error("The individual ZIP-entry limit cannot exceed the complete bundle limit.");
+	return limits;
+};
+//#endregion
+//#region src/react/diagnostic-store.ts
+const createSurveyAssistantDiagnosticId = (prefix = "attempt") => {
+	const randomId = globalThis.crypto?.randomUUID?.();
+	if (randomId) return `${prefix}-${randomId}`.slice(0, 64);
+	const segment = () => Math.random().toString(36).slice(2).padEnd(12, "0");
+	return `${prefix}-${segment()}${segment()}`.slice(0, 64);
+};
+const cloneDiagnosticValue = (value) => {
+	if (typeof structuredClone === "function") return structuredClone(value);
+	return JSON.parse(JSON.stringify(value));
+};
+const getDataUrlBytes = (value) => {
+	const comma = value.indexOf(",");
+	if (comma < 0) return new TextEncoder().encode(value).byteLength;
+	const payload = value.slice(comma + 1).replace(/\s/g, "");
+	if (!/;base64,/i.test(value.slice(0, comma + 1))) try {
+		return new TextEncoder().encode(decodeURIComponent(payload)).byteLength;
+	} catch {
+		return new TextEncoder().encode(payload).byteLength;
+	}
+	const padding = payload.endsWith("==") ? 2 : payload.endsWith("=") ? 1 : 0;
+	return Math.max(0, Math.floor(payload.length * 3 / 4) - padding);
+};
+const stripMessageAttachmentBytes = (messages) => {
+	const cloned = cloneDiagnosticValue(messages);
+	if (!Array.isArray(cloned)) return [];
+	for (const message of cloned) {
+		if (!message || typeof message !== "object" || !("parts" in message)) continue;
+		const parts = message.parts;
+		if (!Array.isArray(parts)) continue;
+		for (const part of parts) if (part && typeof part === "object" && "type" in part && part.type === "file" && "url" in part && typeof part.url === "string" && part.url.startsWith("data:")) part.url = "[attachment bytes retained separately when available]";
+	}
+	return cloned;
+};
+const getApproximateBytes = (value) => {
+	try {
+		return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+	} catch {
+		return 0;
+	}
+};
+const toAttachmentReference = (attachment) => ({
+	bytes: attachment.bytes,
+	filename: attachment.filename,
+	mediaType: attachment.mediaType,
+	sessionContentDigest: attachment.sessionContentDigest,
+	storeKey: attachment.storeKey
+});
+const toPublicAttempt = ({ retainedBytes: _retainedBytes, ...attempt }) => cloneDiagnosticValue(attempt);
+const safeEventFields = (fields) => {
+	if (!fields) return void 0;
+	const allowed = {};
+	for (const [key, value] of Object.entries(fields)) {
+		if (!/^(?:aborted|applied|changeSetId|code|count|durationMs|httpStatus|operationCount|retryable|status|turnId)$/.test(key)) continue;
+		if (value === null || value === void 0 || typeof value === "boolean" || typeof value === "number" || typeof value === "string") allowed[key] = typeof value === "string" ? value.slice(0, 240) : value;
+	}
+	return Object.keys(allowed).length > 0 ? allowed : void 0;
+};
+const createSurveyAssistantDiagnosticStore = (overrides) => {
+	const limits = resolveSurveyAssistantSupportBundleLimits(overrides);
+	const attempts = [];
+	const attachments = /* @__PURE__ */ new Map();
+	let attachmentSequence = 0;
+	const latest = (threadId) => [...attempts].reverse().find((attempt) => attempt.threadId === threadId);
+	const exportAttempt = (threadId) => latest(threadId);
+	const updateAttemptBytes = (attempt) => {
+		const { retainedBytes: _retainedBytes, ...value } = attempt;
+		attempt.retainedBytes = getApproximateBytes(value);
+	};
+	const retainedBytes = () => attempts.reduce((total, attempt) => total + attempt.retainedBytes, 0) + [...attachments.values()].reduce((total, attachment) => total + attachment.retainedBytes, 0);
+	const removeUnreferencedAttachments = () => {
+		const retainedKeys = new Set(attempts.flatMap((attempt) => attempt.attachments.map((item) => item.storeKey)));
+		for (const key of attachments.keys()) if (!retainedKeys.has(key)) attachments.delete(key);
+	};
+	const enforceLimits = () => {
+		if (attempts.length > limits.retainedAttempts) {
+			const newest = attempts.at(-1);
+			const newestFirst = [...attempts].reverse();
+			const retained = new Set([
+				newest,
+				...newestFirst.filter((attempt) => attempt !== newest && (attempt.error !== void 0 || attempt.captureFailure !== void 0)),
+				...newestFirst.filter((attempt) => attempt !== newest && attempt.error === void 0 && attempt.captureFailure === void 0)
+			].slice(0, limits.retainedAttempts));
+			for (let index = attempts.length - 1; index >= 0; index -= 1) if (!retained.has(attempts[index])) attempts.splice(index, 1);
+		}
+		removeUnreferencedAttachments();
+		if (retainedBytes() <= limits.attemptStoreBytes) return;
+		const protectedAttempts = new Set([...new Set(attempts.map((attempt) => attempt.threadId))].map(exportAttempt).filter((attempt) => attempt !== void 0));
+		for (const attempt of attempts) {
+			if (protectedAttempts.has(attempt)) continue;
+			attempt.messages = void 0;
+			attempt.submittedSurvey = void 0;
+			updateAttemptBytes(attempt);
+			if (retainedBytes() <= limits.attemptStoreBytes) return;
+		}
+		const protectedAttachmentKeys = new Set([...protectedAttempts].flatMap((attempt) => attempt.attachments.map((attachment) => attachment.storeKey)));
+		for (const attachment of attachments.values()) {
+			if (protectedAttachmentKeys.has(attachment.storeKey)) continue;
+			attachment.dataUrl = void 0;
+			attachment.retainedBytes = 0;
+			if (retainedBytes() <= limits.attemptStoreBytes) return;
+		}
+		for (const attachment of attachments.values()) {
+			attachment.dataUrl = void 0;
+			attachment.retainedBytes = 0;
+			if (retainedBytes() <= limits.attemptStoreBytes) return;
+		}
+		for (const protectedAttempt of protectedAttempts) {
+			protectedAttempt.messages = void 0;
+			protectedAttempt.submittedSurvey = void 0;
+			protectedAttempt.captureFailure ??= "Diagnostic content was evicted because the browser limit was reached.";
+			updateAttemptBytes(protectedAttempt);
+			if (retainedBytes() <= limits.attemptStoreBytes) return;
+		}
+	};
+	const retainAttachment = (file) => {
+		const dataUrl = typeof file.url === "string" && file.url.startsWith("data:") ? file.url : void 0;
+		const mediaType = file.mediaType || "application/octet-stream";
+		const filename = file.filename?.trim() || "Attached document";
+		const bytes = dataUrl ? getDataUrlBytes(dataUrl) : 0;
+		const sessionContentDigest = hashString(dataUrl ?? `${mediaType}\u0000${filename}\u0000${bytes}`);
+		if (dataUrl) {
+			for (const candidate of attachments.values()) if (candidate.sessionContentDigest === sessionContentDigest && candidate.mediaType === mediaType && candidate.bytes === bytes && candidate.dataUrl === dataUrl) return toAttachmentReference(candidate);
+		}
+		attachmentSequence += 1;
+		const stored = {
+			bytes,
+			filename,
+			mediaType,
+			sessionContentDigest,
+			storeKey: `${sessionContentDigest}-${attachmentSequence}`,
+			retainedBytes: dataUrl?.length ?? 0,
+			...dataUrl ? { dataUrl } : {}
+		};
+		attachments.set(stored.storeKey, stored);
+		return toAttachmentReference(stored);
+	};
+	const retainAttachmentReference = (reference) => {
+		const filename = reference.filename.trim() || "Attached document";
+		const mediaType = reference.mediaType || "application/octet-stream";
+		const sessionContentDigest = hashString(`${reference.documentId ?? "restored"}\u0000${mediaType}\u0000${filename}\u0000${reference.bytes}`);
+		attachmentSequence += 1;
+		const stored = {
+			bytes: reference.bytes,
+			filename,
+			mediaType,
+			retainedBytes: 0,
+			sessionContentDigest,
+			storeKey: `${sessionContentDigest}-${attachmentSequence}`
+		};
+		attachments.set(stored.storeKey, stored);
+		return toAttachmentReference(stored);
+	};
+	const recordEvent = (threadId, event, fields) => {
+		const attempt = latest(threadId);
+		if (!attempt) return;
+		attempt.events.push({
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			event: event.slice(0, 80),
+			...safeEventFields(fields) ? { fields: safeEventFields(fields) } : {}
+		});
+		if (attempt.events.length > limits.attemptEvents) attempt.events.splice(0, attempt.events.length - limits.attemptEvents);
+		updateAttemptBytes(attempt);
+	};
+	return {
+		beginAttempt(input) {
+			const requestId = input.requestId ?? createSurveyAssistantDiagnosticId();
+			const attempt = {
+				attachments: [...input.files.map(retainAttachment), ...(input.attachmentReferences ?? []).map(retainAttachmentReference)],
+				events: [],
+				...input.modelId ? { modelId: input.modelId } : {},
+				requestId,
+				resourceId: input.resourceId,
+				submittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				submittedSurvey: cloneDiagnosticValue(input.submittedSurvey),
+				threadId: input.threadId,
+				retainedBytes: 0
+			};
+			updateAttemptBytes(attempt);
+			attempts.push(attempt);
+			recordEvent(input.threadId, "submission");
+			enforceLimits();
+			return requestId;
+		},
+		deleteThread(threadId) {
+			for (let index = attempts.length - 1; index >= 0; index -= 1) if (attempts[index]?.threadId === threadId) attempts.splice(index, 1);
+			removeUnreferencedAttachments();
+		},
+		getAttachment(storeKey) {
+			return attachments.get(storeKey);
+		},
+		getExportAttempt(threadId) {
+			const attempt = exportAttempt(threadId);
+			return attempt ? toPublicAttempt(attempt) : void 0;
+		},
+		recordApplyOutcome(threadId, outcome) {
+			const attempt = latest(threadId);
+			if (!attempt) return;
+			attempt.applyOutcome = cloneDiagnosticValue(outcome);
+			recordEvent(threadId, "apply-result", { status: outcome.status });
+			enforceLimits();
+		},
+		recordApplyReceipts(threadId, receipts) {
+			const attempt = latest(threadId);
+			if (!attempt) return;
+			attempt.applyReceipts = cloneDiagnosticValue(receipts);
+			recordEvent(threadId, "apply-receipts", {
+				count: receipts.length,
+				operationCount: receipts.reduce((sum, receipt) => sum + receipt.operationCount, 0)
+			});
+			enforceLimits();
+		},
+		recordEvent,
+		recordFailure(threadId, messages, error) {
+			const attempt = latest(threadId);
+			if (!attempt) return;
+			try {
+				attempt.messages = stripMessageAttachmentBytes(messages);
+				attempt.error = cloneDiagnosticValue(error);
+				recordEvent(threadId, "failure", {
+					code: error.code,
+					httpStatus: error.upstreamStatus,
+					retryable: error.retryable
+				});
+				enforceLimits();
+			} catch {
+				attempt.messages = void 0;
+				attempt.captureFailure = "The failed assistant messages could not be captured.";
+				recordEvent(threadId, "capture-failed");
+			}
+		},
+		recordTurnFinal(threadId, turnFinal) {
+			const attempt = latest(threadId);
+			if (!attempt) return;
+			attempt.turnFinal = cloneDiagnosticValue(turnFinal);
+			recordEvent(threadId, "turn-final", {
+				durationMs: turnFinal.durationMs,
+				status: turnFinal.status,
+				turnId: turnFinal.turnId
+			});
+			enforceLimits();
+		}
+	};
+};
+//#endregion
+//#region package.json
+var version = "0.8.0";
+//#endregion
+//#region src/react/support-bundle.ts
+const SURVEY_ASSISTANT_DEFAULT_SUPPORT_BUNDLE_SELECTION = {
+	attachments: true,
+	conversation: true,
+	survey: true
+};
+const isSurveyAssistantSupportBundleEnabled = (config) => config?.enabled !== false;
+const assertSurveyAssistantSupportBundleEnabled = (config) => {
+	if (!isSurveyAssistantSupportBundleEnabled(config)) throw new Error("Support bundle export is disabled by host configuration.");
+};
+const encoder = new TextEncoder();
+const encodeJson = (value) => encoder.encode(JSON.stringify(value));
+const abortIfNeeded = (signal) => {
+	if (signal?.aborted) throw new DOMException("Support bundle preparation was cancelled.", "AbortError");
+};
+const sanitizeValue = (value, state, parent, key, depth = 0) => {
+	state.nodes += 1;
+	if (state.nodes > 1e5) {
+		state.redactions += 1;
+		state.truncated = true;
+		return { redacted: "node-limit" };
+	}
+	if (depth > 32) {
+		state.redactions += 1;
+		state.truncated = true;
+		return { redacted: "depth-limit" };
+	}
+	const binaryMarker = getSurveyAssistantEmbeddedBinaryMarker(value, parent, key);
+	if (binaryMarker) {
+		state.redactions += 1;
+		return binaryMarker;
+	}
+	if (key && isSurveyAssistantSensitiveMetadataKey(key)) {
+		state.redactions += 1;
+		return { redacted: "sensitive-field" };
+	}
+	if (typeof value === "string") {
+		const redacted = redactSurveyAssistantDiagnosticSecrets(value);
+		if (redacted !== value) state.redactions += 1;
+		return redacted.length > 2e5 ? `${redacted.slice(0, 199999)}…` : redacted;
+	}
+	if (value === null || typeof value === "number" || typeof value === "boolean") return value;
+	if (value === void 0) return void 0;
+	if (Array.isArray(value)) {
+		if (value.length > 2e4) state.truncated = true;
+		return value.slice(0, 2e4).map((item) => sanitizeValue(item, state, void 0, void 0, depth + 1));
+	}
+	if (typeof value !== "object") return String(value);
+	const record = value;
+	const sanitized = {};
+	const entries = Object.entries(record);
+	if (entries.length > 2e4) state.truncated = true;
+	for (const [childKey, childValue] of entries.slice(0, 2e4)) sanitized[childKey] = sanitizeValue(childValue, state, record, childKey, depth + 1);
+	return sanitized;
+};
+const sanitizeSurveyAssistantSupportValue = (value) => {
+	const state = {
+		nodes: 0,
+		redactions: 0,
+		truncated: false
+	};
+	const sanitized = sanitizeValue(value, state);
+	return {
+		redactions: state.redactions,
+		truncated: state.truncated,
+		value: sanitized
+	};
+};
+const createJsonEntry = (path, category, source, value) => {
+	const state = {
+		nodes: 0,
+		redactions: 0,
+		truncated: false
+	};
+	const sanitized = sanitizeValue(value, state);
+	return {
+		bytes: encodeJson({
+			redactions: state.redactions,
+			truncated: state.truncated,
+			value: sanitized
+		}),
+		category,
+		path,
+		source
+	};
+};
+const snapshotVersion = (snapshot) => snapshot?.version;
+const extensionForMediaType = (mediaType) => {
+	switch (mediaType.toLocaleLowerCase()) {
+		case "application/pdf": return ".pdf";
+		case "image/jpeg": return ".jpg";
+		case "image/png": return ".png";
+		default: return ".bin";
+	}
+};
+const sanitizeFilename = (filename, mediaType) => {
+	const extension = extensionForMediaType(mediaType);
+	return `${filename.replace(/\.[a-z0-9]{1,10}$/i, "").normalize("NFKD").replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[._-]+|[._-]+$/g, "").slice(0, 100) || "attachment"}${extension}`;
+};
+const disambiguateFilenames = (files) => {
+	const used = /* @__PURE__ */ new Set();
+	return files.map((file) => {
+		const sanitized = sanitizeFilename(file.filename, file.mediaType);
+		const dot = sanitized.lastIndexOf(".");
+		const stem = dot > 0 ? sanitized.slice(0, dot) : sanitized;
+		const extension = dot > 0 ? sanitized.slice(dot) : "";
+		let candidate = sanitized;
+		let index = 2;
+		while (used.has(candidate.toLocaleLowerCase())) {
+			candidate = `${stem}-${index}${extension}`;
+			index += 1;
+		}
+		used.add(candidate.toLocaleLowerCase());
+		return candidate;
+	});
+};
+const dataUrlToBytes = (dataUrl) => {
+	const comma = dataUrl.indexOf(",");
+	if (comma < 0) return encoder.encode(dataUrl);
+	const metadata = dataUrl.slice(0, comma);
+	const payload = dataUrl.slice(comma + 1);
+	if (!/;base64$/i.test(metadata)) return encoder.encode(decodeURIComponent(payload));
+	const decoded = globalThis.atob(payload);
+	const bytes = new Uint8Array(decoded.length);
+	for (let index = 0; index < decoded.length; index += 1) bytes[index] = decoded.charCodeAt(index);
+	return bytes;
+};
+const pushPreparedEntry = (entries, unavailable, entry, limits) => {
+	if (entry.bytes.byteLength > limits.zipEntryBytes) {
+		unavailable.push({
+			bytes: entry.bytes.byteLength,
+			category: entry.category,
+			path: entry.path,
+			reason: "too-large"
+		});
+		return;
+	}
+	entries.push(entry);
+};
+const prepareSurveyAssistantSupportBundle = async ({ config, controller, diagnosticStore, resourceId, signal, threadClient, threadId }) => {
+	assertSurveyAssistantSupportBundleEnabled(config);
+	const limits = resolveSurveyAssistantSupportBundleLimits(config?.limits);
+	const entries = [];
+	const unavailable = [];
+	const attempt = diagnosticStore.getExportAttempt(threadId);
+	const currentSurveyCapturedAt = (/* @__PURE__ */ new Date()).toISOString();
+	let currentSurvey = null;
+	try {
+		currentSurvey = controller?.getSnapshot() ?? null;
+		if (currentSurvey) currentSurvey = typeof structuredClone === "function" ? structuredClone(currentSurvey) : JSON.parse(JSON.stringify(currentSurvey));
+	} catch {
+		unavailable.push({
+			category: "survey",
+			reason: "capture-failed",
+			path: "survey/current-survey.json"
+		});
+	}
+	abortIfNeeded(signal);
+	if (!attempt) unavailable.push({
+		category: "conversation",
+		path: "conversation/attempt-messages.json",
+		reason: "no-attempt-retained"
+	}, {
+		category: "conversation",
+		path: "diagnostics/client-apply-outcome.json",
+		reason: "no-attempt-retained"
+	}, {
+		category: "conversation",
+		path: "diagnostics/client-apply-receipts.json",
+		reason: "no-attempt-retained"
+	}, {
+		category: "attachments",
+		reason: "no-attempt-retained"
+	});
+	if (attempt?.messages) pushPreparedEntry(entries, unavailable, createJsonEntry("conversation/attempt-messages.json", "conversation", "browser-session", attempt.messages), limits);
+	else if (attempt?.captureFailure) unavailable.push({
+		category: "conversation",
+		reason: "capture-failed",
+		path: "conversation/attempt-messages.json"
+	});
+	else if (attempt) unavailable.push({
+		category: "conversation",
+		reason: "not-retained",
+		path: "conversation/attempt-messages.json"
+	});
+	if (attempt?.applyOutcome) pushPreparedEntry(entries, unavailable, createJsonEntry("diagnostics/client-apply-outcome.json", "conversation", "browser-session", attempt.applyOutcome), limits);
+	if (attempt?.applyReceipts) pushPreparedEntry(entries, unavailable, createJsonEntry("diagnostics/client-apply-receipts.json", "conversation", "browser-session", attempt.applyReceipts), limits);
+	const transcriptMessages = [];
+	let transcriptBytes = 0;
+	let transcriptCursor;
+	let transcriptRedactions = 0;
+	let transcriptTruncated = false;
+	try {
+		for (let page = 0; page < limits.transcriptPages; page += 1) {
+			abortIfNeeded(signal);
+			const transcript = await threadClient.read(threadId, transcriptCursor, { signal });
+			abortIfNeeded(signal);
+			const pageState = {
+				nodes: 0,
+				redactions: 0,
+				truncated: false
+			};
+			const sanitizedPage = sanitizeValue(transcript.messages, pageState);
+			transcriptRedactions += pageState.redactions;
+			transcriptTruncated ||= pageState.truncated;
+			const pageMessages = Array.isArray(sanitizedPage) ? sanitizedPage : [];
+			const pageBytes = encodeJson(pageMessages).byteLength;
+			if (transcriptMessages.length + pageMessages.length > limits.transcriptMessages || transcriptBytes + pageBytes > limits.transcriptBytes) {
+				transcriptTruncated = true;
+				break;
+			}
+			transcriptMessages.unshift(...pageMessages);
+			transcriptBytes += pageBytes;
+			transcriptCursor = transcript.nextCursor;
+			if (!transcriptCursor) break;
+			if (page === limits.transcriptPages - 1) transcriptTruncated = true;
+		}
+		pushPreparedEntry(entries, unavailable, {
+			bytes: encodeJson({
+				messages: transcriptMessages,
+				redactions: transcriptRedactions,
+				truncated: transcriptTruncated
+			}),
+			category: "conversation",
+			path: "conversation/transcript.json",
+			source: "authorized-transcript"
+		}, limits);
+	} catch (error) {
+		if (signal?.aborted) throw error;
+		unavailable.push({
+			category: "conversation",
+			reason: "unavailable",
+			path: "conversation/transcript.json"
+		});
+	}
+	if (attempt?.submittedSurvey !== void 0) pushPreparedEntry(entries, unavailable, createJsonEntry("survey/submitted-survey.json", "survey", "browser-session", {
+		snapshot: attempt.submittedSurvey,
+		version: snapshotVersion(attempt.submittedSurvey)
+	}), limits);
+	else unavailable.push({
+		category: "survey",
+		reason: attempt ? "not-retained" : "no-attempt-retained",
+		path: "survey/submitted-survey.json"
+	});
+	if (currentSurvey) pushPreparedEntry(entries, unavailable, createJsonEntry("survey/current-survey.json", "survey", "browser-session", {
+		capturedAt: currentSurveyCapturedAt,
+		snapshot: currentSurvey,
+		version: snapshotVersion(currentSurvey)
+	}), limits);
+	if (attempt) {
+		const availableAttachments = attempt.attachments.map((reference) => ({
+			reference,
+			stored: diagnosticStore.getAttachment(reference.storeKey)
+		})).filter((item) => Boolean(item.stored?.dataUrl));
+		const filenames = disambiguateFilenames(availableAttachments.map(({ reference }) => reference));
+		for (const [index, { reference, stored }] of availableAttachments.entries()) {
+			abortIfNeeded(signal);
+			const bytes = dataUrlToBytes(stored.dataUrl);
+			pushPreparedEntry(entries, unavailable, {
+				bytes,
+				category: "attachments",
+				path: `attachments/${filenames[index]}`,
+				source: "browser-session"
+			}, limits);
+		}
+		for (const reference of attempt.attachments) if (!diagnosticStore.getAttachment(reference.storeKey)?.dataUrl) unavailable.push({
+			bytes: reference.bytes,
+			category: "attachments",
+			filename: reference.filename,
+			mediaType: reference.mediaType,
+			reason: "not-retained"
+		});
+	}
+	const categoryBytes = {
+		attachments: 0,
+		conversation: 0,
+		survey: 0
+	};
+	for (const entry of entries) categoryBytes[entry.category] += entry.bytes.byteLength;
+	return {
+		attempt,
+		categoryBytes,
+		currentSurveyCapturedAt,
+		entries,
+		limits,
+		resourceId,
+		threadId,
+		unavailable
+	};
+};
+const validateZipPath = (path) => {
+	if (!path || path.startsWith("/") || path.includes("\\") || path.split("/").includes("..")) throw new Error(`Unsafe support-bundle ZIP path: ${path}`);
+};
+const toBlobPart = (bytes) => {
+	if (bytes.buffer instanceof ArrayBuffer && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) return bytes.buffer;
+	return bytes.slice().buffer;
+};
+const createZipBlob = (entries) => {
+	const paths = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		validateZipPath(entry.path);
+		if (paths.has(entry.path)) throw new Error(`Duplicate support-bundle ZIP path: ${entry.path}`);
+		paths.add(entry.path);
+	}
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		const zip = new Zip((error, data, final) => {
+			if (error) {
+				reject(error);
+				return;
+			}
+			chunks.push(toBlobPart(data));
+			if (final) resolve(new Blob(chunks, { type: "application/zip" }));
+		});
+		try {
+			for (const entry of entries) {
+				const file = new ZipPassThrough(entry.path);
+				zip.add(file);
+				file.push(entry.bytes, true);
+			}
+			zip.end();
+		} catch (error) {
+			zip.terminate();
+			reject(error);
+		}
+	});
+};
+const categoryDescriptors = (prepared, selection) => Object.keys(selection).map((category) => {
+	const entries = prepared.entries.filter((entry) => entry.category === category);
+	return selection[category] ? {
+		category,
+		included: true,
+		itemCount: entries.length,
+		totalBytes: entries.reduce((total, entry) => total + entry.bytes.byteLength, 0),
+		entries: entries.map((entry) => ({
+			bytes: entry.bytes.byteLength,
+			path: entry.path,
+			source: entry.source
+		}))
+	} : {
+		category,
+		included: false,
+		itemCount: entries.length,
+		totalBytes: entries.reduce((total, entry) => total + entry.bytes.byteLength, 0)
+	};
+});
+const createAttemptMetadata = (prepared, selection) => {
+	const attempt = prepared.attempt;
+	return {
+		attemptAvailable: Boolean(attempt),
+		...attempt ? {
+			captureFailure: attempt.captureFailure,
+			error: attempt.error,
+			events: attempt.events,
+			modelId: attempt.modelId,
+			requestId: attempt.requestId,
+			resourceId: attempt.resourceId,
+			submittedAt: attempt.submittedAt,
+			threadId: attempt.threadId,
+			turnFinal: attempt.turnFinal
+		} : { threadId: prepared.threadId },
+		categories: categoryDescriptors(prepared, selection)
+	};
+};
+const encodeSanitizedJson = (value) => encodeJson(sanitizeSurveyAssistantSupportValue(value).value);
+const createRequiredEntries = (prepared, selection, config, generatedAt) => {
+	const descriptors = categoryDescriptors(prepared, selection);
+	const unavailable = Object.keys(selection).flatMap((category) => {
+		const categoryUnavailable = prepared.unavailable.filter((item) => item.category === category);
+		if (categoryUnavailable.length === 0) return [];
+		if (selection[category]) return categoryUnavailable;
+		return [{
+			category,
+			itemCount: categoryUnavailable.length,
+			totalBytes: categoryUnavailable.reduce((total, item) => total + (item.bytes ?? 0), 0)
+		}];
+	});
+	const manifest = {
+		schemaVersion: 1,
+		generatedAt,
+		packageVersion: config?.packageVersion ?? version,
+		hostBuildVersion: config?.hostBuildVersion,
+		resourceId: prepared.resourceId,
+		threadId: prepared.threadId,
+		requestId: prepared.attempt?.requestId,
+		turnId: prepared.attempt?.turnFinal?.turnId,
+		modelId: prepared.attempt?.modelId,
+		categories: descriptors,
+		unavailable,
+		currentSurveyCapturedAt: prepared.currentSurveyCapturedAt
+	};
+	const readme = [
+		"CASE Survey Assistant support bundle",
+		"",
+		`Generated: ${generatedAt}`,
+		"This archive contains diagnostic data selected by the user, including visible model reasoning when conversation data is included.",
+		"Nothing was uploaded or emailed automatically.",
+		"See manifest.json for the authoritative inventory and availability information.",
+		"Treat the archive as potentially sensitive."
+	].join("\n");
+	return [
+		{
+			bytes: encodeSanitizedJson(manifest),
+			path: "manifest.json"
+		},
+		{
+			bytes: encoder.encode(readme),
+			path: "README.txt"
+		},
+		{
+			bytes: encodeSanitizedJson(createAttemptMetadata(prepared, selection)),
+			path: "diagnostics/client-attempt.json"
+		}
+	];
+};
+const estimateArchiveBytes = (entries) => entries.reduce((total, entry) => total + entry.bytes.byteLength + encoder.encode(entry.path).byteLength * 2 + 110, 22);
+const estimateSurveyAssistantSupportBundleBytes = (prepared, selection, config) => {
+	if (!isSurveyAssistantSupportBundleEnabled(config)) return 0;
+	const entries = [...createRequiredEntries(prepared, selection, config, (/* @__PURE__ */ new Date()).toISOString()), ...prepared.entries.filter((entry) => selection[entry.category]).map(({ bytes, path }) => ({
+		bytes,
+		path
+	}))];
+	return estimateArchiveBytes(entries);
+};
+const generateSurveyAssistantSupportBundle = async (prepared, selection, config) => {
+	assertSurveyAssistantSupportBundleEnabled(config);
+	const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const selectedEntries = prepared.entries.filter((entry) => selection[entry.category]);
+	const allEntries = [...createRequiredEntries(prepared, selection, config, generatedAt), ...selectedEntries.map(({ bytes, path }) => ({
+		bytes,
+		path
+	}))];
+	if (estimateArchiveBytes(allEntries) > prepared.limits.bundleBytes) throw new Error("The selected support-bundle data exceeds the configured bundle limit.");
+	const blob = await createZipBlob(allEntries);
+	if (blob.size > prepared.limits.bundleBytes) throw new Error("The selected support-bundle data exceeds the configured bundle limit.");
+	return {
+		blob,
+		filename: `case-survey-assistant-support-${(prepared.attempt?.requestId ?? prepared.attempt?.turnFinal?.turnId ?? "unidentified").replace(/[^A-Za-z0-9_-]/g, "-").slice(0, 64) || "unidentified"}-${generatedAt.replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z")}.zip`,
+		generatedAt,
+		includedCategories: Object.keys(selection).filter((category) => selection[category]),
+		size: blob.size
+	};
+};
+const downloadSurveyAssistantSupportBundle = (bundle) => {
+	const url = URL.createObjectURL(bundle.blob);
+	const anchor = document.createElement("a");
+	anchor.href = url;
+	anchor.download = bundle.filename;
+	anchor.style.display = "none";
+	document.body.append(anchor);
+	anchor.click();
+	anchor.remove();
+	window.setTimeout(() => URL.revokeObjectURL(url), 0);
+};
+const createSurveyAssistantSupportDetails = ({ bundle, prepared }) => [
+	`File: ${bundle.filename}`,
+	`Request: ${prepared.attempt?.requestId ?? "unavailable"}`,
+	`Model: ${prepared.attempt?.modelId ?? "unavailable"}`,
+	`Error category: ${prepared.attempt?.error?.code ?? "unavailable"}`,
+	`Generated: ${bundle.generatedAt}`
+].join("\n");
+const createSurveyAssistantSupportMailto = ({ bundle, config, prepared }) => {
+	if (!isSurveyAssistantSupportBundleEnabled(config)) return void 0;
+	if (!config.supportEmail?.trim()) return void 0;
+	const subject = `${config.subjectPrefix?.trim() || "CASE Survey Assistant support"} ${prepared.attempt?.requestId ?? ""}`.trim();
+	const body = [
+		"IMPORTANT: ATTACH THE DOWNLOADED ZIP FILE TO THIS EMAIL BEFORE SENDING.",
+		"",
+		"A Survey Assistant support bundle has been downloaded for this issue.",
+		"",
+		createSurveyAssistantSupportDetails({
+			bundle,
+			prepared
+		})
+	].join("\n");
+	return `mailto:${encodeURIComponent(config.supportEmail.trim())}?subject=${encodeURIComponent(subject)}&body=${encodeURIComponent(body)}`;
+};
+//#endregion
+//#region src/react/model-catalog.ts
+const DEFAULT_MODEL_STORAGE_KEY = "survey-assistant-selected-model";
+const createSurveyAssistantModelCatalogClient = (api = "/api/survey-assistant/models") => ({ async get() {
+	const body = await readSurveyAssistantJson(await fetch(api, { cache: "no-store" }), "The assistant model catalog could not be loaded.");
+	return surveyAssistantModelCatalogSchema.parse(body);
+} });
+const useSurveyAssistantModelCatalog = ({ api, client: providedClient, onModelChange, storageKey = DEFAULT_MODEL_STORAGE_KEY } = {}) => {
+	const [models, setModels] = useState([]);
+	const [modelId, setModelId] = useState();
+	const [error, setError] = useState(null);
+	const [loading, setLoading] = useState(true);
+	const [reloadToken, setReloadToken] = useState(0);
+	useEffect(() => {
+		let cancelled = false;
+		const client = providedClient ?? createSurveyAssistantModelCatalogClient(api);
+		setLoading(true);
+		setError(null);
+		client.get().then((catalog) => {
+			if (cancelled) return;
+			const rememberedId = storageKey && typeof window !== "undefined" ? window.localStorage.getItem(storageKey) ?? void 0 : void 0;
+			const selectedId = rememberedId && catalog.models.some((model) => model.id === rememberedId) ? rememberedId : catalog.defaultModelId;
+			setModels(catalog.models);
+			setModelId(selectedId);
+			onModelChange?.(selectedId);
+		}).catch((reason) => {
+			if (!cancelled) setError(reason instanceof Error ? reason : new Error(String(reason)));
+		}).finally(() => {
+			if (!cancelled) setLoading(false);
+		});
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		api,
+		onModelChange,
+		providedClient,
+		reloadToken,
+		storageKey
+	]);
+	const selectModel = useCallback((nextModelId) => {
+		if (!models.some((model) => model.id === nextModelId)) return;
+		setModelId(nextModelId);
+		if (storageKey && typeof window !== "undefined") window.localStorage.setItem(storageKey, nextModelId);
+		onModelChange?.(nextModelId);
+	}, [
+		models,
+		onModelChange,
+		storageKey
+	]);
+	return {
+		error,
+		loading,
+		modelId,
+		models,
+		reload: useCallback(() => setReloadToken((current) => current + 1), []),
+		selectModel
+	};
+};
+//#endregion
+//#region src/react/document-baseline.ts
+const STORAGE_PREFIX = "case-survey-assistant:settled-document:";
+const memoryBaselines = /* @__PURE__ */ new Map();
+const getStorageKey = (resourceId, threadId) => `${STORAGE_PREFIX}${encodeURIComponent(resourceId)}:${encodeURIComponent(threadId)}`;
+const getSessionStorage = () => {
+	if (typeof document === "undefined") return void 0;
+	try {
+		return window.sessionStorage;
+	} catch {
+		return;
+	}
+};
+const readSettledDocumentVersion = ({ resourceId, threadId }) => {
+	const storageKey = getStorageKey(resourceId, threadId);
+	const storedInMemory = memoryBaselines.get(storageKey);
+	if (storedInMemory) return { ...storedInMemory };
+	const serialized = getSessionStorage()?.getItem(storageKey);
+	if (!serialized) return void 0;
+	try {
+		const parsed = surveyDocumentVersionSchema.safeParse(JSON.parse(serialized));
+		if (!parsed.success) return void 0;
+		memoryBaselines.set(storageKey, parsed.data);
+		return { ...parsed.data };
+	} catch {
+		return;
+	}
+};
+const writeSettledDocumentVersion = ({ resourceId, snapshot, threadId }) => {
+	const storageKey = getStorageKey(resourceId, threadId);
+	const version = surveyDocumentVersionSchema.parse(snapshot.version);
+	memoryBaselines.set(storageKey, version);
+	try {
+		getSessionStorage()?.setItem(storageKey, JSON.stringify(version));
+	} catch {}
+};
+//#endregion
+//#region src/react/use-survey-assistant-session.ts
+const createLocalId = (prefix) => {
+	return createSurveyAssistantDiagnosticId(prefix);
+};
+const compactOutcomeText = (value, maximum, fallback) => {
+	const normalized = value.trim() || fallback;
+	return normalized.length > maximum ? `${normalized.slice(0, maximum - 1)}…` : normalized;
+};
+const createApplyOutcome = ({ message, preparedChanges, results, status, turnId }) => surveyAssistantApplyOutcomeSchema.parse({
+	protocolVersion: 1,
+	turnId,
+	status,
+	message: compactOutcomeText(message, 2e3, "No lifecycle detail was reported."),
+	...results && results.length > 0 ? { results: results.slice(0, 100).map((result) => ({
+		status: result.status,
+		changeId: compactOutcomeText(result.changeId, 240, "unknown-change"),
+		summary: compactOutcomeText(result.summary, 500, "Survey change"),
+		message: compactOutcomeText(result.message, 2e3, "No apply detail was reported."),
+		appliedOperations: result.appliedOperations
+	})) } : {},
+	...preparedChanges && preparedChanges.length > 0 ? { preparedChanges: preparedChanges.slice(-24).map((change) => ({
+		changeId: compactOutcomeText(change.id, 240, "unknown-change"),
+		status: change.status,
+		summary: compactOutcomeText(change.summary, 500, "Survey change"),
+		operationCount: change.operations.length
+	})) } : {},
+	createdAt: (/* @__PURE__ */ new Date()).toISOString()
+});
+const getAssistantTextParts = (message) => message.parts.filter((part) => part.type === "text" && part.text.trim().length > 0);
+const findLastAssistantTextMessageIndex = (messages, endExclusive = messages.length) => {
+	for (let index = Math.min(messages.length, endExclusive) - 1; index >= 0; index -= 1) {
+		const message = messages[index];
+		if (message?.role === "assistant" && getAssistantTextParts(message).length > 0) return index;
+	}
+	return -1;
+};
+const findLastUserMessageIndex = (messages) => {
+	for (let index = messages.length - 1; index >= 0; index -= 1) if (messages[index]?.role === "user") return index;
+	return -1;
+};
+const pruneFailedMessagesForDisplay = (messages) => {
+	const lastUserIndex = findLastUserMessageIndex(messages);
+	const lastCompletedAssistantIndex = findLastAssistantTextMessageIndex(messages);
+	if (lastUserIndex > lastCompletedAssistantIndex) return messages.slice(0, lastUserIndex + 1);
+	return lastCompletedAssistantIndex >= 0 ? messages.slice(0, lastCompletedAssistantIndex + 1) : [];
+};
+const hasCompletedAssistantResponseAfterLastUser = (messages) => {
+	const lastUserIndex = findLastUserMessageIndex(messages);
+	return lastUserIndex >= 0 && findLastAssistantTextMessageIndex(messages) > lastUserIndex;
+};
+const collectChangeSetsAfterLastUser = (messages) => {
+	const lastUserIndex = findLastUserMessageIndex(messages);
+	return lastUserIndex < 0 ? [] : collectSurveyChangeSets(messages.slice(lastUserIndex + 1));
+};
+const getInitialSessionState = (messages) => {
+	if (messages.length === 0) return "idle";
+	const authorization = resolveLatestSurveyTurnAuthorization(messages);
+	if (authorization.status === "failed") return "failed";
+	if (authorization.status === "aborted") return "aborted";
+	return "completed";
+};
+const resolveSurveyAssistantReviewDecision = async ({ changeSets, onReviewChangeSets, turnFinal }) => {
+	if (!onReviewChangeSets) throw new Error("No survey assistant review adapter is available.");
+	return onReviewChangeSets(changeSets, turnFinal);
+};
+const useSurveyAssistantSession = ({ api, applyPolicy, controller, diagnosticStore, initialMessages = [], modelId, onApplyReceipts, onSettleApply, onReviewChangeSets, onTurnActiveChange, resourceId: controlledResourceId, surveyId, threadId: controlledThreadId }) => {
+	const [localResourceId] = useState(() => createLocalId("survey-assistant-local-user"));
+	const [localThreadId] = useState(() => createLocalId("survey-assistant-local-thread"));
+	const resourceId = controlledResourceId ?? localResourceId;
+	const threadId = controlledThreadId ?? localThreadId;
+	const applyOutcomeScopeKey = `${resourceId}\u0000${threadId}`;
+	const [state, dispatch] = useReducer(reduceSurveyAssistantSessionState, initialMessages, getInitialSessionState);
+	const [applyResultsByChangeId, setApplyResultsByChangeId] = useState({});
+	const [authorizationError, setAuthorizationError] = useState(null);
+	const handledTurnIdsRef = useRef(/* @__PURE__ */ new Set());
+	const localTurnAwaitingApplyRef = useRef(false);
+	const turnOwnedRef = useRef(false);
+	const turnGenerationRef = useRef(0);
+	const mountedRef = useRef(false);
+	const localTurnStreamStartedRef = useRef(false);
+	const captureSettledVersionRef = useRef(false);
+	const lastSubmittedUIContextRef = useRef(void 0);
+	const lastSubmittedModelIdRef = useRef(void 0);
+	const previousApplyOutcomesRef = useRef(/* @__PURE__ */ new Map());
+	const capturedChatErrorRef = useRef(void 0);
+	const submittedDocumentSessionIdRef = useRef(void 0);
+	const previousAssistantMessageRef = useRef(void 0);
+	const controllerRef = useRef(controller);
+	const invalidateTurn = useCallback(() => {
+		turnGenerationRef.current += 1;
+		turnOwnedRef.current = false;
+		localTurnAwaitingApplyRef.current = false;
+		localTurnStreamStartedRef.current = false;
+		captureSettledVersionRef.current = false;
+	}, []);
+	const sessionScope = JSON.stringify([
+		api,
+		resourceId,
+		surveyId,
+		threadId
+	]);
+	const previousSessionScopeRef = useRef(sessionScope);
+	useLayoutEffect(() => {
+		mountedRef.current = true;
+		if (previousSessionScopeRef.current !== sessionScope) {
+			previousSessionScopeRef.current = sessionScope;
+			dispatch({
+				type: "reset",
+				hasTranscript: initialMessages.length > 0
+			});
+			setApplyResultsByChangeId({});
+			setAuthorizationError(null);
+			handledTurnIdsRef.current.clear();
+			previousApplyOutcomesRef.current.clear();
+			lastSubmittedUIContextRef.current = void 0;
+			lastSubmittedModelIdRef.current = void 0;
+			submittedDocumentSessionIdRef.current = void 0;
+			previousAssistantMessageRef.current = void 0;
+			capturedChatErrorRef.current = void 0;
+		}
+		return () => {
+			mountedRef.current = false;
+			invalidateTurn();
+		};
+	}, [sessionScope, invalidateTurn]);
+	useLayoutEffect(() => {
+		controllerRef.current = controller;
+		if (!turnOwnedRef.current) return;
+		try {
+			if (controller?.getSnapshot()?.version.sessionId === submittedDocumentSessionIdRef.current) return;
+		} catch {}
+		invalidateTurn();
+		dispatch({ type: "aborted" });
+	}, [controller, invalidateTurn]);
+	const transport = useMemo(() => createSurveyAssistantTransport({
+		api,
+		resourceId,
+		surveyId,
+		threadId
+	}), [
+		api,
+		resourceId,
+		surveyId,
+		threadId
+	]);
+	const { messages, setMessages, sendMessage, status, stop: stopChat, error, clearError, regenerate } = useChat({
+		id: threadId,
+		messages: initialMessages,
+		transport
+	});
+	const isStreaming = status === "submitted" || status === "streaming";
+	const messagesRef = useRef(messages);
+	useLayoutEffect(() => {
+		messagesRef.current = messages;
+	}, [messages]);
+	const isTurnActive = isSurveyAssistantTurnActive({
+		isStreaming,
+		state
+	});
+	const notifyTurnActiveChange = useEffectEvent((active) => {
+		onTurnActiveChange?.(active);
+	});
+	const prependMessages = useCallback((olderMessages) => {
+		setMessages((current) => {
+			const currentIds = new Set(current.map((message) => message.id));
+			return [...olderMessages.filter((message) => !currentIds.has(message.id)), ...current];
+		});
+	}, [setMessages]);
+	const turnAuthorization = useMemo(() => resolveLatestSurveyTurnAuthorization(messages), [messages]);
+	const latestTurnOutcome = useMemo(() => resolveSurveyTurnOutcome({
+		applyResultsByChangeId,
+		authorization: turnAuthorization
+	}), [applyResultsByChangeId, turnAuthorization]);
+	const hasUsefulLatestAssistantResponse = useMemo(() => hasCompletedAssistantResponseAfterLastUser(messages) || collectChangeSetsAfterLastUser(messages).length > 0, [messages]);
+	const reportAuthorizationError = useCallback((message) => {
+		try {
+			diagnosticStore?.recordFailure(threadId, messagesRef.current, {
+				code: "request_failed",
+				detail: message,
+				retryable: false
+			});
+		} catch {}
+		const generation = turnGenerationRef.current;
+		queueMicrotask(() => {
+			if (!mountedRef.current || turnGenerationRef.current !== generation) return;
+			setAuthorizationError(message);
+			dispatch({ type: "failed" });
+		});
+	}, [diagnosticStore, threadId]);
+	const rememberApplyOutcome = useCallback((outcome) => {
+		previousApplyOutcomesRef.current.set(applyOutcomeScopeKey, outcome);
+		try {
+			diagnosticStore?.recordApplyOutcome(threadId, outcome);
+		} catch {}
+	}, [
+		applyOutcomeScopeKey,
+		diagnosticStore,
+		threadId
+	]);
+	useEffect(() => {
+		if (status === "submitted") dispatch({ type: "submit" });
+		if (status === "streaming") dispatch({ type: "stream-started" });
+	}, [status]);
+	useEffect(() => {
+		notifyTurnActiveChange(isTurnActive);
+		return () => {
+			if (isTurnActive) notifyTurnActiveChange(false);
+		};
+	}, [isTurnActive]);
+	useEffect(() => {
+		if (isStreaming || state !== "completed" && state !== "failed" && state !== "aborted" && state !== "applied") return;
+		turnOwnedRef.current = false;
+		if (!captureSettledVersionRef.current) return;
+		captureSettledVersionRef.current = false;
+		try {
+			const snapshot = controller?.getSnapshot();
+			if (snapshot && snapshot.version.sessionId === submittedDocumentSessionIdRef.current) writeSettledDocumentVersion({
+				resourceId,
+				snapshot,
+				threadId
+			});
+		} catch {}
+	}, [
+		controller,
+		isStreaming,
+		resourceId,
+		state,
+		threadId
+	]);
+	useEffect(() => {
+		if (isStreaming) {
+			localTurnStreamStartedRef.current = true;
+			return;
+		}
+		if (!localTurnAwaitingApplyRef.current) return;
+		if (!localTurnStreamStartedRef.current && [...messages].reverse().find((message) => message.role === "assistant") === previousAssistantMessageRef.current) return;
+		if ("turnFinal" in turnAuthorization && handledTurnIdsRef.current.has(turnAuthorization.turnFinal.turnId)) return;
+		if (turnAuthorization.status === "pending") {
+			if (!localTurnStreamStartedRef.current) return;
+			const timeoutId = window.setTimeout(() => {
+				if (capturedChatErrorRef.current) return;
+				localTurnAwaitingApplyRef.current = false;
+				localTurnStreamStartedRef.current = false;
+				reportAuthorizationError("The assistant response ended without a valid turn final.");
+			}, 100);
+			return () => window.clearTimeout(timeoutId);
+		}
+		localTurnAwaitingApplyRef.current = false;
+		localTurnStreamStartedRef.current = false;
+		if (turnAuthorization.status === "invalid") {
+			reportAuthorizationError(turnAuthorization.reason);
+			return;
+		}
+		const { turnFinal } = turnAuthorization;
+		try {
+			diagnosticStore?.recordTurnFinal(threadId, turnFinal);
+		} catch {}
+		if (handledTurnIdsRef.current.has(turnFinal.turnId)) return;
+		handledTurnIdsRef.current.add(turnFinal.turnId);
+		const preparedChanges = collectChangeSetsAfterLastUser(messages).filter((change) => change.turnId === turnFinal.turnId);
+		if (turnAuthorization.status === "failed") {
+			rememberApplyOutcome(createApplyOutcome({
+				turnId: turnFinal.turnId,
+				status: "not-applied",
+				message: "The previous assistant turn failed before editor authorization. Every request-scoped draft change from that turn was discarded and was not applied.",
+				preparedChanges
+			}));
+			dispatch({ type: "failed" });
+			return;
+		}
+		if (turnAuthorization.status === "aborted") {
+			rememberApplyOutcome(createApplyOutcome({
+				turnId: turnFinal.turnId,
+				status: "not-applied",
+				message: "The previous assistant turn was interrupted before editor authorization. Every request-scoped draft change from that turn was discarded and was not applied.",
+				preparedChanges
+			}));
+			dispatch({ type: "aborted" });
+			return;
+		}
+		if (turnAuthorization.changeSets.length === 0) {
+			if ((turnFinal.blockedChangeSetIds?.length ?? 0) > 0) rememberApplyOutcome(createApplyOutcome({
+				turnId: turnFinal.turnId,
+				status: "not-applied",
+				message: "The previous assistant turn ended with unresolved rejected changes. No request-scoped draft change from that turn was authorized or applied.",
+				preparedChanges
+			}));
+			dispatch({ type: "completed" });
+			return;
+		}
+		if (applyPolicy === "deny") {
+			rememberApplyOutcome(createApplyOutcome({
+				turnId: turnFinal.turnId,
+				status: "not-applied",
+				message: "The host apply policy did not authorize editor mutations for this turn.",
+				preparedChanges
+			}));
+			dispatch({ type: "completed" });
+			return;
+		}
+		captureSettledVersionRef.current = false;
+		const generation = turnGenerationRef.current;
+		const isCurrentTurn = () => mountedRef.current && turnGenerationRef.current === generation;
+		dispatch({ type: "apply-started" });
+		(async () => {
+			if (applyPolicy === "review") {
+				let approved;
+				try {
+					approved = await resolveSurveyAssistantReviewDecision({
+						changeSets: turnAuthorization.changeSets,
+						onReviewChangeSets,
+						turnFinal
+					});
+				} catch (error) {
+					if (!isCurrentTurn()) return;
+					const message = error instanceof Error && error.message === "No survey assistant review adapter is available." ? error.message : "The survey assistant review could not be completed.";
+					rememberApplyOutcome(createApplyOutcome({
+						turnId: turnFinal.turnId,
+						status: "not-applied",
+						message,
+						preparedChanges
+					}));
+					reportAuthorizationError(message);
+					return;
+				}
+				if (!isCurrentTurn()) return;
+				if (!approved) {
+					rememberApplyOutcome(createApplyOutcome({
+						turnId: turnFinal.turnId,
+						status: "not-applied",
+						message: "The proposed editor changes were not approved during review.",
+						preparedChanges
+					}));
+					dispatch({ type: "completed" });
+					return;
+				}
+			}
+			if (!isCurrentTurn()) return;
+			const currentController = controllerRef.current;
+			if (!currentController?.applyAssistantChanges) {
+				const message = "No survey editor apply adapter is available.";
+				rememberApplyOutcome(createApplyOutcome({
+					turnId: turnFinal.turnId,
+					status: "apply-failed",
+					message,
+					preparedChanges
+				}));
+				reportAuthorizationError(message);
+				return;
+			}
+			const results = [];
+			let applyStarted = false;
+			const hasCompleteApplyResults = () => {
+				const ids = new Set(results.map((result) => result.changeId));
+				return results.length === turnAuthorization.changeSets.length && ids.size === results.length && turnAuthorization.changeSets.every((change) => ids.has(change.id));
+			};
+			const allChangesApplied = () => hasCompleteApplyResults() && results.every((result) => result.status === "applied");
+			const retainApplyResults = () => {
+				const entries = results.map((result) => [result.changeId, result]);
+				queueMicrotask(() => {
+					if (!isCurrentTurn()) return;
+					setApplyResultsByChangeId((current) => ({
+						...current,
+						...Object.fromEntries(entries)
+					}));
+				});
+			};
+			try {
+				const beforeSnapshot = currentController.getSnapshot();
+				if (!isCurrentTurn()) return;
+				if (!beforeSnapshot) throw new Error("Editor snapshot unavailable.");
+				if (beforeSnapshot.version.sessionId !== submittedDocumentSessionIdRef.current) {
+					invalidateTurn();
+					dispatch({ type: "aborted" });
+					return;
+				}
+				if (!isCurrentTurn()) return;
+				applyStarted = true;
+				results.push(...currentController.applyAssistantChanges(turnAuthorization.changeSets).results);
+				if (!isCurrentTurn()) return;
+				retainApplyResults();
+				const receipts = createApplyReceipts({
+					beforeSnapshot,
+					afterSnapshot: currentController.getSnapshot(),
+					changeSets: turnAuthorization.changeSets,
+					results,
+					turnFinal
+				});
+				try {
+					diagnosticStore?.recordApplyReceipts(threadId, receipts);
+				} catch {}
+				if (!isCurrentTurn()) return;
+				onApplyReceipts?.(receipts);
+				if (!isCurrentTurn()) return;
+				if (!hasCompleteApplyResults()) throw new Error("The host returned mismatched apply results.");
+				if (!allChangesApplied()) {
+					rememberApplyOutcome(createApplyOutcome({
+						turnId: turnFinal.turnId,
+						status: "apply-failed",
+						message: "One or more authorized survey changes could not be applied to the editor.",
+						preparedChanges,
+						results
+					}));
+					dispatch({ type: "completed" });
+					return;
+				}
+				await onSettleApply?.({
+					changeSets: turnAuthorization.changeSets,
+					receipts,
+					turnFinal
+				});
+				if (!isCurrentTurn()) return;
+				const settledSnapshot = controllerRef.current?.getSnapshot();
+				if (!isCurrentTurn()) return;
+				if (!settledSnapshot) throw new Error("Editor snapshot unavailable after settlement.");
+				if (settledSnapshot.version.sessionId !== submittedDocumentSessionIdRef.current) {
+					invalidateTurn();
+					dispatch({ type: "aborted" });
+					return;
+				}
+				writeSettledDocumentVersion({
+					resourceId,
+					snapshot: settledSnapshot,
+					threadId
+				});
+				previousApplyOutcomesRef.current.delete(applyOutcomeScopeKey);
+				dispatch({ type: "applied" });
+			} catch {
+				if (!isCurrentTurn()) return;
+				retainApplyResults();
+				const applied = allChangesApplied();
+				const message = applied ? "The assistant changes were applied locally but could not be settled by the host." : applyStarted ? "The host could not complete the assistant apply lifecycle. Some changes may already have been applied." : "The editor state was unavailable before applying the assistant changes. No changes were applied.";
+				rememberApplyOutcome(createApplyOutcome({
+					turnId: turnFinal.turnId,
+					status: applied ? "settle-failed" : "apply-failed",
+					message,
+					preparedChanges,
+					results
+				}));
+				reportAuthorizationError(message);
+			}
+		})();
+	}, [
+		applyPolicy,
+		applyOutcomeScopeKey,
+		controller,
+		diagnosticStore,
+		isStreaming,
+		invalidateTurn,
+		onApplyReceipts,
+		onReviewChangeSets,
+		onSettleApply,
+		reportAuthorizationError,
+		rememberApplyOutcome,
+		resourceId,
+		messages,
+		threadId,
+		turnAuthorization
+	]);
+	useEffect(() => {
+		if (!error) {
+			capturedChatErrorRef.current = void 0;
+			return;
+		}
+		if (capturedChatErrorRef.current === error) return;
+		capturedChatErrorRef.current = error;
+		localTurnAwaitingApplyRef.current = false;
+		localTurnStreamStartedRef.current = false;
+		dispatch({ type: "failed" });
+		try {
+			diagnosticStore?.recordFailure(threadId, messagesRef.current, parseSurveyAssistantError(error));
+		} catch {}
+		if (!hasUsefulLatestAssistantResponse) setMessages(pruneFailedMessagesForDisplay);
+	}, [
+		diagnosticStore,
+		error,
+		hasUsefulLatestAssistantResponse,
+		setMessages,
+		threadId
+	]);
+	const submit = useCallback(({ files, modelId: submittedModelId, text: rawText, uiContext }) => {
+		const text = rawText.trim();
+		if (!text && files.length === 0) return false;
+		if (!mountedRef.current || isStreaming || turnOwnedRef.current) return false;
+		let snapshot;
+		try {
+			snapshot = applySurveyAssistantLaunchUIContext(controller?.getSnapshot() ?? null, uiContext);
+		} catch {
+			reportAuthorizationError("The editor state was unavailable before sending the assistant request. No request was sent.");
+			return false;
+		}
+		turnOwnedRef.current = true;
+		submittedDocumentSessionIdRef.current = snapshot?.version.sessionId;
+		previousAssistantMessageRef.current = [...messagesRef.current].reverse().find((message) => message.role === "assistant");
+		turnGenerationRef.current += 1;
+		localTurnAwaitingApplyRef.current = true;
+		localTurnStreamStartedRef.current = false;
+		setAuthorizationError(null);
+		if ((authorizationError || error) && !hasUsefulLatestAssistantResponse) setMessages(pruneFailedMessagesForDisplay);
+		clearError();
+		dispatch({ type: "submit" });
+		captureSettledVersionRef.current = true;
+		lastSubmittedUIContextRef.current = uiContext;
+		lastSubmittedModelIdRef.current = submittedModelId ?? modelId;
+		const requestId = createSurveyAssistantDiagnosticId();
+		try {
+			diagnosticStore?.beginAttempt({
+				files,
+				modelId: lastSubmittedModelIdRef.current,
+				requestId,
+				resourceId,
+				submittedSurvey: snapshot,
+				threadId
+			});
+		} catch {}
+		sendMessage(files.length > 0 ? text ? {
+			text,
+			files
+		} : { files } : { text }, { body: {
+			requestId,
+			snapshot,
+			previousSettledVersion: readSettledDocumentVersion({
+				resourceId,
+				threadId
+			}),
+			previousApplyOutcome: previousApplyOutcomesRef.current.get(applyOutcomeScopeKey),
+			...lastSubmittedModelIdRef.current ? { modelId: lastSubmittedModelIdRef.current } : {}
+		} });
+		return true;
+	}, [
+		authorizationError,
+		applyOutcomeScopeKey,
+		clearError,
+		controller,
+		diagnosticStore,
+		error,
+		hasUsefulLatestAssistantResponse,
+		isStreaming,
+		modelId,
+		resourceId,
+		reportAuthorizationError,
+		sendMessage,
+		setMessages,
+		threadId
+	]);
+	const stop = useCallback(() => {
+		invalidateTurn();
+		dispatch({ type: "aborted" });
+		stopChat();
+	}, [invalidateTurn, stopChat]);
+	const retry = useCallback(() => {
+		if (!mountedRef.current || isStreaming || turnOwnedRef.current) return;
+		let snapshot;
+		try {
+			snapshot = applySurveyAssistantLaunchUIContext(controller?.getSnapshot() ?? null, lastSubmittedUIContextRef.current);
+		} catch {
+			reportAuthorizationError("The editor state was unavailable before retrying the assistant request. No request was sent.");
+			return;
+		}
+		turnOwnedRef.current = true;
+		submittedDocumentSessionIdRef.current = snapshot?.version.sessionId;
+		previousAssistantMessageRef.current = [...messagesRef.current].reverse().find((message) => message.role === "assistant");
+		turnGenerationRef.current += 1;
+		localTurnAwaitingApplyRef.current = true;
+		localTurnStreamStartedRef.current = false;
+		setAuthorizationError(null);
+		clearError();
+		dispatch({ type: "submit" });
+		captureSettledVersionRef.current = true;
+		const latestUserMessage = [...messagesRef.current].reverse().find((message) => message.role === "user");
+		const files = (latestUserMessage?.parts ?? []).filter((part) => part.type === "file");
+		const attachmentReferences = (latestUserMessage?.parts ?? []).flatMap((part) => part.type === "data-survey-assistant-attachment" && typeof part.data === "object" && part.data !== null ? [part.data] : []);
+		const requestId = createSurveyAssistantDiagnosticId();
+		try {
+			diagnosticStore?.beginAttempt({
+				attachmentReferences,
+				files,
+				modelId: lastSubmittedModelIdRef.current ?? modelId,
+				requestId,
+				resourceId,
+				submittedSurvey: snapshot,
+				threadId
+			});
+			diagnosticStore?.recordEvent(threadId, "retry");
+		} catch {}
+		regenerate({ body: {
+			requestId,
+			snapshot,
+			previousSettledVersion: readSettledDocumentVersion({
+				resourceId,
+				threadId
+			}),
+			previousApplyOutcome: previousApplyOutcomesRef.current.get(applyOutcomeScopeKey),
+			...lastSubmittedModelIdRef.current ? { modelId: lastSubmittedModelIdRef.current } : {}
+		} });
+	}, [
+		applyOutcomeScopeKey,
+		clearError,
+		controller,
+		diagnosticStore,
+		modelId,
+		isStreaming,
+		regenerate,
+		resourceId,
+		reportAuthorizationError,
+		threadId
+	]);
+	return {
+		applyResultsByChangeId,
+		authorizationError,
+		dismissError: useCallback(() => {
+			if (turnOwnedRef.current || isStreaming) return;
+			localTurnAwaitingApplyRef.current = false;
+			localTurnStreamStartedRef.current = false;
+			if (!hasUsefulLatestAssistantResponse) setMessages(pruneFailedMessagesForDisplay);
+			setAuthorizationError(null);
+			clearError();
+			dispatch({
+				type: "reset",
+				hasTranscript: messages.length > 0
+			});
+			try {
+				diagnosticStore?.recordEvent(threadId, "dismiss");
+			} catch {}
+		}, [
+			clearError,
+			diagnosticStore,
+			hasUsefulLatestAssistantResponse,
+			messages.length,
+			isStreaming,
+			setMessages,
+			threadId
+		]),
+		error,
+		isStreaming,
+		latestTurnOutcome,
+		messages,
+		prependMessages,
+		state,
+		status,
+		stop,
+		submit,
+		retry
+	};
+};
+//#endregion
+export { resolveLatestSurveyTurnAuthorization as C, reduceSurveyAssistantSessionState as D, isSurveyAssistantTurnActive as E, parseSurveyChangeSet as S, unwrapSurveyAssistantToolOutput as T, createSurveyAssistantThreadClient as _, createSurveyAssistantSupportDetails as a, createApplyReceipts as b, estimateSurveyAssistantSupportBundleBytes as c, prepareSurveyAssistantSupportBundle as d, sanitizeSurveyAssistantSupportValue as f, resolveSurveyAssistantSupportBundleLimits as g, SURVEY_ASSISTANT_DEFAULT_SUPPORT_BUNDLE_LIMITS as h, SURVEY_ASSISTANT_DEFAULT_SUPPORT_BUNDLE_SELECTION as i, generateSurveyAssistantSupportBundle as l, createSurveyAssistantDiagnosticStore as m, createSurveyAssistantModelCatalogClient as n, createSurveyAssistantSupportMailto as o, createSurveyAssistantDiagnosticId as p, useSurveyAssistantModelCatalog as r, downloadSurveyAssistantSupportBundle as s, useSurveyAssistantSession as t, isSurveyAssistantSupportBundleEnabled as u, createSurveyAssistantTransport as v, resolveSurveyTurnOutcome as w, getSurveyDocumentVersionFromSnapshot as x, collectSurveyChangeSets as y };
+
+//# sourceMappingURL=react-C_GY-Fsc.mjs.map