reflet-sdk 0.6.5 → 0.6.6

package/dist/use-survey-session-LK6sN1Fg.js

@@ -0,0 +1,1247 @@
+import { t as RefletContext } from "./react-context-Kazo_JCz.js";
+import { useContext, useEffect, useId, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region ../survey-core/src/defaults.ts
+const DEFAULT_ENDING = {
+	description: "Your answers have been recorded.",
+	id: "default",
+	title: "Thank you!"
+};
+const DEFAULT_DISPLAY = {
+	frequency: "once",
+	position: "bottom_right"
+};
+const DEFAULT_TIME_DELAY_MS = 5e3;
+const DEFAULT_RATING_MIN = 1;
+const DEFAULT_RATING_MAX = 5;
+/** Every survey has at least one ending: stored endings, or the default thank-you. */
+const endingsOf = (endings) => endings && endings.length > 0 ? [...endings] : [DEFAULT_ENDING];
+const displayOf = (display) => display ?? DEFAULT_DISPLAY;
+const ratingRange = (config) => ({
+	max: config?.maxValue ?? DEFAULT_RATING_MAX,
+	min: config?.minValue ?? DEFAULT_RATING_MIN
+});
+const textMaxChars = (config) => config?.maxLength ?? 1e3;
+/** Statements show a message and a button; they never collect an answer. */
+const takesAnswer = (type) => type !== "statement";
+//#endregion
+//#region ../survey-core/src/answers.ts
+const isIntegerBetween = (value, min, max) => typeof value === "number" && Number.isInteger(value) && value >= min && value <= max;
+/** A choice outside the list is accepted only as the respondent's "Other" text. */
+const choiceIssue = (choice, config) => {
+	if (typeof choice !== "string" || choice.trim() === "") return "Pick one of the options.";
+	if (config?.choices?.includes(choice)) return null;
+	if (!config?.allowOther) return "Pick one of the options.";
+	return choice.length > 200 ? `Keep “Other” under 200 characters.` : null;
+};
+const multipleChoiceIssue = (value, config) => {
+	if (!Array.isArray(value)) return "Pick at least one option.";
+	if (new Set(value).size !== value.length) return "Each option can only be picked once.";
+	const listed = config?.choices ?? [];
+	const others = value.filter((choice) => !listed.includes(choice));
+	if (others.length > 1) return "Only one “Other” answer is allowed.";
+	return others.length === 1 ? choiceIssue(others[0], config) : null;
+};
+/** Why `value` can't be stored for `question`, or null when it's a valid answer. */
+const answerIssue = (question, value) => {
+	switch (question.type) {
+		case "rating": {
+			const { max, min } = ratingRange(question.config);
+			return isIntegerBetween(value, min, max) ? null : `Pick a rating from ${min} to ${max}.`;
+		}
+		case "nps": return isIntegerBetween(value, 0, 10) ? null : `Pick a score from 0 to 10.`;
+		case "boolean": return typeof value === "boolean" ? null : "Answer yes or no.";
+		case "text": {
+			if (typeof value !== "string") return "Type an answer.";
+			const max = textMaxChars(question.config);
+			return value.length > max ? `Keep your answer under ${max} characters.` : null;
+		}
+		case "single_choice": return choiceIssue(value, question.config);
+		case "multiple_choice": return multipleChoiceIssue(value, question.config);
+		case "statement": return "This step doesn’t take an answer.";
+		default: return "Unknown question type.";
+	}
+};
+//#endregion
+//#region ../survey-core/src/flow.ts
+const isEmptyAnswer = (value) => {
+	if (value === void 0) return true;
+	if (typeof value === "string") return value.trim() === "";
+	if (Array.isArray(value)) return value.length === 0;
+	return false;
+};
+const includesValue = (answer, expected) => {
+	if (typeof expected !== "string") return false;
+	if (Array.isArray(answer)) return answer.includes(expected);
+	return typeof answer === "string" && answer.toLowerCase().includes(expected.toLowerCase());
+};
+const compareNumbers = (answer, expected, compare) => typeof answer === "number" && typeof expected === "number" && compare(answer, expected);
+const evaluateRule = (rule, answer) => {
+	const empty = isEmptyAnswer(answer);
+	if (rule.operator === "answered") return !empty;
+	if (rule.operator === "skipped") return empty;
+	if (answer === void 0 || empty) return false;
+	switch (rule.operator) {
+		case "equals": return answer === rule.value;
+		case "not_equals": return answer !== rule.value;
+		case "greater_than": return compareNumbers(answer, rule.value, (a, b) => a > b);
+		case "less_than": return compareNumbers(answer, rule.value, (a, b) => a < b);
+		case "includes": return includesValue(answer, rule.value);
+		default: return false;
+	}
+};
+const sortByOrder = (questions) => [...questions].sort((a, b) => a.order - b.order);
+/** `endingsOf` never returns an empty list, so the first ending always exists. */
+const firstEnding = (endings) => endings[0];
+/**
+* Jumps only go forward in question order, so every flow ends. A target that
+* points backward or at a deleted question is ignored and the default path wins.
+*/
+const stepForTarget = (sorted, from, target, endings) => {
+	if (target.kind === "ending") return {
+		ending: endings.find((candidate) => candidate.id === target.endingId) ?? firstEnding(endings),
+		kind: "ending"
+	};
+	const question = sorted.find((q) => q._id === target.questionId);
+	return question && question.order > from.order ? {
+		kind: "question",
+		question
+	} : null;
+};
+const defaultStepAfter = (sorted, from, endings) => {
+	const following = sorted.find((q) => q.order > from.order);
+	return following ? {
+		kind: "question",
+		question: following
+	} : {
+		ending: firstEnding(endings),
+		kind: "ending"
+	};
+};
+const firstStep = (questions, storedEndings) => {
+	const [first] = sortByOrder(questions);
+	return first ? {
+		kind: "question",
+		question: first
+	} : {
+		ending: firstEnding(endingsOf(storedEndings)),
+		kind: "ending"
+	};
+};
+const resolveNextStep = (questions, current, answer, storedEndings) => {
+	const sorted = sortByOrder(questions);
+	const endings = endingsOf(storedEndings);
+	const target = (takesAnswer(current.type) ? current.logic?.find((rule) => evaluateRule(rule, answer)) : void 0)?.target ?? current.next;
+	return (target ? stepForTarget(sorted, current, target, endings) : null) ?? defaultStepAfter(sorted, current, endings);
+};
+/** Follows the flow from `start` using known answers; unanswered questions take their skipped path. */
+const walkFrom = (questions, start, answers, storedEndings) => {
+	const visited = [];
+	let step = start;
+	while (step.kind === "question" && visited.length <= questions.length) {
+		visited.push(step.question);
+		step = resolveNextStep(questions, step.question, answers.get(step.question._id), storedEndings);
+	}
+	return {
+		ending: step.kind === "ending" ? step.ending : firstEnding(endingsOf(storedEndings)),
+		questions: visited
+	};
+};
+//#endregion
+//#region ../survey-core/src/session.ts
+const REQUIRED_ANSWER_MESSAGE = "This question needs an answer.";
+const SAVE_FAILED_MESSAGE = "Couldn’t save your answer. Try again.";
+const START_FAILED_MESSAGE = "Couldn’t load this survey. Try again.";
+const previewTransport = {
+	answer: () => Promise.resolve(),
+	complete: () => Promise.resolve(),
+	dismiss: () => Promise.resolve(),
+	start: () => Promise.resolve({ responseId: "preview" })
+};
+var SurveySession = class {
+	survey;
+	transport;
+	callbacks;
+	endings;
+	listeners = /* @__PURE__ */ new Set();
+	submitted = /* @__PURE__ */ new Set();
+	history = [];
+	answers = /* @__PURE__ */ new Map();
+	current = null;
+	ending = null;
+	error = null;
+	isSubmitting = false;
+	phase = "starting";
+	responseId = null;
+	snapshot;
+	constructor(options) {
+		this.survey = options.survey;
+		this.transport = options.transport;
+		this.callbacks = options.callbacks ?? {};
+		this.endings = endingsOf(options.survey.endings);
+		this.snapshot = this.buildSnapshot();
+	}
+	subscribe = (listener) => {
+		this.listeners.add(listener);
+		return () => this.listeners.delete(listener);
+	};
+	getSnapshot = () => this.snapshot;
+	/** A method, not a field read, so TS doesn't narrow `phase` across awaits. */
+	isDismissed() {
+		return this.phase === "dismissed";
+	}
+	async start() {
+		if (this.phase !== "starting" && this.phase !== "start_failed") return;
+		this.update({
+			error: null,
+			phase: "starting"
+		});
+		try {
+			const { responseId } = await this.transport.start({ surveyId: this.survey._id });
+			this.responseId = responseId;
+			if (this.isDismissed()) {
+				this.transport.dismiss({ responseId }).catch(() => void 0);
+				return;
+			}
+			this.callbacks.onStart?.({
+				responseId,
+				surveyId: this.survey._id
+			});
+			const step = firstStep(this.survey.questions, this.endings);
+			if (step.kind === "question") {
+				this.current = step.question;
+				this.update({ phase: "question" });
+			} else await this.finish(step.ending);
+		} catch {
+			if (!this.isDismissed()) this.update({
+				error: START_FAILED_MESSAGE,
+				phase: "start_failed"
+			});
+		}
+	}
+	setAnswer(value) {
+		if (!this.current || this.phase !== "question") return;
+		const answers = new Map(this.answers);
+		if (value === void 0) answers.delete(this.current._id);
+		else answers.set(this.current._id, value);
+		this.answers = answers;
+		this.update({ error: null });
+	}
+	async next() {
+		const question = this.current;
+		const responseId = this.responseId;
+		if (!(question && responseId) || this.isSubmitting) return;
+		const value = this.answers.get(question._id);
+		const validationError = this.validate(question, value);
+		if (validationError) {
+			this.update({ error: validationError });
+			return;
+		}
+		this.update({
+			error: null,
+			isSubmitting: true
+		});
+		try {
+			await this.saveAnswer(question, responseId, value);
+			if (this.isDismissed()) return;
+			const step = resolveNextStep(this.survey.questions, question, value, this.endings);
+			if (step.kind === "question") {
+				this.history = [...this.history, question];
+				this.current = step.question;
+				this.update({ isSubmitting: false });
+			} else await this.finish(step.ending);
+		} catch {
+			if (!this.isDismissed()) this.update({
+				error: SAVE_FAILED_MESSAGE,
+				isSubmitting: false
+			});
+		}
+	}
+	back() {
+		const previous = this.history.at(-1);
+		if (!previous || this.isSubmitting || this.phase !== "question") return;
+		this.history = this.history.slice(0, -1);
+		this.current = previous;
+		this.update({ error: null });
+	}
+	dismiss() {
+		if (this.phase === "dismissed") return;
+		const closesAfterEnding = this.phase === "ending";
+		if (this.phase === "question" && this.responseId) this.transport.dismiss({ responseId: this.responseId }).catch(() => void 0);
+		if (!closesAfterEnding) this.callbacks.onDismiss?.({
+			answeredCount: this.submitted.size,
+			responseId: this.responseId,
+			surveyId: this.survey._id
+		});
+		this.update({ phase: "dismissed" });
+	}
+	validate(question, value) {
+		if (!takesAnswer(question.type)) return null;
+		if (value === void 0 || isEmptyAnswer(value)) return question.required ? REQUIRED_ANSWER_MESSAGE : null;
+		return answerIssue(question, value);
+	}
+	async saveAnswer(question, responseId, value) {
+		if (!takesAnswer(question.type)) return;
+		if (value !== void 0 && !isEmptyAnswer(value)) {
+			await this.transport.answer({
+				questionId: question._id,
+				responseId,
+				value
+			});
+			this.submitted.add(question._id);
+			this.callbacks.onAnswer?.({
+				questionId: question._id,
+				surveyId: this.survey._id,
+				value
+			});
+			return;
+		}
+		if (this.submitted.has(question._id)) {
+			await this.transport.answer({
+				questionId: question._id,
+				responseId,
+				value: null
+			});
+			this.submitted.delete(question._id);
+		}
+	}
+	async finish(ending) {
+		const responseId = this.responseId;
+		if (!responseId) return;
+		await this.transport.complete({ responseId });
+		if (this.isDismissed()) return;
+		this.ending = ending;
+		this.current = null;
+		this.update({
+			isSubmitting: false,
+			phase: "ending"
+		});
+		this.callbacks.onComplete?.({
+			endingId: ending.id,
+			responseId,
+			surveyId: this.survey._id
+		});
+	}
+	update(patch) {
+		if (patch.error !== void 0) this.error = patch.error;
+		if (patch.isSubmitting !== void 0) this.isSubmitting = patch.isSubmitting;
+		if (patch.phase !== void 0) this.phase = patch.phase;
+		this.snapshot = this.buildSnapshot();
+		for (const listener of this.listeners) listener();
+	}
+	buildSnapshot() {
+		const question = this.phase === "question" ? this.current : null;
+		const answered = this.history.length;
+		const remaining = question ? walkFrom(this.survey.questions, {
+			kind: "question",
+			question
+		}, this.answers, this.endings).questions.length : 0;
+		const isLastStep = question ? resolveNextStep(this.survey.questions, question, this.answers.get(question._id), this.endings).kind === "ending" : false;
+		return {
+			answers: this.answers,
+			canGoBack: question !== null && answered > 0,
+			ending: this.phase === "ending" ? this.ending : null,
+			error: this.error,
+			isLastStep,
+			isSubmitting: this.isSubmitting,
+			phase: this.phase,
+			progress: this.phase === "ending" ? 1 : answered / (answered + remaining || 1),
+			question
+		};
+	}
+};
+//#endregion
+//#region ../survey-core/src/links.ts
+const RELATIVE_LINK_BASE = "https://relative.invalid";
+/** Only http(s) or relative links reach a button href: survey content is rendered on customer sites. */
+const safeLinkUrl = (url) => {
+	if (!url) return null;
+	try {
+		const { protocol } = new URL(url, RELATIVE_LINK_BASE);
+		return protocol === "http:" || protocol === "https:" ? url : null;
+	} catch {
+		return null;
+	}
+};
+//#endregion
+//#region src/surveys/card/card-keyboard.ts
+const DIGIT = /^\d$/;
+const pickByKey = (key, question) => {
+	if (question.type === "boolean") {
+		const lower = key.toLowerCase();
+		if (lower === "y") return {
+			kind: "pick",
+			value: true
+		};
+		return lower === "n" ? {
+			kind: "pick",
+			value: false
+		} : null;
+	}
+	if (!DIGIT.test(key)) return null;
+	const digit = Number(key);
+	if (question.type === "nps") return {
+		kind: "pick",
+		value: digit
+	};
+	if (question.type === "rating") {
+		const { max, min } = ratingRange(question.config);
+		return digit >= min && digit <= max ? {
+			kind: "pick",
+			value: digit
+		} : null;
+	}
+	if (question.type === "single_choice") {
+		const choice = question.config?.choices?.[digit - 1];
+		return choice === void 0 ? null : {
+			kind: "pick",
+			value: choice
+		};
+	}
+	return null;
+};
+/**
+* Enter moves on, Escape closes, and digits (or Y/N) answer single-click
+* questions — except while typing, where keys belong to the field.
+*/
+const cardKeyAction = (event, question) => {
+	const { target } = event;
+	if (event.key === "Escape") return { kind: "close" };
+	const isTextArea = target instanceof HTMLTextAreaElement;
+	const isTextInput = target instanceof HTMLInputElement;
+	if (event.key === "Enter") {
+		if (isTextArea) return event.metaKey || event.ctrlKey ? { kind: "next" } : null;
+		return target instanceof HTMLButtonElement || target instanceof HTMLAnchorElement || !question ? null : { kind: "next" };
+	}
+	if (isTextArea || isTextInput || !question) return null;
+	return pickByKey(event.key, question);
+};
+//#endregion
+//#region src/surveys/card/card-styles.ts
+const LIGHT_TOKENS = `
+  --rfs-bg: #ffffff;
+  --rfs-text: #18181b;
+  --rfs-muted: #71717a;
+  --rfs-border: rgb(24 24 27 / 10%);
+  --rfs-subtle: rgb(24 24 27 / 4%);
+  --rfs-hover: rgb(24 24 27 / 7%);
+  --rfs-danger: #dc2626;
+  --rfs-success: #16a34a;
+  --rfs-primary: var(--rf-survey-primary, #18181b);
+  --rfs-primary-text: var(--rf-survey-primary-text, #ffffff);
+  --rfs-shadow: 0 0 0 1px var(--rfs-border), 0 2px 6px -1px rgb(15 15 15 / 8%), 0 18px 44px -14px rgb(15 15 15 / 24%);
+  color-scheme: light;
+`;
+const DARK_TOKENS = `
+  --rfs-bg: #1c1c1f;
+  --rfs-text: #f4f4f5;
+  --rfs-muted: #a1a1aa;
+  --rfs-border: rgb(255 255 255 / 10%);
+  --rfs-subtle: rgb(255 255 255 / 5%);
+  --rfs-hover: rgb(255 255 255 / 9%);
+  --rfs-danger: #f87171;
+  --rfs-success: #4ade80;
+  --rfs-primary: var(--rf-survey-primary, #fafafa);
+  --rfs-primary-text: var(--rf-survey-primary-text, #18181b);
+  --rfs-shadow: 0 0 0 1px var(--rfs-border), 0 2px 6px -1px rgb(0 0 0 / 30%), 0 18px 44px -14px rgb(0 0 0 / 60%);
+  color-scheme: dark;
+`;
+/** Every selector hangs off `.rf-survey`, so the card looks the same in a shadow root and in a page. */
+const SURVEY_CARD_STYLES = `
+.rf-survey {
+  ${LIGHT_TOKENS}
+  --rfs-radius: 14px;
+  --rfs-control-radius: 9px;
+  --rfs-ease: cubic-bezier(0.16, 1, 0.3, 1);
+  position: relative;
+  box-sizing: border-box;
+  width: 100%;
+  padding: 20px;
+  border-radius: var(--rfs-radius);
+  background: var(--rfs-bg);
+  color: var(--rfs-text);
+  font-family: ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+  font-size: 14px;
+  line-height: 1.45;
+  text-align: left;
+  -webkit-font-smoothing: antialiased;
+  overflow: hidden;
+}
+.rf-survey[data-theme="dark"] { ${DARK_TOKENS} }
+@media (prefers-color-scheme: dark) {
+  .rf-survey[data-theme="auto"] { ${DARK_TOKENS} }
+}
+.rf-survey *, .rf-survey *::before, .rf-survey *::after { box-sizing: border-box; }
+.rf-survey :where(h2, p) { margin: 0; }
+.rf-survey :where(fieldset) { min-width: 0; margin: 0; padding: 0; border: 0; }
+.rf-survey :where(button, input, textarea, a) {
+  margin: 0;
+  font: inherit;
+  color: inherit;
+  letter-spacing: inherit;
+}
+.rf-survey :where(button) { cursor: pointer; background: none; border: 0; padding: 0; }
+.rf-survey :where(button:disabled) { cursor: default; }
+.rf-survey :where(button, a, input, textarea):focus-visible {
+  outline: 2px solid var(--rfs-primary);
+  outline-offset: 2px;
+}
+.rf-survey[data-variant="floating"] { box-shadow: var(--rfs-shadow); animation: rfs-enter 360ms var(--rfs-ease); }
+.rf-survey[data-variant="inline"] { box-shadow: 0 0 0 1px var(--rfs-border); }
+.rf-survey[data-variant="page"] {
+  max-width: 560px;
+  margin: 0 auto;
+  padding: 32px;
+  box-shadow: var(--rfs-shadow);
+  font-size: 15px;
+}
+.rfs-progress { position: absolute; inset: 0 0 auto; height: 3px; background: var(--rfs-subtle); }
+.rfs-progress-fill {
+  height: 100%;
+  background: var(--rfs-primary);
+  transform-origin: left;
+  transition: transform 400ms var(--rfs-ease);
+}
+.rfs-close {
+  position: absolute;
+  top: 12px;
+  right: 12px;
+  display: grid;
+  place-items: center;
+  width: 28px;
+  height: 28px;
+  border-radius: 8px;
+  color: var(--rfs-muted);
+  transition: background-color 150ms ease, color 150ms ease;
+}
+.rfs-close:hover { background: var(--rfs-hover); color: var(--rfs-text); }
+.rfs-step { display: flex; flex-direction: column; gap: 14px; animation: rfs-step-in 280ms var(--rfs-ease); }
+.rfs-heading { display: flex; flex-direction: column; gap: 4px; padding-right: 28px; }
+.rfs-title { font-size: 1.07em; font-weight: 600; line-height: 1.35; text-wrap: balance; outline: none; }
+.rfs-description { color: var(--rfs-muted); text-wrap: pretty; white-space: pre-line; }
+.rfs-scale { display: flex; gap: 6px; }
+.rfs-scale[data-kind="nps"] { display: grid; grid-template-columns: repeat(11, minmax(0, 1fr)); gap: 4px; }
+.rfs-scale-option {
+  flex: 1;
+  min-width: 0;
+  height: 40px;
+  border-radius: var(--rfs-control-radius);
+  background: var(--rfs-subtle);
+  box-shadow: inset 0 0 0 1px var(--rfs-border);
+  font-weight: 500;
+  font-variant-numeric: tabular-nums;
+  transition: background-color 150ms ease, color 150ms ease, transform 150ms var(--rfs-ease);
+}
+.rfs-scale[data-kind="nps"] .rfs-scale-option { height: 36px; font-size: 13px; }
+.rfs-scale-option:hover { background: var(--rfs-hover); }
+.rfs-scale-option:active { transform: scale(0.96); }
+.rfs-scale-option[aria-pressed="true"] { background: var(--rfs-primary); color: var(--rfs-primary-text); box-shadow: none; }
+.rfs-scale[data-style="star"], .rfs-scale[data-style="emoji"] { gap: 2px; justify-content: center; }
+.rfs-scale[data-style="star"] .rfs-scale-option,
+.rfs-scale[data-style="emoji"] .rfs-scale-option {
+  flex: 0 1 44px;
+  height: 44px;
+  background: none;
+  box-shadow: none;
+  color: var(--rfs-border);
+}
+.rfs-scale[data-style="star"] .rfs-scale-option[data-lit="true"] { color: #f5a524; }
+.rfs-scale[data-style="emoji"] .rfs-scale-option { font-size: 26px; filter: grayscale(1); opacity: 0.55; }
+.rfs-scale[data-style="emoji"] .rfs-scale-option:hover,
+.rfs-scale[data-style="emoji"] .rfs-scale-option[aria-pressed="true"] { filter: none; opacity: 1; transform: scale(1.12); background: none; }
+.rfs-scale-labels { display: flex; justify-content: space-between; gap: 12px; margin-top: -6px; color: var(--rfs-muted); font-size: 12px; }
+.rfs-choices { display: flex; flex-direction: column; gap: 6px; }
+.rfs-choice {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  width: 100%;
+  min-height: 40px;
+  padding: 8px 12px;
+  border-radius: var(--rfs-control-radius);
+  background: var(--rfs-subtle);
+  box-shadow: inset 0 0 0 1px var(--rfs-border);
+  text-align: left;
+  transition: background-color 150ms ease, box-shadow 150ms ease;
+}
+.rfs-choice:hover { background: var(--rfs-hover); }
+.rfs-choice[aria-pressed="true"] { box-shadow: inset 0 0 0 1.5px var(--rfs-primary); background: var(--rfs-bg); }
+.rfs-indicator {
+  flex: none;
+  display: grid;
+  place-items: center;
+  width: 16px;
+  height: 16px;
+  border-radius: 999px;
+  box-shadow: inset 0 0 0 1.5px var(--rfs-muted);
+  color: var(--rfs-primary-text);
+  transition: background-color 150ms ease, box-shadow 150ms ease;
+}
+.rfs-indicator[data-shape="square"] { border-radius: 5px; }
+.rfs-choice[aria-pressed="true"] .rfs-indicator { background: var(--rfs-primary); box-shadow: none; }
+.rfs-boolean { display: grid; grid-template-columns: 1fr 1fr; gap: 8px; }
+.rfs-boolean .rfs-choice { justify-content: center; font-weight: 500; }
+.rfs-input {
+  display: block;
+  width: 100%;
+  padding: 10px 12px;
+  border: 0;
+  border-radius: var(--rfs-control-radius);
+  background: var(--rfs-subtle);
+  box-shadow: inset 0 0 0 1px var(--rfs-border);
+  resize: vertical;
+  transition: box-shadow 150ms ease;
+}
+.rfs-input::placeholder { color: var(--rfs-muted); }
+.rfs-input:focus { outline: none; box-shadow: inset 0 0 0 1.5px var(--rfs-primary); }
+.rfs-input-wrap { display: flex; flex-direction: column; gap: 4px; }
+.rfs-counter { align-self: flex-end; color: var(--rfs-muted); font-size: 12px; font-variant-numeric: tabular-nums; }
+.rfs-counter[data-full="true"] { color: var(--rfs-danger); }
+.rfs-error { color: var(--rfs-danger); font-size: 13px; }
+.rfs-footer { display: flex; align-items: center; justify-content: flex-end; gap: 8px; margin-top: 2px; }
+.rfs-button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  height: 36px;
+  padding: 0 16px;
+  border-radius: var(--rfs-control-radius);
+  font-weight: 500;
+  text-decoration: none;
+  transition: background-color 150ms ease, opacity 150ms ease, transform 150ms var(--rfs-ease);
+}
+.rfs-button:active:not(:disabled) { transform: scale(0.97); }
+.rfs-button[data-tone="primary"] { background: var(--rfs-primary); color: var(--rfs-primary-text); }
+.rfs-button[data-tone="primary"]:hover:not(:disabled) { opacity: 0.88; }
+.rfs-button[data-tone="primary"]:disabled { opacity: 0.55; }
+.rfs-button[data-tone="ghost"] { margin-right: auto; color: var(--rfs-muted); }
+.rfs-button[data-tone="ghost"]:hover { background: var(--rfs-hover); color: var(--rfs-text); }
+.rfs-ending { align-items: center; padding: 8px 0 4px; text-align: center; }
+.rfs-ending .rfs-heading { padding-right: 0; align-items: center; }
+.rfs-ending-mark {
+  display: grid;
+  place-items: center;
+  width: 40px;
+  height: 40px;
+  border-radius: 999px;
+  background: var(--rfs-subtle);
+  color: var(--rfs-success);
+  animation: rfs-pop 420ms var(--rfs-ease);
+}
+.rfs-skeleton { display: flex; flex-direction: column; gap: 10px; }
+.rfs-skeleton-line { height: 12px; border-radius: 6px; background: var(--rfs-subtle); animation: rfs-pulse 1.4s ease-in-out infinite; }
+.rfs-skeleton-line:first-child { width: 70%; height: 16px; }
+@keyframes rfs-enter { from { opacity: 0; transform: translateY(12px) scale(0.98); } }
+@keyframes rfs-step-in { from { opacity: 0; transform: translateX(8px); } }
+@keyframes rfs-pop { from { opacity: 0; transform: scale(0.6); } }
+@keyframes rfs-pulse { 50% { opacity: 0.5; } }
+@media (prefers-reduced-motion: reduce) {
+  .rf-survey, .rf-survey * { animation: none !important; transition: none !important; }
+}
+`;
+//#endregion
+//#region src/surveys/card/choice-fields.tsx
+const OTHER_LABEL = "Other";
+function CheckIcon() {
+	return /* @__PURE__ */ jsx("svg", {
+		"aria-hidden": "true",
+		fill: "none",
+		height: "10",
+		stroke: "currentColor",
+		strokeLinecap: "round",
+		strokeLinejoin: "round",
+		strokeWidth: "3",
+		viewBox: "0 0 24 24",
+		width: "10",
+		children: /* @__PURE__ */ jsx("path", { d: "M5 12.5l4.5 4.5L19 7.5" })
+	});
+}
+function ChoiceOption({ checked, label, multiple, onSelect }) {
+	return /* @__PURE__ */ jsxs("button", {
+		"aria-pressed": checked,
+		className: "rfs-choice",
+		onClick: onSelect,
+		type: "button",
+		children: [/* @__PURE__ */ jsx("span", {
+			className: "rfs-indicator",
+			"data-shape": multiple ? "square" : "round",
+			children: checked && /* @__PURE__ */ jsx(CheckIcon, {})
+		}), label]
+	});
+}
+function OtherInput({ onChange, value }) {
+	const inputRef = useRef(null);
+	useEffect(() => {
+		inputRef.current?.focus({ preventScroll: true });
+	}, []);
+	return /* @__PURE__ */ jsx("input", {
+		"aria-label": "Other answer",
+		className: "rfs-input",
+		maxLength: 200,
+		onChange: (event) => onChange(event.target.value),
+		placeholder: "Type your answer…",
+		ref: inputRef,
+		type: "text",
+		value
+	});
+}
+function SingleChoiceField({ labelledBy, onChange, onPick, question, value }) {
+	const choices = question.config?.choices ?? [];
+	const typedOther = typeof value === "string" && !choices.includes(value) ? value : "";
+	const [otherOpen, setOtherOpen] = useState(typedOther !== "");
+	return /* @__PURE__ */ jsxs("fieldset", {
+		"aria-labelledby": labelledBy,
+		className: "rfs-choices",
+		children: [
+			choices.map((choice) => /* @__PURE__ */ jsx(ChoiceOption, {
+				checked: !otherOpen && value === choice,
+				label: choice,
+				multiple: false,
+				onSelect: () => {
+					setOtherOpen(false);
+					onPick(choice);
+				}
+			}, choice)),
+			question.config?.allowOther && /* @__PURE__ */ jsx(ChoiceOption, {
+				checked: otherOpen,
+				label: OTHER_LABEL,
+				multiple: false,
+				onSelect: () => {
+					setOtherOpen(true);
+					onChange(typedOther || void 0);
+				}
+			}),
+			otherOpen && /* @__PURE__ */ jsx(OtherInput, {
+				onChange: (text) => onChange(text || void 0),
+				value: typedOther
+			})
+		]
+	});
+}
+function MultipleChoiceField({ labelledBy, onChange, question, value }) {
+	const choices = question.config?.choices ?? [];
+	const picked = Array.isArray(value) ? value : [];
+	const listed = picked.filter((choice) => choices.includes(choice));
+	const typedOther = picked.find((choice) => !choices.includes(choice)) ?? "";
+	const [otherOpen, setOtherOpen] = useState(typedOther !== "");
+	const commit = (nextListed, other) => {
+		const next = other ? [...nextListed, other] : nextListed;
+		onChange(next.length > 0 ? next : void 0);
+	};
+	return /* @__PURE__ */ jsxs("fieldset", {
+		"aria-labelledby": labelledBy,
+		className: "rfs-choices",
+		children: [
+			choices.map((choice) => {
+				const checked = listed.includes(choice);
+				return /* @__PURE__ */ jsx(ChoiceOption, {
+					checked,
+					label: choice,
+					multiple: true,
+					onSelect: () => commit(checked ? listed.filter((item) => item !== choice) : choices.filter((item) => item === choice || listed.includes(item)), typedOther)
+				}, choice);
+			}),
+			question.config?.allowOther && /* @__PURE__ */ jsx(ChoiceOption, {
+				checked: otherOpen,
+				label: OTHER_LABEL,
+				multiple: true,
+				onSelect: () => {
+					setOtherOpen(!otherOpen);
+					commit(listed, otherOpen ? "" : typedOther);
+				}
+			}),
+			otherOpen && /* @__PURE__ */ jsx(OtherInput, {
+				onChange: (text) => commit(listed, text),
+				value: typedOther
+			})
+		]
+	});
+}
+function BooleanField({ labelledBy, onPick, value }) {
+	return /* @__PURE__ */ jsx("fieldset", {
+		"aria-labelledby": labelledBy,
+		className: "rfs-boolean",
+		children: [{
+			answer: true,
+			label: "Yes"
+		}, {
+			answer: false,
+			label: "No"
+		}].map(({ answer, label }) => /* @__PURE__ */ jsx("button", {
+			"aria-pressed": value === answer,
+			className: "rfs-choice",
+			onClick: () => onPick(answer),
+			type: "button",
+			children: label
+		}, label))
+	});
+}
+//#endregion
+//#region src/surveys/card/scale-fields.tsx
+const EMOJI_FACES = [
+	"😞",
+	"🙁",
+	"😐",
+	"🙂",
+	"😄"
+];
+const DEFAULT_NPS_MIN_LABEL = "Not likely";
+const DEFAULT_NPS_MAX_LABEL = "Very likely";
+const valuesBetween = (min, max) => Array.from({ length: max - min + 1 }, (_, index) => min + index);
+function StarIcon() {
+	return /* @__PURE__ */ jsx("svg", {
+		"aria-hidden": "true",
+		fill: "currentColor",
+		height: "28",
+		viewBox: "0 0 24 24",
+		width: "28",
+		children: /* @__PURE__ */ jsx("path", { d: "M12 2.8l2.83 5.74 6.33.92-4.58 4.46 1.08 6.3L12 17.25l-5.66 2.97 1.08-6.3L2.84 9.46l6.33-.92z" })
+	});
+}
+function ScaleLabels({ max, min }) {
+	if (!(min || max)) return null;
+	return /* @__PURE__ */ jsxs("div", {
+		"aria-hidden": "true",
+		className: "rfs-scale-labels",
+		children: [/* @__PURE__ */ jsx("span", { children: min }), /* @__PURE__ */ jsx("span", { children: max })]
+	});
+}
+function RatingField({ labelledBy, onPick, question, value }) {
+	const [hovered, setHovered] = useState(null);
+	const { max, min } = ratingRange(question.config);
+	const style = question.config?.ratingStyle ?? "number";
+	const values = valuesBetween(min, max);
+	const lit = hovered ?? value ?? Number.NEGATIVE_INFINITY;
+	const faceFor = (option) => {
+		const step = values.length > 1 ? (option - min) / (max - min) : 1;
+		return EMOJI_FACES[Math.round(step * (EMOJI_FACES.length - 1))];
+	};
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("fieldset", {
+		"aria-labelledby": labelledBy,
+		className: "rfs-scale",
+		"data-style": style,
+		children: values.map((option) => /* @__PURE__ */ jsxs("button", {
+			"aria-label": `${option} of ${max}`,
+			"aria-pressed": value === option,
+			className: "rfs-scale-option",
+			"data-lit": option <= lit,
+			onClick: () => onPick(option),
+			onPointerEnter: () => setHovered(option),
+			onPointerLeave: () => setHovered(null),
+			type: "button",
+			children: [
+				style === "number" && option,
+				style === "star" && /* @__PURE__ */ jsx(StarIcon, {}),
+				style === "emoji" && faceFor(option)
+			]
+		}, option))
+	}), /* @__PURE__ */ jsx(ScaleLabels, {
+		max: question.config?.maxLabel,
+		min: question.config?.minLabel
+	})] });
+}
+function NpsField({ labelledBy, onPick, question, value }) {
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("fieldset", {
+		"aria-labelledby": labelledBy,
+		className: "rfs-scale",
+		"data-kind": "nps",
+		children: valuesBetween(0, 10).map((option) => /* @__PURE__ */ jsx("button", {
+			"aria-pressed": value === option,
+			className: "rfs-scale-option",
+			onClick: () => onPick(option),
+			type: "button",
+			children: option
+		}, option))
+	}), /* @__PURE__ */ jsx(ScaleLabels, {
+		max: question.config?.maxLabel ?? DEFAULT_NPS_MAX_LABEL,
+		min: question.config?.minLabel ?? DEFAULT_NPS_MIN_LABEL
+	})] });
+}
+//#endregion
+//#region src/surveys/card/question-body.tsx
+function TextField({ labelledBy, onChange, question, value }) {
+	const max = textMaxChars(question.config);
+	const text = typeof value === "string" ? value : "";
+	return /* @__PURE__ */ jsxs("div", {
+		className: "rfs-input-wrap",
+		children: [/* @__PURE__ */ jsx("textarea", {
+			"aria-labelledby": labelledBy,
+			className: "rfs-input",
+			maxLength: max,
+			onChange: (event) => onChange(event.target.value || void 0),
+			placeholder: question.config?.placeholder ?? "Type your answer…",
+			rows: 3,
+			value: text
+		}), /* @__PURE__ */ jsxs("span", {
+			className: "rfs-counter",
+			"data-full": text.length >= max,
+			children: [
+				text.length,
+				"/",
+				max
+			]
+		})]
+	});
+}
+function QuestionBody(props) {
+	const { labelledBy, onPick, question, value } = props;
+	const numericValue = typeof value === "number" ? value : void 0;
+	switch (question.type) {
+		case "rating": return /* @__PURE__ */ jsx(RatingField, {
+			labelledBy,
+			onPick,
+			question,
+			value: numericValue
+		});
+		case "nps": return /* @__PURE__ */ jsx(NpsField, {
+			labelledBy,
+			onPick,
+			question,
+			value: numericValue
+		});
+		case "single_choice": return /* @__PURE__ */ jsx(SingleChoiceField, { ...props });
+		case "multiple_choice": return /* @__PURE__ */ jsx(MultipleChoiceField, { ...props });
+		case "boolean": return /* @__PURE__ */ jsx(BooleanField, { ...props });
+		case "text": return /* @__PURE__ */ jsx(TextField, { ...props });
+		default: return null;
+	}
+}
+function StepHeading({ description, headingId, headingRef, title }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "rfs-heading",
+		children: [/* @__PURE__ */ jsx("h2", {
+			className: "rfs-title",
+			id: headingId,
+			ref: headingRef,
+			tabIndex: -1,
+			children: title
+		}), description && /* @__PURE__ */ jsx("p", {
+			className: "rfs-description",
+			children: description
+		})]
+	});
+}
+function ActionButton({ children, disabled, onClick, url }) {
+	const safeUrl = safeLinkUrl(url);
+	if (safeUrl) return /* @__PURE__ */ jsx("a", {
+		className: "rfs-button",
+		"data-tone": "primary",
+		href: safeUrl,
+		onClick,
+		rel: "noopener noreferrer",
+		target: "_blank",
+		children
+	});
+	return /* @__PURE__ */ jsx("button", {
+		className: "rfs-button",
+		"data-tone": "primary",
+		disabled,
+		onClick,
+		type: "button",
+		children
+	});
+}
+function SuccessMark() {
+	return /* @__PURE__ */ jsx("span", {
+		className: "rfs-ending-mark",
+		children: /* @__PURE__ */ jsx("svg", {
+			"aria-hidden": "true",
+			fill: "none",
+			height: "20",
+			stroke: "currentColor",
+			strokeLinecap: "round",
+			strokeLinejoin: "round",
+			strokeWidth: "2.5",
+			viewBox: "0 0 24 24",
+			width: "20",
+			children: /* @__PURE__ */ jsx("path", { d: "M5 12.5l4.5 4.5L19 7.5" })
+		})
+	});
+}
+function EndingStep({ ending, headingId, headingRef, onClose }) {
+	const hasButton = Boolean(ending.buttonUrl || ending.buttonLabel);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "rfs-step rfs-ending",
+		children: [
+			/* @__PURE__ */ jsx(SuccessMark, {}),
+			/* @__PURE__ */ jsx(StepHeading, {
+				description: ending.description,
+				headingId,
+				headingRef,
+				title: ending.title
+			}),
+			hasButton && /* @__PURE__ */ jsx(ActionButton, {
+				onClick: onClose,
+				url: ending.buttonUrl,
+				children: ending.buttonLabel ?? "Continue"
+			})
+		]
+	});
+}
+function LoadingStep() {
+	return /* @__PURE__ */ jsxs("div", {
+		"aria-busy": "true",
+		"aria-label": "Loading survey",
+		className: "rfs-skeleton",
+		role: "status",
+		children: [
+			/* @__PURE__ */ jsx("span", { className: "rfs-skeleton-line" }),
+			/* @__PURE__ */ jsx("span", { className: "rfs-skeleton-line" }),
+			/* @__PURE__ */ jsx("span", { className: "rfs-skeleton-line" })
+		]
+	});
+}
+function StartFailedStep({ message, onRetry }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "rfs-step",
+		children: [/* @__PURE__ */ jsx("p", {
+			className: "rfs-error",
+			role: "alert",
+			children: message
+		}), /* @__PURE__ */ jsx("div", {
+			className: "rfs-footer",
+			children: /* @__PURE__ */ jsx(ActionButton, {
+				onClick: onRetry,
+				children: "Try again"
+			})
+		})]
+	});
+}
+//#endregion
+//#region src/surveys/card/question-step.tsx
+function QuestionStep({ headingId, headingRef, onPick, question, session }) {
+	const { snapshot } = session;
+	const isStatement = question.type === "statement";
+	const nextLabel = snapshot.isLastStep ? "Submit" : "Next";
+	return /* @__PURE__ */ jsxs("div", {
+		className: "rfs-step",
+		children: [
+			/* @__PURE__ */ jsx(StepHeading, {
+				description: question.description,
+				headingId,
+				headingRef,
+				title: question.title
+			}),
+			/* @__PURE__ */ jsx(QuestionBody, {
+				labelledBy: headingId,
+				onChange: session.setAnswer,
+				onPick,
+				question,
+				value: snapshot.answers.get(question._id)
+			}),
+			snapshot.error && /* @__PURE__ */ jsx("p", {
+				className: "rfs-error",
+				role: "alert",
+				children: snapshot.error
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "rfs-footer",
+				children: [snapshot.canGoBack && /* @__PURE__ */ jsx("button", {
+					className: "rfs-button",
+					"data-tone": "ghost",
+					disabled: snapshot.isSubmitting,
+					onClick: session.back,
+					type: "button",
+					children: "Back"
+				}), /* @__PURE__ */ jsx(ActionButton, {
+					disabled: snapshot.isSubmitting,
+					onClick: () => session.next(),
+					url: isStatement ? question.config?.buttonUrl : void 0,
+					children: isStatement ? question.config?.buttonLabel ?? "Continue" : nextLabel
+				})]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/surveys/card/survey-card.tsx
+const HEX_COLOR = /^#([\da-f]{3}|[\da-f]{6})$/i;
+const LIGHT_LUMINANCE_THRESHOLD = .6;
+const DARK_TEXT = "#18181b";
+const LIGHT_TEXT = "#ffffff";
+/** Dark text on light brand colors, white text otherwise. */
+const readableTextOn = (color) => {
+	const match = HEX_COLOR.exec(color.trim());
+	if (!match?.[1]) return LIGHT_TEXT;
+	const hex = match[1].length === 3 ? [...match[1]].map((digit) => digit + digit).join("") : match[1];
+	const [red = 0, green = 0, blue = 0] = [
+		0,
+		2,
+		4
+	].map((offset) => Number.parseInt(hex.slice(offset, offset + 2), 16) / 255);
+	return .2126 * red + .7152 * green + .0722 * blue > LIGHT_LUMINANCE_THRESHOLD ? DARK_TEXT : LIGHT_TEXT;
+};
+function CloseIcon() {
+	return /* @__PURE__ */ jsx("svg", {
+		"aria-hidden": "true",
+		fill: "none",
+		height: "16",
+		stroke: "currentColor",
+		strokeLinecap: "round",
+		strokeWidth: "2",
+		viewBox: "0 0 24 24",
+		width: "16",
+		children: /* @__PURE__ */ jsx("path", { d: "M6 6l12 12M18 6L6 18" })
+	});
+}
+/**
+* Renders any survey session: questions, branching, endings and errors.
+* Ships its own scoped styles, so it works in a shadow root or a page.
+*/
+function SurveyCard({ className, onClose, primaryColor, session, theme = "auto", variant = "inline" }) {
+	const { snapshot } = session;
+	const { ending, phase, question } = snapshot;
+	const headingId = useId();
+	const headingRef = useRef(null);
+	const hasInteracted = useRef(false);
+	const stepKey = question?._id ?? phase;
+	useEffect(() => {
+		if (stepKey && hasInteracted.current) headingRef.current?.focus({ preventScroll: true });
+	}, [stepKey]);
+	if (phase === "dismissed") return null;
+	const closable = onClose !== void 0 || variant === "floating";
+	const close = () => {
+		session.dismiss();
+		onClose?.();
+	};
+	const pick = (value) => {
+		session.setAnswer(value);
+		session.next();
+	};
+	const onKeyDown = (event) => {
+		hasInteracted.current = true;
+		if (event.nativeEvent.isComposing) return;
+		const action = cardKeyAction({
+			ctrlKey: event.ctrlKey,
+			key: event.key,
+			metaKey: event.metaKey,
+			target: event.target
+		}, question);
+		if (!action || action.kind === "close" && !closable) return;
+		event.preventDefault();
+		if (action.kind === "close") close();
+		else if (action.kind === "next") session.next();
+		else pick(action.value);
+	};
+	const themeStyle = primaryColor ? {
+		"--rf-survey-primary": primaryColor,
+		"--rf-survey-primary-text": readableTextOn(primaryColor)
+	} : {};
+	const showsProgress = phase === "question" || phase === "ending";
+	return /* @__PURE__ */ jsxs("section", {
+		"aria-label": question || ending ? void 0 : session.survey.title,
+		"aria-labelledby": question || ending ? headingId : void 0,
+		className: className ? `rf-survey ${className}` : "rf-survey",
+		"data-theme": theme,
+		"data-variant": variant,
+		onKeyDown,
+		onPointerDown: () => {
+			hasInteracted.current = true;
+		},
+		style: themeStyle,
+		children: [
+			/* @__PURE__ */ jsx("style", { children: SURVEY_CARD_STYLES }),
+			showsProgress && /* @__PURE__ */ jsx("div", {
+				"aria-label": "Survey progress",
+				"aria-valuemax": 100,
+				"aria-valuemin": 0,
+				"aria-valuenow": Math.round(snapshot.progress * 100),
+				className: "rfs-progress",
+				role: "progressbar",
+				children: /* @__PURE__ */ jsx("div", {
+					className: "rfs-progress-fill",
+					style: { transform: `scaleX(${snapshot.progress})` }
+				})
+			}),
+			closable && /* @__PURE__ */ jsx("button", {
+				"aria-label": "Close survey",
+				className: "rfs-close",
+				onClick: close,
+				type: "button",
+				children: /* @__PURE__ */ jsx(CloseIcon, {})
+			}),
+			phase === "starting" && /* @__PURE__ */ jsx(LoadingStep, {}),
+			phase === "start_failed" && /* @__PURE__ */ jsx(StartFailedStep, {
+				message: snapshot.error,
+				onRetry: () => session.start()
+			}),
+			ending && /* @__PURE__ */ jsx(EndingStep, {
+				ending,
+				headingId,
+				headingRef,
+				onClose: close
+			}, ending.id),
+			question && /* @__PURE__ */ jsx(QuestionStep, {
+				headingId,
+				headingRef,
+				onPick: pick,
+				question,
+				session
+			}, question._id)
+		]
+	});
+}
+//#endregion
+//#region src/surveys/client-transport.ts
+/** Runs a survey session against the Reflet REST API with this client's key and user. */
+const createRefletSurveyTransport = (client, options = {}) => ({
+	answer: (input) => client.submitSurveyAnswer(input),
+	complete: ({ responseId }) => client.completeSurveyResponse(responseId),
+	dismiss: ({ responseId }) => client.dismissSurveyResponse(responseId),
+	start: ({ surveyId }) => client.startSurveyResponse({
+		pageUrl: options.pageUrl,
+		surveyId
+	})
+});
+//#endregion
+//#region src/surveys/use-survey-session.ts
+const startedSessions = /* @__PURE__ */ new WeakSet();
+/** Subscribes a component to an existing session. */
+function useSessionHandle(session) {
+	const snapshot = useSyncExternalStore(session.subscribe, session.getSnapshot, session.getSnapshot);
+	return useMemo(() => ({
+		back: () => session.back(),
+		dismiss: () => session.dismiss(),
+		next: () => session.next(),
+		setAnswer: (value) => session.setAnswer(value),
+		snapshot,
+		start: () => session.start(),
+		survey: session.survey
+	}), [session, snapshot]);
+}
+/**
+* Headless survey runner for custom UIs. A new session begins whenever
+* `survey` or `transport` changes identity, so memoize them.
+*/
+function useSurveySession(survey, options = {}) {
+	const { autoStart = true, callbacks, transport } = options;
+	const client = useContext(RefletContext)?.client;
+	const callbacksRef = useRef(callbacks);
+	useEffect(() => {
+		callbacksRef.current = callbacks;
+	});
+	const resolvedTransport = useMemo(() => {
+		if (transport) return transport;
+		return client ? createRefletSurveyTransport(client) : previewTransport;
+	}, [client, transport]);
+	const session = useMemo(() => new SurveySession({
+		callbacks: {
+			onAnswer: (event) => callbacksRef.current?.onAnswer?.(event),
+			onComplete: (event) => callbacksRef.current?.onComplete?.(event),
+			onDismiss: (event) => callbacksRef.current?.onDismiss?.(event),
+			onStart: (event) => callbacksRef.current?.onStart?.(event)
+		},
+		survey,
+		transport: resolvedTransport
+	}), [survey, resolvedTransport]);
+	useEffect(() => {
+		if (!autoStart || startedSessions.has(session)) return;
+		startedSessions.add(session);
+		session.start();
+	}, [autoStart, session]);
+	return useSessionHandle(session);
+}
+//#endregion
+export { SurveySession as a, displayOf as c, SurveyCard as i, useSurveySession as n, previewTransport as o, createRefletSurveyTransport as r, DEFAULT_TIME_DELAY_MS as s, useSessionHandle as t };
+
+//# sourceMappingURL=use-survey-session-LK6sN1Fg.js.map