(`/timers/${id}/reset`),
+};
diff --git a/apps-archived/clock/apps/web/src/lib/components/AuthGateModal.svelte b/apps-archived/clock/apps/web/src/lib/components/AuthGateModal.svelte
new file mode 100644
index 000000000..6f3c17552
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/components/AuthGateModal.svelte
@@ -0,0 +1,226 @@
+
+
+{#if open}
+
+
+
e.stopPropagation()}>
+
+
+
+
{currentMessage.description}
+
+ {#if itemCount > 0}
+
+
+
+ Du hast {itemCount}
+ {itemCount === 1 ? 'Element' : 'Elemente'} in deiner Session. Diese werden nach der Anmeldung
+ in deinen Account übertragen.
+
+ {/if}
+
+
+
+ Später
+ Anmelden
+ Registrieren
+
+
+
+ {#if mapLoaded}
+
+
+
+ handleCityClick(city.timezone, city.city)}>
+
+ {city.city}
+
+ {/if}
+
+ {/each}
+
+
+ {:else}
+
+ Karte wird geladen...
+
+ {/if}
+
+
+
+
+
+ {i * 10}
+
+ {/each}
+
+
+
+
+ {percentage.toFixed(1)}%
+ gelebt
+
+
+
+
+
+
+ {daysLived.toLocaleString('de-DE')}
+ Tage gelebt
+
+
+
+ {remainingDays.toLocaleString('de-DE')}
+ Tage verbleibend
+
+
+
Basierend auf {lifeExpectancyYears} Jahren Lebenserwartung
+
+
+
+
+ {#each Array(6) as _, i}
+
+
+ {/each}
+
+
+
+
+ {#each Array(3) as _, i}
+
+ {/each}
+
+
+
+
+ {#each Array(4) as _, i}
+
+
+
+
+
+
+
+
+ {#each Array(2) as _, i}
+
+ {/each}
+
+
+
+
+
+
+
+
+ {#each Array(4) as _, i}
+
+ {/each}
+
+
Du kannst Wecker auf verschiedene Arten erstellen:
Schnellwecker : Drücke A oder klicke auf das + Symbol im Wecker-TabUhrzeit wählen : Stelle Stunde und Minute ein und wähle die gewünschten WochentageLabel : Gib deinem Wecker einen Namen, z.B. "Morgenroutine"Klingelton : Wähle aus verschiedenen Tönen oder nutze einen sanften WecktonYou can create alarms in several ways:
Quick alarm : Press A or click the + icon in the Alarms tabSet time : Choose hour and minute and select the desired weekdaysLabel : Give your alarm a name, e.g. "Morning routine"Ringtone : Choose from various sounds or use a gentle wake-up toneClock bietet zwei Zeitmesser:
Timer : Stelle eine Countdown-Zeit ein und starte ihn. Du kannst mehrere Timer gleichzeitig laufen lassen. Drücke T für einen neuen Timer.Stoppuhr : Messe verstrichene Zeit mit Rundenzeiten. Starte, pausiere und setze zurück.Beide laufen auch im Hintergrund weiter und benachrichtigen dich, wenn die Zeit abgelaufen ist.
'
+ : 'Clock offers two time measurement tools:
Timer : Set a countdown duration and start it. You can run multiple timers simultaneously. Press T for a new timer.Stopwatch : Measure elapsed time with lap splits. Start, pause, and reset.Both continue running in the background and notify you when time is up.
',
+ category: 'features',
+ order: 2,
+ language: isDE ? 'de' : 'en',
+ tags: isDE ? ['timer', 'stoppuhr', 'countdown'] : ['timer', 'stopwatch', 'countdown'],
+ },
+ {
+ id: 'faq-pomodoro',
+ question: isDE ? 'Was ist die Pomodoro-Technik?' : 'What is the Pomodoro technique?',
+ answer: isDE
+ ? 'Die Pomodoro-Technik ist eine Zeitmanagement-Methode:
Arbeite 25 Minuten konzentriert (ein "Pomodoro") Mache eine 5-Minuten-Pause Nach 4 Pomodoros: 15-30 Minuten längere Pause In Clock kannst du die Intervalle anpassen, deinen Fortschritt verfolgen und Statistiken über deine Produktivität einsehen.
'
+ : 'The Pomodoro technique is a time management method:
Work for 25 minutes with focus (one "Pomodoro") Take a 5-minute break After 4 Pomodoros: take a 15-30 minute longer break In Clock you can customize the intervals, track your progress, and view statistics about your productivity.
',
+ category: 'features',
+ order: 3,
+ language: isDE ? 'de' : 'en',
+ tags: isDE
+ ? ['pomodoro', 'produktivität', 'fokus', 'technik']
+ : ['pomodoro', 'productivity', 'focus', 'technique'],
+ },
+ {
+ id: 'faq-life-clock',
+ question: isDE ? 'Was ist die Life Clock?' : 'What is the Life Clock?',
+ answer: isDE
+ ? 'Die Life Clock ist eine einzigartige Visualisierung deiner Lebenszeit:
Gib dein Geburtsdatum und deine geschätzte Lebenserwartung ein Sieh, wie viel deiner Zeit bereits vergangen ist und wie viel noch vor dir liegt Verschiedene Darstellungen: Wochen, Monate oder Jahre als Raster Die Life Clock soll dich motivieren, deine Zeit bewusst zu nutzen — keine Angst, sondern Inspiration .
'
+ : 'The Life Clock is a unique visualization of your lifetime:
Enter your birth date and estimated life expectancy See how much of your time has passed and how much lies ahead Various display modes: weeks, months, or years as a grid The Life Clock is meant to motivate you to use your time mindfully — not fear, but inspiration .
',
+ category: 'features',
+ order: 4,
+ language: isDE ? 'de' : 'en',
+ tags: isDE
+ ? ['life-clock', 'lebenszeit', 'visualisierung']
+ : ['life-clock', 'lifetime', 'visualization'],
+ },
+ ...getPrivacyFAQs(locale, {
+ dataTypeDE: 'Daten',
+ dataTypeEN: 'data',
+ extraBulletsDE: [
+ 'Lokale Speicherung : Wecker und Timer werden lokal auf deinem Gerät gespeichert',
+ ],
+ extraBulletsEN: [
+ 'Local storage : Alarms and timers are stored locally on your device',
+ ],
+ }),
+ ],
+ features: [
+ {
+ id: 'feature-alarms',
+ title: isDE ? 'Wecker' : 'Alarms',
+ description: isDE
+ ? 'Erstelle wiederkehrende und einmalige Wecker mit individuellen Tönen'
+ : 'Create recurring and one-time alarms with custom sounds',
+ icon: '⏰',
+ category: 'core',
+ highlights: isDE
+ ? ['Wiederkehrende Wecker', 'Individuelle Töne', 'Schlummerfunktion', 'Labels']
+ : ['Recurring alarms', 'Custom sounds', 'Snooze function', 'Labels'],
+ content: '',
+ order: 1,
+ language: isDE ? 'de' : 'en',
+ },
+ {
+ id: 'feature-timers-stopwatch',
+ title: isDE ? 'Timer & Stoppuhr' : 'Timers & Stopwatch',
+ description: isDE
+ ? 'Mehrere gleichzeitige Timer und eine Stoppuhr mit Rundenzeiten'
+ : 'Multiple simultaneous timers and a stopwatch with lap times',
+ icon: '⏱️',
+ category: 'core',
+ highlights: isDE
+ ? ['Mehrere Timer', 'Rundenzeiten', 'Hintergrund-Benachrichtigung', 'Voreinstellungen']
+ : ['Multiple timers', 'Lap times', 'Background notifications', 'Presets'],
+ content: '',
+ order: 2,
+ language: isDE ? 'de' : 'en',
+ },
+ {
+ id: 'feature-pomodoro',
+ title: 'Pomodoro',
+ description: isDE
+ ? 'Steigere deine Produktivität mit der Pomodoro-Technik und Statistiken'
+ : 'Boost your productivity with the Pomodoro technique and statistics',
+ icon: '🍅',
+ category: 'advanced',
+ highlights: isDE
+ ? ['Anpassbare Intervalle', 'Sitzungs-Tracking', 'Statistiken', 'Benachrichtigungen']
+ : ['Customizable intervals', 'Session tracking', 'Statistics', 'Notifications'],
+ content: '',
+ order: 3,
+ language: isDE ? 'de' : 'en',
+ },
+ {
+ id: 'feature-world-clock',
+ title: isDE ? 'Weltzeituhr' : 'World Clock',
+ description: isDE
+ ? 'Behalte die Uhrzeit in verschiedenen Zeitzonen im Blick'
+ : 'Keep track of the time across different time zones',
+ icon: '🌍',
+ category: 'core',
+ highlights: isDE
+ ? ['Alle Zeitzonen', 'Zeitvergleich', 'Favoriten', 'Analoges Zifferblatt']
+ : ['All time zones', 'Time comparison', 'Favorites', 'Analog clock face'],
+ content: '',
+ order: 4,
+ language: isDE ? 'de' : 'en',
+ },
+ ],
+ shortcuts: [
+ {
+ id: 'shortcuts-general',
+ category: 'general',
+ title: isDE ? 'Allgemein' : 'General',
+ language: isDE ? 'de' : 'en',
+ order: 1,
+ shortcuts: [
+ {
+ shortcut: 'Cmd/Ctrl + K',
+ action: isDE ? 'Kommandoleiste öffnen' : 'Open command bar',
+ },
+ {
+ shortcut: 'A',
+ action: isDE ? 'Neuer Wecker' : 'New alarm',
+ },
+ {
+ shortcut: 'T',
+ action: isDE ? 'Neuer Timer' : 'New timer',
+ },
+ ],
+ },
+ {
+ id: 'shortcuts-navigation',
+ category: 'navigation',
+ title: 'Navigation',
+ language: isDE ? 'de' : 'en',
+ order: 2,
+ shortcuts: [
+ {
+ shortcut: 'Cmd/Ctrl + 1',
+ action: isDE ? 'Wecker öffnen' : 'Open Alarms',
+ },
+ {
+ shortcut: 'Cmd/Ctrl + 2',
+ action: isDE ? 'Timer öffnen' : 'Open Timers',
+ },
+ {
+ shortcut: 'Cmd/Ctrl + 3',
+ action: isDE ? 'Stoppuhr öffnen' : 'Open Stopwatch',
+ },
+ {
+ shortcut: 'Cmd/Ctrl + 4',
+ action: isDE ? 'Pomodoro öffnen' : 'Open Pomodoro',
+ },
+ {
+ shortcut: 'Cmd/Ctrl + 5',
+ action: isDE ? 'Weltzeituhr öffnen' : 'Open World Clock',
+ },
+ {
+ shortcut: 'Cmd/Ctrl + 6',
+ action: isDE ? 'Life Clock öffnen' : 'Open Life Clock',
+ },
+ {
+ shortcut: 'Cmd/Ctrl + 7',
+ action: isDE ? 'Statistiken öffnen' : 'Open Statistics',
+ },
+ {
+ shortcut: 'Cmd/Ctrl + 8',
+ action: isDE ? 'Einstellungen öffnen' : 'Open Settings',
+ },
+ ],
+ },
+ ],
+ gettingStarted: [],
+ changelog: [],
+ contact: {
+ id: 'contact-support',
+ title: isDE ? 'Support kontaktieren' : 'Contact Support',
+ content: isDE
+ ? 'Unser Support-Team hilft dir bei allen Fragen rund um Clock.
'
+ : 'Our support team is here to help you with any questions about Clock.
',
+ language: isDE ? 'de' : 'en',
+ order: 1,
+ supportEmail: 'support@mana.how',
+ documentationUrl: 'https://mana.how/docs',
+ responseTime: isDE ? 'Normalerweise innerhalb von 24 Stunden' : 'Usually within 24 hours',
+ },
+ };
+}
diff --git a/apps-archived/clock/apps/web/src/lib/data/guest-seed.ts b/apps-archived/clock/apps/web/src/lib/data/guest-seed.ts
new file mode 100644
index 000000000..6739c7dc3
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/data/guest-seed.ts
@@ -0,0 +1,36 @@
+/**
+ * Guest seed data for the Clock app.
+ *
+ * These records are loaded into IndexedDB when a new guest visits the app.
+ * They provide sample alarms and world clocks to showcase the app.
+ */
+
+import type { LocalAlarm, LocalWorldClock } from './local-store';
+
+export const guestAlarms: LocalAlarm[] = [
+ {
+ id: 'alarm-weekday-morning',
+ label: 'Wecker Wochentags',
+ time: '07:00',
+ enabled: true,
+ repeatDays: [1, 2, 3, 4, 5], // Mon-Fri
+ snoozeMinutes: 5,
+ sound: null,
+ vibrate: true,
+ },
+];
+
+export const guestWorldClocks: LocalWorldClock[] = [
+ {
+ id: 'wc-new-york',
+ timezone: 'America/New_York',
+ cityName: 'New York',
+ sortOrder: 0,
+ },
+ {
+ id: 'wc-tokyo',
+ timezone: 'Asia/Tokyo',
+ cityName: 'Tokio',
+ sortOrder: 1,
+ },
+];
diff --git a/apps-archived/clock/apps/web/src/lib/data/local-store.ts b/apps-archived/clock/apps/web/src/lib/data/local-store.ts
new file mode 100644
index 000000000..728302506
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/data/local-store.ts
@@ -0,0 +1,69 @@
+/**
+ * Clock App — Local-First Data Layer
+ *
+ * Defines the IndexedDB database, collections, and guest seed data.
+ * This is the single source of truth for all Clock data.
+ */
+
+import { createLocalStore, type BaseRecord } from '@manacore/local-store';
+import { guestAlarms, guestWorldClocks } from './guest-seed';
+
+// ─── Types ──────────────────────────────────────────────────
+
+export interface LocalAlarm extends BaseRecord {
+ label: string | null;
+ time: string; // HH:mm format
+ enabled: boolean;
+ repeatDays: number[] | null; // [0-6] where 0 = Sunday
+ snoozeMinutes: number | null;
+ sound: string | null;
+ vibrate: boolean | null;
+}
+
+export interface LocalTimer extends BaseRecord {
+ label: string | null;
+ durationSeconds: number;
+ remainingSeconds: number | null;
+ status: 'idle' | 'running' | 'paused' | 'finished';
+ startedAt: string | null;
+ pausedAt: string | null;
+ sound: string | null;
+}
+
+export interface LocalWorldClock extends BaseRecord {
+ timezone: string; // IANA timezone e.g. 'America/New_York'
+ cityName: string;
+ sortOrder: number;
+}
+
+// ─── Store ──────────────────────────────────────────────────
+
+const SYNC_SERVER_URL = import.meta.env.PUBLIC_SYNC_SERVER_URL || 'http://localhost:3050';
+
+export const clockStore = createLocalStore({
+ appId: 'clock',
+ collections: [
+ {
+ name: 'alarms',
+ indexes: ['enabled', 'time'],
+ guestSeed: guestAlarms,
+ },
+ {
+ name: 'timers',
+ indexes: ['status'],
+ },
+ {
+ name: 'worldClocks',
+ indexes: ['sortOrder', 'timezone'],
+ guestSeed: guestWorldClocks,
+ },
+ ],
+ sync: {
+ serverUrl: SYNC_SERVER_URL,
+ },
+});
+
+// Typed collection accessors
+export const alarmCollection = clockStore.collection('alarms');
+export const timerCollection = clockStore.collection('timers');
+export const worldClockCollection = clockStore.collection('worldClocks');
diff --git a/apps-archived/clock/apps/web/src/lib/data/queries.ts b/apps-archived/clock/apps/web/src/lib/data/queries.ts
new file mode 100644
index 000000000..88e9a4c61
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/data/queries.ts
@@ -0,0 +1,106 @@
+/**
+ * Reactive Queries & Pure Helpers for Clock
+ *
+ * Uses Dexie liveQuery to automatically re-render when IndexedDB changes
+ * (local writes, sync updates, other tabs). Components call these hooks
+ * at init time; no manual fetch/refresh needed.
+ */
+
+import { useLiveQueryWithDefault } from '@manacore/local-store/svelte';
+import {
+ alarmCollection,
+ timerCollection,
+ worldClockCollection,
+ type LocalAlarm,
+ type LocalTimer,
+ type LocalWorldClock,
+} from './local-store';
+import type { Alarm, Timer, WorldClock } from '@clock/shared';
+
+// ─── Type Converters ───────────────────────────────────────
+
+export function toAlarm(local: LocalAlarm): Alarm {
+ return {
+ id: local.id,
+ userId: 'local',
+ label: local.label,
+ time: local.time,
+ enabled: local.enabled,
+ repeatDays: local.repeatDays,
+ snoozeMinutes: local.snoozeMinutes,
+ sound: local.sound,
+ vibrate: local.vibrate ?? null,
+ createdAt: local.createdAt ?? new Date().toISOString(),
+ updatedAt: local.updatedAt ?? new Date().toISOString(),
+ };
+}
+
+export function toTimer(local: LocalTimer): Timer {
+ return {
+ id: local.id,
+ userId: 'local',
+ label: local.label,
+ durationSeconds: local.durationSeconds,
+ remainingSeconds: local.remainingSeconds,
+ status: local.status,
+ startedAt: local.startedAt,
+ pausedAt: local.pausedAt,
+ sound: local.sound,
+ createdAt: local.createdAt ?? new Date().toISOString(),
+ updatedAt: local.updatedAt ?? new Date().toISOString(),
+ };
+}
+
+export function toWorldClock(local: LocalWorldClock): WorldClock {
+ return {
+ id: local.id,
+ userId: 'local',
+ timezone: local.timezone,
+ cityName: local.cityName,
+ sortOrder: local.sortOrder,
+ createdAt: local.createdAt ?? new Date().toISOString(),
+ };
+}
+
+// ─── Live Query Hooks (call during component init) ─────────
+
+/** All alarms, auto-updates on any change. */
+export function useAllAlarms() {
+ return useLiveQueryWithDefault(async () => {
+ const locals = await alarmCollection.getAll();
+ return locals.map(toAlarm);
+ }, [] as Alarm[]);
+}
+
+/** All timers, auto-updates on any change. */
+export function useAllTimers() {
+ return useLiveQueryWithDefault(async () => {
+ const locals = await timerCollection.getAll();
+ return locals.map(toTimer);
+ }, [] as Timer[]);
+}
+
+/** All world clocks, sorted by sortOrder. Auto-updates on any change. */
+export function useAllWorldClocks() {
+ return useLiveQueryWithDefault(async () => {
+ const locals = await worldClockCollection.getAll(undefined, {
+ sortBy: 'sortOrder',
+ sortDirection: 'asc',
+ });
+ return locals.map(toWorldClock);
+ }, [] as WorldClock[]);
+}
+
+// ─── Pure Filter Functions (for $derived) ──────────────────
+
+export function filterEnabledAlarms(alarms: Alarm[]): Alarm[] {
+ return alarms.filter((a) => a.enabled);
+}
+
+export function filterActiveTimers(timers: Timer[]): Timer[] {
+ return timers.filter((t) => t.status === 'running' || t.status === 'paused');
+}
+
+export function sortWorldClocksByOrder(clocks: WorldClock[]): WorldClock[] {
+ return [...clocks].sort((a, b) => a.sortOrder - b.sortOrder);
+}
diff --git a/apps-archived/clock/apps/web/src/lib/i18n/index.ts b/apps-archived/clock/apps/web/src/lib/i18n/index.ts
new file mode 100644
index 000000000..e6c3a0023
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/i18n/index.ts
@@ -0,0 +1,49 @@
+import { browser } from '$app/environment';
+import { init, register, locale, waitLocale } from 'svelte-i18n';
+
+// List of supported locales
+export const supportedLocales = ['de', 'en'] as const;
+export type SupportedLocale = (typeof supportedLocales)[number];
+
+// Default locale
+const defaultLocale = 'de';
+
+// Register all available locales
+register('de', () => import('./locales/de.json'));
+register('en', () => import('./locales/en.json'));
+
+// Get initial locale from browser or localStorage
+function getInitialLocale(): SupportedLocale {
+ if (browser) {
+ // Check localStorage first
+ const stored = localStorage.getItem('clock_locale');
+ if (stored && supportedLocales.includes(stored as SupportedLocale)) {
+ return stored as SupportedLocale;
+ }
+
+ // Fall back to browser language
+ const browserLang = navigator.language.split('-')[0];
+ if (supportedLocales.includes(browserLang as SupportedLocale)) {
+ return browserLang as SupportedLocale;
+ }
+ }
+
+ return defaultLocale;
+}
+
+// Initialize i18n at module scope (required for SSR)
+init({
+ fallbackLocale: defaultLocale,
+ initialLocale: getInitialLocale(),
+});
+
+// Set locale and persist to localStorage
+export function setLocale(newLocale: SupportedLocale) {
+ locale.set(newLocale);
+ if (browser) {
+ localStorage.setItem('clock_locale', newLocale);
+ }
+}
+
+// Wait for locale to be loaded (useful for SSR)
+export { waitLocale };
diff --git a/apps-archived/clock/apps/web/src/lib/i18n/locales/de.json b/apps-archived/clock/apps/web/src/lib/i18n/locales/de.json
new file mode 100644
index 000000000..fc35180f9
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/i18n/locales/de.json
@@ -0,0 +1,23 @@
+{
+ "app": {
+ "name": "Clock"
+ },
+ "common": {
+ "back": "Zurück",
+ "cancel": "Abbrechen",
+ "loading": "Lade..."
+ },
+ "nav": {
+ "home": "Startseite",
+ "settings": "Einstellungen"
+ },
+ "clock": {
+ "title": "Life Clock",
+ "remaining": "Verbleibende Zeit",
+ "elapsed": "Vergangene Zeit"
+ },
+ "messages": {
+ "saved": "Gespeichert",
+ "error": "Ein Fehler ist aufgetreten"
+ }
+}
diff --git a/apps-archived/clock/apps/web/src/lib/i18n/locales/en.json b/apps-archived/clock/apps/web/src/lib/i18n/locales/en.json
new file mode 100644
index 000000000..f6f978137
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/i18n/locales/en.json
@@ -0,0 +1,23 @@
+{
+ "app": {
+ "name": "Clock"
+ },
+ "common": {
+ "back": "Back",
+ "cancel": "Cancel",
+ "loading": "Loading..."
+ },
+ "nav": {
+ "home": "Home",
+ "settings": "Settings"
+ },
+ "clock": {
+ "title": "Life Clock",
+ "remaining": "Time remaining",
+ "elapsed": "Time elapsed"
+ },
+ "messages": {
+ "saved": "Saved",
+ "error": "An error occurred"
+ }
+}
diff --git a/apps-archived/clock/apps/web/src/lib/stores/alarms.svelte.ts b/apps-archived/clock/apps/web/src/lib/stores/alarms.svelte.ts
new file mode 100644
index 000000000..e35201385
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/stores/alarms.svelte.ts
@@ -0,0 +1,97 @@
+/**
+ * Alarms Store — Mutation-Only Service
+ *
+ * All reads are handled by useLiveQuery() hooks in queries.ts.
+ * This store only provides write operations (create, update, delete, toggle).
+ * IndexedDB writes automatically trigger UI updates via Dexie liveQuery.
+ */
+
+import { alarmCollection, type LocalAlarm } from '$lib/data/local-store';
+import { toAlarm } from '$lib/data/queries';
+import type { CreateAlarmInput, UpdateAlarmInput, Alarm } from '@clock/shared';
+
+let error = $state(null);
+
+export const alarmsStore = {
+ get error() {
+ return error;
+ },
+
+ /**
+ * Create a new alarm -- writes to IndexedDB instantly.
+ */
+ async createAlarm(input: CreateAlarmInput) {
+ error = null;
+ try {
+ const newLocal: LocalAlarm = {
+ id: crypto.randomUUID(),
+ label: input.label ?? null,
+ time: input.time,
+ enabled: input.enabled ?? true,
+ repeatDays: input.repeatDays ?? null,
+ snoozeMinutes: input.snoozeMinutes ?? null,
+ sound: input.sound ?? null,
+ vibrate: input.vibrate ?? null,
+ };
+
+ const inserted = await alarmCollection.insert(newLocal);
+ return { success: true, data: toAlarm(inserted) };
+ } catch (e) {
+ error = e instanceof Error ? e.message : 'Failed to create alarm';
+ console.error('Failed to create alarm:', e);
+ return { success: false, error: error };
+ }
+ },
+
+ /**
+ * Update an alarm -- writes to IndexedDB instantly.
+ */
+ async updateAlarm(id: string, input: UpdateAlarmInput) {
+ error = null;
+ try {
+ const updateData: Partial = {};
+ if (input.label !== undefined) updateData.label = input.label ?? null;
+ if (input.time !== undefined) updateData.time = input.time;
+ if (input.enabled !== undefined) updateData.enabled = input.enabled;
+ if (input.repeatDays !== undefined) updateData.repeatDays = input.repeatDays ?? null;
+ if (input.snoozeMinutes !== undefined) updateData.snoozeMinutes = input.snoozeMinutes ?? null;
+ if (input.sound !== undefined) updateData.sound = input.sound ?? null;
+ if (input.vibrate !== undefined) updateData.vibrate = input.vibrate ?? null;
+
+ const updated = await alarmCollection.update(id, updateData);
+ if (updated) {
+ return { success: true, data: toAlarm(updated) };
+ }
+ return { success: false, error: 'Alarm not found' };
+ } catch (e) {
+ error = e instanceof Error ? e.message : 'Failed to update alarm';
+ console.error('Failed to update alarm:', e);
+ return { success: false, error: error };
+ }
+ },
+
+ /**
+ * Toggle alarm enabled state.
+ */
+ async toggleAlarm(id: string, currentAlarms: Alarm[]) {
+ const alarm = currentAlarms.find((a) => a.id === id);
+ if (!alarm) return { success: false, error: 'Alarm not found' };
+
+ return this.updateAlarm(id, { enabled: !alarm.enabled });
+ },
+
+ /**
+ * Delete an alarm -- removes from IndexedDB instantly.
+ */
+ async deleteAlarm(id: string) {
+ error = null;
+ try {
+ await alarmCollection.delete(id);
+ return { success: true };
+ } catch (e) {
+ error = e instanceof Error ? e.message : 'Failed to delete alarm';
+ console.error('Failed to delete alarm:', e);
+ return { success: false, error: error };
+ }
+ },
+};
diff --git a/apps-archived/clock/apps/web/src/lib/stores/app-onboarding.svelte.ts b/apps-archived/clock/apps/web/src/lib/stores/app-onboarding.svelte.ts
new file mode 100644
index 000000000..faf855557
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/stores/app-onboarding.svelte.ts
@@ -0,0 +1,82 @@
+import { createAppOnboardingStore, type AppOnboardingStep } from '@manacore/shared-app-onboarding';
+import { userSettings } from './user-settings.svelte';
+
+/**
+ * Clock-specific onboarding steps
+ */
+const clockOnboardingSteps: AppOnboardingStep[] = [
+ {
+ id: 'features',
+ type: 'info',
+ question: 'Willkommen bei Clock!',
+ description: 'Das kann Clock für dich tun:',
+ emoji: '🕐',
+ gradient: { from: 'blue-500', to: 'blue-700' },
+ bullets: [
+ 'Flexible Timer & Stoppuhr',
+ 'Pomodoro-Technik für produktives Arbeiten',
+ 'Voreingestellte Timer-Dauern',
+ 'Minimalistisches Design',
+ ],
+ },
+ {
+ id: 'defaultTimer',
+ type: 'select',
+ question: 'Welche Timer-Dauer nutzt du am häufigsten?',
+ description: 'Du kannst Timer jederzeit individuell einstellen.',
+ emoji: '⏱️',
+ gradient: { from: 'blue-500', to: 'blue-700' },
+ options: [
+ {
+ id: '5',
+ label: '5 Minuten',
+ description: 'Für kurze Pausen',
+ emoji: '⚡',
+ },
+ {
+ id: '15',
+ label: '15 Minuten',
+ description: 'Für konzentrierte Einheiten',
+ emoji: '🎯',
+ },
+ {
+ id: '25',
+ label: '25 Minuten',
+ description: 'Pomodoro-Technik (Empfohlen)',
+ emoji: '🍅',
+ },
+ {
+ id: '45',
+ label: '45 Minuten',
+ description: 'Für längere Arbeitsphasen',
+ emoji: '🧘',
+ },
+ ],
+ defaultValue: '25',
+ },
+ {
+ id: 'welcome',
+ type: 'info',
+ question: 'Deine Uhr ist bereit!',
+ description: 'Hier sind einige Tipps:',
+ emoji: '🎉',
+ gradient: { from: 'primary', to: 'primary/70' },
+ bullets: [
+ 'Nutze die Stoppuhr für freie Zeitmessung',
+ 'Stelle Wecker für wichtige Erinnerungen',
+ 'Die Weltuhr zeigt mehrere Zeitzonen gleichzeitig',
+ 'Drücke Cmd/Ctrl+K für die Schnellsuche',
+ ],
+ },
+];
+
+/**
+ * Clock app onboarding store
+ */
+export const clockOnboarding = createAppOnboardingStore({
+ appId: 'clock',
+ steps: clockOnboardingSteps,
+ userSettings,
+ onComplete: async () => {},
+ onSkip: async () => {},
+});
diff --git a/apps-archived/clock/apps/web/src/lib/stores/auth.svelte.ts b/apps-archived/clock/apps/web/src/lib/stores/auth.svelte.ts
new file mode 100644
index 000000000..5f0483975
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/stores/auth.svelte.ts
@@ -0,0 +1,9 @@
+/**
+ * Auth Store — uses centralized Mana auth factory.
+ */
+
+import { createManaAuthStore } from '@manacore/shared-auth-stores';
+
+export const authStore = createManaAuthStore({
+ devBackendPort: 3017,
+});
diff --git a/apps-archived/clock/apps/web/src/lib/stores/navigation.ts b/apps-archived/clock/apps/web/src/lib/stores/navigation.ts
new file mode 100644
index 000000000..08ea3eeec
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/stores/navigation.ts
@@ -0,0 +1,5 @@
+import { createSimpleNavigationStores } from '@manacore/shared-stores';
+
+export const { isNavCollapsed } = createSimpleNavigationStores({
+ storageKey: 'clock',
+});
diff --git a/apps-archived/clock/apps/web/src/lib/stores/session-alarms.svelte.ts b/apps-archived/clock/apps/web/src/lib/stores/session-alarms.svelte.ts
new file mode 100644
index 000000000..04e334e34
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/stores/session-alarms.svelte.ts
@@ -0,0 +1,150 @@
+/**
+ * Session Alarms Store - Manages alarms in sessionStorage for guest users
+ * This allows users to try the app without signing in.
+ * Data is stored in sessionStorage (lost when tab closes).
+ */
+
+import type { Alarm, CreateAlarmInput, UpdateAlarmInput } from '@clock/shared';
+
+const STORAGE_KEY = 'clock-session-alarms';
+
+// State
+let alarms = $state([]);
+
+// Generate session ID
+function generateSessionId(): string {
+ return `session_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+
+// Load from sessionStorage
+function loadFromStorage(): void {
+ if (typeof window === 'undefined') return;
+
+ try {
+ const stored = sessionStorage.getItem(STORAGE_KEY);
+ if (stored) {
+ alarms = JSON.parse(stored);
+ }
+ } catch (e) {
+ console.error('Failed to load session alarms:', e);
+ }
+}
+
+// Save to sessionStorage
+function saveToStorage(): void {
+ if (typeof window === 'undefined') return;
+
+ try {
+ sessionStorage.setItem(STORAGE_KEY, JSON.stringify(alarms));
+ } catch (e) {
+ console.error('Failed to save session alarms:', e);
+ }
+}
+
+// Initialize on load
+if (typeof window !== 'undefined') {
+ loadFromStorage();
+}
+
+export const sessionAlarmsStore = {
+ // Getters
+ get alarms() {
+ return alarms;
+ },
+ get enabledAlarms() {
+ return alarms.filter((a) => a.enabled);
+ },
+
+ /**
+ * Create a new session alarm
+ */
+ createAlarm(input: CreateAlarmInput): Alarm {
+ const now = new Date().toISOString();
+ const alarm: Alarm = {
+ id: generateSessionId(),
+ userId: 'guest',
+ label: input.label || null,
+ time: input.time,
+ enabled: input.enabled ?? true,
+ repeatDays: input.repeatDays || null,
+ snoozeMinutes: input.snoozeMinutes || null,
+ sound: input.sound || null,
+ vibrate: input.vibrate ?? null,
+ createdAt: now,
+ updatedAt: now,
+ };
+
+ alarms = [...alarms, alarm];
+ saveToStorage();
+
+ return alarm;
+ },
+
+ /**
+ * Update a session alarm
+ */
+ updateAlarm(id: string, input: UpdateAlarmInput): Alarm | null {
+ const index = alarms.findIndex((a) => a.id === id);
+ if (index === -1) return null;
+
+ const updated: Alarm = {
+ ...alarms[index],
+ ...input,
+ updatedAt: new Date().toISOString(),
+ };
+
+ alarms = alarms.map((a) => (a.id === id ? updated : a));
+ saveToStorage();
+
+ return updated;
+ },
+
+ /**
+ * Toggle alarm enabled state
+ */
+ toggleAlarm(id: string): Alarm | null {
+ const alarm = alarms.find((a) => a.id === id);
+ if (!alarm) return null;
+
+ return this.updateAlarm(id, { enabled: !alarm.enabled });
+ },
+
+ /**
+ * Delete a session alarm
+ */
+ deleteAlarm(id: string): void {
+ alarms = alarms.filter((a) => a.id !== id);
+ saveToStorage();
+ },
+
+ /**
+ * Check if ID is a session alarm
+ */
+ isSessionAlarm(id: string): boolean {
+ return id.startsWith('session_');
+ },
+
+ /**
+ * Get all alarms for migration
+ */
+ getAllAlarms(): Alarm[] {
+ return [...alarms];
+ },
+
+ /**
+ * Clear all session data
+ */
+ clear(): void {
+ alarms = [];
+ if (typeof window !== 'undefined') {
+ sessionStorage.removeItem(STORAGE_KEY);
+ }
+ },
+
+ /**
+ * Get count of session alarms
+ */
+ get count(): number {
+ return alarms.length;
+ },
+};
diff --git a/apps-archived/clock/apps/web/src/lib/stores/session-timers.svelte.ts b/apps-archived/clock/apps/web/src/lib/stores/session-timers.svelte.ts
new file mode 100644
index 000000000..d2953a383
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/stores/session-timers.svelte.ts
@@ -0,0 +1,214 @@
+/**
+ * Session Timers Store - Manages timers in sessionStorage for guest users
+ * This allows users to try the app without signing in.
+ * Data is stored in sessionStorage (lost when tab closes).
+ */
+
+import type { Timer, CreateTimerInput, UpdateTimerInput, TimerStatus } from '@clock/shared';
+
+const STORAGE_KEY = 'clock-session-timers';
+
+// State
+let timers = $state([]);
+
+// Generate session ID
+function generateSessionId(): string {
+ return `session_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+
+// Load from sessionStorage
+function loadFromStorage(): void {
+ if (typeof window === 'undefined') return;
+
+ try {
+ const stored = sessionStorage.getItem(STORAGE_KEY);
+ if (stored) {
+ timers = JSON.parse(stored);
+ }
+ } catch (e) {
+ console.error('Failed to load session timers:', e);
+ }
+}
+
+// Save to sessionStorage
+function saveToStorage(): void {
+ if (typeof window === 'undefined') return;
+
+ try {
+ sessionStorage.setItem(STORAGE_KEY, JSON.stringify(timers));
+ } catch (e) {
+ console.error('Failed to save session timers:', e);
+ }
+}
+
+// Initialize on load
+if (typeof window !== 'undefined') {
+ loadFromStorage();
+}
+
+export const sessionTimersStore = {
+ // Getters
+ get timers() {
+ return timers;
+ },
+ get activeTimers() {
+ return timers.filter((t) => t.status === 'running' || t.status === 'paused');
+ },
+
+ /**
+ * Create a new session timer
+ */
+ createTimer(input: CreateTimerInput): Timer {
+ const now = new Date().toISOString();
+ const timer: Timer = {
+ id: generateSessionId(),
+ userId: 'guest',
+ label: input.label || null,
+ durationSeconds: input.durationSeconds,
+ remainingSeconds: input.durationSeconds,
+ status: 'idle' as TimerStatus,
+ startedAt: null,
+ pausedAt: null,
+ sound: input.sound || null,
+ createdAt: now,
+ updatedAt: now,
+ };
+
+ timers = [...timers, timer];
+ saveToStorage();
+
+ return timer;
+ },
+
+ /**
+ * Update a session timer
+ */
+ updateTimer(id: string, input: UpdateTimerInput): Timer | null {
+ const index = timers.findIndex((t) => t.id === id);
+ if (index === -1) return null;
+
+ const updated: Timer = {
+ ...timers[index],
+ ...input,
+ updatedAt: new Date().toISOString(),
+ };
+
+ timers = timers.map((t) => (t.id === id ? updated : t));
+ saveToStorage();
+
+ return updated;
+ },
+
+ /**
+ * Start a timer
+ */
+ startTimer(id: string): Timer | null {
+ const timer = timers.find((t) => t.id === id);
+ if (!timer) return null;
+
+ const now = new Date().toISOString();
+ const updated: Timer = {
+ ...timer,
+ status: 'running',
+ startedAt: now,
+ pausedAt: null,
+ updatedAt: now,
+ };
+
+ timers = timers.map((t) => (t.id === id ? updated : t));
+ saveToStorage();
+
+ return updated;
+ },
+
+ /**
+ * Pause a timer
+ */
+ pauseTimer(id: string): Timer | null {
+ const timer = timers.find((t) => t.id === id);
+ if (!timer) return null;
+
+ const now = new Date().toISOString();
+ const updated: Timer = {
+ ...timer,
+ status: 'paused',
+ pausedAt: now,
+ updatedAt: now,
+ };
+
+ timers = timers.map((t) => (t.id === id ? updated : t));
+ saveToStorage();
+
+ return updated;
+ },
+
+ /**
+ * Reset a timer
+ */
+ resetTimer(id: string): Timer | null {
+ const timer = timers.find((t) => t.id === id);
+ if (!timer) return null;
+
+ const now = new Date().toISOString();
+ const updated: Timer = {
+ ...timer,
+ status: 'idle',
+ remainingSeconds: timer.durationSeconds,
+ startedAt: null,
+ pausedAt: null,
+ updatedAt: now,
+ };
+
+ timers = timers.map((t) => (t.id === id ? updated : t));
+ saveToStorage();
+
+ return updated;
+ },
+
+ /**
+ * Update local timer state (for countdown display)
+ */
+ updateLocalState(id: string, updates: Partial): void {
+ timers = timers.map((t) => (t.id === id ? { ...t, ...updates } : t));
+ saveToStorage();
+ },
+
+ /**
+ * Delete a session timer
+ */
+ deleteTimer(id: string): void {
+ timers = timers.filter((t) => t.id !== id);
+ saveToStorage();
+ },
+
+ /**
+ * Check if ID is a session timer
+ */
+ isSessionTimer(id: string): boolean {
+ return id.startsWith('session_');
+ },
+
+ /**
+ * Get all timers for migration
+ */
+ getAllTimers(): Timer[] {
+ return [...timers];
+ },
+
+ /**
+ * Clear all session data
+ */
+ clear(): void {
+ timers = [];
+ if (typeof window !== 'undefined') {
+ sessionStorage.removeItem(STORAGE_KEY);
+ }
+ },
+
+ /**
+ * Get count of session timers
+ */
+ get count(): number {
+ return timers.length;
+ },
+};
diff --git a/apps-archived/clock/apps/web/src/lib/stores/stopwatch.svelte.ts b/apps-archived/clock/apps/web/src/lib/stores/stopwatch.svelte.ts
new file mode 100644
index 000000000..5573dfbc8
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/stores/stopwatch.svelte.ts
@@ -0,0 +1,231 @@
+/**
+ * Stopwatch Store - Manages stopwatch state using Svelte 5 runes
+ * Stopwatches are local-only (no backend sync)
+ */
+
+export interface Lap {
+ number: number;
+ time: number; // milliseconds since start
+ delta: number; // milliseconds since last lap
+}
+
+export interface Stopwatch {
+ id: string;
+ label: string;
+ startTime: number | null; // timestamp when started
+ elapsedTime: number; // accumulated milliseconds when paused
+ status: 'idle' | 'running' | 'paused';
+ laps: Lap[];
+ color: string;
+}
+
+export const STOPWATCH_COLORS = [
+ '#3B82F6', // blue
+ '#10B981', // green
+ '#F59E0B', // amber
+ '#EF4444', // red
+ '#8B5CF6', // violet
+ '#EC4899', // pink
+ '#14B8A6', // teal
+ '#F97316', // orange
+];
+
+// State
+let stopwatches = $state([]);
+let focusedId = $state(null);
+let colorIndex = 0;
+
+// Tick interval for updating display
+let tickInterval: ReturnType | null = null;
+
+function getNextColor(): string {
+ const color = STOPWATCH_COLORS[colorIndex % STOPWATCH_COLORS.length];
+ colorIndex++;
+ return color;
+}
+
+function startTicking() {
+ if (tickInterval) return;
+ tickInterval = setInterval(() => {
+ // Force reactivity update by reassigning
+ stopwatches = [...stopwatches];
+ }, 100);
+}
+
+function stopTickingIfNoRunning() {
+ const hasRunning = stopwatches.some((sw) => sw.status === 'running');
+ if (!hasRunning && tickInterval) {
+ clearInterval(tickInterval);
+ tickInterval = null;
+ }
+}
+
+export const stopwatchesStore = {
+ // Getters
+ get stopwatches() {
+ return stopwatches;
+ },
+ get focusedId() {
+ return focusedId;
+ },
+ get focusedStopwatch() {
+ return stopwatches.find((sw) => sw.id === focusedId) || null;
+ },
+
+ /**
+ * Create a new stopwatch
+ */
+ create(label?: string): string {
+ const id = crypto.randomUUID();
+ const newStopwatch: Stopwatch = {
+ id,
+ label: label || `Stopwatch ${stopwatches.length + 1}`,
+ startTime: null,
+ elapsedTime: 0,
+ status: 'idle',
+ laps: [],
+ color: getNextColor(),
+ };
+ stopwatches = [...stopwatches, newStopwatch];
+ if (!focusedId) {
+ focusedId = id;
+ }
+ return id;
+ },
+
+ /**
+ * Start a stopwatch
+ */
+ start(id: string) {
+ stopwatches = stopwatches.map((sw) => {
+ if (sw.id !== id) return sw;
+ return {
+ ...sw,
+ startTime: Date.now(),
+ status: 'running' as const,
+ };
+ });
+ startTicking();
+ },
+
+ /**
+ * Pause a stopwatch
+ */
+ pause(id: string) {
+ stopwatches = stopwatches.map((sw) => {
+ if (sw.id !== id || sw.status !== 'running') return sw;
+ const elapsed = sw.startTime ? Date.now() - sw.startTime : 0;
+ return {
+ ...sw,
+ startTime: null,
+ elapsedTime: sw.elapsedTime + elapsed,
+ status: 'paused' as const,
+ };
+ });
+ stopTickingIfNoRunning();
+ },
+
+ /**
+ * Reset a stopwatch
+ */
+ reset(id: string) {
+ stopwatches = stopwatches.map((sw) => {
+ if (sw.id !== id) return sw;
+ return {
+ ...sw,
+ startTime: null,
+ elapsedTime: 0,
+ status: 'idle' as const,
+ laps: [],
+ };
+ });
+ stopTickingIfNoRunning();
+ },
+
+ /**
+ * Add a lap to a stopwatch
+ */
+ addLap(id: string) {
+ stopwatches = stopwatches.map((sw) => {
+ if (sw.id !== id || sw.status !== 'running') return sw;
+ const currentTime = this.getElapsed(sw);
+ const lastLap = sw.laps[sw.laps.length - 1];
+ const delta = lastLap ? currentTime - lastLap.time : currentTime;
+ const newLap: Lap = {
+ number: sw.laps.length + 1,
+ time: currentTime,
+ delta,
+ };
+ return {
+ ...sw,
+ laps: [...sw.laps, newLap],
+ };
+ });
+ },
+
+ /**
+ * Delete a stopwatch
+ */
+ delete(id: string) {
+ stopwatches = stopwatches.filter((sw) => sw.id !== id);
+ if (focusedId === id) {
+ focusedId = stopwatches[0]?.id || null;
+ }
+ stopTickingIfNoRunning();
+ },
+
+ /**
+ * Set focused stopwatch
+ */
+ setFocused(id: string | null) {
+ focusedId = id;
+ },
+
+ /**
+ * Update stopwatch label
+ */
+ updateLabel(id: string, label: string) {
+ stopwatches = stopwatches.map((sw) => (sw.id === id ? { ...sw, label } : sw));
+ },
+
+ /**
+ * Get elapsed time for a stopwatch
+ */
+ getElapsed(sw: Stopwatch): number {
+ if (sw.status === 'running' && sw.startTime) {
+ return sw.elapsedTime + (Date.now() - sw.startTime);
+ }
+ return sw.elapsedTime;
+ },
+};
+
+/**
+ * Format time in milliseconds to display string
+ */
+export function formatTime(ms: number): string {
+ const totalSeconds = Math.floor(ms / 1000);
+ const hours = Math.floor(totalSeconds / 3600);
+ const minutes = Math.floor((totalSeconds % 3600) / 60);
+ const seconds = totalSeconds % 60;
+ const centiseconds = Math.floor((ms % 1000) / 10);
+
+ if (hours > 0) {
+ return `${hours}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}.${centiseconds.toString().padStart(2, '0')}`;
+ }
+ return `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}.${centiseconds.toString().padStart(2, '0')}`;
+}
+
+/**
+ * Format lap time (delta) for display
+ */
+export function formatLapTime(ms: number): string {
+ const totalSeconds = Math.floor(ms / 1000);
+ const minutes = Math.floor(totalSeconds / 60);
+ const seconds = totalSeconds % 60;
+ const centiseconds = Math.floor((ms % 1000) / 10);
+
+ if (minutes > 0) {
+ return `+${minutes}:${seconds.toString().padStart(2, '0')}.${centiseconds.toString().padStart(2, '0')}`;
+ }
+ return `+${seconds}.${centiseconds.toString().padStart(2, '0')}`;
+}
diff --git a/apps-archived/clock/apps/web/src/lib/stores/tags.svelte.ts b/apps-archived/clock/apps/web/src/lib/stores/tags.svelte.ts
new file mode 100644
index 000000000..074782375
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/stores/tags.svelte.ts
@@ -0,0 +1,13 @@
+/**
+ * Tag Store — Local-First via Shared Tag Store
+ * Tags are stored in shared IndexedDB ('manacore-tags'), accessible across all apps.
+ * Use context ('tags') for reads, tagMutations for writes.
+ */
+export {
+ tagMutations,
+ useAllTags,
+ getTagById,
+ getTagsByIds,
+ getTagColor,
+ getTagsByGroup,
+} from '@manacore/shared-stores';
diff --git a/apps-archived/clock/apps/web/src/lib/stores/theme.svelte.ts b/apps-archived/clock/apps/web/src/lib/stores/theme.svelte.ts
new file mode 100644
index 000000000..5784cfeec
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/stores/theme.svelte.ts
@@ -0,0 +1,7 @@
+import { createThemeStore } from '@manacore/shared-theme';
+
+// Create theme store with Clock's styling
+export const theme = createThemeStore({
+ appId: 'clock',
+ defaultVariant: 'lume',
+});
diff --git a/apps-archived/clock/apps/web/src/lib/stores/timers.svelte.ts b/apps-archived/clock/apps/web/src/lib/stores/timers.svelte.ts
new file mode 100644
index 000000000..0c5e3441e
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/stores/timers.svelte.ts
@@ -0,0 +1,191 @@
+/**
+ * Timers Store — Mutation-Only Service
+ *
+ * All reads are handled by useLiveQuery() hooks in queries.ts.
+ * This store only provides write operations (create, update, delete, start, pause, reset).
+ * IndexedDB writes automatically trigger UI updates via Dexie liveQuery.
+ */
+
+import { timerCollection, type LocalTimer } from '$lib/data/local-store';
+import { toTimer } from '$lib/data/queries';
+import type { CreateTimerInput, UpdateTimerInput } from '@clock/shared';
+import { ClockEvents } from '@manacore/shared-utils/analytics';
+
+let error = $state(null);
+
+export const timersStore = {
+ get error() {
+ return error;
+ },
+
+ /**
+ * Create a new timer -- writes to IndexedDB instantly.
+ */
+ async createTimer(input: CreateTimerInput) {
+ error = null;
+ try {
+ const newLocal: LocalTimer = {
+ id: crypto.randomUUID(),
+ label: input.label ?? null,
+ durationSeconds: input.durationSeconds,
+ remainingSeconds: null,
+ status: 'idle',
+ startedAt: null,
+ pausedAt: null,
+ sound: input.sound ?? null,
+ };
+
+ const inserted = await timerCollection.insert(newLocal);
+ return { success: true, data: toTimer(inserted) };
+ } catch (e) {
+ error = e instanceof Error ? e.message : 'Failed to create timer';
+ console.error('Failed to create timer:', e);
+ return { success: false, error: error };
+ }
+ },
+
+ /**
+ * Update a timer -- writes to IndexedDB instantly.
+ */
+ async updateTimer(id: string, input: UpdateTimerInput) {
+ error = null;
+ try {
+ const updateData: Partial = {};
+ if (input.label !== undefined) updateData.label = input.label ?? null;
+ if (input.durationSeconds !== undefined) updateData.durationSeconds = input.durationSeconds;
+ if (input.sound !== undefined) updateData.sound = input.sound ?? null;
+
+ const updated = await timerCollection.update(id, updateData);
+ if (updated) {
+ return { success: true, data: toTimer(updated) };
+ }
+ return { success: false, error: 'Timer not found' };
+ } catch (e) {
+ error = e instanceof Error ? e.message : 'Failed to update timer';
+ console.error('Failed to update timer:', e);
+ return { success: false, error: error };
+ }
+ },
+
+ /**
+ * Start a timer -- sets status to running with current timestamp.
+ */
+ async startTimer(id: string) {
+ error = null;
+ try {
+ const existing = await timerCollection.get(id);
+ if (!existing) return { success: false, error: 'Timer not found' };
+
+ const updateData: Partial = {
+ status: 'running',
+ startedAt: new Date().toISOString(),
+ pausedAt: null,
+ };
+
+ // If resuming from pause, keep remaining seconds
+ if (existing.status !== 'paused') {
+ updateData.remainingSeconds = existing.durationSeconds;
+ }
+
+ const updated = await timerCollection.update(id, updateData);
+ if (updated) {
+ const updatedTimer = toTimer(updated);
+ ClockEvents.timerStarted(
+ (updatedTimer as any).type as 'pomodoro' | 'stopwatch' | 'countdown'
+ );
+ return { success: true, data: updatedTimer };
+ }
+ return { success: false, error: 'Timer not found' };
+ } catch (e) {
+ error = e instanceof Error ? e.message : 'Failed to start timer';
+ console.error('Failed to start timer:', e);
+ return { success: false, error: error };
+ }
+ },
+
+ /**
+ * Pause a timer -- calculates remaining seconds and saves.
+ */
+ async pauseTimer(id: string) {
+ error = null;
+ try {
+ const existing = await timerCollection.get(id);
+ if (!existing) return { success: false, error: 'Timer not found' };
+
+ // Calculate remaining seconds
+ let remaining = existing.remainingSeconds ?? existing.durationSeconds;
+ if (existing.startedAt) {
+ const elapsed = (Date.now() - new Date(existing.startedAt).getTime()) / 1000;
+ remaining = Math.max(0, remaining - elapsed);
+ }
+
+ const updateData: Partial = {
+ status: 'paused',
+ pausedAt: new Date().toISOString(),
+ remainingSeconds: Math.round(remaining),
+ startedAt: null,
+ };
+
+ const updated = await timerCollection.update(id, updateData);
+ if (updated) {
+ return { success: true, data: toTimer(updated) };
+ }
+ return { success: false, error: 'Timer not found' };
+ } catch (e) {
+ error = e instanceof Error ? e.message : 'Failed to pause timer';
+ console.error('Failed to pause timer:', e);
+ return { success: false, error: error };
+ }
+ },
+
+ /**
+ * Reset a timer -- back to idle with full duration.
+ */
+ async resetTimer(id: string) {
+ error = null;
+ try {
+ const updateData: Partial = {
+ status: 'idle',
+ remainingSeconds: null,
+ startedAt: null,
+ pausedAt: null,
+ };
+
+ const updated = await timerCollection.update(id, updateData);
+ if (updated) {
+ return { success: true, data: toTimer(updated) };
+ }
+ return { success: false, error: 'Timer not found' };
+ } catch (e) {
+ error = e instanceof Error ? e.message : 'Failed to reset timer';
+ console.error('Failed to reset timer:', e);
+ return { success: false, error: error };
+ }
+ },
+
+ /**
+ * Delete a timer -- removes from IndexedDB instantly.
+ */
+ async deleteTimer(id: string) {
+ error = null;
+ try {
+ await timerCollection.delete(id);
+ return { success: true };
+ } catch (e) {
+ error = e instanceof Error ? e.message : 'Failed to delete timer';
+ console.error('Failed to delete timer:', e);
+ return { success: false, error: error };
+ }
+ },
+
+ /**
+ * Update remaining seconds in IndexedDB (for countdown display).
+ */
+ async updateLocalTimer(id: string, remainingSeconds: number) {
+ try {
+ await timerCollection.update(id, { remainingSeconds });
+ } catch (e) {
+ console.error('Failed to update local timer:', e);
+ }
+ },
+};
diff --git a/apps-archived/clock/apps/web/src/lib/stores/user-settings.svelte.ts b/apps-archived/clock/apps/web/src/lib/stores/user-settings.svelte.ts
new file mode 100644
index 000000000..d28b67ea6
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/stores/user-settings.svelte.ts
@@ -0,0 +1,28 @@
+/**
+ * User Settings Store for Clock
+ *
+ * This store syncs settings with mana-core-auth and provides:
+ * - Global settings that apply to all apps
+ * - Per-app overrides for customization
+ * - localStorage caching for offline support
+ */
+
+import { browser } from '$app/environment';
+import { createUserSettingsStore } from '@manacore/shared-theme';
+import { authStore } from './auth.svelte';
+
+// Get auth URL dynamically at runtime
+function getAuthUrl(): string {
+ if (browser && typeof window !== 'undefined') {
+ const injectedUrl = (window as unknown as { __PUBLIC_MANA_CORE_AUTH_URL__?: string })
+ .__PUBLIC_MANA_CORE_AUTH_URL__;
+ if (injectedUrl) return injectedUrl;
+ }
+ return import.meta.env.DEV ? 'http://localhost:3001' : '';
+}
+
+export const userSettings = createUserSettingsStore({
+ appId: 'clock',
+ authUrl: getAuthUrl,
+ getAccessToken: () => authStore.getAccessToken(),
+});
diff --git a/apps-archived/clock/apps/web/src/lib/stores/world-clocks.svelte.ts b/apps-archived/clock/apps/web/src/lib/stores/world-clocks.svelte.ts
new file mode 100644
index 000000000..252468d9a
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/stores/world-clocks.svelte.ts
@@ -0,0 +1,74 @@
+/**
+ * World Clocks Store — Mutation-Only Service
+ *
+ * All reads are handled by useLiveQuery() hooks in queries.ts.
+ * This store only provides write operations (add, remove, reorder).
+ * IndexedDB writes automatically trigger UI updates via Dexie liveQuery.
+ */
+
+import { worldClockCollection, type LocalWorldClock } from '$lib/data/local-store';
+import type { CreateWorldClockInput, WorldClock } from '@clock/shared';
+
+let error = $state(null);
+
+export const worldClocksStore = {
+ get error() {
+ return error;
+ },
+
+ /**
+ * Add a new world clock -- writes to IndexedDB instantly.
+ */
+ async addWorldClock(input: CreateWorldClockInput, currentCount: number = 0) {
+ error = null;
+ try {
+ const newLocal: LocalWorldClock = {
+ id: crypto.randomUUID(),
+ timezone: input.timezone,
+ cityName: input.cityName,
+ sortOrder: currentCount,
+ };
+
+ await worldClockCollection.insert(newLocal);
+ return { success: true };
+ } catch (e) {
+ error = e instanceof Error ? e.message : 'Failed to add world clock';
+ console.error('Failed to add world clock:', e);
+ return { success: false, error: error };
+ }
+ },
+
+ /**
+ * Remove a world clock -- removes from IndexedDB instantly.
+ */
+ async removeWorldClock(id: string) {
+ error = null;
+ try {
+ await worldClockCollection.delete(id);
+ return { success: true };
+ } catch (e) {
+ error = e instanceof Error ? e.message : 'Failed to remove world clock';
+ console.error('Failed to remove world clock:', e);
+ return { success: false, error: error };
+ }
+ },
+
+ /**
+ * Reorder world clocks -- updates sortOrder in IndexedDB.
+ */
+ async reorder(ids: string[]) {
+ error = null;
+ try {
+ for (let i = 0; i < ids.length; i++) {
+ await worldClockCollection.update(ids[i], {
+ sortOrder: i,
+ } as Partial);
+ }
+ return { success: true };
+ } catch (e) {
+ error = e instanceof Error ? e.message : 'Failed to reorder world clocks';
+ console.error('Failed to reorder world clocks:', e);
+ return { success: false, error: error };
+ }
+ },
+};
diff --git a/apps-archived/clock/apps/web/src/lib/version.ts b/apps-archived/clock/apps/web/src/lib/version.ts
new file mode 100644
index 000000000..d63b4cfef
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/lib/version.ts
@@ -0,0 +1,4 @@
+export const APP_VERSION = '0.2.0';
+export const BUILD_TIME: string =
+ typeof __BUILD_TIME__ !== 'undefined' ? __BUILD_TIME__ : new Date().toISOString();
+export const BUILD_HASH: string = typeof __BUILD_HASH__ !== 'undefined' ? __BUILD_HASH__ : 'dev';
diff --git a/apps-archived/clock/apps/web/src/routes/(app)/+layout.svelte b/apps-archived/clock/apps/web/src/routes/(app)/+layout.svelte
new file mode 100644
index 000000000..79c8a9c38
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/routes/(app)/+layout.svelte
@@ -0,0 +1,465 @@
+
+
+
+
+
+
+
+ {#if isTagStripVisible}
+
({
+ id: t.id,
+ name: t.name,
+ color: t.color || '#3b82f6',
+ }))}
+ selectedIds={[]}
+ onToggle={() => {}}
+ onClear={() => {}}
+ managementHref="/tags"
+ />
+ {/if}
+
+
+
+ {@render children()}
+
+
+
+
+ (commandBarOpen = false)}
+ onSearch={handleCommandBarSearch}
+ onSelect={handleCommandBarSelect}
+ quickActions={commandBarQuickActions}
+ placeholder="Schnellzugriff..."
+ emptyText="Keine Ergebnisse"
+ searchingText="Suche..."
+ />
+ (showGuestWelcome = false)}
+ onLogin={() => goto('/login')}
+ onRegister={() => goto('/register')}
+ locale={($locale || 'de') === 'de' ? 'de' : 'en'}
+ />
+
+ {#if authStore.isAuthenticated}
+
+
+
diff --git a/apps-archived/clock/apps/web/src/routes/(app)/+page.svelte b/apps-archived/clock/apps/web/src/routes/(app)/+page.svelte
new file mode 100644
index 000000000..74d5d5739
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/routes/(app)/+page.svelte
@@ -0,0 +1,115 @@
+
+
+
+ Clock - Dashboard
+
+
+{#if isLoading}
+
+
+ Clock
+ Dein Zeit-Management Hub
+
+
+
+
+
+
+
+
+
+ {new Date().toLocaleTimeString('de-DE', {
+ hour: '2-digit',
+ minute: '2-digit',
+ second: '2-digit',
+ })}
+
+
+ {new Date().toLocaleDateString('de-DE', {
+ weekday: 'long',
+ year: 'numeric',
+ month: 'long',
+ day: 'numeric',
+ })}
+
+
+
+
+
+
+
+
+
+
+
+ {#if showOptions}
+
+ {#each dayNames as day, i}
+ toggleNewDay(i)}
+ >
+ {day}
+
+ {/each}
+
+ {/if}
+
+
+
+ {#each DEFAULT_ALARM_PRESETS as preset}
+ {@const existingAlarm = findAlarmForPreset(preset.time)}
+ {@const isActive = existingAlarm?.enabled ?? false}
+
togglePreset(preset.time, preset.label)}
+ onkeydown={(e) => e.key === 'Enter' && togglePreset(preset.time, preset.label)}
+ >
+
+ {preset.time}
+
+
+ {existingAlarm?.label || preset.label}
+
+
+ {/each}
+
+
+
+ {#if allAlarms.value.filter((a) => !DEFAULT_ALARM_PRESETS.some((p) => p.time === a.time.slice(0, 5))).length > 0}
+ {@const customAlarms = allAlarms.value.filter(
+ (a) => !DEFAULT_ALARM_PRESETS.some((p) => p.time === a.time.slice(0, 5))
+ )}
+
+
+ {$_('alarm.custom')}
+
+
+ {#each customAlarms as alarm (alarm.id)}
+
handleToggle(alarm.id)}
+ onkeydown={(e) => e.key === 'Enter' && handleToggle(alarm.id)}
+ >
+
+ {alarm.time.slice(0, 5)}
+
+
+ {alarm.label || getRepeatText(alarm.repeatDays)}
+
+
+ {/each}
+
+
+ {/if}
+
+
+ {#if showEditModal}
+
+
+
{$_('alarm.edit')}
+
+
+
+
+ {/if}
+
+ {translations.title} | Clock
+
+
+ goto('/')}
+ showGettingStarted={false}
+ showChangelog={false}
+ defaultSection="faq"
+/>
diff --git a/apps-archived/clock/apps/web/src/routes/(app)/mana/+page.svelte b/apps-archived/clock/apps/web/src/routes/(app)/mana/+page.svelte
new file mode 100644
index 000000000..55f06f19a
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/routes/(app)/mana/+page.svelte
@@ -0,0 +1,6 @@
+
+
+
+
{$_('settings.title')}
+
+
+
+
+
+
+
{$_('settings.clockFormat')}
+
+
+
Zeitformat
+
+ setClockFormat('24h')}
+ >
+ {$_('settings.format24h')}
+
+ setClockFormat('12h')}
+ >
+ {$_('settings.format12h')}
+
+
+
+
+
+
+
+
{$_('settings.notifications')}
+
+ Benachrichtigungen werden für Wecker, Timer und Pomodoro-Sitzungen verwendet.
+
+
+
{
+ if ('Notification' in window) {
+ const permission = await Notification.requestPermission();
+ if (permission === 'granted') {
+ new Notification('Clock', {
+ body: 'Benachrichtigungen sind jetzt aktiviert!',
+ });
+ }
+ }
+ }}
+ >
+ Benachrichtigungen aktivieren
+
+
+
+
+
+
{$_('settings.sounds')}
+
+ Töne können für einzelne Wecker und Timer in deren Einstellungen angepasst werden.
+
+
+
+
v{APP_VERSION}
+
+
+
+
+
+ {$_('stopwatch.new')}
+
+
+
+
+
{$_('stopwatch.noStopwatches')}
+
{$_('stopwatch.noStopwatchesDescription')}
+
+
+
+ {$_('stopwatch.startFirst')}
+
+
+
+ {#if focused}
+ {@const bestLap = stopwatchesStore.getBestLap(focused.id)}
+ {@const worstLap = stopwatchesStore.getWorstLap(focused.id)}
+
+
+
+
+
+ {#if editingLabelId === focused.id}
+
+ {:else}
+
startEditLabel(focused)}
+ >
+ {focused.label}
+
+ {/if}
+
+
stopwatchesStore.delete(focused.id)}
+ >
+
+
+
+
+
+
+
+
+ {formatTime(focused.elapsedTime)}
+
+ {#if focused.laps.length > 0}
+
+ {focused.laps.length}
+ {$_('stopwatch.laps')}
+
+ {/if}
+
+
+
+
+ {#if focused.isRunning}
+
stopwatchesStore.pause(focused.id)}
+ >
+
+
+ {$_('stopwatch.stop')}
+
+
stopwatchesStore.lap(focused.id)}>
+
+
+ {$_('stopwatch.lap')}
+
+ {:else if focused.elapsedTime > 0}
+
stopwatchesStore.start(focused.id)}
+ >
+
+
+ {$_('stopwatch.continue')}
+
+
stopwatchesStore.reset(focused.id)}
+ >
+
+
+ {$_('stopwatch.reset')}
+
+ {:else}
+
stopwatchesStore.start(focused.id)}
+ >
+
+
+ {$_('stopwatch.start')}
+
+ {/if}
+
+
+
+ {#if focused.laps.length > 0}
+
+
+ {$_('stopwatch.laps')} ({focused.laps.length})
+
+
+
+ {$_('stopwatch.total')}
+
+ {formatTime(focused.elapsedTime)}
+
+
+
+ {/if}
+
+ {/if}
+
+
+ {#if otherStopwatches.length > 0}
+
+
+ {$_('stopwatch.otherStopwatches')} ({otherStopwatches.length})
+
+
+ {#each otherStopwatches as sw (sw.id)}
+
handleFocus(sw.id)}
+ onkeydown={(e) => e.key === 'Enter' && handleFocus(sw.id)}
+ role="button"
+ tabindex="0"
+ >
+
+
+
+
{
+ e.stopPropagation();
+ stopwatchesStore.delete(sw.id);
+ }}
+ >
+
+
+
+
+
+
+
+ {formatTime(sw.elapsedTime)}
+
+
+
+
+ {sw.label}
+
+
+
+
+ {#if sw.isRunning}
+
{
+ e.stopPropagation();
+ stopwatchesStore.pause(sw.id);
+ }}
+ >
+ {$_('stopwatch.stop')}
+
+ {:else}
+
{
+ e.stopPropagation();
+ stopwatchesStore.start(sw.id);
+ }}
+ >
+ {sw.elapsedTime > 0 ? $_('stopwatch.continue') : $_('stopwatch.start')}
+
+ {/if}
+ {#if sw.elapsedTime > 0 && !sw.isRunning}
+
{
+ e.stopPropagation();
+ stopwatchesStore.reset(sw.id);
+ }}
+ >
+
+
+
+ {/if}
+
+
+
+ {#if sw.laps.length > 0}
+
+ {sw.laps.length}
+
+ {/if}
+
+ {/each}
+
+
+ {/if}
+
+ Tags | Clock
+
+
+
+
Tags verwalten
+
+ Tags sind app-übergreifend — Änderungen gelten in allen ManaCore-Apps.
+
+
+ {#if tagsCtx.value.length === 0}
+
Keine Tags vorhanden.
+ {:else}
+
+ {#each tagsCtx.value as tag}
+
+ {tag.name}
+
+ {/each}
+
+ {/if}
+
+
Alle Themes
+
+
+ {#each THEME_VARIANTS as variant}
+ {@const def = THEME_DEFINITIONS[variant]}
+
theme.setVariant(variant)}
+ >
+
+
{def.icon}
+
+
{def.label}
+
{def.description}
+
+
✓ Aktiv
+ {/if}
+
+ {/each}
+
+
+
+
+
+
+
+ {#each QUICK_TIMER_PRESETS as preset}
+ setPreset(preset.seconds)}>
+ {preset.label}
+
+ {/each}
+
+
+ {#if allTimers.length > 0}
+
+
+
+ Aktiv ({allTimers.length})
+
+
+ {#each allTimers as timer (timer.id)}
+ {@const isLocal = isLocalTimer(timer)}
+
+
+
+ {getTimerDisplay(timer)}
+
+
{
+ e.stopPropagation();
+ handleDelete(timer.id, isLocal);
+ }}
+ >
+
+
+
+
+
{timer.label}
+
+
+ {#if timer.status === 'running'}
+ handlePause(timer.id, isLocal)}
+ >
+ Pause
+
+ {:else}
+ handleStart(timer.id, isLocal)}
+ >
+ {timer.status === 'finished' ? 'Neu' : 'Start'}
+
+ {/if}
+ handleReset(timer.id, isLocal)}
+ >
+ Reset
+
+
+
+ {/each}
+
+
+ {/if}
+
+ {#snippet actions()}
+
+ (showMap = !showMap)}
+ title={showMap ? 'Karte ausblenden' : 'Karte anzeigen'}
+ >
+
+
+ + {$_('worldClock.add')}
+
+
+ {/snippet}
+
+
+
+
+ {#if showMap}
+
+
+
+
+ Klicke auf eine Stadt um sie hinzuzufügen
+
+
+ {/if}
+
+
+ {#if allWorldClocks.value.length === 0}
+
+
{$_('worldClock.noClocks')}
+
+ {$_('worldClock.add')}
+
+
+ {:else}
+
+ {#each allWorldClocks.value as clock (clock.id)}
+ {@const isDay = isDaytime(clock.timezone)}
+
+
+
removeCity(clock.id)}
+ >
+
+
+
+
+
+
+ {isDay ? 'Tag' : 'Nacht'}
+ {clock.cityName}
+
+
+
+
+ {getTimeForTimezone(clock.timezone)}
+
+
+
+
+
+ {getDateForTimezone(clock.timezone)}
+
+
+ {getOffsetText(clock.timezone)}
+
+
+
+ {/each}
+
+ {/if}
+
+
+ {#if showAddModal}
+
+
+
+
{$_('worldClock.add')}
+
+
+
+
+
+
+
+
+
+
+
+ {#each filteredTimezones as tz}
+ {@const alreadyAdded = allWorldClocks.value.some((wc) => wc.timezone === tz.timezone)}
+
addCity(tz.timezone, tz.city)}
+ >
+
+
{tz.city}
+
{tz.timezone}
+
+
{getTimeForTimezone(tz.timezone)}
+
{tz.region}
+
+ {/each}
+
+ {#if filteredTimezones.length === 0}
+
+ Keine Ergebnisse für "{searchQuery}"
+
+ {/if}
+
+
+
+ {/if}
+
+ {translations.title} | Clock
+
+
+ authStore.signInWithPasskey()}
+ onVerifyTwoFactor={(code, trust) => authStore.verifyTwoFactor(code, trust)}
+ onVerifyBackupCode={(code) => authStore.verifyBackupCode(code)}
+ onSendMagicLink={(email) => authStore.sendMagicLink(email)}
+ {goto}
+ successRedirect={redirectTo}
+ registerPath="/register"
+ forgotPasswordPath="/forgot-password"
+ lightBackground="#fffbeb"
+ darkBackground="#1c1917"
+ {translations}
+ {verified}
+ {initialEmail}
+ version={APP_VERSION}
+ buildTime={BUILD_TIME}
+/>
diff --git a/apps-archived/clock/apps/web/src/routes/(auth)/register/+page.svelte b/apps-archived/clock/apps/web/src/routes/(auth)/register/+page.svelte
new file mode 100644
index 000000000..2af0a135b
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/routes/(auth)/register/+page.svelte
@@ -0,0 +1,52 @@
+
+
+
+ {translations.title} | Clock
+
+
+
+ Reset Password - Clock
+
+
+
+
+
+
+
+
+
Reset Password
+
+ {#if success}Password reset successfully
+ {:else if hasToken}Enter your new password
+ {:else}Invalid or missing token{/if}
+
+
+
+ {#if success}
+
+
+
✅
+
+ Your password has been reset successfully. You will be redirected to the login page
+ shortly.
+
+
+ Go to login
+
+
+
+ {:else if hasToken}
+
+ {:else}
+
+ {/if}
+
+
+ {@render children()}
+
+{/if}
diff --git a/apps-archived/clock/apps/web/src/routes/+layout.ts b/apps-archived/clock/apps/web/src/routes/+layout.ts
new file mode 100644
index 000000000..ad6cddb06
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/routes/+layout.ts
@@ -0,0 +1,2 @@
+// Disable SSR — all data is local-first (IndexedDB + mana-sync)
+export const ssr = false;
diff --git a/apps-archived/clock/apps/web/src/routes/health/+server.ts b/apps-archived/clock/apps/web/src/routes/health/+server.ts
new file mode 100644
index 000000000..91a4d2956
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/routes/health/+server.ts
@@ -0,0 +1,10 @@
+import { json } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+
+export const GET: RequestHandler = async () => {
+ return json({
+ status: 'ok',
+ service: 'clock-web',
+ timestamp: new Date().toISOString(),
+ });
+};
diff --git a/apps-archived/clock/apps/web/src/routes/offline/+page.svelte b/apps-archived/clock/apps/web/src/routes/offline/+page.svelte
new file mode 100644
index 000000000..688302729
--- /dev/null
+++ b/apps-archived/clock/apps/web/src/routes/offline/+page.svelte
@@ -0,0 +1,9 @@
+
+
+