@hearthlog/runtime 0.0.0-stage → 0.1.1

package/src/runtime/view.ts

@@ -0,0 +1,83 @@
+import { get, writable } from 'svelte/store';
+import { createSubscriber } from 'svelte/reactivity';
+
+interface ApplicationViewState {
+    effectiveNow: string;
+    revision: number;
+}
+
+type InternalApplicationViewState = ApplicationViewState & { initialized: boolean };
+
+const initialState: InternalApplicationViewState = {
+    effectiveNow: new Date().toISOString(),
+    revision: 0,
+    initialized: false,
+};
+
+// SAFETY: keyed on a private globalThis field that this module alone writes; a
+// stale/mismatched value can only come from an incompatible older build.
+const globalForApplicationView = globalThis as unknown as {
+    storApplicationViewStore?: ReturnType<typeof writable<InternalApplicationViewState>>;
+    storApplicationViewWaiters?: Array<(date: Date) => void>;
+};
+const state = globalForApplicationView.storApplicationViewStore ?? writable(initialState);
+globalForApplicationView.storApplicationViewStore = state;
+const readyWaiters = globalForApplicationView.storApplicationViewWaiters ?? [];
+globalForApplicationView.storApplicationViewWaiters = readyWaiters;
+
+// Lets `$derived(appClock.now())` and effects follow the clock as it advances.
+const trackClock = createSubscriber((update) => {
+    let initial = true;
+    return state.subscribe(() => {
+        if (initial) {
+            initial = false;
+            return;
+        }
+        update();
+    });
+});
+
+export const appClock = {
+    now(): Date {
+        trackClock();
+        return new Date(get(state).effectiveNow);
+    },
+    iso(): string {
+        trackClock();
+        return get(state).effectiveNow;
+    },
+    ready(): Promise<Date> {
+        const current = get(state);
+        if (current.initialized) return Promise.resolve(new Date(current.effectiveNow));
+        return new Promise((resolve) => readyWaiters.push(resolve));
+    },
+};
+
+/** Existing callers use this for internal links; routes no longer carry a read version. */
+export function contextualHref(path: string, _currentUrl?: URL): string { return path; }
+
+export function updateApplicationView(input: { effectiveNow: string }): void {
+    state.update((current) => ({
+        effectiveNow: input.effectiveNow,
+        revision: current.revision + 1,
+        initialized: true,
+    }));
+    const now = new Date(input.effectiveNow);
+    for (const resolve of readyWaiters.splice(0)) resolve(now);
+}
+
+export function beginApplicationViewTransition(): void {
+    state.update((current) => ({ ...current, initialized: false }));
+}
+
+export function cancelApplicationViewTransition(): void {
+    const current = get(state);
+    state.set({ ...current, initialized: true });
+    const now = new Date(current.effectiveNow);
+    for (const resolve of readyWaiters.splice(0)) resolve(now);
+}
+
+export function resetApplicationView(): void {
+    state.set({ ...initialState, effectiveNow: new Date().toISOString() });
+    readyWaiters.splice(0);
+}

package/src/runtime/workspace.ts

@@ -0,0 +1,62 @@
+import { recordTiming, measurementMetadata } from '../utils/perf.js';
+import { bootstrapLocalStore, type LocalStoreBootstrapResult } from '../db/bootstrap.js';
+import { eventLogFilename } from '../store/event-log.svelte.js';
+import { activateCurrentReadTarget, beginReadTargetTransition, failReadTargetTransition } from './read-coordinator.js';
+import { workspaceIsReady } from '@hearthlog/ui/state/readiness.js';
+import { schedulePwaRegistration } from '../pwa/registration.js';
+
+export interface WorkspaceTicket {
+    logId: string | null;
+    ready: Promise<LocalStoreBootstrapResult>;
+}
+
+let ticket: WorkspaceTicket | undefined;
+let recordedLocalReady = false;
+let activationQueue: Promise<unknown> = Promise.resolve();
+
+/** Called by committed loads only: the app preloads code, never load functions. */
+export function prepareWorkspace(url: URL): WorkspaceTicket {
+    const logId = eventLogFilename.value;
+    if (ticket && (!ticket.logId || ticket.logId === logId)) return ticket;
+
+    beginReadTargetTransition();
+    const next: WorkspaceTicket = { logId, ready: undefined! };
+    ticket = next;
+    const bootstrap = bootstrapLocalStore();
+    if (import.meta.env.PROD) void schedulePwaRegistration(bootstrap);
+    next.ready = activationQueue.catch(() => undefined).then(async () => {
+        const result = await bootstrap;
+        if (ticket !== next) throw new DOMException('Navigation superseded', 'AbortError');
+        next.logId = eventLogFilename.value;
+        if (!next.logId) throw new Error('Select an event log before opening this workspace.');
+        await activateCurrentReadTarget();
+        if (ticket !== next) {
+            beginReadTargetTransition();
+            throw new DOMException('Navigation superseded', 'AbortError');
+        }
+        if (!recordedLocalReady && typeof window !== 'undefined') {
+            recordedLocalReady = true;
+            recordTiming('startup', 'dataReady', performance.now(), {
+                ...measurementMetadata(), baselineMetric: 'dataReady', route: url.pathname,
+                schemaRebuilt: result.schemaRebuilt, hasSelectedLog: true,
+            });
+        }
+        return { ...result, activeLogId: next.logId };
+    }).catch((error) => {
+        if (ticket === next) {
+            ticket = undefined;
+            failReadTargetTransition(error);
+        }
+        throw error;
+    });
+    // A fast rejection must be handled even before Svelte mounts its consumer.
+    void bootstrap.catch(() => undefined);
+    void next.ready.catch(() => undefined);
+    activationQueue = next.ready;
+    return next;
+}
+
+export async function waitForWorkspace(): Promise<void> {
+    if (ticket) await ticket.ready;
+    if (!workspaceIsReady()) throw new Error('Local data is not ready.');
+}

package/src/storage/indexeddb-statistics.ts

@@ -0,0 +1,153 @@
+import { MODULE_LOCAL_STORES } from '#generated/modules';
+
+export interface IndexedDbStoreStats {
+    name: string;
+    entries: number;
+}
+
+export interface IndexedDbDatabaseStats {
+    name: string;
+    label: string;
+    stores: IndexedDbStoreStats[];
+    measuresFiles: boolean;
+    fileCount: number;
+    pdfCount: number;
+    isdocCount: number;
+    fileBytes: number;
+}
+
+export interface IndexedDbStats {
+    databases: IndexedDbDatabaseStats[];
+    fileCount: number;
+    fileBytes: number;
+    originUsage: number | null;
+    originQuota: number | null;
+}
+
+const knownDatabases: Record<string, { label: string; fileStore?: string; kinds?: boolean }> = {
+    // The enabled modules name their own file databases (`localStores` in the manifest).
+    ...Object.fromEntries(MODULE_LOCAL_STORES.map(({ database, ...store }) => [database, store])),
+    'kv-store': { label: 'App settings' },
+};
+
+function openExistingDatabase(name: string): Promise<IDBDatabase> {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(name);
+        let expired = false;
+        const timer = setTimeout(() => {
+            expired = true;
+            reject(new Error(`Timed out opening ${name}`));
+        }, 5000);
+        request.onupgradeneeded = () => {
+            // A database disappeared after enumeration. Do not create it.
+            request.transaction?.abort();
+        };
+        request.onsuccess = () => {
+            clearTimeout(timer);
+            if (expired) {
+                request.result.close();
+                return;
+            }
+            resolve(request.result);
+        };
+        request.onerror = () => {
+            clearTimeout(timer);
+            expired = true;
+            reject(request.error ?? new Error(`Could not open ${name}`));
+        };
+        request.onblocked = () => {
+            clearTimeout(timer);
+            expired = true;
+            reject(new Error(`${name} is blocked by another tab`));
+        };
+    });
+}
+
+function readStore(db: IDBDatabase, name: string, measureFiles: boolean, kinds: boolean): Promise<{
+    entries: number; fileCount: number; pdfCount: number; isdocCount: number; fileBytes: number;
+}> {
+    return new Promise((resolve, reject) => {
+        const transaction = db.transaction(name, 'readonly');
+        const store = transaction.objectStore(name);
+        const count = store.count();
+        let fileCount = 0;
+        let pdfCount = 0;
+        let isdocCount = 0;
+        let fileBytes = 0;
+        if (measureFiles) {
+            const cursor = store.openCursor();
+            cursor.onsuccess = () => {
+                const row = cursor.result;
+                if (!row) return;
+                const value = row.value as { blob?: unknown; kind?: string };
+                if (value.blob instanceof Blob) {
+                    fileCount += 1;
+                    fileBytes += value.blob.size;
+                    if (kinds) {
+                        if (value.kind === 'isdoc') isdocCount += 1;
+                        else pdfCount += 1; // Older originals have no kind field.
+                    }
+                }
+                row.continue();
+            };
+        }
+        transaction.oncomplete = () => resolve({
+            entries: count.result,
+            fileCount,
+            pdfCount,
+            isdocCount,
+            fileBytes,
+        });
+        transaction.onerror = () => reject(transaction.error ?? new Error(`Could not read ${name}`));
+        transaction.onabort = () => reject(transaction.error ?? new Error(`Could not read ${name}`));
+    });
+}
+
+/** Read-only inventory. File bytes are Blob payloads, not an IndexedDB disk-size estimate. */
+export async function loadIndexedDbStats(): Promise<IndexedDbStats> {
+    if (typeof indexedDB === 'undefined' || !indexedDB.databases) {
+        throw new Error('This browser cannot list IndexedDB databases.');
+    }
+    const discovered = await indexedDB.databases();
+    const names = discovered.flatMap((database) => database.name ? [database.name] : []);
+    const databases: IndexedDbDatabaseStats[] = [];
+    for (const name of names.sort()) {
+        const config = knownDatabases[name];
+        const db = await openExistingDatabase(name);
+        try {
+            const stores: IndexedDbStoreStats[] = [];
+            let fileCount = 0;
+            let pdfCount = 0;
+            let isdocCount = 0;
+            let fileBytes = 0;
+            for (const storeName of Array.from(db.objectStoreNames)) {
+                const result = await readStore(db, storeName, config?.fileStore === storeName, config?.kinds === true);
+                stores.push({ name: storeName, entries: result.entries });
+                fileCount += result.fileCount;
+                pdfCount += result.pdfCount;
+                isdocCount += result.isdocCount;
+                fileBytes += result.fileBytes;
+            }
+            databases.push({
+                name,
+                label: config?.label ?? name,
+                stores,
+                measuresFiles: !!config?.fileStore && stores.some((store) => store.name === config.fileStore),
+                fileCount,
+                pdfCount,
+                isdocCount,
+                fileBytes,
+            });
+        } finally {
+            db.close();
+        }
+    }
+    const estimate = await navigator.storage?.estimate?.().catch(() => null);
+    return {
+        databases,
+        fileCount: databases.reduce((sum, database) => sum + database.fileCount, 0),
+        fileBytes: databases.reduce((sum, database) => sum + database.fileBytes, 0),
+        originUsage: estimate?.usage ?? null,
+        originQuota: estimate?.quota ?? null,
+    };
+}

package/src/store/attention.svelte.ts

@@ -0,0 +1,51 @@
+import { format } from 'date-fns';
+import type { AttentionBadge, AttentionContribution } from '@hearthlog/contracts';
+import { appClock } from '../runtime/view.js';
+
+/**
+ * Navigation badges: counts of work that is late, supplied by the enabled
+ * modules (`AttentionContribution.badges`). Counts come from SQL against the
+ * active log and refresh whenever events change; a failed read keeps the
+ * previous badges because they are advisory.
+ */
+class AttentionStore {
+    badges = $state<AttentionBadge[]>([]);
+    #sources: readonly AttentionContribution[] = [];
+    #run = 0;
+
+    /** Sets the composed modules' contributions (once, from the root layout). */
+    configure(sources: readonly AttentionContribution[]): void {
+        this.#sources = sources;
+    }
+
+    /** Reminders for the native shell, from every module that has some. */
+    async reminders(today: Date) {
+        const lists = await Promise.all(this.#sources.map((source) => source.reminders?.({ today }) ?? []));
+        return lists.flat();
+    }
+
+    async refresh(): Promise<void> {
+        const run = ++this.#run;
+        const today = format(appClock.now(), 'yyyy-MM-dd');
+        try {
+            const next = (await Promise.all(this.#sources.map((source) => source.badges?.({ today }) ?? []))).flat();
+            if (run === this.#run) this.badges = next;
+        } catch {
+            // Keep the last known badges; the page itself still shows the details.
+        }
+    }
+
+    /** Badge for a navigation destination or sub-page id, or null when nothing is waiting. */
+    badge(id: string): AttentionBadge | null {
+        return this.badges.find((badge) => badge.count > 0 && badge.ids.includes(id)) ?? null;
+    }
+
+    /** Total of all badges: the native app icon's badge. */
+    get total(): number {
+        return this.badges.reduce((sum, badge) => sum + badge.count, 0);
+    }
+}
+
+export const attention = new AttentionStore();
+
+export type AttentionTone = AttentionBadge['tone'];

package/src/store/conflict-merge.ts

@@ -0,0 +1,169 @@
+/**
+ * Merging a local batch with edits another device already had accepted.
+ *
+ * An update event carries only the fields it changed, so two devices that edit
+ * different fields of one record merge by simply sending the local batch again
+ * on top of the other device's events. A real clash is decided by a person:
+ * both devices set one field to different values, one device deleted a record
+ * the other edited, or the other way round. Nothing here rewrites a stored
+ * event; a resolution is either the unchanged batch sent again, or a new batch
+ * without the values the person gave up.
+ */
+
+export interface EntityEdit {
+    type: string;
+    payload: Record<string, unknown>;
+}
+
+export type EntityClash =
+    /** Both devices set one field to different values. */
+    | { kind: 'field'; entityId: string; field: string; mine: unknown; theirs: unknown }
+    /** Another device deleted the record this batch edits; sending would restore it. */
+    | { kind: 'edited_after_removed'; entityId: string }
+    /** This batch deletes a record another device edited since. */
+    | { kind: 'removed_after_edited'; entityId: string; fields: string[] };
+
+type EditKind = 'added' | 'updated' | 'removed';
+
+/** Entity events end in _ADDED, _UPDATED or _REMOVED; anything else is not an edit. */
+function editKind(type: string): EditKind | null {
+    if (type.endsWith('_ADDED')) return 'added';
+    if (type.endsWith('_UPDATED')) return 'updated';
+    if (type.endsWith('_REMOVED')) return 'removed';
+    return null;
+}
+
+/** The value each field ends with: the last event that names it wins. */
+function finalFields(edits: readonly EntityEdit[]): Map<string, unknown> {
+    const fields = new Map<string, unknown>();
+    for (const edit of edits) {
+        const kind = editKind(edit.type);
+        if (kind !== 'added' && kind !== 'updated') continue;
+        for (const [key, value] of Object.entries(edit.payload)) {
+            if (key !== 'id') fields.set(key, value);
+        }
+    }
+    return fields;
+}
+
+function lastKind(edits: readonly EntityEdit[]): EditKind | null {
+    for (let index = edits.length - 1; index >= 0; index--) {
+        const kind = editKind(edits[index]!.type);
+        if (kind) return kind;
+    }
+    return null;
+}
+
+function sameValue(left: unknown, right: unknown): boolean {
+    return JSON.stringify(canonical(left)) === JSON.stringify(canonical(right));
+}
+
+function canonical(value: unknown): unknown {
+    if (Array.isArray(value)) return value.map(canonical);
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(
+            Object.entries(value as Record<string, unknown>)
+                .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+                .map(([key, nested]) => [key, canonical(nested)]),
+        );
+    }
+    return value;
+}
+
+/**
+ * What needs a decision between this batch's edits to one record (`mine`, in
+ * order) and the edits other devices had accepted since this batch's base
+ * version (`theirs`, in order). No clash means the batch can be sent again as is.
+ */
+export function findClashes(
+    entityId: string,
+    mine: readonly EntityEdit[],
+    theirs: readonly EntityEdit[],
+): EntityClash[] {
+    const mineFinal = lastKind(mine);
+    const theirsFinal = lastKind(theirs);
+    if (mineFinal === null || theirsFinal === null) return [];
+
+    if (theirsFinal === 'removed') {
+        return mineFinal === 'removed' ? [] : [{ kind: 'edited_after_removed', entityId }];
+    }
+    if (mineFinal === 'removed') {
+        const touched = [...finalFields(theirs).keys()];
+        return touched.length > 0 ? [{ kind: 'removed_after_edited', entityId, fields: touched }] : [];
+    }
+
+    const mineFields = finalFields(mine);
+    const clashes: EntityClash[] = [];
+    for (const [field, theirValue] of finalFields(theirs)) {
+        if (!mineFields.has(field)) continue;
+        const myValue = mineFields.get(field);
+        if (!sameValue(myValue, theirValue)) {
+            clashes.push({ kind: 'field', entityId, field, mine: myValue, theirs: theirValue });
+        }
+    }
+    return clashes;
+}
+
+export interface BatchRow {
+    type: string;
+    entity_id: string | null;
+    payload: string;
+}
+
+/**
+ * The batch without what the person gave up: a clashing field is dropped from
+ * every event that sets it (an event left with nothing but its id is dropped),
+ * a record the other device deleted is left deleted, and a deletion of a record
+ * the other device edited is not sent.
+ */
+export function withoutClashes<T extends BatchRow>(rows: readonly T[], clashes: readonly EntityClash[]): T[] {
+    const kept: T[] = [];
+    for (const row of rows) {
+        const own = clashes.filter((clash) => clash.entityId === row.entity_id);
+        const kind = editKind(row.type);
+        if (own.length === 0 || kind === null) {
+            kept.push(row);
+            continue;
+        }
+        if (own.some((clash) => clash.kind === 'edited_after_removed')) continue;
+        if (kind === 'removed' && own.some((clash) => clash.kind === 'removed_after_edited')) continue;
+        const dropped = new Set(own.flatMap((clash) => (clash.kind === 'field' ? [clash.field] : [])));
+        if (dropped.size === 0 || kind === 'removed') {
+            kept.push(row);
+            continue;
+        }
+        const payload = JSON.parse(row.payload) as Record<string, unknown>;
+        for (const field of dropped) delete payload[field];
+        if (Object.keys(payload).every((key) => key === 'id')) continue;
+        kept.push({ ...row, payload: JSON.stringify(payload) });
+    }
+    return kept;
+}
+
+export function humanizeField(name: string): string {
+    const spaced = name.replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/_/g, ' ').trim().toLowerCase();
+    return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+
+/** A value as a person would read it in a one-line summary. */
+export function formatClashValue(value: unknown): string {
+    if (value === null || value === undefined || value === '') return 'empty';
+    if (typeof value === 'boolean') return value ? 'yes' : 'no';
+    const text = typeof value === 'string' ? value : JSON.stringify(value);
+    return text.length > 60 ? `${text.slice(0, 57)}…` : text;
+}
+
+export function describeClash(clash: EntityClash): string {
+    switch (clash.kind) {
+        case 'field':
+            return `${humanizeField(clash.field)}: yours ${formatClashValue(clash.mine)}, theirs ${formatClashValue(clash.theirs)}`;
+        case 'edited_after_removed':
+            return `${humanizeField(clash.entityId.split(':')[0] ?? 'record')} was deleted on another device; your edit would restore it`;
+        case 'removed_after_edited':
+            return `${humanizeField(clash.entityId.split(':')[0] ?? 'record')} was edited on another device; your deletion would discard that edit`;
+    }
+}
+
+export function describeClashes(clashes: readonly EntityClash[]): string {
+    return clashes.map(describeClash).join(' · ');
+}

package/src/store/entity-sync-state.svelte.ts

@@ -0,0 +1,36 @@
+import { db, requireActiveContext } from '../db/index.js';
+
+export type EntitySyncState = 'pending' | 'blocked';
+
+export const entitySyncState = $state<Record<string, EntitySyncState>>({});
+
+export function getEntitySyncState(entityId: string): EntitySyncState | null {
+    return entitySyncState[entityId] ?? null;
+}
+
+export async function refreshEntitySyncState(): Promise<void> {
+    try {
+        const context = await requireActiveContext();
+        const rows = await db.selectFrom('raw_events as event')
+            .leftJoin('outbox_operations as operation', 'operation.batch_id', 'event.local_batch_id')
+            .select(['event.entity_id', 'event.sync_state', 'operation.status'])
+            .where('event.tenant_id', '=', context.tenantId)
+            .where('event.log_id', '=', context.logId)
+            .where('event.projection_state', '=', 'effective')
+            .where((eb) => eb.or([
+                eb('event.sync_state', '=', 'pending'),
+                eb('operation.status', '=', 'needs_attention'),
+            ]))
+            .execute();
+        const next: Record<string, EntitySyncState> = {};
+        for (const row of rows) {
+            if (!row.entity_id || row.entity_id.startsWith('tombstone:')) continue;
+            const state = row.status === 'needs_attention' ? 'blocked' : 'pending';
+            if (state === 'blocked' || !next[row.entity_id]) next[row.entity_id] = state;
+        }
+        Object.keys(entitySyncState).forEach((key) => delete entitySyncState[key]);
+        Object.assign(entitySyncState, next);
+    } catch {
+        Object.keys(entitySyncState).forEach((key) => delete entitySyncState[key]);
+    }
+}

package/src/store/event-log.svelte.ts

@@ -0,0 +1,109 @@
+import { get, set as setKv } from '../db/kv.js';
+import { getLedgerClient } from '../ledger/index.js';
+import { getLedgerCacheKey } from './local-context.js';
+
+interface CachedLogSelection {
+    logId: string;
+    logName: string | null;
+}
+
+const LEGACY_SELECTION_MIGRATED_KEY = 'ledger-selected-log-migrated';
+
+class EventLogStore {
+    #value = $state<string | null>(null);
+    #logName = $state<string | null>(null);
+    #isInitialized = $state(false);
+    #initializationPromise: Promise<void>;
+
+    constructor() {
+        this.#initializationPromise = this.initialize();
+    }
+
+    async initialize() {
+        try {
+            const selectionKey = await getLedgerCacheKey('selected-log');
+            const cachedSelection = await get<CachedLogSelection>(selectionKey);
+            let logId = cachedSelection?.logId ?? null;
+            let logName = cachedSelection?.logName ?? null;
+
+            if (!cachedSelection && !(await get<boolean>(LEGACY_SELECTION_MIGRATED_KEY))) {
+                logId = await get<string>('event-log-id');
+                logName = await get<string>('event-log-name');
+                if (logId) {
+                    await setKv(selectionKey, { logId, logName });
+                }
+                await setKv(LEGACY_SELECTION_MIGRATED_KEY, true);
+            }
+
+            if (!logId) {
+                try {
+                    const client = getLedgerClient();
+                    const logs = await client.listLogs();
+
+                    if (logs.length > 0) {
+                        // Prefer a log named 'default' if it exists
+                        const defaultLog = logs.find(log => log.name === 'default');
+                        const selectedLog = defaultLog || logs[0];
+
+                        logId = selectedLog.id;
+                        logName = selectedLog.name;
+                        await this.set(logId, logName);
+                        console.log(`Default event log set to: ${logName} (${logId})`);
+                    } else {
+                        // Auto-create a default log on first run
+                        const defaultName = 'default';
+                        try {
+                            const response = await client.createLog({ name: defaultName });
+                            logId = response.id;
+                            logName = response.name || null;
+                            await this.set(logId, logName ?? undefined);
+                            console.log(`Created default event log in Ledger Service: ${logName} (${logId})`);
+                        } catch (createErr) {
+                            console.warn("Failed to auto-create default event log in Ledger Service:", createErr);
+                            console.warn("No event logs found in Ledger Service. Please create one on the developer page.");
+                        }
+                    }
+                } catch (error) {
+                    console.error("Failed to initialize default event log:", error);
+                }
+            }
+
+            this.#value = logId;
+            this.#logName = logName;
+        } finally {
+            this.#isInitialized = true;
+        }
+    }
+
+    async set(logId: string, logName?: string) {
+        this.#value = logId;
+        this.#logName = logName || null;
+        await setKv(await getLedgerCacheKey('selected-log'), {
+            logId,
+            logName: logName || null,
+        } satisfies CachedLogSelection);
+        // Retain legacy keys for older builds sharing this browser profile.
+        await setKv('event-log-id', logId);
+        if (logName) {
+            await setKv('event-log-name', logName);
+        }
+    }
+
+    get value() {
+        return this.#value;
+    }
+
+    get name() {
+        return this.#logName;
+    }
+
+    get isInitialized() {
+        return this.#isInitialized;
+    }
+
+    ready(): Promise<void> {
+        return this.#initializationPromise;
+    }
+}
+
+export const eventLogFilename = new EventLogStore();

package/src/store/events.svelte.ts

@@ -0,0 +1,14 @@
+// Svelte-native signal for notifying when events data change
+// Export a $state object and mutate its property (reassignment of exported $state is not allowed)
+export let events = $state({ updatedAt: 0, refreshRequiredAt: 0 });
+
+export function notifyEventsChanged(options: { routesInvalidated?: boolean } = {}) {
+    // Several changes can finish in the same millisecond.
+    events.updatedAt = Math.max(Date.now(), events.updatedAt + 1);
+    // Badges and file consumers still hear about changes whose route data was
+    // refreshed by sync. Only unhandled changes ask a page to refresh itself.
+    if (!options.routesInvalidated) events.refreshRequiredAt = events.updatedAt;
+    if (typeof window !== 'undefined') {
+        window.dispatchEvent(new CustomEvent('stor:events-changed'));
+    }
+}