@phuetz/code-buddy 1.6.1 → 2.1.0

package/dist/knowledge/workspace-indexer.js

@@ -12,6 +12,7 @@ import { EventEmitter } from 'events';
 import { logger } from '../utils/logger.js';
 import glob from 'fast-glob';
 import { EmbeddingProvider } from '../embeddings/embedding-provider.js';
+import { readJsonAtomicSync, writeJsonAtomic, writeJsonAtomicSync } from '../utils/atomic-write.js';
 // Fallback brute-force index if USearch is not available
 class BruteForceIndex {
     dim;
@@ -44,12 +45,13 @@ class BruteForceIndex {
         return scores.slice(0, k);
     }
     save(filePath) {
-        fs.writeFileSync(filePath, JSON.stringify(Array.from(this.vectors.entries())));
+        writeJsonAtomicSync(filePath, Array.from(this.vectors.entries()));
     }
     load(filePath) {
         if (fs.existsSync(filePath)) {
-            const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-            this.vectors = new Map(data);
+            const data = readJsonAtomicSync(filePath, []);
+            if (Array.isArray(data))
+                this.vectors = new Map(data);
         }
     }
     remove(id) {
@@ -62,7 +64,7 @@ const DEFAULT_CONFIG = {
     chunkSize: 1000,
     chunkOverlap: 200,
     filePatterns: ['**/*.ts', '**/*.js', '**/*.tsx', '**/*.jsx', '**/*.py', '**/*.go', '**/*.rs', '**/*.md', '**/*.json'],
-    ignorePatterns: ['node_modules/**', 'dist/**', '.git/**', 'build/**', '.codebuddy/**'],
+    ignorePatterns: ['**/node_modules/**', '**/dist/**', '**/.git/**', '**/build/**', '**/.codebuddy/**'],
 };
 export class WorkspaceIndexer extends EventEmitter {
     config;
@@ -99,15 +101,17 @@ export class WorkspaceIndexer extends EventEmitter {
         const metaPath = this.config.indexPath + '.meta.json';
         if (fs.existsSync(metaPath)) {
             try {
-                const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+                const meta = readJsonAtomicSync(metaPath, null);
+                if (!meta || !Array.isArray(meta.entries))
+                    return;
                 this.entries = new Map(meta.entries);
-                this.nextId = meta.nextId;
+                this.nextId = typeof meta.nextId === 'number' ? meta.nextId : 0;
                 if (this.vectorIndex.load) {
                     await this.vectorIndex.load(this.config.indexPath);
                 }
                 logger.info(`Loaded workspace index with ${this.entries.size} chunks.`);
             }
-            catch (e) {
+            catch (_e) {
                 logger.warn('Failed to load index metadata, starting fresh.');
             }
         }
@@ -118,7 +122,7 @@ export class WorkspaceIndexer extends EventEmitter {
             entries: Array.from(this.entries.entries()),
             nextId: this.nextId
         };
-        fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+        writeJsonAtomicSync(metaPath, meta);
         if (this.vectorIndex.save) {
             await this.vectorIndex.save(this.config.indexPath);
         }
@@ -134,15 +138,18 @@ export class WorkspaceIndexer extends EventEmitter {
                 cwd: this.config.workspaceRoot,
                 ignore: this.config.ignorePatterns,
                 absolute: false,
+                // Ne pas suivre les symlinks : une boucle de liens (ex. node_modules
+                // imbriqués) provoquait `ELOOP: too many symbolic links` et tuait l'index.
+                followSymbolicLinks: false,
+                // Un lien cassé / une permission refusée ne doit pas faire échouer tout l'index.
+                suppressErrors: true,
             });
             const mtimeCachePath = path.join(path.dirname(this.config.indexPath), 'mtimes.json');
             let mtimeCache = {};
             try {
-                if (fs.existsSync(mtimeCachePath)) {
-                    mtimeCache = JSON.parse(await fs.readFile(mtimeCachePath, 'utf-8'));
-                }
+                mtimeCache = readJsonAtomicSync(mtimeCachePath, {});
             }
-            catch (e) {
+            catch (_e) {
                 logger.warn('Failed to load mtime cache, starting fresh.');
             }
             const newMtimeCache = {};
@@ -157,7 +164,7 @@ export class WorkspaceIndexer extends EventEmitter {
                         filesToIndex.push(file);
                     }
                 }
-                catch (err) {
+                catch (_err) {
                     // Can't stat, skip
                 }
             }
@@ -217,11 +224,11 @@ export class WorkspaceIndexer extends EventEmitter {
                         await new Promise(r => setTimeout(r, 10));
                     }
                 }
-                catch (fileErr) {
+                catch (_fileErr) {
                     // Skip unreadable files
                 }
             }
-            await fs.writeFile(mtimeCachePath, JSON.stringify(newMtimeCache, null, 2));
+            await writeJsonAtomic(mtimeCachePath, newMtimeCache);
             await this.saveIndexMetadata();
             logger.info(`Workspace indexing complete: ${processedFiles} files, ${totalChunks} chunks.`);
             this.emit('indexing:complete', { files: processedFiles, chunks: totalChunks });

package/dist/life-rhythm/cooking-timer-store.d.ts

@@ -0,0 +1,50 @@
+export declare const MIN_COOKING_TIMER_DURATION_MS = 1000;
+export declare const MAX_COOKING_TIMER_DURATION_MS: number;
+export declare const MAX_COOKING_TIMER_LABEL_LENGTH = 120;
+export interface CookingTimer {
+    id: string;
+    label: string;
+    durationMs: number;
+    startedAt: string;
+    /** Absolute instant: restoration never restarts the original duration. */
+    dueAt: string;
+}
+export interface CookingTimerView extends CookingTimer {
+    state: 'running' | 'due';
+    remainingMs: number;
+}
+export interface CookingTimerStoreOptions {
+    filePath?: string;
+    now?: () => Date;
+}
+/**
+ * Persistent named cooking timers for hands-free use.
+ *
+ * This store owns no Node timer and starts no daemon. `dueAt` is absolute;
+ * callers poll `due(now)` from their existing loop and a due timer stays due
+ * until it is explicitly acknowledged or cancelled.
+ */
+export declare class CookingTimerStore {
+    readonly filePath: string;
+    private readonly now;
+    private mutationTail;
+    constructor(options?: CookingTimerStoreOptions);
+    start(durationMs: number, label: string): Promise<CookingTimer>;
+    /** List every unacknowledged timer, including timers already due. */
+    listActive(at?: Date | number): Promise<CookingTimerView[]>;
+    /** Return due, unacknowledged timers without consuming them. */
+    due(at?: Date | number): Promise<CookingTimerView[]>;
+    /** Acknowledge a timer only after its absolute due instant. */
+    acknowledge(id: string, at?: Date | number): Promise<CookingTimer | null>;
+    /** Cancel a running or due timer. Missing ids are idempotent. */
+    cancel(id: string): Promise<CookingTimer | null>;
+    private validateDuration;
+    private validateLabel;
+    private currentTime;
+    private resolveTime;
+    private toView;
+    private enqueueMutation;
+    private readTimers;
+    private writeTimers;
+    private enforcePrivatePermissions;
+}

package/dist/life-rhythm/cooking-timer-store.js

@@ -0,0 +1,240 @@
+import { randomUUID } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { logger } from '../utils/logger.js';
+const COOKING_TIMER_SCHEMA_VERSION = 1;
+export const MIN_COOKING_TIMER_DURATION_MS = 1_000;
+export const MAX_COOKING_TIMER_DURATION_MS = 24 * 60 * 60 * 1_000;
+export const MAX_COOKING_TIMER_LABEL_LENGTH = 120;
+function defaultFilePath() {
+    return path.join(os.homedir(), '.codebuddy', 'life-rhythm', 'cooking-timers.json');
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function validInstant(value) {
+    return typeof value === 'string' && !Number.isNaN(new Date(value).getTime());
+}
+function parseTimer(value) {
+    if (!isRecord(value))
+        return null;
+    if (typeof value.id !== 'string' ||
+        !/^cooking_[0-9a-f-]{36}$/i.test(value.id) ||
+        typeof value.label !== 'string' ||
+        !value.label.trim() ||
+        value.label !== value.label.trim() ||
+        value.label.length > MAX_COOKING_TIMER_LABEL_LENGTH ||
+        typeof value.durationMs !== 'number' ||
+        !Number.isInteger(value.durationMs) ||
+        value.durationMs < MIN_COOKING_TIMER_DURATION_MS ||
+        value.durationMs > MAX_COOKING_TIMER_DURATION_MS ||
+        !validInstant(value.startedAt) ||
+        !validInstant(value.dueAt)) {
+        return null;
+    }
+    const startedAtMs = new Date(value.startedAt).getTime();
+    const dueAtMs = new Date(value.dueAt).getTime();
+    if (dueAtMs - startedAtMs !== value.durationMs)
+        return null;
+    return {
+        id: value.id,
+        label: value.label,
+        durationMs: value.durationMs,
+        startedAt: value.startedAt,
+        dueAt: value.dueAt,
+    };
+}
+/**
+ * Persistent named cooking timers for hands-free use.
+ *
+ * This store owns no Node timer and starts no daemon. `dueAt` is absolute;
+ * callers poll `due(now)` from their existing loop and a due timer stays due
+ * until it is explicitly acknowledged or cancelled.
+ */
+export class CookingTimerStore {
+    filePath;
+    now;
+    mutationTail = Promise.resolve();
+    constructor(options = {}) {
+        this.filePath = path.resolve(options.filePath ?? defaultFilePath());
+        this.now = options.now ?? (() => new Date());
+    }
+    async start(durationMs, label) {
+        this.validateDuration(durationMs);
+        const normalizedLabel = this.validateLabel(label);
+        return this.enqueueMutation(async () => {
+            const now = this.currentTime();
+            const timer = {
+                id: `cooking_${randomUUID()}`,
+                label: normalizedLabel,
+                durationMs,
+                startedAt: now.toISOString(),
+                dueAt: new Date(now.getTime() + durationMs).toISOString(),
+            };
+            const timers = await this.readTimers();
+            timers.push(timer);
+            await this.writeTimers(timers);
+            return { ...timer };
+        });
+    }
+    /** List every unacknowledged timer, including timers already due. */
+    async listActive(at) {
+        await this.mutationTail;
+        const now = this.resolveTime(at);
+        const timers = await this.readTimers();
+        return timers
+            .map((timer) => this.toView(timer, now))
+            .sort((a, b) => a.dueAt.localeCompare(b.dueAt) || a.id.localeCompare(b.id));
+    }
+    /** Return due, unacknowledged timers without consuming them. */
+    async due(at) {
+        return (await this.listActive(at)).filter((timer) => timer.state === 'due');
+    }
+    /** Acknowledge a timer only after its absolute due instant. */
+    async acknowledge(id, at) {
+        return this.enqueueMutation(async () => {
+            const now = this.resolveTime(at);
+            const timers = await this.readTimers();
+            const index = timers.findIndex((timer) => timer.id === id);
+            if (index < 0)
+                return null;
+            const timer = timers[index];
+            if (new Date(timer.dueAt).getTime() > now.getTime())
+                return null;
+            timers.splice(index, 1);
+            await this.writeTimers(timers);
+            return { ...timer };
+        });
+    }
+    /** Cancel a running or due timer. Missing ids are idempotent. */
+    async cancel(id) {
+        return this.enqueueMutation(async () => {
+            const timers = await this.readTimers();
+            const index = timers.findIndex((timer) => timer.id === id);
+            if (index < 0)
+                return null;
+            const [timer] = timers.splice(index, 1);
+            await this.writeTimers(timers);
+            return timer ? { ...timer } : null;
+        });
+    }
+    validateDuration(durationMs) {
+        if (!Number.isInteger(durationMs) ||
+            durationMs < MIN_COOKING_TIMER_DURATION_MS ||
+            durationMs > MAX_COOKING_TIMER_DURATION_MS) {
+            throw new RangeError(`durationMs must be an integer between ${MIN_COOKING_TIMER_DURATION_MS} and ${MAX_COOKING_TIMER_DURATION_MS}`);
+        }
+    }
+    validateLabel(label) {
+        if (typeof label !== 'string')
+            throw new TypeError('label must be a string');
+        const normalized = label.trim();
+        if (!normalized)
+            throw new RangeError('label must not be empty');
+        if (normalized.length > MAX_COOKING_TIMER_LABEL_LENGTH) {
+            throw new RangeError(`label must not exceed ${MAX_COOKING_TIMER_LABEL_LENGTH} characters`);
+        }
+        return normalized;
+    }
+    currentTime() {
+        return this.resolveTime(this.now());
+    }
+    resolveTime(value) {
+        const date = value === undefined
+            ? this.now()
+            : value instanceof Date
+                ? new Date(value.getTime())
+                : new Date(value);
+        if (Number.isNaN(date.getTime()))
+            throw new RangeError('timer clock must be a valid instant');
+        return date;
+    }
+    toView(timer, now) {
+        const remainingMs = Math.max(0, new Date(timer.dueAt).getTime() - now.getTime());
+        return {
+            ...timer,
+            state: remainingMs === 0 ? 'due' : 'running',
+            remainingMs,
+        };
+    }
+    enqueueMutation(operation) {
+        const run = this.mutationTail.then(operation, operation);
+        this.mutationTail = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    async readTimers() {
+        let parsed;
+        try {
+            parsed = JSON.parse(await fs.readFile(this.filePath, 'utf8'));
+            await this.enforcePrivatePermissions();
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                logger.warn('[life-rhythm] cooking timer store unreadable; returning no timers', {
+                    filePath: this.filePath,
+                    error: errorMessage(error),
+                });
+            }
+            return [];
+        }
+        if (!isRecord(parsed) ||
+            parsed.schemaVersion !== COOKING_TIMER_SCHEMA_VERSION ||
+            !Array.isArray(parsed.timers)) {
+            logger.warn('[life-rhythm] cooking timer store schema invalid; returning no timers', {
+                filePath: this.filePath,
+            });
+            return [];
+        }
+        const timers = parsed.timers.map(parseTimer);
+        if (timers.some((timer) => timer === null)) {
+            logger.warn('[life-rhythm] cooking timer store contains invalid timer data; returning no timers', {
+                filePath: this.filePath,
+            });
+            return [];
+        }
+        const validTimers = timers;
+        if (new Set(validTimers.map((timer) => timer.id)).size !== validTimers.length) {
+            logger.warn('[life-rhythm] cooking timer store contains duplicate ids; returning no timers', {
+                filePath: this.filePath,
+            });
+            return [];
+        }
+        return validTimers.map((timer) => ({ ...timer }));
+    }
+    async writeTimers(timers) {
+        const directory = path.dirname(this.filePath);
+        const temporary = `${this.filePath}.tmp.${process.pid}.${randomUUID()}`;
+        const envelope = {
+            schemaVersion: COOKING_TIMER_SCHEMA_VERSION,
+            timers,
+        };
+        try {
+            await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+            if (process.platform !== 'win32')
+                await fs.chmod(directory, 0o700);
+            await fs.writeFile(temporary, `${JSON.stringify(envelope, null, 2)}\n`, {
+                encoding: 'utf8',
+                mode: 0o600,
+            });
+            await fs.rename(temporary, this.filePath);
+            await this.enforcePrivatePermissions();
+        }
+        catch (error) {
+            await fs.rm(temporary, { force: true }).catch(() => undefined);
+            throw new Error(`Unable to persist cooking timers: ${errorMessage(error)}`);
+        }
+    }
+    async enforcePrivatePermissions() {
+        if (process.platform === 'win32')
+            return;
+        await Promise.all([
+            fs.chmod(path.dirname(this.filePath), 0o700),
+            fs.chmod(this.filePath, 0o600),
+        ]);
+    }
+}
+//# sourceMappingURL=cooking-timer-store.js.map

package/dist/life-rhythm/day-context.d.ts

@@ -0,0 +1,30 @@
+import type { DayContext, HomeModeState, PresenceSnapshot, PublicHolidayProvider } from './types.js';
+export interface HomeModeReader {
+    getCurrent(): Promise<HomeModeState>;
+}
+export interface BuildDayContextOptions {
+    timeZone: string;
+    instant?: Date;
+    holidayProvider?: PublicHolidayProvider;
+    homeMode?: HomeModeState;
+    homeModeStore?: HomeModeReader;
+    presence?: PresenceSnapshot;
+}
+export interface ZonedDateTimeParts {
+    timeZone: string;
+    localDate: string;
+    localTime: string;
+    weekday: number;
+    isoWeekday: number;
+    utcOffsetMinutes: number;
+}
+/** Validate and canonicalize an IANA timezone with the runtime's ICU data. */
+export declare function canonicalizeTimeZone(timeZone: string): string;
+/**
+ * Resolve an instant into local civil time using Intl/ICU. No fixed offset is
+ * retained, so calls on either side of a daylight-saving transition use the
+ * correct offset for that exact instant.
+ */
+export declare function resolveZonedDateTime(instant: Date, timeZone: string): ZonedDateTimeParts;
+/** Build the immutable daily context for one exact instant. */
+export declare function buildDayContext(options: BuildDayContextOptions): Promise<DayContext>;

package/dist/life-rhythm/day-context.js

@@ -0,0 +1,198 @@
+import { logger } from '../utils/logger.js';
+const ISO_DATE_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+function requirePart(parts, name) {
+    const raw = parts[name];
+    if (raw === undefined) {
+        throw new Error(`Intl.DateTimeFormat did not return '${name}'`);
+    }
+    const value = Number(raw);
+    if (!Number.isInteger(value)) {
+        throw new Error(`Intl.DateTimeFormat returned an invalid '${name}': ${raw}`);
+    }
+    return value;
+}
+/** Validate and canonicalize an IANA timezone with the runtime's ICU data. */
+export function canonicalizeTimeZone(timeZone) {
+    const candidate = timeZone.trim();
+    if (!candidate)
+        throw new RangeError('timeZone must not be empty');
+    try {
+        return new Intl.DateTimeFormat('en-US', { timeZone: candidate })
+            .resolvedOptions()
+            .timeZone;
+    }
+    catch {
+        throw new RangeError(`Invalid IANA timeZone: ${timeZone}`);
+    }
+}
+/**
+ * Resolve an instant into local civil time using Intl/ICU. No fixed offset is
+ * retained, so calls on either side of a daylight-saving transition use the
+ * correct offset for that exact instant.
+ */
+export function resolveZonedDateTime(instant, timeZone) {
+    if (Number.isNaN(instant.getTime()))
+        throw new RangeError('instant must be a valid Date');
+    const canonicalTimeZone = canonicalizeTimeZone(timeZone);
+    const formatter = new Intl.DateTimeFormat('en-CA-u-ca-iso8601-nu-latn', {
+        timeZone: canonicalTimeZone,
+        calendar: 'iso8601',
+        numberingSystem: 'latn',
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hourCycle: 'h23',
+    });
+    const values = {};
+    for (const part of formatter.formatToParts(instant)) {
+        if (part.type !== 'literal')
+            values[part.type] = part.value;
+    }
+    const year = requirePart(values, 'year');
+    const month = requirePart(values, 'month');
+    const day = requirePart(values, 'day');
+    const hour = requirePart(values, 'hour');
+    const minute = requirePart(values, 'minute');
+    const second = requirePart(values, 'second');
+    const localDate = `${String(year).padStart(4, '0')}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+    const localTime = `${String(hour).padStart(2, '0')}:${String(minute).padStart(2, '0')}:${String(second).padStart(2, '0')}`;
+    // The weekday depends only on the local civil date. UTC is used here solely
+    // as a Gregorian calendar calculator, not as the household timezone.
+    const weekday = new Date(Date.UTC(year, month - 1, day)).getUTCDay();
+    const isoWeekday = weekday === 0 ? 7 : weekday;
+    const wholeSecondInstant = Math.trunc(instant.getTime() / 1_000) * 1_000;
+    const localFieldsAsUtc = Date.UTC(year, month - 1, day, hour, minute, second);
+    const utcOffsetMinutes = (localFieldsAsUtc - wholeSecondInstant) / 60_000;
+    return {
+        timeZone: canonicalTimeZone,
+        localDate,
+        localTime,
+        weekday,
+        isoWeekday,
+        utcOffsetMinutes,
+    };
+}
+function unavailableHoliday(date, checkedAt, message) {
+    const match = ISO_DATE_RE.exec(date);
+    const year = match?.[1] === undefined ? 0 : Number(match[1]);
+    return {
+        date,
+        available: false,
+        holiday: null,
+        provenance: {
+            provider: 'none',
+            source: 'unavailable',
+            freshness: 'unavailable',
+            checkedAt: checkedAt.toISOString(),
+            year,
+        },
+        ...(message ? { error: message } : {}),
+    };
+}
+function defaultHomeMode(instant) {
+    return {
+        mode: 'normal',
+        setAt: instant.toISOString(),
+        source: 'default',
+    };
+}
+function normalizeHomeMode(state, instant) {
+    if (!state.expiresAt)
+        return state;
+    const expiresAt = new Date(state.expiresAt);
+    if (!Number.isNaN(expiresAt.getTime()) && expiresAt.getTime() <= instant.getTime()) {
+        return {
+            mode: 'normal',
+            setAt: instant.toISOString(),
+            source: 'expired',
+            previousMode: state.mode,
+        };
+    }
+    return state;
+}
+function normalizePresence(presence) {
+    if (!presence)
+        return { status: 'unknown', source: 'none' };
+    if (presence.confidence !== undefined &&
+        (!Number.isFinite(presence.confidence) || presence.confidence < 0 || presence.confidence > 1)) {
+        throw new RangeError('presence.confidence must be between 0 and 1');
+    }
+    if (presence.observedAt && Number.isNaN(new Date(presence.observedAt).getTime())) {
+        throw new RangeError('presence.observedAt must be an ISO-compatible timestamp');
+    }
+    return { ...presence };
+}
+async function resolveHomeMode(options, instant) {
+    if (options.homeMode)
+        return normalizeHomeMode(options.homeMode, instant);
+    if (!options.homeModeStore)
+        return defaultHomeMode(instant);
+    try {
+        return normalizeHomeMode(await options.homeModeStore.getCurrent(), instant);
+    }
+    catch (error) {
+        logger.warn('[life-rhythm] home mode unavailable; using normal', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return defaultHomeMode(instant);
+    }
+}
+async function resolveHoliday(provider, localDate, checkedAt) {
+    if (!provider)
+        return unavailableHoliday(localDate, checkedAt);
+    try {
+        const result = await provider.lookup(localDate);
+        if (result.date !== localDate || (result.holiday && result.holiday.date !== localDate)) {
+            throw new Error(`Holiday provider returned a mismatched date for ${localDate}`);
+        }
+        if (!result.available && result.holiday) {
+            throw new Error(`Holiday provider returned data while marking ${localDate} unavailable`);
+        }
+        return result;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.warn('[life-rhythm] holiday lookup failed softly', { localDate, error: message });
+        return unavailableHoliday(localDate, checkedAt, message);
+    }
+}
+function resolveDayKind(weekday, isPublicHoliday, holidayCalendarAvailable) {
+    if (isPublicHoliday)
+        return 'public_holiday';
+    if (weekday === 0 || weekday === 6)
+        return 'weekend';
+    if (!holidayCalendarAvailable)
+        return 'unknown';
+    return 'workday';
+}
+/** Build the immutable daily context for one exact instant. */
+export async function buildDayContext(options) {
+    const instant = options.instant ? new Date(options.instant.getTime()) : new Date();
+    if (Number.isNaN(instant.getTime()))
+        throw new RangeError('instant must be a valid Date');
+    const zoned = resolveZonedDateTime(instant, options.timeZone);
+    const [holiday, homeMode] = await Promise.all([
+        resolveHoliday(options.holidayProvider, zoned.localDate, instant),
+        resolveHomeMode(options, instant),
+    ]);
+    const publicHoliday = holiday.holiday;
+    return {
+        schemaVersion: 1,
+        instant: instant.toISOString(),
+        timeZone: zoned.timeZone,
+        localDate: zoned.localDate,
+        localTime: zoned.localTime,
+        weekday: zoned.weekday,
+        isoWeekday: zoned.isoWeekday,
+        utcOffsetMinutes: zoned.utcOffsetMinutes,
+        dayKind: resolveDayKind(zoned.weekday, publicHoliday !== null, holiday.available),
+        publicHoliday,
+        holidayProvenance: holiday.provenance,
+        homeMode,
+        presence: normalizePresence(options.presence),
+    };
+}
+//# sourceMappingURL=day-context.js.map

package/dist/life-rhythm/etalab-holiday-provider.d.ts

@@ -0,0 +1,40 @@
+import { type EtalabHolidayZone, type HolidayLookupResult, type HolidayYearResult, type PublicHolidayProvider } from './types.js';
+/** Defensive bounds for the year-specific Etalab endpoint. */
+export declare const MIN_HOLIDAY_YEAR = 1900;
+export declare const MAX_HOLIDAY_YEAR = 2200;
+export interface EtalabHolidayProviderOptions {
+    zone?: EtalabHolidayZone;
+    baseUrl?: string;
+    cachePath?: string;
+    cacheTtlMs?: number;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+    now?: () => Date;
+}
+export declare function isEtalabHolidayZone(value: unknown): value is EtalabHolidayZone;
+export declare function assertEtalabHolidayZone(value: unknown): asserts value is EtalabHolidayZone;
+export declare function assertHolidayYear(year: number): void;
+/**
+ * Persistent, fail-soft provider for Etalab's official French public-holiday
+ * endpoint. Valid cache remains usable when the network is unavailable; stale
+ * cache is explicitly labelled rather than silently presented as fresh.
+ */
+export declare class EtalabHolidayProvider implements PublicHolidayProvider {
+    readonly zone: EtalabHolidayZone;
+    private readonly baseUrl;
+    private readonly cachePath;
+    private readonly cacheTtlMs;
+    private readonly timeoutMs;
+    private readonly fetchImpl;
+    private readonly now;
+    constructor(options?: EtalabHolidayProviderOptions);
+    lookup(date: string): Promise<HolidayLookupResult>;
+    getHolidays(year: number): Promise<HolidayYearResult>;
+    private currentTime;
+    private fetchWithTimeout;
+    private cacheAge;
+    private resultFromEntry;
+    private provenance;
+    private readCache;
+    private writeCache;
+}