rei-kit 0.1.0

package/dist/index.js

@@ -0,0 +1,1349 @@
+import { n as registerErrorMapper, r as toAppError, t as AppError } from "./app-error-DF9cijE0.js";
+import { Fragment, Teleport, Transition, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, mergeModels, mergeProps, nextTick, normalizeClass, normalizeStyle, onMounted, onScopeDispose, onUnmounted, openBlock, readonly, ref, renderList, renderSlot, resolveDynamicComponent, toDisplayString, unref, useId, useModel, vModelDynamic, vModelRadio, watch, watchEffect, withCtx, withDirectives } from "vue";
+import { ArrowDown, ArrowRight, ArrowUp, ChevronRight, X } from "lucide-vue-next";
+import { createI18n } from "vue-i18n";
+//#region src/utils/date.ts
+/**
+* Local calendar-day helpers.
+*
+* Every function is pure and works on `YYYY-MM-DD` keys, the same shape as the
+* `date` columns in Postgres. Nothing here calls `toISOString`: that converts to
+* UTC, so in a UTC+9 timezone every entry made between midnight and 09:00 would
+* be written to the previous day.
+*/
+/**
+* Formats a `Date` as a local `YYYY-MM-DD` key.
+*
+* @param date - Any `Date`; only its local year, month and day are read.
+* @returns The calendar day in the runtime's own timezone.
+*
+* @example
+* ```ts
+* // 2026-08-23 01:30 in Tokyo
+* toDateKey(new Date())        // '2026-08-23'
+* new Date().toISOString()     // '2026-08-22T16:30…'  ← the bug
+* ```
+*/
+function toDateKey(date) {
+	return `${String(date.getFullYear()).padStart(4, "0")}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+}
+/** Today's key in the user's own timezone. */
+function todayKey() {
+	return toDateKey(/* @__PURE__ */ new Date());
+}
+/**
+* Parses a `YYYY-MM-DD` key into a `Date` at local midnight.
+*
+* @param key - A key produced by {@link toDateKey}.
+* @returns Local midnight of that calendar day.
+* @throws If the key is not three numeric parts.
+*
+* @example
+* ```ts
+* fromDateKey('2026-08-23')      // local midnight, correct
+* new Date('2026-08-23')         // UTC midnight — shifts a day in some zones
+* ```
+*/
+function fromDateKey(key) {
+	const [year, month, day] = key.split("-").map(Number);
+	if (year === void 0 || month === void 0 || day === void 0) throw new Error(`Invalid date key: ${key}`);
+	return new Date(year, month - 1, day);
+}
+/**
+* Shifts a date key by whole calendar days.
+*
+* Uses `setDate`, which is calendar-aware: it rolls over month and year ends,
+* and stays correct across daylight-saving transitions. Adding
+* `days * 86_400_000` milliseconds would not — a DST day is 23 or 25 hours long.
+*
+* @param key - Starting `YYYY-MM-DD` key.
+* @param days - Days to add; negative goes back.
+* @returns The resulting key.
+*
+* @example
+* ```ts
+* addDays('2026-01-31', 1)   // '2026-02-01'
+* addDays('2026-01-01', -1)  // '2025-12-31'
+* addDays('2028-02-28', 1)   // '2028-02-29'  — leap year
+* ```
+*/
+function addDays(key, days) {
+	const date = fromDateKey(key);
+	date.setDate(date.getDate() + days);
+	return toDateKey(date);
+}
+/**
+* The last `count` days ending today, oldest first.
+*
+* `today` is a parameter so the function stays pure and testable; call sites
+* normally omit it.
+*
+* @param count - How many days to return, including `today`.
+* @param today - End of the range. Defaults to the real today.
+* @returns Keys in ascending order.
+*
+* @example
+* ```ts
+* lastNDays(3, '2026-08-23')  // ['2026-08-21', '2026-08-22', '2026-08-23']
+* ```
+*/
+function lastNDays(count, today = todayKey()) {
+	const keys = [];
+	for (let offset = count - 1; offset >= 0; offset -= 1) keys.push(addDays(today, -offset));
+	return keys;
+}
+/**
+* The first day of the week containing `key`.
+*
+* The user's preference is a parameter, not a module-level setting: changing it
+* in Profile has to re-render the week grid and the year heatmap immediately,
+* and a global would make that a hidden dependency.
+*
+* @param key - Any day in the week.
+* @param weekStartsOn - 0 for Sunday, 1 for Monday.
+* @returns Key of that week's first day.
+*
+* @example
+* ```ts
+* // 2026-08-23 is a Sunday
+* startOfWeek('2026-08-23', 1)  // '2026-08-17'  — previous Monday
+* startOfWeek('2026-08-23', 0)  // '2026-08-23'  — already Sunday
+* ```
+*/
+function startOfWeek(key, weekStartsOn) {
+	return addDays(key, -((fromDateKey(key).getDay() - weekStartsOn + 7) % 7));
+}
+/**
+* Every day of a calendar year, in order.
+*
+* Leap years fall out of the loop for free: it walks day by day until the year
+* rolls over, so February 29 is included when it exists.
+*
+* @param year - Four-digit year.
+* @returns 365 or 366 keys, oldest first.
+*/
+function eachDayOfYear(year) {
+	const keys = [];
+	const date = new Date(year, 0, 1);
+	while (date.getFullYear() === year) {
+		keys.push(toDateKey(date));
+		date.setDate(date.getDate() + 1);
+	}
+	return keys;
+}
+/**
+* Empty cells before a block's first day in a seven-row column grid.
+*
+* The grid fills column by column, so the first column is only partly used
+* unless the block starts exactly on the week's first day. An off-by-one here
+* shifts the whole block by a row, so this is unit tested.
+*
+* @param firstDayKey - First day of the block, e.g. `'2026-02-01'`.
+* @param weekStartsOn - 0 for Sunday, 1 for Monday.
+* @returns 0-6 blank cells.
+*
+* @example
+* ```ts
+* leadingBlanks('2026-01-01', 1)  // 3 — a Thursday, Mon-Wed are blank
+* leadingBlanks('2024-01-01', 1)  // 0 — a Monday
+* ```
+*/
+function leadingBlanks(firstDayKey, weekStartsOn) {
+	return (fromDateKey(firstDayKey).getDay() - weekStartsOn + 7) % 7;
+}
+//#endregion
+//#region src/utils/format.ts
+/**
+* The locale `Intl` formatting uses.
+*
+* Held here rather than imported from an i18n runtime so the utilities have no
+* i18n dependency at all: an app that never installs vue-i18n still gets dates
+* in the right language. `createI18nRuntime` sets this when it is used.
+*/
+var locale = ref(typeof navigator === "undefined" ? "en" : navigator.language ?? "en");
+/**
+* Points every formatter at a new locale.
+*
+* @example
+* ```ts
+* setFormatLocale('tr-TR')
+* ```
+*/
+function setFormatLocale(next) {
+	locale.value = next;
+}
+/**
+* `Intl.DateTimeFormat` is expensive to construct, so instances are cached per
+* locale and option set. The key includes the locale, which is what lets the
+* cache survive a language change instead of returning stale formatters.
+*/
+var cache = /* @__PURE__ */ new Map();
+/**
+* Formats a date in the active locale.
+*
+* Reading the locale ref here is deliberate: called from a `computed`, the
+* result re-evaluates when the language changes.
+*
+* @param date - Date to format.
+* @param options - Passed straight to `Intl.DateTimeFormat`.
+*
+* @example
+* ```ts
+* formatDate(new Date(), { weekday: 'narrow' }) // 'T'
+* ```
+*/
+function formatDate(date, options) {
+	const tag = locale.value;
+	const key = `${tag}:${JSON.stringify(options)}`;
+	let formatter = cache.get(key);
+	if (!formatter) {
+		formatter = new Intl.DateTimeFormat(tag, options);
+		cache.set(key, formatter);
+	}
+	return formatter.format(date);
+}
+//#endregion
+//#region src/utils/day-label.ts
+/**
+* A short name for a day, relative to today.
+*
+* "Today" and "Yesterday" are worth spelling out — they are the two a user
+* actually reaches for. Anything older gets its weekday, which inside a
+* five-day window is unambiguous and stays two or three characters in every
+* language.
+*
+* The two words are arguments rather than translated here: a library that calls
+* `t()` forces every consumer onto one i18n setup.
+*
+* @param dateKey - The day to label (`YYYY-MM-DD`).
+* @param today - Today's key, passed in so the caller controls the clock.
+* @param labels - What to call today and yesterday.
+*
+* @example
+* ```ts
+* relativeDayLabel('2026-08-28', '2026-08-31', { today: 'Today', yesterday: 'Yesterday' })
+* // 'Fri'
+* ```
+*/
+function relativeDayLabel(dateKey, today, labels) {
+	if (dateKey === today) return labels.today;
+	if (dateKey === addDays(today, -1)) return labels.yesterday;
+	return formatDate(fromDateKey(dateKey), { weekday: "short" });
+}
+//#endregion
+//#region src/utils/download.ts
+/**
+* Hands the user a file without a server round trip.
+*
+* @param data - Anything `JSON.stringify` can serialise.
+* @param filename - Suggested name, e.g. `hibi-export-2026-08-24.json`.
+*/
+function downloadJson(data, filename) {
+	const blob = new Blob([JSON.stringify(data, null, 2)], { type: "application/json" });
+	const url = URL.createObjectURL(blob);
+	const link = document.createElement("a");
+	link.href = url;
+	link.download = filename;
+	link.click();
+	URL.revokeObjectURL(url);
+}
+//#endregion
+//#region src/utils/redirect.ts
+/**
+* Resolves a `?redirect=` query value into a safe in-app path.
+*
+* Only same-origin paths are accepted. Anything else falls back to `/`,
+* so a crafted link cannot bounce a user from the real login page to a
+* phishing clone.
+*
+* Pure: takes the query value instead of reading the router, so it also
+* works inside navigation guards and can be unit tested.
+*
+* @param target - Raw `route.query.redirect` value. May be a string, an
+*   array (repeated query key), `null`, or `undefined`.
+* @returns A path starting with a single `/`. Defaults to `/`.
+*
+* @example
+* ```ts
+* // in a view
+* await router.push(safeRedirect(route.query.redirect))
+*
+* // in a guard
+* return safeRedirect(to.query.redirect)
+* ```
+*
+* @example
+* ```ts
+* safeRedirect('/week')              // '/week'
+* safeRedirect('https://evil.com')   // '/'
+* safeRedirect('//evil.com')         // '/'  (protocol-relative URL)
+* safeRedirect(['/a', '/b'])         // '/'
+* safeRedirect(undefined)            // '/'
+* ```
+*/
+function safeRedirect(target) {
+	if (typeof target === "string" && target.startsWith("/") && !target.startsWith("//")) return target;
+	return "/";
+}
+//#endregion
+//#region src/utils/haptics.ts
+/**
+* A short vibration for a confirmed tap.
+*
+* Optional chaining is not decoration: iOS Safari has no `vibrate` at all, and
+* calling it unguarded would throw on every marked day.
+*
+* @param duration - Milliseconds. Keep it under ~15ms; longer reads as an alert.
+*/
+function tapFeedback(duration = 10) {
+	navigator.vibrate?.(duration);
+}
+//#endregion
+//#region src/utils/platform.ts
+/**
+* Whether the app is running from the Home Screen rather than a browser tab.
+*
+* Two checks because iOS predates the standard one: `display-mode: standalone`
+* is the modern signal, `navigator.standalone` is Safari's own.
+*/
+function isInstalled() {
+	if (typeof window === "undefined") return false;
+	return window.matchMedia("(display-mode: standalone)").matches || navigator.standalone === true;
+}
+/** iPhone and iPad, including iPadOS reporting itself as a Mac. */
+function isApplePortable() {
+	if (typeof window === "undefined") return false;
+	return /iPad|iPhone|iPod/.test(navigator.userAgent) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1;
+}
+/**
+* Whether this device can only receive notifications once the app is installed.
+*
+* Safari on iOS grants notification permission to an installed web app and to
+* nothing else — in a normal tab the request does not even prompt. Telling the
+* user to allow notifications there is asking for something the browser will
+* not offer, so the UI has to say "add to Home Screen" instead.
+*
+* @example
+* ```ts
+* if (needsIosInstall()) // show the Home Screen instruction, not the button
+* ```
+*/
+function needsIosInstall() {
+	return isApplePortable() && !isInstalled();
+}
+//#endregion
+//#region src/composables/use-theme.ts
+/**
+* Namespaced by the app, not by this package.
+*
+* Two rei-kit apps served from the same origin would otherwise share one theme
+* setting — and during development on localhost, they will be.
+*/
+var storageKey = "rei-theme";
+function isThemePreference(value) {
+	return value === "system" || value === "light" || value === "dark";
+}
+/** Reads the stored preference, falling back to `system`. */
+function readStoredTheme() {
+	try {
+		const stored = localStorage.getItem(storageKey);
+		return isThemePreference(stored) ? stored : "system";
+	} catch {
+		return "system";
+	}
+}
+function storeTheme(preference) {
+	try {
+		localStorage.setItem(storageKey, preference);
+	} catch {}
+}
+/** Adds or removes `.dark` on `<html>`, resolving `system` against the OS. */
+function applyTheme(preference) {
+	const prefersDark = window.matchMedia("(prefers-color-scheme: dark)").matches;
+	const isDark = preference === "dark" || preference === "system" && prefersDark;
+	document.documentElement.classList.toggle("dark", isDark);
+}
+/**
+* The shared preference, created on first use rather than at import.
+*
+* Lazy on purpose: reading storage at import time would lock in the default key
+* before an app had a chance to set its own, leaving the controller reading one
+* key and writing another.
+*/
+var preference = null;
+function controller() {
+	if (preference) return preference;
+	preference = ref(readStoredTheme());
+	watch(preference, (next) => {
+		storeTheme(next);
+		applyTheme(next);
+	}, { immediate: true });
+	window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", () => {
+		if (preference?.value === "system") applyTheme("system");
+	});
+	return preference;
+}
+/**
+* Sets where the preference is stored.
+*
+* Safe in either order: called before the first `useTheme()` it simply changes
+* the key, and called after it re-reads under the new one, so the controller
+* never reads from one key while writing to another.
+*
+* @example
+* ```ts
+* setThemeStorageKey('hibi-theme')   // once, at startup
+* ```
+*/
+function setThemeStorageKey(key) {
+	storageKey = key;
+	if (preference) preference.value = readStoredTheme();
+}
+/** @returns The shared preference ref; assigning to it stores and applies it. */
+function useTheme() {
+	return controller();
+}
+//#endregion
+//#region src/composables/use-today.ts
+/**
+* Today's date key, kept current while the app stays open.
+*
+* `todayKey()` called once in `setup` freezes the date for the lifetime of the
+* component. Nobody notices in a session that lasts minutes, but a phone left
+* on the Today screen overnight would keep marking yesterday, and the Week grid
+* would disable the column that just became today.
+*/
+var current = ref(todayKey());
+var timer;
+/** A second past midnight, so a fast timer cannot fire on the old date. */
+function msUntilMidnight() {
+	const now = /* @__PURE__ */ new Date();
+	return new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1, 0, 0, 1).getTime() - now.getTime();
+}
+function refresh() {
+	current.value = todayKey();
+}
+function schedule() {
+	clearTimeout(timer);
+	timer = setTimeout(() => {
+		refresh();
+		schedule();
+	}, msUntilMidnight());
+}
+schedule();
+document.addEventListener("visibilitychange", () => {
+	if (document.visibilityState !== "visible") return;
+	refresh();
+	schedule();
+});
+/**
+* @returns Read-only ref holding today's `YYYY-MM-DD` key.
+*
+* @example
+* ```ts
+* const today = useToday()
+* const isFuture = computed(() => day > today.value)
+* ```
+*/
+function useToday() {
+	return readonly(current);
+}
+//#endregion
+//#region src/composables/use-online.ts
+/**
+* Tracks whether the browser thinks it has a network connection.
+*
+* Note the limit: `navigator.onLine` only reports whether a network interface
+* is up, not whether requests actually succeed. Treat it as a hint for the UI,
+* never as a reason to skip error handling.
+*
+* Listeners are removed on unmount, so the composable is safe to call per view.
+*
+* @returns A readonly ref that flips with the browser's online/offline events.
+*
+* @example
+* ```ts
+* const isOnline = useOnline()
+* // <p v-if="!isOnline">You're offline.</p>
+* ```
+*/
+function useOnline() {
+	const isOnline = ref(true);
+	function update() {
+		isOnline.value = navigator.onLine;
+	}
+	onMounted(() => {
+		update();
+		window.addEventListener("online", update);
+		window.addEventListener("offline", update);
+	});
+	onUnmounted(() => {
+		window.removeEventListener("online", update);
+		window.removeEventListener("offline", update);
+	});
+	return readonly(isOnline);
+}
+//#endregion
+//#region src/composables/use-debounced-callback.ts
+/**
+* Delays a callback until the caller stops calling it.
+*
+* Used for note autosave: a request per keystroke would be wasteful, but losing
+* the last keystrokes when the user navigates away would be worse — so the
+* pending call is flushed on dispose, and `flush` is exposed for route guards.
+*
+* @param callback - Runs with the arguments of the most recent call.
+* @param delay - Quiet period in milliseconds.
+* @returns `run` to schedule, `flush` to run now, `cancel` to drop.
+*
+* @example
+* ```ts
+* const save = useDebouncedCallback((body: string) => mutate(body), 800)
+* watch(text, (value) => save.run(value))
+* onBeforeRouteLeave(() => save.flush())
+* ```
+*/
+function useDebouncedCallback(callback, delay = 800) {
+	let timer = null;
+	let pending = null;
+	/** Runs the pending call right now, if there is one. */
+	function flush() {
+		if (timer !== null) clearTimeout(timer);
+		timer = null;
+		if (pending !== null) {
+			const args = pending;
+			pending = null;
+			callback(...args);
+		}
+	}
+	/** Drops the pending call without running it. */
+	function cancel() {
+		if (timer !== null) clearTimeout(timer);
+		timer = null;
+		pending = null;
+	}
+	function run(...args) {
+		pending = args;
+		if (timer !== null) clearTimeout(timer);
+		timer = setTimeout(flush, delay);
+	}
+	onScopeDispose(flush);
+	return {
+		run,
+		flush,
+		cancel
+	};
+}
+//#endregion
+//#region src/composables/use-drag-scroll.ts
+/** Movement before a press counts as a drag rather than a tap. */
+var DRAG_THRESHOLD_PX = 6;
+/**
+* Drag-to-scroll for a horizontally scrolling element.
+*
+* The app puts `touch-action: pan-y` on the page content so the tab-swipe
+* gesture keeps its pointer events — the browser never claims a horizontal
+* drag, which also means it never pans this element natively. Rather than give
+* that up, horizontal scrolling is driven here.
+*
+* @param target - The scroll container.
+* @returns `didDrag`, so a click handler can ignore the press that ended a drag.
+*
+* @example
+* ```ts
+* const scroller = ref<HTMLElement | null>(null)
+* const { didDrag } = useDragScroll(scroller)
+*
+* function onClick() {
+*   if (didDrag()) return
+*   // …treat as a tap
+* }
+* ```
+*/
+function useDragScroll(target) {
+	let pointerId = null;
+	let startX = 0;
+	let startScroll = 0;
+	let dragged = false;
+	function onPointerDown(event) {
+		const element = target.value;
+		if (!element || event.pointerType === "mouse") return;
+		pointerId = event.pointerId;
+		startX = event.clientX;
+		startScroll = element.scrollLeft;
+		dragged = false;
+	}
+	function onPointerMove(event) {
+		const element = target.value;
+		if (!element || event.pointerId !== pointerId) return;
+		const dx = event.clientX - startX;
+		if (!dragged && Math.abs(dx) < DRAG_THRESHOLD_PX) return;
+		if (!dragged) {
+			dragged = true;
+			element.setPointerCapture(event.pointerId);
+		}
+		element.scrollLeft = startScroll - dx;
+	}
+	function onPointerUp(event) {
+		const element = target.value;
+		if (element?.hasPointerCapture(event.pointerId)) element.releasePointerCapture(event.pointerId);
+		pointerId = null;
+	}
+	function bind(element) {
+		element.addEventListener("pointerdown", onPointerDown);
+		element.addEventListener("pointermove", onPointerMove);
+		element.addEventListener("pointerup", onPointerUp);
+		element.addEventListener("pointercancel", onPointerUp);
+	}
+	function unbind(element) {
+		element.removeEventListener("pointerdown", onPointerDown);
+		element.removeEventListener("pointermove", onPointerMove);
+		element.removeEventListener("pointerup", onPointerUp);
+		element.removeEventListener("pointercancel", onPointerUp);
+	}
+	watch(target, (element, previous) => {
+		if (previous) unbind(previous);
+		if (element) bind(element);
+	}, { immediate: true });
+	onScopeDispose(() => {
+		if (target.value) unbind(target.value);
+	});
+	return { didDrag: () => dragged };
+}
+//#endregion
+//#region src/composables/use-visual-viewport.ts
+/**
+* Tracks the visual viewport.
+*
+* Chrome and Android browsers honour `interactive-widget=resizes-content`, so
+* the layout viewport already shrinks for the keyboard there. Safari on iOS
+* does not implement it: it shrinks only the *visual* viewport, leaving a sheet
+* sized in `dvh` sitting partly underneath the keyboard.
+*
+* `null` means the API is unavailable, which callers should read as "trust the
+* layout viewport" rather than as zero.
+*
+* @example
+* ```ts
+* const viewport = useVisualViewport()
+* // :style="viewport ? { height: `${viewport.height}px` } : undefined"
+* ```
+*/
+function useVisualViewport() {
+	const rect = ref(null);
+	const viewport = window.visualViewport;
+	if (!viewport) return readonly(rect);
+	function read() {
+		if (!viewport) return;
+		rect.value = {
+			height: viewport.height,
+			offsetTop: viewport.offsetTop
+		};
+	}
+	read();
+	viewport.addEventListener("resize", read);
+	viewport.addEventListener("scroll", read);
+	onScopeDispose(() => {
+		viewport.removeEventListener("resize", read);
+		viewport.removeEventListener("scroll", read);
+	});
+	return readonly(rect);
+}
+//#endregion
+//#region src/components/BaseButton.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$12 = [
+	"type",
+	"disabled",
+	"aria-busy"
+];
+var _hoisted_2$11 = {
+	key: 0,
+	class: "size-4 animate-spin rounded-full border-2 border-current border-t-transparent",
+	"aria-hidden": "true"
+};
+//#endregion
+//#region src/components/BaseButton.vue
+var BaseButton_default = /* @__PURE__ */ defineComponent({
+	__name: "BaseButton",
+	props: {
+		variant: { default: "primary" },
+		size: { default: "md" },
+		loading: {
+			type: Boolean,
+			default: false
+		},
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		type: { default: "button" }
+	},
+	setup(__props) {
+		const VARIANT_CLASS = {
+			primary: "bg-primary text-white hover:bg-primary/90",
+			ghost: "bg-transparent text-ink hover:bg-muted",
+			danger: "bg-negative text-white hover:bg-negative/90"
+		};
+		const SIZE_CLASS = {
+			sm: "h-9 px-3 text-sm",
+			md: "h-11 px-4 text-base"
+		};
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("button", {
+				type: __props.type,
+				disabled: __props.disabled || __props.loading,
+				"aria-busy": __props.loading,
+				class: normalizeClass(["rounded-card focus-visible:outline-primary inline-flex items-center justify-center gap-2 font-medium transition-transform duration-100 select-none focus-visible:outline-2 focus-visible:outline-offset-2 active:scale-95 disabled:pointer-events-none disabled:opacity-50", [VARIANT_CLASS[__props.variant], SIZE_CLASS[__props.size]]])
+			}, [__props.loading ? (openBlock(), createElementBlock("span", _hoisted_2$11)) : createCommentVNode("", true), renderSlot(_ctx.$slots, "default")], 10, _hoisted_1$12);
+		};
+	}
+});
+//#endregion
+//#region src/components/BaseInput.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$11 = { class: "flex flex-col gap-1.5" };
+var _hoisted_2$10 = ["for"];
+var _hoisted_3$6 = [
+	"id",
+	"type",
+	"aria-invalid",
+	"aria-describedby"
+];
+//#endregion
+//#region src/components/BaseInput.vue
+var BaseInput_default = /* @__PURE__ */ defineComponent({
+	inheritAttrs: false,
+	__name: "BaseInput",
+	props: /*@__PURE__*/ mergeModels({
+		label: {},
+		error: { default: "" },
+		hint: { default: "" },
+		labelHidden: {
+			type: Boolean,
+			default: false
+		},
+		type: { default: "text" }
+	}, {
+		"modelValue": {},
+		"modelModifiers": {}
+	}),
+	emits: ["update:modelValue"],
+	setup(__props) {
+		const model = useModel(__props, "modelValue");
+		const id = useId();
+		const errorId = `${id}-error`;
+		const hintId = `${id}-hint`;
+		const describedBy = computed(() => {
+			if (__props.error) return errorId;
+			if (__props.hint) return hintId;
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1$11, [
+				createElementVNode("label", {
+					for: unref(id),
+					class: normalizeClass(["text-ink text-sm font-medium", __props.labelHidden ? "sr-only" : ""])
+				}, toDisplayString(__props.label), 11, _hoisted_2$10),
+				withDirectives(createElementVNode("input", mergeProps({
+					id: unref(id),
+					"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => model.value = $event),
+					type: __props.type,
+					"aria-invalid": Boolean(__props.error),
+					"aria-describedby": describedBy.value
+				}, _ctx.$attrs, { class: ["border-hair bg-surface text-ink rounded-card focus-visible:outline-primary h-11 border px-3 focus-visible:outline-2 focus-visible:outline-offset-1", __props.error ? "border-negative" : ""] }), null, 16, _hoisted_3$6), [[vModelDynamic, model.value]]),
+				__props.error ? (openBlock(), createElementBlock("p", {
+					key: 0,
+					id: errorId,
+					class: "text-negative text-xs"
+				}, toDisplayString(__props.error), 1)) : __props.hint ? (openBlock(), createElementBlock("p", {
+					key: 1,
+					id: hintId,
+					class: "text-ink-soft text-xs"
+				}, toDisplayString(__props.hint), 1)) : createCommentVNode("", true)
+			]);
+		};
+	}
+});
+//#endregion
+//#region src/components/BaseSheet.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$10 = { class: "shell-frame md:rounded-shell relative flex max-h-full flex-col justify-end overflow-hidden" };
+var _hoisted_2$9 = ["aria-label"];
+var _hoisted_3$5 = { class: "flex shrink-0 items-start gap-3 px-6 pt-4 pb-5" };
+var _hoisted_4$4 = { class: "min-w-0 flex-1" };
+var _hoisted_5$3 = { class: "text-ink text-xl leading-tight font-semibold" };
+var _hoisted_6$1 = {
+	key: 0,
+	class: "text-ink-soft mt-1 text-sm leading-snug"
+};
+var _hoisted_7$1 = ["aria-label"];
+var _hoisted_8 = { class: "min-h-0 flex-1 overflow-y-auto px-6 pb-[calc(2rem+env(safe-area-inset-bottom,0px))]" };
+var BaseSheet_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
+	__name: "BaseSheet",
+	props: /*@__PURE__*/ mergeModels({
+		title: {},
+		subtitle: { default: "" },
+		closeLabel: { default: "Close" }
+	}, {
+		"modelValue": {
+			type: Boolean,
+			required: true
+		},
+		"modelModifiers": {}
+	}),
+	emits: ["update:modelValue"],
+	setup(__props) {
+		const open = useModel(__props, "modelValue");
+		const viewport = useVisualViewport();
+		/**
+		* Pins the sheet to the area the keyboard has left visible.
+		*
+		* Only needed where the layout viewport does not shrink on its own — iOS. On
+		* Android the numbers already agree, so this is a no-op there rather than a
+		* second, competing adjustment.
+		*/
+		const viewportStyle = computed(() => viewport.value ? {
+			height: `${viewport.value.height}px`,
+			top: `${viewport.value.offsetTop}px`
+		} : void 0);
+		const panel = ref(null);
+		let lastFocused = null;
+		function close() {
+			open.value = false;
+		}
+		function onKeydown(event) {
+			if (event.key === "Escape") close();
+		}
+		watch(open, async (isOpen) => {
+			if (isOpen) {
+				setBackgroundInert(true);
+				lastFocused = document.activeElement instanceof HTMLElement ? document.activeElement : null;
+				window.addEventListener("keydown", onKeydown);
+				await nextTick();
+				panel.value?.focus();
+			} else {
+				window.removeEventListener("keydown", onKeydown);
+				lastFocused?.focus();
+				lastFocused = null;
+				setBackgroundInert(false);
+			}
+		});
+		/**
+		* `inert` takes the whole app out of tab order and pointer events while the
+		* sheet is open — a real focus trap without keydown bookkeeping.
+		*
+		* The sheet itself is teleported to `#sheet-root`, a sibling of `#app`, so it
+		* stays interactive.
+		*/
+		function setBackgroundInert(isInert) {
+			document.getElementById("app")?.toggleAttribute("inert", isInert);
+		}
+		onUnmounted(() => {
+			window.removeEventListener("keydown", onKeydown);
+			setBackgroundInert(false);
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(Teleport, { to: "#sheet-root" }, [createVNode(Transition, { name: "sheet" }, {
+				default: withCtx(() => [open.value ? (openBlock(), createElementBlock("div", {
+					key: 0,
+					class: "fixed inset-x-0 top-0 bottom-0 z-50 flex items-center justify-center",
+					style: normalizeStyle(viewportStyle.value)
+				}, [createElementVNode("div", _hoisted_1$10, [createElementVNode("div", {
+					class: "bg-ink/45 absolute inset-0 backdrop-blur-[2px]",
+					onClick: close
+				}), createElementVNode("section", {
+					ref_key: "panel",
+					ref: panel,
+					role: "dialog",
+					"aria-modal": "true",
+					"aria-label": __props.title,
+					tabindex: "-1",
+					class: "sheet-panel bg-surface relative flex max-h-[94%] min-h-[56dvh] flex-col rounded-t-[28px] shadow-2xl outline-none"
+				}, [
+					_cache[0] || (_cache[0] = createElementVNode("div", {
+						class: "flex shrink-0 justify-center pt-3",
+						"aria-hidden": "true"
+					}, [createElementVNode("span", { class: "bg-hair h-1.5 w-10 rounded-full" })], -1)),
+					createElementVNode("header", _hoisted_3$5, [createElementVNode("div", _hoisted_4$4, [createElementVNode("h2", _hoisted_5$3, toDisplayString(__props.title), 1), __props.subtitle ? (openBlock(), createElementBlock("p", _hoisted_6$1, toDisplayString(__props.subtitle), 1)) : createCommentVNode("", true)]), createElementVNode("button", {
+						type: "button",
+						class: "text-ink-soft hover:bg-muted hover:text-ink -mt-1 flex size-10 shrink-0 items-center justify-center rounded-full transition-colors active:scale-90",
+						"aria-label": __props.closeLabel,
+						onClick: close
+					}, [createVNode(unref(X), { class: "size-5" })], 8, _hoisted_7$1)]),
+					createElementVNode("div", _hoisted_8, [renderSlot(_ctx.$slots, "default", {}, void 0, true)])
+				], 8, _hoisted_2$9)])], 4)) : createCommentVNode("", true)]),
+				_: 3
+			})]);
+		};
+	}
+});
+//#endregion
+//#region \0plugin-vue:export-helper
+var _plugin_vue_export_helper_default = (sfc, props) => {
+	const target = sfc.__vccOpts || sfc;
+	for (const [key, val] of props) target[key] = val;
+	return target;
+};
+//#endregion
+//#region src/components/BaseSheet.vue
+var BaseSheet_default = /*#__PURE__*/ _plugin_vue_export_helper_default(BaseSheet_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-3f2e9ce4"]]);
+//#endregion
+//#region src/components/EmptyState.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$9 = { class: "flex flex-col items-center gap-3 px-6 py-10 text-center" };
+var _hoisted_2$8 = {
+	key: 0,
+	class: "bg-muted text-primary rounded-card flex size-12 items-center"
+};
+var _hoisted_3$4 = { class: "text-ink text-base font-semibold" };
+var _hoisted_4$3 = {
+	key: 1,
+	class: "text-ink-soft max-w-[36ch] text-sm"
+};
+var _hoisted_5$2 = {
+	key: 2,
+	class: "mt-2 flex w-full flex-col gap-2"
+};
+//#endregion
+//#region src/components/EmptyState.vue
+var EmptyState_default = /* @__PURE__ */ defineComponent({
+	__name: "EmptyState",
+	props: {
+		title: {},
+		description: { default: "" }
+	},
+	setup(__props) {
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1$9, [
+				_ctx.$slots.icon ? (openBlock(), createElementBlock("div", _hoisted_2$8, [renderSlot(_ctx.$slots, "icon")])) : createCommentVNode("", true),
+				createElementVNode("h3", _hoisted_3$4, toDisplayString(__props.title), 1),
+				__props.description ? (openBlock(), createElementBlock("p", _hoisted_4$3, toDisplayString(__props.description), 1)) : createCommentVNode("", true),
+				_ctx.$slots.action ? (openBlock(), createElementBlock("div", _hoisted_5$2, [renderSlot(_ctx.$slots, "action")])) : createCommentVNode("", true)
+			]);
+		};
+	}
+});
+//#endregion
+//#region src/components/PageHeader.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$8 = { class: "grid h-12 shrink-0 grid-cols-[2.5rem_1fr_2.5rem] items-center" };
+var _hoisted_2$7 = { class: "justify-self-start" };
+var _hoisted_3$3 = { class: "text-ink flex min-w-0 justify-center text-base font-semibold tabular-nums" };
+var _hoisted_4$2 = { class: "truncate" };
+var _hoisted_5$1 = { class: "justify-self-end" };
+//#endregion
+//#region src/components/PageHeader.vue
+var PageHeader_default = /* @__PURE__ */ defineComponent({
+	__name: "PageHeader",
+	props: { title: {} },
+	setup(__props) {
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("header", _hoisted_1$8, [
+				createElementVNode("div", _hoisted_2$7, [renderSlot(_ctx.$slots, "left")]),
+				createElementVNode("h1", _hoisted_3$3, [renderSlot(_ctx.$slots, "title", {}, () => [createElementVNode("span", _hoisted_4$2, toDisplayString(__props.title), 1)])]),
+				createElementVNode("div", _hoisted_5$1, [renderSlot(_ctx.$slots, "right")])
+			]);
+		};
+	}
+});
+//#endregion
+//#region src/components/ToneDot.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$7 = { class: "inline-flex items-center gap-1.5" };
+var _hoisted_2$6 = {
+	key: 0,
+	class: "text-ink-soft text-xs font-medium"
+};
+//#endregion
+//#region src/components/ToneDot.vue
+var ToneDot_default = /* @__PURE__ */ defineComponent({
+	__name: "ToneDot",
+	props: {
+		fill: {},
+		label: { default: "" }
+	},
+	setup(__props) {
+		/**
+		* A small coloured dot, optionally labelled.
+		*
+		* Takes the colour as a class rather than a category, so an app can key it off
+		* whatever its own domain calls a category — habit kinds, expense types,
+		* priorities — without this component knowing about any of them.
+		*/
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("span", _hoisted_1$7, [createElementVNode("span", { class: normalizeClass(["size-2 rounded-full", __props.fill]) }, null, 2), __props.label ? (openBlock(), createElementBlock("span", _hoisted_2$6, toDisplayString(__props.label), 1)) : createCommentVNode("", true)]);
+		};
+	}
+});
+//#endregion
+//#region src/components/SectionHeading.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$6 = {
+	key: 0,
+	class: "text-ink-soft text-xs tabular-nums"
+};
+//#endregion
+//#region src/components/SectionHeading.vue
+var SectionHeading_default = /* @__PURE__ */ defineComponent({
+	__name: "SectionHeading",
+	props: {
+		tone: {},
+		label: {},
+		count: { default: 0 }
+	},
+	setup(__props) {
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("h2", { class: normalizeClass(["flex items-center gap-2 self-start rounded-full border px-3 py-1", __props.tone.card]) }, [
+				createVNode(ToneDot_default, { fill: __props.tone.fill }, null, 8, ["fill"]),
+				createElementVNode("span", { class: normalizeClass(["text-xs font-semibold tracking-wide uppercase", __props.tone.text]) }, toDisplayString(__props.label), 3),
+				__props.count > 0 ? (openBlock(), createElementBlock("span", _hoisted_1$6, toDisplayString(__props.count), 1)) : createCommentVNode("", true)
+			], 2);
+		};
+	}
+});
+//#endregion
+//#region src/components/SegmentedControl.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$5 = { class: "bg-muted rounded-card flex w-full gap-1 p-1" };
+var _hoisted_2$5 = ["value", "name"];
+//#endregion
+//#region src/components/SegmentedControl.vue
+var SegmentedControl_default = /* @__PURE__ */ defineComponent({
+	__name: "SegmentedControl",
+	props: /*@__PURE__*/ mergeModels({ options: {} }, {
+		"modelValue": { required: true },
+		"modelModifiers": {}
+	}),
+	emits: ["update:modelValue"],
+	setup(__props) {
+		const model = useModel(__props, "modelValue");
+		const name = useId();
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1$5, [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.options, (option) => {
+				return openBlock(), createElementBlock("label", {
+					key: String(option.value),
+					class: "flex-1 cursor-pointer"
+				}, [withDirectives(createElementVNode("input", {
+					"onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => model.value = $event),
+					type: "radio",
+					value: option.value,
+					name: unref(name),
+					class: "sr-only"
+				}, null, 8, _hoisted_2$5), [[vModelRadio, model.value]]), createElementVNode("span", { class: normalizeClass(["flex h-10 items-center justify-center rounded-xl px-2 text-sm font-medium transition-colors select-none", model.value === option.value ? "bg-surface text-ink shadow-sm" : "text-ink-soft"]) }, toDisplayString(option.label), 3)]);
+			}), 128))]);
+		};
+	}
+});
+//#endregion
+//#region src/components/SettingsGroup.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$4 = { class: "flex flex-col gap-2" };
+var _hoisted_2$4 = { class: "text-ink-soft px-1 text-xs font-semibold tracking-wide uppercase" };
+var _hoisted_3$2 = { class: "border-hair bg-surface rounded-card divide-hair divide-y overflow-hidden border" };
+//#endregion
+//#region src/components/SettingsGroup.vue
+var SettingsGroup_default = /* @__PURE__ */ defineComponent({
+	__name: "SettingsGroup",
+	props: { title: {} },
+	setup(__props) {
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("section", _hoisted_1$4, [createElementVNode("h2", _hoisted_2$4, toDisplayString(__props.title), 1), createElementVNode("div", _hoisted_3$2, [renderSlot(_ctx.$slots, "default")])]);
+		};
+	}
+});
+//#endregion
+//#region src/components/SettingsRow.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$3 = { class: "flex items-center gap-3" };
+var _hoisted_2$3 = {
+	key: 0,
+	class: "bg-muted text-ink-soft flex size-9 shrink-0 items-center justify-center rounded-xl",
+	"aria-hidden": "true"
+};
+var _hoisted_3$1 = { class: "min-w-0 flex-1" };
+var _hoisted_4$1 = { class: "text-ink text-sm font-medium" };
+var _hoisted_5 = {
+	key: 0,
+	class: "text-ink-soft mt-0.5 text-xs leading-snug"
+};
+var _hoisted_6 = {
+	key: 1,
+	class: "shrink-0"
+};
+var _hoisted_7 = { key: 0 };
+//#endregion
+//#region src/components/SettingsRow.vue
+var SettingsRow_default = /* @__PURE__ */ defineComponent({
+	__name: "SettingsRow",
+	props: {
+		label: {},
+		description: { default: "" },
+		icon: { default: () => void 0 },
+		interactive: {
+			type: Boolean,
+			default: false
+		},
+		stacked: {
+			type: Boolean,
+			default: false
+		}
+	},
+	emits: ["click"],
+	setup(__props, { emit: __emit }) {
+		const emit = __emit;
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(resolveDynamicComponent(__props.interactive ? "button" : "div"), {
+				type: __props.interactive ? "button" : void 0,
+				class: normalizeClass(["flex w-full items-center gap-3 px-4 py-3 text-left", [__props.interactive ? "hover:bg-muted/60 transition-colors active:scale-[0.99]" : "", __props.stacked ? "flex-col items-stretch gap-3" : ""]]),
+				onClick: _cache[0] || (_cache[0] = ($event) => __props.interactive && emit("click"))
+			}, {
+				default: withCtx(() => [createElementVNode("div", _hoisted_1$3, [
+					__props.icon ? (openBlock(), createElementBlock("span", _hoisted_2$3, [(openBlock(), createBlock(resolveDynamicComponent(__props.icon), { class: "size-[18px]" }))])) : createCommentVNode("", true),
+					createElementVNode("div", _hoisted_3$1, [createElementVNode("p", _hoisted_4$1, toDisplayString(__props.label), 1), __props.description ? (openBlock(), createElementBlock("p", _hoisted_5, toDisplayString(__props.description), 1)) : createCommentVNode("", true)]),
+					!__props.stacked ? (openBlock(), createElementBlock("div", _hoisted_6, [renderSlot(_ctx.$slots, "default")])) : createCommentVNode("", true),
+					__props.interactive ? (openBlock(), createBlock(unref(ChevronRight), {
+						key: 2,
+						class: "text-ink-soft size-4 shrink-0",
+						"aria-hidden": "true"
+					})) : createCommentVNode("", true)
+				]), __props.stacked ? (openBlock(), createElementBlock("div", _hoisted_7, [renderSlot(_ctx.$slots, "default")])) : createCommentVNode("", true)]),
+				_: 3
+			}, 8, ["type", "class"]);
+		};
+	}
+});
+//#endregion
+//#region src/components/SkeletonList.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$2 = {
+	role: "status",
+	class: "flex flex-col gap-1"
+};
+var _hoisted_2$2 = { class: "sr-only" };
+//#endregion
+//#region src/components/SkeletonList.vue
+var SkeletonList_default = /* @__PURE__ */ defineComponent({
+	__name: "SkeletonList",
+	props: {
+		rows: { default: 3 },
+		rowHeight: { default: "h-14" },
+		label: { default: "Loading…" }
+	},
+	setup(__props) {
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1$2, [createElementVNode("span", _hoisted_2$2, toDisplayString(__props.label), 1), (openBlock(true), createElementBlock(Fragment, null, renderList(__props.rows, (row) => {
+				return openBlock(), createElementBlock("div", {
+					key: row,
+					class: normalizeClass(["bg-muted rounded-card animate-pulse", __props.rowHeight]),
+					"aria-hidden": "true"
+				}, null, 2);
+			}), 128))]);
+		};
+	}
+});
+//#endregion
+//#region src/components/StatCard.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1$1 = { class: "border-hair rounded-card flex flex-1 flex-col gap-0.5 border p-3" };
+var _hoisted_2$1 = { class: "flex items-baseline gap-1" };
+var _hoisted_3 = { class: "text-ink text-xl font-semibold tabular-nums" };
+var _hoisted_4 = { class: "text-ink-soft text-xs" };
+//#endregion
+//#region src/components/StatCard.vue
+var StatCard_default = /* @__PURE__ */ defineComponent({
+	__name: "StatCard",
+	props: {
+		value: {},
+		label: {},
+		trend: { default: null }
+	},
+	setup(__props) {
+		const TREND_ICON = {
+			up: ArrowUp,
+			down: ArrowDown,
+			flat: ArrowRight
+		};
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", _hoisted_1$1, [createElementVNode("div", _hoisted_2$1, [createElementVNode("span", _hoisted_3, toDisplayString(__props.value), 1), __props.trend ? (openBlock(), createBlock(resolveDynamicComponent(TREND_ICON[__props.trend]), {
+				key: 0,
+				class: "text-ink-soft size-3"
+			})) : createCommentVNode("", true)]), createElementVNode("span", _hoisted_4, toDisplayString(__props.label), 1)]);
+		};
+	}
+});
+//#endregion
+//#region src/components/LocaleLinks.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = ["aria-label"];
+var _hoisted_2 = [
+	"lang",
+	"aria-pressed",
+	"onClick"
+];
+//#endregion
+//#region src/components/LocaleLinks.vue
+var LocaleLinks_default = /* @__PURE__ */ defineComponent({
+	__name: "LocaleLinks",
+	props: /*@__PURE__*/ mergeModels({
+		locales: {},
+		labels: {},
+		label: { default: "" }
+	}, {
+		"modelValue": { required: true },
+		"modelModifiers": {}
+	}),
+	emits: ["update:modelValue"],
+	setup(__props) {
+		/**
+		* A flat language switcher for screens with no Settings behind them.
+		*
+		* The list and the labels are props: only the app knows which languages it
+		* ships, and endonyms — each language written in itself — are what make the
+		* right option legible to someone who cannot read the current interface.
+		*/
+		/**
+		* Two-way bound rather than taking the runtime's ref as a prop: props are not
+		* unwrapped in a template and cannot be assigned to, so the ref would compare
+		* against itself and the click handler would not compile.
+		*/
+		const preference = useModel(__props, "modelValue");
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("nav", {
+				class: "flex flex-wrap items-center justify-center gap-1",
+				"aria-label": __props.label || void 0
+			}, [(openBlock(true), createElementBlock(Fragment, null, renderList(__props.locales, (locale) => {
+				return openBlock(), createElementBlock("button", {
+					key: locale,
+					type: "button",
+					lang: locale,
+					class: normalizeClass(["rounded-full px-2.5 py-1.5 text-xs transition-colors", preference.value === locale ? "bg-muted text-ink font-semibold" : "text-ink-soft hover:text-ink"]),
+					"aria-pressed": preference.value === locale,
+					onClick: ($event) => preference.value = locale
+				}, toDisplayString(__props.labels[locale]), 11, _hoisted_2);
+			}), 128))], 8, _hoisted_1);
+		};
+	}
+});
+//#endregion
+//#region src/i18n/runtime.ts
+/**
+* Builds an i18n runtime around an app's own catalogue.
+*
+* A factory rather than a module singleton because the schema is the app's:
+* typing every locale as `typeof en` is what makes a missing key a build error,
+* and this package has no `en` of its own to type against.
+*
+* @example
+* ```ts
+* export const { i18n, t, useLocalePreference, loadActiveLocale } =
+*   createI18nRuntime({
+*     locales: ['en', 'tr'] as const,
+*     fallback: 'en',
+*     intlTags: { en: 'en-GB', tr: 'tr-TR' },
+*     messages: en,
+*     loaders: { tr: () => import('./locales/tr') },
+*     storageKey: 'myapp-locale',
+*   })
+* ```
+*/
+function createI18nRuntime(options) {
+	const { locales, fallback, intlTags, messages, storageKey = "rei-locale" } = options;
+	const loaders = options.loaders ?? {};
+	function isSupported(value) {
+		return locales.includes(value);
+	}
+	/**
+	* First browser language the app can actually speak.
+	*
+	* `navigator.languages` is ordered by the user's own preference, so the first
+	* match is the best one — not simply the first entry.
+	*/
+	function detectSystemLocale() {
+		for (const tag of navigator.languages ?? [navigator.language]) {
+			const base = tag.split("-")[0]?.toLowerCase();
+			if (base && isSupported(base)) return base;
+		}
+		return fallback;
+	}
+	function readStored() {
+		try {
+			const stored = localStorage.getItem(storageKey);
+			if (stored === "system" || stored && isSupported(stored)) return stored;
+		} catch {}
+		return "system";
+	}
+	const preference = ref(readStored());
+	const activeLocale = computed(() => preference.value === "system" ? detectSystemLocale() : preference.value);
+	const intlLocale = computed(() => intlTags[activeLocale.value]);
+	const initial = { [fallback]: messages };
+	const i18n = createI18n({
+		legacy: false,
+		locale: activeLocale.value,
+		fallbackLocale: fallback,
+		messages: initial
+	});
+	/**
+	* A narrow view of the instance.
+	*
+	* vue-i18n infers its own generics from the messages it is handed, which
+	* fights a runtime that is generic over the app's schema. Casting once, here,
+	* keeps that fight out of every call site — and the surface below is the
+	* whole of what this runtime uses.
+	*/
+	const core = i18n.global;
+	const loaded = /* @__PURE__ */ new Set([fallback]);
+	/**
+	* Makes sure a locale's messages are in place before it becomes active.
+	*
+	* Awaited rather than fired and forgotten: setting the locale first paints one
+	* frame of the fallback at every other user, which is the flash a fallback
+	* exists to prevent, not cause.
+	*/
+	async function ensureMessages(locale) {
+		if (loaded.has(locale)) return;
+		const load = loaders[locale];
+		if (!load) return;
+		try {
+			const module = await load();
+			core.setLocaleMessage(locale, module.default);
+			loaded.add(locale);
+		} catch {}
+	}
+	/** Loads whatever the stored preference resolves to. Call before mounting. */
+	function loadActiveLocale() {
+		return ensureMessages(activeLocale.value);
+	}
+	watchEffect(() => {
+		core.locale.value = activeLocale.value;
+		setFormatLocale(intlLocale.value);
+		document.documentElement.lang = activeLocale.value;
+	});
+	/** Read and write the language preference. */
+	function useLocalePreference() {
+		return computed({
+			get: () => preference.value,
+			set: (next) => {
+				ensureMessages(next === "system" ? detectSystemLocale() : next).then(() => {
+					preference.value = next;
+				});
+				try {
+					localStorage.setItem(storageKey, next);
+				} catch {}
+			}
+		});
+	}
+	return {
+		i18n,
+		/** `t` for code outside a component. Tracks the locale inside a computed. */
+		t: core.t,
+		activeLocale,
+		intlLocale,
+		ensureMessages,
+		loadActiveLocale,
+		useLocalePreference
+	};
+}
+//#endregion
+//#region src/index.ts
+/**
+* rei-kit — the layer every app starts from.
+*
+* Everything here is free of any backend, router or i18n choice. Components
+* take strings rather than calling a translator, and utilities take the clock
+* rather than reading it, so nothing in this package can force a decision on
+* the app that installs it.
+*
+* @see https://github.com/ramazandogna/rei-kit
+*/
+var VERSION = "0.0.0";
+//#endregion
+export { AppError, BaseButton_default as BaseButton, BaseInput_default as BaseInput, BaseSheet_default as BaseSheet, EmptyState_default as EmptyState, LocaleLinks_default as LocaleLinks, PageHeader_default as PageHeader, SectionHeading_default as SectionHeading, SegmentedControl_default as SegmentedControl, SettingsGroup_default as SettingsGroup, SettingsRow_default as SettingsRow, SkeletonList_default as SkeletonList, StatCard_default as StatCard, ToneDot_default as ToneDot, VERSION, addDays, applyTheme, createI18nRuntime, downloadJson, eachDayOfYear, formatDate, fromDateKey, isApplePortable, isInstalled, isThemePreference, lastNDays, leadingBlanks, needsIosInstall, readStoredTheme, registerErrorMapper, relativeDayLabel, safeRedirect, setFormatLocale, setThemeStorageKey, startOfWeek, tapFeedback, toAppError, toDateKey, todayKey, useDebouncedCallback, useDragScroll, useOnline, useTheme, useToday, useVisualViewport };
+
+//# sourceMappingURL=index.js.map