@posthog/wizard 2.32.0 → 2.33.0

package/dist/store-D15C9YSW.js

@@ -0,0 +1,763 @@
+import { t as __exportAll } from "./rolldown-runtime-B_-DWIq7.js";
+import { s as logToFile, y as getBlockingServiceKeys } from "./debug-BGMe1wP6.js";
+import { n as isTaskStatus } from "./wizard-ui-WZ48rUgr.js";
+import { r as sessionProperties, t as analytics } from "./analytics-CU4o3eF8.js";
+import { a as buildSession } from "./wizard-session-CN55LYyZ.js";
+import { d as Program, f as getProgramConfig, u as PROGRAM_REGISTRY } from "./bin.js";
+import { atom, map } from "nanostores";
+//#region src/lib/programs/program-step.ts
+/**
+* Project program steps into the narrower Screen shape the router consumes.
+*
+* Two things happen here:
+*   1. Headless steps (no `screenId`) are filtered out. The router walks
+*      visible screens; gate-only steps like `detect` are store concerns.
+*   2. The step is narrowed to just { id, show, isComplete } — the
+*      router has no business touching gate, onInit, or label.
+*
+* This intentional separation keeps the router focused on one question:
+* "Which screen should be rendered right now?"
+*/
+function createProgramSequence(steps) {
+	const entries = steps.filter((step) => step.screenId != null).map((step) => ({
+		id: step.screenId,
+		show: step.show,
+		isComplete: step.isComplete ?? step.gate
+	}));
+	entries.push({
+		id: "exit",
+		show: void 0,
+		isComplete: void 0
+	});
+	return entries;
+}
+//#endregion
+//#region src/lib/programs/ai-opt-in-gate.ts
+/** Step id — also the ScreenId.AiOptIn enum value in screen-sequences. */
+const AI_OPT_IN_STEP_ID = "ai-opt-in";
+function aiApproved(session) {
+	return !!session.apiUser?.organization?.is_ai_data_processing_approved;
+}
+/**
+* Returns the program's steps with the AI opt-in gate injected after
+* `auth`. Programs with `requiresAi: false` or no auth step pass
+* through unchanged — without auth, `apiUser` would never be populated
+* for evaluation anyway.
+*/
+function withAiOptInGate(config) {
+	if (config.requiresAi === false) return config.steps;
+	const authIdx = config.steps.findIndex((s) => s.id === "auth");
+	if (authIdx === -1) return config.steps;
+	const gateStep = {
+		id: AI_OPT_IN_STEP_ID,
+		label: "AI opt-in check",
+		screenId: AI_OPT_IN_STEP_ID,
+		show: (session) => !session.ci && session.apiUser != null && !aiApproved(session),
+		isComplete: (session) => session.ci || aiApproved(session),
+		gate: (session) => session.ci || aiApproved(session)
+	};
+	return [
+		...config.steps.slice(0, authIdx + 1),
+		gateStep,
+		...config.steps.slice(authIdx + 1)
+	];
+}
+//#endregion
+//#region src/ui/tui/screen-sequences.ts
+/** All program screen sequences keyed by program id. */
+const PROGRAM_SEQUENCES = Object.fromEntries(PROGRAM_REGISTRY.map((c) => [c.id, createProgramSequence(withAiOptInGate(c))]));
+//#endregion
+//#region src/ui/tui/router.ts
+var WizardRouter = class {
+	sequence;
+	programId;
+	overlays = [];
+	constructor(programId = Program.PostHogIntegration) {
+		this.programId = programId;
+		this.sequence = PROGRAM_SEQUENCES[programId];
+	}
+	/**
+	* Resolve which screen should be active based on session state.
+	* Walks the program sequence, skipping hidden entries and completed entries,
+	* returns the first incomplete screen.
+	*/
+	resolve(session) {
+		if (this.overlays.length > 0) return this.overlays[this.overlays.length - 1];
+		for (const entry of this.sequence) {
+			if (entry.show && !entry.show(session)) continue;
+			if (entry.isComplete && entry.isComplete(session)) continue;
+			return entry.id;
+		}
+		return this.sequence[this.sequence.length - 1].id;
+	}
+	/** The screen that should be rendered right now. */
+	get activeScreen() {
+		if (this.overlays.length > 0) return this.overlays[this.overlays.length - 1];
+		return this.sequence[0].id;
+	}
+	/** The id of the active program. */
+	get activeProgram() {
+		return this.programId;
+	}
+	/** Whether an overlay is currently active. */
+	get hasOverlay() {
+		return this.overlays.length > 0;
+	}
+	/**
+	* Push an overlay that interrupts the current program.
+	* The program resumes when the overlay is dismissed via popOverlay().
+	*/
+	pushOverlay(overlay) {
+		this.overlays.push(overlay);
+	}
+	/**
+	* Dismiss the topmost overlay. The program screen underneath resumes.
+	*/
+	popOverlay() {
+		this.overlays.pop();
+	}
+	/**
+	* Direction hint for screen transitions.
+	*/
+	_lastDirection = null;
+	get lastNavDirection() {
+		return this._lastDirection;
+	}
+	/** @internal — called by store wrapper to track direction */
+	_setDirection(dir) {
+		this._lastDirection = dir;
+	}
+};
+//#endregion
+//#region src/ui/tui/store.ts
+/**
+* WizardStore — Nanostore-backed reactive store for the TUI.
+* React components subscribe via useSyncExternalStore.
+*
+* The active screen is derived from session state — WizardRouter walks
+* the flow and shows the first step whose `isComplete` is still false.
+*
+* Define a step `gate` if your screen needs to await user interactions.
+* bin.ts calls `await store.getGate(stepId)` to pause until the gate
+* predicate becomes true.
+*
+* All session mutations that affect screen resolution go through
+* explicit setters so emitChange() is always called.
+*/
+var store_exports = /* @__PURE__ */ __exportAll({
+	Program: () => Program,
+	WizardStore: () => WizardStore
+});
+/**
+* FIFO cap on retained status lines. The status bar is the only consumer and
+* renders at most EXPANDED_COUNT lines, so there is no reason to retain more —
+* the cap is tied to the window it feeds.
+*/
+const MAX_STATUS_MESSAGES = 10;
+/**
+* Fired once per blocked readiness result, so we can quantify how often
+* the wizard refuses to start and — crucially — split that between
+* confirmed PostHog outages and probe-level reachability failures that
+* are most likely the user's network. Helps us decide whether the
+* health-check UX is over-firing.
+*/
+function captureHealthCheckBlocked(result) {
+	try {
+		const health = result.health;
+		const blockingKeys = getBlockingServiceKeys(health);
+		const blockingStatuses = blockingKeys.map((k) => health[k]?.status);
+		const allNoConnection = blockingStatuses.length > 0 && blockingStatuses.every((s) => s === "no-connection");
+		const decision = blockingKeys.length === 1 && blockingKeys[0] === "githubReleases" ? "github-releases-down" : allNoConnection ? "no-connection" : "confirmed-outage";
+		const posthogStatus = health.posthogOverall?.status;
+		const retriesUsed = Math.max(0, ...[
+			"llmGateway",
+			"mcp",
+			"githubReleases"
+		].map((k) => {
+			const m = (health[k]?.rawIndicator ?? "").match(/attempts=(\d+)/);
+			return m ? Number(m[1]) - 1 : 0;
+		}));
+		analytics.wizardCapture("health check blocked", {
+			decision,
+			blocking_keys: blockingKeys,
+			posthog_status_reachable: posthogStatus !== "no-connection",
+			posthog_status_reports_incident: posthogStatus === "down" || posthogStatus === "degraded",
+			retries_used: retriesUsed
+		});
+	} catch (err) {
+		logToFile(`[health-checks] failed to capture analytics: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+var WizardStore = class {
+	$session = map(buildSession({}));
+	$statusMessages = atom([]);
+	$statusExpanded = atom(false);
+	$tasks = atom([]);
+	$eventPlan = atom([]);
+	$learnCardBlockIdx = atom(0);
+	$learnCardComplete = atom(false);
+	$version = atom(0);
+	$currentStage = atom(null);
+	_onTasksChanged = null;
+	/** Last screen seen — used to detect screen transitions for analytics. */
+	_lastScreen = null;
+	/** Hooks run when transitioning onto a screen. */
+	_enterScreenHooks = /* @__PURE__ */ new Map();
+	/** Gate promises derived from program step definitions. */
+	_gates = /* @__PURE__ */ new Map();
+	version = "";
+	/** Navigation router — resolves active screen from session state. */
+	router;
+	/** Blocks agent execution until the settings-override overlay is dismissed. */
+	_resolveSettingsOverride = null;
+	_backupAndFixSettings = null;
+	/** Blocks OAuth flow until the port-conflict overlay is dismissed. */
+	_resolvePortConflict = null;
+	/** Resolves the OAuth flow with a manually-entered authorization code. */
+	_resolveManualAuthCode = null;
+	/** Resolves the in-flight wizard_ask request. */
+	_resolvePendingQuestion = null;
+	constructor(program = Program.PostHogIntegration) {
+		this.router = new WizardRouter(program);
+		this._initFromProgram(program);
+	}
+	/**
+	* Scan program steps for gate predicates and create gate promises.
+	*
+	* Steps are wrapped with withAiOptInGate so the injected ai-opt-in
+	* step's gate registers here — the agent runner awaits it (via
+	* WizardUI.waitForAiOptIn) before any source leaves the machine.
+	* Same wrapper screen-sequences.ts uses, so the gate and its screen
+	* can't drift apart.
+	*/
+	_initFromProgram(program) {
+		const steps = withAiOptInGate(getProgramConfig(program));
+		for (const step of steps) if (step.gate) {
+			let resolve;
+			const promise = new Promise((r) => {
+				resolve = r;
+			});
+			this._gates.set(step.id, {
+				predicate: step.gate,
+				promise,
+				resolve,
+				resolved: false
+			});
+		}
+	}
+	/**
+	* Run the program steps' onInit callbacks. startTUI calls this once
+	* the screens are actually rendering — constructing a store alone
+	* (tests, playground) must not fire init work like the health-check
+	* pre-flight, whose probes belong only to flows that show its screen.
+	*/
+	runInitHooks() {
+		const steps = getProgramConfig(this.router.activeProgram).steps;
+		const getSession = () => this.session;
+		const ctx = {
+			get session() {
+				return getSession();
+			},
+			setReadinessResult: (r) => this.setReadinessResult(r),
+			setFrameworkContext: (k, v) => this.setFrameworkContext(k, v),
+			emitChange: () => this.emitChange()
+		};
+		for (const step of steps) step.onInit?.(ctx);
+	}
+	/**
+	* Run all `onReady` hooks declared by the current flow's steps, in
+	* order. Must be called after `store.session = session` so hooks see
+	* the real installDir. bin.ts calls this generically — it doesn't
+	* need to know which program has which pre-flow work.
+	*/
+	async runReadyHooks() {
+		const steps = getProgramConfig(this.router.activeProgram).steps;
+		const ctx = {
+			session: this.session,
+			setFrameworkContext: (k, v) => this.setFrameworkContext(k, v),
+			setFrameworkConfig: (i, c) => this.setFrameworkConfig(i, c),
+			setDetectedFramework: (l) => this.setDetectedFramework(l),
+			setSkillId: (id) => this.setSkillId(id),
+			setUnsupportedVersion: (info) => this.setUnsupportedVersion(info),
+			addDiscoveredFeature: (f) => this.addDiscoveredFeature(f),
+			setDetectionComplete: () => this.setDetectionComplete()
+		};
+		for (const step of steps) if (step.onReady) await step.onReady(ctx);
+	}
+	/**
+	* Get a gate promise by step ID — the primary blocking checkpoint API
+	* for bin.ts. `await store.getGate('...')` parks the caller until the
+	* corresponding program step's gate predicate flips to true (if the
+	* predicate stays false, the caller stays parked indefinitely — the
+	* TUI keeps rendering so the user can resolve whatever is blocking).
+	*
+	* If the program doesn't define a step with this ID, or the step
+	* has no `gate` predicate, this returns an already-resolved promise
+	* so bin.ts flows straight through. This lets programs opt in to
+	* gates on a per-step basis without bin.ts needing to know which
+	* gates exist in which flow.
+	*/
+	getGate(stepId) {
+		return this._gates.get(stepId)?.promise ?? Promise.resolve();
+	}
+	/**
+	* Re-evaluate every gate predicate against the current session and
+	* resolve any whose predicate now returns true. Called after every
+	* emitChange(), so gates unblock as soon as the session mutation
+	* that satisfies them lands. Gates only resolve once — a predicate
+	* that goes true → false → true will NOT re-block a caller that
+	* already awaited through.
+	*/
+	_checkGates() {
+		for (const [, gate] of this._gates) if (!gate.resolved && gate.predicate(this.session)) {
+			gate.resolved = true;
+			gate.resolve();
+		}
+	}
+	get session() {
+		return this.$session.get();
+	}
+	set session(value) {
+		this.$session.set(value);
+		this.emitChange();
+	}
+	get statusMessages() {
+		return this.$statusMessages.get();
+	}
+	get tasks() {
+		return this.$tasks.get();
+	}
+	get eventPlan() {
+		return this.$eventPlan.get();
+	}
+	get currentStage() {
+		return this.$currentStage.get();
+	}
+	/** No-op when the stage hasn't changed, so `startedAt` survives across
+	*  re-renders and tab switches and measures real stage time. */
+	setCurrentStage(stage) {
+		if (this.$currentStage.get()?.stage === stage) return;
+		this.$currentStage.set({
+			stage,
+			startedAt: Date.now()
+		});
+		this.emitChange();
+	}
+	get statusExpanded() {
+		return this.$statusExpanded.get();
+	}
+	toggleStatusExpanded() {
+		this.$statusExpanded.set(!this.$statusExpanded.get());
+		this.emitChange();
+	}
+	setStatusExpanded(expanded) {
+		if (this.$statusExpanded.get() !== expanded) {
+			this.$statusExpanded.set(expanded);
+			this.emitChange();
+		}
+	}
+	/** Sets setupConfirmed. Gate resolves via _checkGates(). */
+	completeSetup() {
+		this.$session.setKey("setupConfirmed", true);
+		analytics.wizardCapture("setup confirmed", sessionProperties(this.session));
+		this.emitChange();
+	}
+	setRunPhase(phase) {
+		this.$session.setKey("runPhase", phase);
+		this.emitChange();
+	}
+	setCredentials(credentials) {
+		this.$session.setKey("credentials", credentials);
+		if (credentials?.projectId) analytics.setTag("project_id", credentials.projectId);
+		analytics.wizardCapture("auth complete", { project_id: credentials?.projectId });
+		this.emitChange();
+	}
+	setRoleAtOrganization(role) {
+		this.$session.setKey("roleAtOrganization", role);
+		this.emitChange();
+	}
+	setApiUser(user) {
+		this.$session.setKey("apiUser", user);
+		this.emitChange();
+	}
+	setFrameworkConfig(integration, config) {
+		this.$session.setKey("integration", integration);
+		this.$session.setKey("frameworkConfig", config);
+		this.$session.setKey("unsupportedVersion", null);
+		if (integration) analytics.setTag("integration", integration);
+		this.emitChange();
+	}
+	setDetectionComplete() {
+		this.$session.setKey("detectionComplete", true);
+		this.emitChange();
+	}
+	setDetectedFramework(label) {
+		this.$session.setKey("detectedFrameworkLabel", label);
+		analytics.setTag("detected_framework", label);
+		this.emitChange();
+	}
+	setSkillId(skillId) {
+		this.$session.setKey("skillId", skillId);
+		this.emitChange();
+	}
+	setUnsupportedVersion(info) {
+		this.$session.setKey("unsupportedVersion", info);
+		this.emitChange();
+	}
+	setLoginUrl(url) {
+		this.$session.setKey("loginUrl", url);
+		this.emitChange();
+	}
+	setAuthorizeUrl(url) {
+		this.$session.setKey("authorizeUrl", url);
+		this.emitChange();
+	}
+	setReadinessResult(result) {
+		this.$session.setKey("readinessResult", result);
+		if (result && result.decision === "no") captureHealthCheckBlocked(result);
+		this.emitChange();
+	}
+	/** User dismissed the blocking outage screen. Gate resolves via _checkGates(). */
+	dismissOutage() {
+		logToFile("[health-checks] user dismissed outage screen, continuing");
+		this.$session.setKey("outageDismissed", true);
+		this.emitChange();
+	}
+	/**
+	* Push the settings-override overlay and return a promise that blocks
+	* until the user dismisses it via backupAndFixSettingsOverride().
+	*/
+	showSettingsOverride(conflicts, backupAndFix) {
+		const allKeys = conflicts.flatMap((c) => c.keys);
+		this.$session.setKey("settingsOverrideKeys", allKeys);
+		this.$session.setKey("settingsConflicts", conflicts);
+		this._backupAndFixSettings = backupAndFix;
+		if (conflicts.some((c) => !c.writable)) this.pushOverlay("managed-settings");
+		else this.pushOverlay("settings-override");
+		return new Promise((resolve) => {
+			this._resolveSettingsOverride = resolve;
+		});
+	}
+	/**
+	* Push the port-conflict overlay and return a promise that blocks
+	* until the user frees the ports and retries, or exits.
+	*/
+	showPortConflict(processInfo) {
+		this.$session.setKey("portConflictProcess", processInfo);
+		this.pushOverlay("port-conflict");
+		return new Promise((resolve) => {
+			this._resolvePortConflict = resolve;
+		});
+	}
+	/** Dismiss the port-conflict overlay and retry the OAuth port loop. */
+	resolvePortConflict() {
+		this.$session.setKey("portConflictProcess", null);
+		this.popOverlay();
+		this._resolvePortConflict?.();
+		this._resolvePortConflict = null;
+	}
+	/**
+	* Return a promise that resolves when the user submits a manually-entered
+	* OAuth code via the paste modal. The OAuth flow races this against the
+	* local callback server — see `performOAuthFlow`.
+	*/
+	waitForManualAuthCode() {
+		return new Promise((resolve) => {
+			this._resolveManualAuthCode = resolve;
+		});
+	}
+	/** Open the manual OAuth code-entry overlay over the auth screen. */
+	showManualAuthCode() {
+		this.pushOverlay("manual-auth-code");
+	}
+	/** Dismiss the manual OAuth code overlay without submitting. */
+	dismissManualAuthCode() {
+		this.popOverlay();
+	}
+	/**
+	* Submit a manually-entered authorization code: dismiss the overlay and
+	* resolve the in-flight OAuth flow so it can exchange the code for a token.
+	*/
+	submitManualAuthCode(code) {
+		this.popOverlay();
+		this._resolveManualAuthCode?.(code);
+		this._resolveManualAuthCode = null;
+	}
+	/**
+	* Open the WizardAsk overlay with a set of questions and return a promise
+	* that resolves once the user submits answers (or the request is cancelled).
+	*
+	* Only one request is in flight at a time — calling this while a request
+	* is already pending throws.
+	*/
+	requestQuestion(question) {
+		if (this._resolvePendingQuestion) throw new Error("requestQuestion called while another wizard_ask request is pending");
+		this.$session.setKey("pendingQuestion", question);
+		this.pushOverlay("wizard-ask");
+		analytics.wizardCapture("wizard_ask shown", {
+			source: question.source,
+			question_count: question.questions.length,
+			kinds: question.questions.map((q) => q.kind)
+		});
+		return new Promise((resolve) => {
+			this._resolvePendingQuestion = resolve;
+		});
+	}
+	/**
+	* Resolve the in-flight wizard_ask request with the user's answers and
+	* dismiss the overlay. Answers flow back to the agent as the tool result.
+	*/
+	resolvePendingQuestion(answers) {
+		const resolve = this._resolvePendingQuestion;
+		this._resolvePendingQuestion = null;
+		this.$session.setKey("pendingQuestion", null);
+		this.popOverlay();
+		resolve?.(answers);
+	}
+	/**
+	* Cancel the in-flight wizard_ask request — the bridge sends a sentinel
+	* answer ("__cancelled__") so the skill can decide how to handle it.
+	*/
+	cancelPendingQuestion() {
+		const pending = this.session.pendingQuestion;
+		if (!pending) return;
+		const cancelled = {};
+		for (const q of pending.questions) cancelled[q.id] = "__cancelled__";
+		this.resolvePendingQuestion(cancelled);
+	}
+	/**
+	* Back up .claude/settings.json. Dismisses the overlay on success.
+	*/
+	backupAndFixSettingsOverride() {
+		const ok = this._backupAndFixSettings?.() ?? false;
+		if (ok) {
+			this.$session.setKey("settingsOverrideKeys", null);
+			this.$session.setKey("settingsConflicts", null);
+			this.popOverlay();
+			this._resolveSettingsOverride?.();
+			this._resolveSettingsOverride = null;
+			this._backupAndFixSettings = null;
+		}
+		return ok;
+	}
+	/** Push the auth-error overlay (no dismiss — user must exit). */
+	showAuthError(detail) {
+		this.$session.setKey("authErrorDetail", detail ?? null);
+		this.pushOverlay("auth-error");
+	}
+	/** Push the session-timeout overlay (no dismiss — user must exit). */
+	showSessionTimeout() {
+		this.pushOverlay("session-timeout");
+	}
+	addDiscoveredFeature(feature) {
+		if (!this.session.discoveredFeatures.includes(feature)) {
+			this.session.discoveredFeatures.push(feature);
+			this.emitChange();
+		}
+	}
+	/**
+	* Enable an additional feature: enqueue it for the stop hook
+	* and set any feature-specific session flags.
+	*/
+	enableFeature(feature) {
+		if (!this.session.additionalFeatureQueue.includes(feature)) this.session.additionalFeatureQueue.push(feature);
+		if (feature === "llm") this.session.llmOptIn = true;
+		analytics.wizardCapture("feature enabled", { feature });
+		this.emitChange();
+	}
+	setMcpComplete(outcome = "skipped", installedClients = [], featuresSelected) {
+		this.$session.setKey("mcpComplete", true);
+		this.$session.setKey("mcpOutcome", outcome);
+		this.$session.setKey("mcpInstalledClients", installedClients);
+		const featuresPayload = outcome === "installed" && featuresSelected !== void 0 ? { mcp_features_selected: featuresSelected } : {};
+		analytics.wizardCapture("mcp complete", {
+			mcp_outcome: outcome,
+			mcp_installed_clients: installedClients,
+			...featuresPayload,
+			...sessionProperties(this.session)
+		});
+		this.emitChange();
+	}
+	setSkillsComplete(kept) {
+		this.$session.setKey("skillsComplete", true);
+		analytics.wizardCapture("skills complete", {
+			skills_kept: kept,
+			...sessionProperties(this.session)
+		});
+		this.emitChange();
+	}
+	setMcpSuggestedPromptsDismissed() {
+		this.$session.setKey("mcpSuggestedPromptsDismissed", true);
+		this.emitChange();
+	}
+	setSlackStepDismissed() {
+		this.$session.setKey("slackStepDismissed", true);
+		this.emitChange();
+	}
+	setSlackConnected(connected) {
+		this.$session.setKey("slackConnected", connected);
+		this.emitChange();
+	}
+	setOutroDismissed() {
+		this.$session.setKey("outroDismissed", true);
+		this.emitChange();
+	}
+	setOutroData(data) {
+		this.$session.setKey("outroData", data);
+		this.emitChange();
+	}
+	setDashboardUrl(url) {
+		logToFile(`store.setDashboardUrl: ${url}`);
+		this.$session.setKey("dashboardUrl", url);
+		this.emitChange();
+	}
+	setNotebookUrl(url) {
+		logToFile(`store.setNotebookUrl: ${url}`);
+		this.$session.setKey("notebookUrl", url);
+		this.emitChange();
+	}
+	setFrameworkContext(key, value) {
+		const ctx = {
+			...this.$session.get().frameworkContext,
+			[key]: value
+		};
+		this.$session.setKey("frameworkContext", ctx);
+		this.emitChange();
+	}
+	/**
+	* The screen that should be rendered right now.
+	* Derived from session state via the router.
+	*/
+	get currentScreen() {
+		return this.router.resolve(this.session);
+	}
+	/** Direction hint for screen transitions. */
+	get lastNavDirection() {
+		return this.router.lastNavDirection;
+	}
+	getVersion() {
+		return this.$version.get();
+	}
+	/**
+	* Notify React that state has changed.
+	* The router re-resolves the active screen on next render.
+	* Gate predicates are checked and resolved if ready.
+	*/
+	emitChange() {
+		this.router._setDirection("push");
+		this.$version.set(this.$version.get() + 1);
+		this._checkGates();
+		this._detectTransition();
+	}
+	pushOverlay(overlay) {
+		this.router._setDirection("push");
+		this.router.pushOverlay(overlay);
+		this.$version.set(this.$version.get() + 1);
+		this._detectTransition();
+	}
+	popOverlay() {
+		this.router._setDirection("pop");
+		this.router.popOverlay();
+		this.$version.set(this.$version.get() + 1);
+		this._detectTransition();
+	}
+	/**
+	* Register a callback to run when transitioning onto the given screen.
+	* Fires after every transition that lands on this screen.
+	*/
+	onEnterScreen(screen, fn) {
+		const list = this._enterScreenHooks.get(screen) ?? [];
+		list.push(fn);
+		this._enterScreenHooks.set(screen, list);
+	}
+	/**
+	* Detect screen transitions, run enter-screen hooks, and fire analytics.
+	* Called at the end of emitChange/pushOverlay/popOverlay.
+	*/
+	_detectTransition() {
+		const next = this.router.resolve(this.session);
+		const prev = this._lastScreen;
+		if (next !== prev) analytics.setTag("$screen_name", next);
+		if (prev !== null && next !== prev) {
+			const hooks = this._enterScreenHooks.get(next);
+			if (hooks) for (const fn of hooks) fn();
+			analytics.wizardCapture(`screen ${next}`, {
+				from_screen: prev,
+				program_id: this.router.activeProgram,
+				...sessionProperties(this.session)
+			});
+		}
+		this._lastScreen = next;
+	}
+	pushStatus(message) {
+		const msgs = this.$statusMessages.get();
+		if (msgs.length > 0 && msgs[msgs.length - 1] === message) return;
+		const next = msgs.length >= MAX_STATUS_MESSAGES ? [...msgs.slice(msgs.length - MAX_STATUS_MESSAGES + 1), message] : [...msgs, message];
+		this.$statusMessages.set(next);
+		this.emitChange();
+	}
+	setTasks(tasks) {
+		this.$tasks.set(tasks);
+		this.emitChange();
+	}
+	updateTask(index, done) {
+		const tasks = this.$tasks.get();
+		if (tasks[index]) {
+			const updated = [...tasks];
+			updated[index] = {
+				...updated[index],
+				done,
+				status: done ? "completed" : "pending"
+			};
+			this.$tasks.set(updated);
+			this.emitChange();
+		}
+	}
+	setEventPlan(events) {
+		this.$eventPlan.set(events);
+		this.emitChange();
+	}
+	get learnCardBlockIdx() {
+		return this.$learnCardBlockIdx.get();
+	}
+	setLearnCardBlockIdx(idx) {
+		this.$learnCardBlockIdx.set(idx);
+	}
+	get learnCardComplete() {
+		return this.$learnCardComplete.get();
+	}
+	setLearnCardComplete() {
+		this.$learnCardComplete.set(true);
+		this.emitChange();
+	}
+	syncTodos(todos) {
+		const incoming = todos.map((t) => {
+			const status = isTaskStatus(t.status) ? t.status : "pending";
+			return {
+				label: t.content,
+				activeForm: t.activeForm,
+				status,
+				done: status === "completed"
+			};
+		});
+		const incomingLabels = new Set(incoming.map((t) => t.label));
+		const retained = this.$tasks.get().filter((t) => t.done && !incomingLabels.has(t.label));
+		this.$tasks.set([...retained, ...incoming]);
+		this.emitChange();
+		this._onTasksChanged?.();
+	}
+	/** Register a listener for task state changes (e.g. task stream push). */
+	set onTasksChanged(fn) {
+		this._onTasksChanged = fn;
+	}
+	subscribe(callback) {
+		return this.$version.listen(() => callback());
+	}
+	getSnapshot() {
+		return this.$version.get();
+	}
+};
+//#endregion
+export { store_exports as n, WizardStore as t };
+
+//# sourceMappingURL=store-D15C9YSW.js.map