@murphai/murph 0.2.12 → 1.0.0

package/node_modules/@murphai/query/dist/browser-replica.js

@@ -0,0 +1,986 @@
+import { buildOverviewMetrics, buildOverviewWeeklyStatsFromDailySampleSummaries, isActiveOverviewExperimentStatus, summarizeOverviewExperiments, summarizeRecentOverviewJournals, } from "./overview.js";
+import { summarizeDailySamples } from "./summaries.js";
+import { buildTimeline } from "./timeline.js";
+import { buildWearableAssistantSummary, summarizeWearableActivity, summarizeWearableBodyState, summarizeWearableRecovery, summarizeWearableSleep, summarizeWearableSourceHealth, } from "./wearables.js";
+export const BROWSER_VAULT_REPLICA_SCHEMA = "murph.browser-vault-replica.v1";
+export const BROWSER_VAULT_REPLICA_POLICY_ID = "health-vault-browser-v1";
+const BODY_PREVIEW_CHARS = 280;
+const METRIC_LOOKBACK_DAYS = 365;
+const RECENT_JOURNAL_LIMIT = 4;
+const TRACKED_EXPERIMENT_LIMIT = 24;
+const TIMELINE_LIMIT = 240;
+const SIGNAL_LIMIT = 30;
+const SOURCE_HEALTH_LIMIT = 24;
+const WEEKLY_SAMPLE_LOOKBACK_DAYS = 365;
+const INCLUDED_FAMILIES = [
+    "allergy",
+    "assessment",
+    "condition",
+    "event",
+    "experiment",
+    "family",
+    "genetics",
+    "goal",
+    "journal",
+    "protocol",
+    "provider",
+    "sample",
+    "workout_format",
+];
+const EXCLUDED_FAMILIES = [
+    "audit",
+    "core",
+    "food",
+    "recipe",
+];
+export async function createBrowserVaultReplica(input) {
+    const generatedAt = input.generatedAt
+        ? requireIsoDateTime(input.generatedAt, "Browser vault replica generatedAt")
+        : new Date().toISOString();
+    const policy = createBrowserVaultReplicaPolicy();
+    const entities = input.vault.entities
+        .filter((entity) => isBrowserVaultIncludedFamily(entity.family))
+        .map(projectEntity);
+    const timelineRows = buildTimeline(input.vault, { limit: TIMELINE_LIMIT })
+        .map(projectTimelineRow);
+    const weeklySampleSummaries = projectWeeklySampleSummaries(input.vault, generatedAt);
+    const activity = summarizeWearableActivity(input.vault, { limit: SIGNAL_LIMIT });
+    const sleep = summarizeWearableSleep(input.vault, { limit: SIGNAL_LIMIT });
+    const recovery = summarizeWearableRecovery(input.vault, { limit: SIGNAL_LIMIT });
+    const bodyState = summarizeWearableBodyState(input.vault, { limit: SIGNAL_LIMIT });
+    const metricDayRows = [
+        ...activity.map(projectActivityMetricDayRow),
+        ...sleep.map(projectSleepMetricDayRow),
+        ...recovery.map(projectRecoveryMetricDayRow),
+        ...bodyState.map(projectBodyStateMetricDayRow),
+    ];
+    const metricRows = metricDayRows.flatMap((day) => dayToMetricRows(day));
+    const sourceHealthRows = summarizeWearableSourceHealth(input.vault, { limit: SOURCE_HEALTH_LIMIT })
+        .map(projectSourceHealthRow);
+    const replicaWithoutVersion = {
+        assistantSummary: projectWearableAssistantSummary(buildWearableAssistantSummary(input.vault)),
+        entities,
+        generatedAt,
+        metricDayRows,
+        metricRows,
+        policy,
+        schema: BROWSER_VAULT_REPLICA_SCHEMA,
+        searchRows: entities.map(projectSearchRow),
+        source: {
+            dataVersion: "pending",
+            sourceBundleHash: requireString(input.sourceBundleHash, "Browser vault replica sourceBundleHash"),
+        },
+        sourceHealthRows,
+        timelineRows,
+        weeklySampleSummaries,
+    };
+    const dataVersion = await hashBrowserVaultReplicaData(replicaWithoutVersion);
+    return {
+        ...replicaWithoutVersion,
+        source: {
+            ...replicaWithoutVersion.source,
+            dataVersion,
+        },
+    };
+}
+export async function hashBrowserVaultReplicaData(replica) {
+    const stableReplica = {
+        ...replica,
+        generatedAt: "",
+        source: {
+            ...replica.source,
+            dataVersion: "pending",
+        },
+    };
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(stableStringify(stableReplica)));
+    return [...new Uint8Array(digest)]
+        .map((byte) => byte.toString(16).padStart(2, "0"))
+        .join("");
+}
+export function parseBrowserVaultReplica(value, label = "Browser vault replica") {
+    const record = requireRecord(value, label);
+    const schema = requireString(record.schema, `${label}.schema`);
+    if (schema !== BROWSER_VAULT_REPLICA_SCHEMA) {
+        throw new TypeError(`${label}.schema must be ${BROWSER_VAULT_REPLICA_SCHEMA}.`);
+    }
+    return {
+        assistantSummary: parseAssistantSummary(record.assistantSummary, `${label}.assistantSummary`),
+        entities: requireArray(record.entities, `${label}.entities`).map((entry, index) => parseEntity(entry, `${label}.entities[${index}]`)),
+        generatedAt: requireIsoDateTime(record.generatedAt, `${label}.generatedAt`),
+        metricDayRows: requireArray(record.metricDayRows, `${label}.metricDayRows`).map((entry, index) => parseMetricDayRow(entry, `${label}.metricDayRows[${index}]`)),
+        metricRows: requireArray(record.metricRows, `${label}.metricRows`).map((entry, index) => parseMetricRow(entry, `${label}.metricRows[${index}]`)),
+        policy: parsePolicy(record.policy, `${label}.policy`),
+        schema: BROWSER_VAULT_REPLICA_SCHEMA,
+        searchRows: requireArray(record.searchRows, `${label}.searchRows`).map((entry, index) => parseSearchRow(entry, `${label}.searchRows[${index}]`)),
+        source: parseSource(record.source, `${label}.source`),
+        sourceHealthRows: requireArray(record.sourceHealthRows, `${label}.sourceHealthRows`).map((entry, index) => parseSourceHealthRow(entry, `${label}.sourceHealthRows[${index}]`)),
+        timelineRows: requireArray(record.timelineRows, `${label}.timelineRows`).map((entry, index) => parseTimelineRow(entry, `${label}.timelineRows[${index}]`)),
+        weeklySampleSummaries: requireArray(record.weeklySampleSummaries, `${label}.weeklySampleSummaries`).map((entry, index) => parseWeeklySampleSummary(entry, `${label}.weeklySampleSummaries[${index}]`)),
+    };
+}
+export function createBrowserVaultQueryClient(replica) {
+    const byLookupId = new Map();
+    for (const entity of replica.entities) {
+        byLookupId.set(entity.id, entity);
+        for (const lookupId of entity.lookupIds) {
+            byLookupId.set(lookupId, entity);
+        }
+    }
+    return {
+        entities: {
+            get(idOrLookupId) {
+                return byLookupId.get(idOrLookupId) ?? null;
+            },
+            list(filters = {}) {
+                return replica.entities.filter((entity) => matchesEntityFilters(entity, filters));
+            },
+        },
+        metricDays: {
+            list(filters = {}) {
+                return replica.metricDayRows.filter((row) => matchesMetricDayFilters(row, filters));
+            },
+        },
+        metrics: {
+            latest(filters = {}) {
+                return replica.metricRows.find((row) => matchesMetricFilters(row, filters)) ?? null;
+            },
+            list(filters = {}) {
+                return replica.metricRows.filter((row) => matchesMetricFilters(row, filters));
+            },
+            series(filters = {}) {
+                return replica.metricRows.filter((row) => matchesMetricFilters(row, filters)).slice().reverse();
+            },
+        },
+        replica,
+        search(query, filters = {}) {
+            const normalizedQuery = normalizeSearch(query);
+            const familySet = filters.families ? new Set(filters.families) : null;
+            if (normalizedQuery.length === 0) {
+                return [];
+            }
+            return replica.searchRows.filter((row) => {
+                if (familySet && !familySet.has(row.family)) {
+                    return false;
+                }
+                return normalizeSearch(row.text).includes(normalizedQuery);
+            });
+        },
+        timeline: {
+            list(filters = {}) {
+                return replica.timelineRows.filter((row) => matchesTimelineFilters(row, filters));
+            },
+        },
+    };
+}
+export function selectBrowserVaultOverview(client) {
+    const vault = vaultViewFromReplica(client.replica);
+    return {
+        metrics: buildOverviewMetrics(vault),
+        recentJournals: summarizeRecentOverviewJournals(vault, RECENT_JOURNAL_LIMIT),
+        trackedExperiments: summarizeOverviewExperiments(vault, TRACKED_EXPERIMENT_LIMIT),
+        weeklySampleSummaries: client.replica.weeklySampleSummaries.slice(),
+    };
+}
+export function selectBrowserVaultHistory(client) {
+    return {
+        timeline: client.timeline.list().slice(0, TIMELINE_LIMIT),
+    };
+}
+export function selectBrowserVaultTrackedExperiments(client) {
+    return selectBrowserVaultOverview(client).trackedExperiments;
+}
+export function selectBrowserVaultSignals(client) {
+    return {
+        activity: client.metricDays.list({ domain: "activity" }).map(dayToActivitySummary),
+        assistantSummary: {
+            highlights: client.replica.assistantSummary.highlights.slice(),
+            latestDate: client.replica.assistantSummary.latestDate,
+        },
+        bodyState: client.metricDays.list({ domain: "body_state" }).map(dayToBodyStateSummary),
+        recovery: client.metricDays.list({ domain: "recovery" }).map(dayToRecoverySummary),
+        sleep: client.metricDays.list({ domain: "sleep" }).map(dayToSleepSummary),
+        sourceHealth: client.replica.sourceHealthRows.slice(),
+    };
+}
+function vaultViewFromReplica(replica) {
+    const byFamily = {};
+    const entities = replica.entities.map(entityFromBrowserEntity);
+    for (const entity of entities) {
+        byFamily[entity.family] = byFamily[entity.family] ?? [];
+        byFamily[entity.family]?.push(entity);
+    }
+    return {
+        allergies: byFamily.allergy ?? [],
+        assessments: byFamily.assessment ?? [],
+        audits: [],
+        byFamily,
+        conditions: byFamily.condition ?? [],
+        coreDocument: null,
+        entities,
+        events: byFamily.event ?? [],
+        experiments: byFamily.experiment ?? [],
+        familyMembers: byFamily.family ?? [],
+        foods: [],
+        format: "murph.query.v1",
+        geneticVariants: byFamily.genetics ?? [],
+        goals: byFamily.goal ?? [],
+        journalEntries: byFamily.journal ?? [],
+        metadata: null,
+        protocols: byFamily.protocol ?? [],
+        providers: byFamily.provider ?? [],
+        recipes: [],
+        samples: byFamily.sample ?? [],
+        vaultRoot: "browser-vault-replica",
+        workoutFormats: byFamily.workout_format ?? [],
+    };
+}
+function entityFromBrowserEntity(entity) {
+    return {
+        attributes: cloneRecord(entity.attributes),
+        body: entity.bodyPreview,
+        date: entity.date,
+        entityId: entity.id,
+        experimentSlug: entity.experimentSlug,
+        family: entity.family,
+        frontmatter: cloneRecord(entity.attributes),
+        kind: entity.kind,
+        links: entity.links.map((link) => ({ targetId: link.targetId, type: link.type })),
+        lookupIds: entity.lookupIds.slice(),
+        occurredAt: entity.occurredAt,
+        path: `browser://${entity.id}`,
+        primaryLookupId: entity.lookupIds[0] ?? entity.id,
+        recordClass: entity.recordClass,
+        relatedIds: entity.links.map((link) => link.targetId),
+        status: entity.status,
+        stream: entity.stream,
+        tags: entity.tags.slice(),
+        title: entity.title,
+    };
+}
+function createBrowserVaultReplicaPolicy() {
+    return {
+        bodyPreviewChars: BODY_PREVIEW_CHARS,
+        excludedFamilies: EXCLUDED_FAMILIES.slice(),
+        id: BROWSER_VAULT_REPLICA_POLICY_ID,
+        includedFamilies: INCLUDED_FAMILIES.slice(),
+        metricLookbackDays: METRIC_LOOKBACK_DAYS,
+    };
+}
+function isBrowserVaultIncludedFamily(family) {
+    return INCLUDED_FAMILIES.includes(family);
+}
+function projectEntity(entity) {
+    return {
+        attributes: projectSafeAttributes(entity),
+        bodyPreview: previewText(entity.body, BODY_PREVIEW_CHARS),
+        date: entity.date,
+        experimentSlug: entity.experimentSlug,
+        family: entity.family,
+        id: entity.entityId,
+        kind: entity.kind,
+        links: entity.links.map((link) => ({ targetId: link.targetId, type: link.type })),
+        lookupIds: uniqueStrings([entity.primaryLookupId, ...entity.lookupIds, entity.entityId]),
+        occurredAt: entity.occurredAt,
+        recordClass: entity.recordClass,
+        status: entity.status,
+        stream: entity.stream,
+        tags: entity.tags.slice(),
+        title: entity.title,
+    };
+}
+function projectSafeAttributes(entity) {
+    const source = entity.frontmatter ?? entity.attributes;
+    const allowed = {};
+    for (const key of [
+        "analysisPlan",
+        "assistantSupport",
+        "baselineEnd",
+        "baselineStart",
+        "category",
+        "completedAt",
+        "endedOn",
+        "group",
+        "metric",
+        "onboarding",
+        "outcome",
+        "outcomeRef",
+        "protocolRef",
+        "runPlan",
+        "startedOn",
+        "status",
+        "summary",
+        "unit",
+        "value",
+    ]) {
+        if (source[key] !== undefined && isBrowserSafeJson(source[key])) {
+            allowed[key] = cloneJson(source[key]);
+        }
+    }
+    return allowed;
+}
+function projectTimelineRow(entry) {
+    return {
+        date: entry.date,
+        entityId: entry.id,
+        entryType: entry.entryType,
+        family: entry.entryType === "sample_summary" ? "sample" : entry.entryType,
+        id: entry.id,
+        kind: entry.kind,
+        occurredAt: entry.occurredAt,
+        stream: entry.stream,
+        tags: entry.tags.slice(),
+        title: entry.title,
+    };
+}
+function projectSearchRow(entity) {
+    return {
+        date: entity.date,
+        entityId: entity.id,
+        family: entity.family,
+        id: entity.id,
+        kind: entity.kind,
+        occurredAt: entity.occurredAt,
+        tags: entity.tags.slice(),
+        text: [entity.title, entity.bodyPreview, entity.kind, entity.status, entity.stream, entity.tags.join(" ")]
+            .filter((value) => typeof value === "string" && value.length > 0)
+            .join("\n"),
+        title: entity.title,
+    };
+}
+function projectWeeklySampleSummaries(vault, generatedAt) {
+    const cutoffDate = subtractDaysFromIsoDate(generatedAt.slice(0, 10), WEEKLY_SAMPLE_LOOKBACK_DAYS);
+    return summarizeDailySamples(vault)
+        .filter((entry) => entry.date >= cutoffDate)
+        .map(projectWeeklySampleSummary);
+}
+function projectWeeklySampleSummary(entry) {
+    return {
+        date: entry.date,
+        numericSampleCount: entry.numericSampleCount,
+        sampleCount: entry.sampleCount,
+        stream: entry.stream,
+        sumValue: entry.sumValue,
+        unit: entry.unit,
+    };
+}
+function projectWearableAssistantSummary(summary) {
+    return {
+        highlights: summary.highlights.slice(),
+        latestDate: summary.latestDate,
+    };
+}
+function projectActivityMetricDayRow(summary) {
+    return buildMetricDayRow({
+        attributes: { activityTypes: summary.activityTypes.slice() },
+        confidence: summary.summaryConfidence.level,
+        date: summary.date,
+        domain: "activity",
+        metrics: {
+            activityScore: projectWearableResolvedMetric(summary.activityScore),
+            activeCalories: projectWearableResolvedMetric(summary.activeCalories),
+            dayStrain: projectWearableResolvedMetric(summary.dayStrain),
+            distanceKm: projectWearableResolvedMetric(summary.distanceKm),
+            sessionCount: projectWearableResolvedMetric(summary.sessionCount),
+            sessionMinutes: projectWearableResolvedMetric(summary.sessionMinutes),
+            steps: projectWearableResolvedMetric(summary.steps),
+        },
+        notes: summary.notes,
+    });
+}
+function projectSleepMetricDayRow(summary) {
+    return buildMetricDayRow({
+        attributes: {
+            sleepEndAt: summary.sleepEndAt,
+            sleepStartAt: summary.sleepStartAt,
+            sleepWindowProvider: summary.sleepWindowProvider,
+        },
+        confidence: summary.summaryConfidence.level,
+        date: summary.date,
+        domain: "sleep",
+        metrics: {
+            averageHeartRate: projectWearableResolvedMetric(summary.averageHeartRate),
+            awakeMinutes: projectWearableResolvedMetric(summary.awakeMinutes),
+            deepMinutes: projectWearableResolvedMetric(summary.deepMinutes),
+            hrv: projectWearableResolvedMetric(summary.hrv),
+            lightMinutes: projectWearableResolvedMetric(summary.lightMinutes),
+            lowestHeartRate: projectWearableResolvedMetric(summary.lowestHeartRate),
+            remMinutes: projectWearableResolvedMetric(summary.remMinutes),
+            respiratoryRate: projectWearableResolvedMetric(summary.respiratoryRate),
+            sessionMinutes: projectWearableResolvedMetric(summary.sessionMinutes),
+            sleepConsistency: projectWearableResolvedMetric(summary.sleepConsistency),
+            sleepEfficiency: projectWearableResolvedMetric(summary.sleepEfficiency),
+            sleepPerformance: projectWearableResolvedMetric(summary.sleepPerformance),
+            sleepScore: projectWearableResolvedMetric(summary.sleepScore),
+            spo2: projectWearableResolvedMetric(summary.spo2),
+            timeInBedMinutes: projectWearableResolvedMetric(summary.timeInBedMinutes),
+            totalSleepMinutes: projectWearableResolvedMetric(summary.totalSleepMinutes),
+        },
+        notes: summary.notes,
+    });
+}
+function projectRecoveryMetricDayRow(summary) {
+    return buildMetricDayRow({
+        attributes: {},
+        confidence: summary.summaryConfidence.level,
+        date: summary.date,
+        domain: "recovery",
+        metrics: {
+            bodyBattery: projectWearableResolvedMetric(summary.bodyBattery),
+            hrv: projectWearableResolvedMetric(summary.hrv),
+            readinessScore: projectWearableResolvedMetric(summary.readinessScore),
+            recoveryScore: projectWearableResolvedMetric(summary.recoveryScore),
+            respiratoryRate: projectWearableResolvedMetric(summary.respiratoryRate),
+            restingHeartRate: projectWearableResolvedMetric(summary.restingHeartRate),
+            spo2: projectWearableResolvedMetric(summary.spo2),
+            stressLevel: projectWearableResolvedMetric(summary.stressLevel),
+            temperature: projectWearableResolvedMetric(summary.temperature),
+            temperatureDeviation: projectWearableResolvedMetric(summary.temperatureDeviation),
+        },
+        notes: summary.notes,
+    });
+}
+function projectBodyStateMetricDayRow(summary) {
+    return buildMetricDayRow({
+        attributes: {},
+        confidence: summary.summaryConfidence.level,
+        date: summary.date,
+        domain: "body_state",
+        metrics: {
+            bmi: projectWearableResolvedMetric(summary.bmi),
+            bodyFatPercentage: projectWearableResolvedMetric(summary.bodyFatPercentage),
+            temperature: projectWearableResolvedMetric(summary.temperature),
+            weightKg: projectWearableResolvedMetric(summary.weightKg),
+        },
+        notes: summary.notes,
+    });
+}
+function buildMetricDayRow(input) {
+    const metricIds = Object.keys(input.metrics).map((metric) => `${input.domain}:${input.date}:${metric}`);
+    return {
+        attributes: cloneRecord(input.attributes),
+        confidence: input.confidence,
+        date: input.date,
+        domain: input.domain,
+        id: `${input.domain}:${input.date}`,
+        metricIds,
+        metrics: cloneMetricMap(input.metrics),
+        notes: input.notes.slice(),
+    };
+}
+function dayToMetricRows(day) {
+    return Object.entries(day.metrics).map(([metric, resolved]) => ({
+        confidence: day.confidence,
+        date: day.date,
+        domain: day.domain,
+        id: `${day.id}:${metric}`,
+        metric,
+        recordIds: [],
+        sourceFamily: "derived",
+        sourceKind: "summary",
+        unit: resolved.selection.unit,
+        value: resolved.selection.value,
+    }));
+}
+function projectWearableResolvedMetric(metric) {
+    return {
+        selection: {
+            unit: metric.selection.unit,
+            value: metric.selection.value,
+        },
+    };
+}
+function projectSourceHealthRow(summary) {
+    return {
+        activityDays: summary.activityDays,
+        bodyStateDays: summary.bodyStateDays,
+        conflictCount: summary.conflictCount,
+        firstDate: null,
+        lastDate: summary.lastDate,
+        latestRecordedAt: summary.lastDate,
+        provider: summary.provider,
+        providerDisplayName: summary.providerDisplayName,
+        recoveryDays: summary.recoveryDays,
+        selectedMetrics: summary.selectedMetrics,
+        sleepNights: summary.sleepNights,
+        stalenessVsNewestDays: summary.stalenessVsNewestDays,
+    };
+}
+function dayToActivitySummary(day) {
+    return {
+        activityScore: metric(day, "activityScore"),
+        activeCalories: metric(day, "activeCalories"),
+        activityTypes: readStringArray(day.attributes.activityTypes),
+        date: day.date,
+        dayStrain: metric(day, "dayStrain"),
+        distanceKm: metric(day, "distanceKm"),
+        notes: day.notes.slice(),
+        sessionCount: metric(day, "sessionCount"),
+        sessionMinutes: metric(day, "sessionMinutes"),
+        steps: metric(day, "steps"),
+        summaryConfidence: { level: day.confidence },
+    };
+}
+function dayToSleepSummary(day) {
+    return {
+        averageHeartRate: metric(day, "averageHeartRate"),
+        awakeMinutes: metric(day, "awakeMinutes"),
+        date: day.date,
+        deepMinutes: metric(day, "deepMinutes"),
+        hrv: metric(day, "hrv"),
+        lightMinutes: metric(day, "lightMinutes"),
+        lowestHeartRate: metric(day, "lowestHeartRate"),
+        notes: day.notes.slice(),
+        remMinutes: metric(day, "remMinutes"),
+        respiratoryRate: metric(day, "respiratoryRate"),
+        sessionMinutes: metric(day, "sessionMinutes"),
+        sleepConsistency: metric(day, "sleepConsistency"),
+        sleepEfficiency: metric(day, "sleepEfficiency"),
+        sleepEndAt: readNullableString(day.attributes.sleepEndAt),
+        sleepPerformance: metric(day, "sleepPerformance"),
+        sleepScore: metric(day, "sleepScore"),
+        sleepStartAt: readNullableString(day.attributes.sleepStartAt),
+        sleepWindowProvider: readNullableString(day.attributes.sleepWindowProvider),
+        spo2: metric(day, "spo2"),
+        summaryConfidence: { level: day.confidence },
+        timeInBedMinutes: metric(day, "timeInBedMinutes"),
+        totalSleepMinutes: metric(day, "totalSleepMinutes"),
+    };
+}
+function dayToRecoverySummary(day) {
+    return {
+        bodyBattery: metric(day, "bodyBattery"),
+        date: day.date,
+        hrv: metric(day, "hrv"),
+        notes: day.notes.slice(),
+        readinessScore: metric(day, "readinessScore"),
+        recoveryScore: metric(day, "recoveryScore"),
+        respiratoryRate: metric(day, "respiratoryRate"),
+        restingHeartRate: metric(day, "restingHeartRate"),
+        spo2: metric(day, "spo2"),
+        stressLevel: metric(day, "stressLevel"),
+        summaryConfidence: { level: day.confidence },
+        temperature: metric(day, "temperature"),
+        temperatureDeviation: metric(day, "temperatureDeviation"),
+    };
+}
+function dayToBodyStateSummary(day) {
+    return {
+        bmi: metric(day, "bmi"),
+        bodyFatPercentage: metric(day, "bodyFatPercentage"),
+        date: day.date,
+        notes: day.notes.slice(),
+        summaryConfidence: { level: day.confidence },
+        temperature: metric(day, "temperature"),
+        weightKg: metric(day, "weightKg"),
+    };
+}
+function metric(day, key) {
+    return day.metrics[key] ?? { selection: { unit: null, value: null } };
+}
+function matchesEntityFilters(entity, filters) {
+    if (filters.ids && !filters.ids.some((id) => entity.lookupIds.includes(id) || entity.id === id)) {
+        return false;
+    }
+    if (filters.families && !filters.families.includes(entity.family)) {
+        return false;
+    }
+    if (filters.kinds && !filters.kinds.includes(entity.kind)) {
+        return false;
+    }
+    if (filters.statuses && (!entity.status || !filters.statuses.includes(entity.status))) {
+        return false;
+    }
+    if (filters.tags && !filters.tags.every((tag) => entity.tags.includes(tag))) {
+        return false;
+    }
+    if (filters.from && (entity.date ?? "") < filters.from) {
+        return false;
+    }
+    if (filters.to && (entity.date ?? "9999-12-31") > filters.to) {
+        return false;
+    }
+    if (filters.text) {
+        return normalizeSearch([entity.title, entity.bodyPreview, entity.tags.join(" ")].join(" "))
+            .includes(normalizeSearch(filters.text));
+    }
+    return true;
+}
+function matchesMetricFilters(row, filters) {
+    if (filters.domain && row.domain !== filters.domain) {
+        return false;
+    }
+    if (filters.metric && row.metric !== filters.metric) {
+        return false;
+    }
+    if (filters.from && row.date < filters.from) {
+        return false;
+    }
+    if (filters.to && row.date > filters.to) {
+        return false;
+    }
+    return true;
+}
+function matchesMetricDayFilters(row, filters) {
+    if (filters.domain && row.domain !== filters.domain) {
+        return false;
+    }
+    if (filters.metric && !Object.hasOwn(row.metrics, filters.metric)) {
+        return false;
+    }
+    if (filters.from && row.date < filters.from) {
+        return false;
+    }
+    if (filters.to && row.date > filters.to) {
+        return false;
+    }
+    return true;
+}
+function matchesTimelineFilters(row, filters) {
+    if (filters.families && !filters.families.includes(row.family)) {
+        return false;
+    }
+    if (filters.kinds && !filters.kinds.includes(row.kind)) {
+        return false;
+    }
+    if (filters.tags && !filters.tags.every((tag) => row.tags.includes(tag))) {
+        return false;
+    }
+    if (filters.from && row.date < filters.from) {
+        return false;
+    }
+    if (filters.to && row.date > filters.to) {
+        return false;
+    }
+    return true;
+}
+function parsePolicy(value, label) {
+    const record = requireRecord(value, label);
+    const id = requireString(record.id, `${label}.id`);
+    if (id !== BROWSER_VAULT_REPLICA_POLICY_ID) {
+        throw new TypeError(`${label}.id must be ${BROWSER_VAULT_REPLICA_POLICY_ID}.`);
+    }
+    return {
+        bodyPreviewChars: requireNonNegativeInteger(record.bodyPreviewChars, `${label}.bodyPreviewChars`),
+        excludedFamilies: requireStringArray(record.excludedFamilies, `${label}.excludedFamilies`),
+        id,
+        includedFamilies: requireStringArray(record.includedFamilies, `${label}.includedFamilies`),
+        metricLookbackDays: requireNonNegativeInteger(record.metricLookbackDays, `${label}.metricLookbackDays`),
+    };
+}
+function parseSource(value, label) {
+    const record = requireRecord(value, label);
+    return {
+        dataVersion: requireString(record.dataVersion, `${label}.dataVersion`),
+        sourceBundleHash: requireString(record.sourceBundleHash, `${label}.sourceBundleHash`),
+    };
+}
+function parseEntity(value, label) {
+    const record = requireRecord(value, label);
+    return {
+        attributes: requireRecord(record.attributes, `${label}.attributes`),
+        bodyPreview: readNullableString(record.bodyPreview),
+        date: readNullableString(record.date),
+        experimentSlug: readNullableString(record.experimentSlug),
+        family: requireString(record.family, `${label}.family`),
+        id: requireString(record.id, `${label}.id`),
+        kind: requireString(record.kind, `${label}.kind`),
+        links: requireArray(record.links, `${label}.links`).map((entry, index) => parseEntityLink(entry, `${label}.links[${index}]`)),
+        lookupIds: requireStringArray(record.lookupIds, `${label}.lookupIds`),
+        occurredAt: readNullableString(record.occurredAt),
+        recordClass: requireRecordClass(record.recordClass, `${label}.recordClass`),
+        status: readNullableString(record.status),
+        stream: readNullableString(record.stream),
+        tags: requireStringArray(record.tags, `${label}.tags`),
+        title: readNullableString(record.title),
+    };
+}
+function parseEntityLink(value, label) {
+    const record = requireRecord(value, label);
+    return {
+        targetId: requireString(record.targetId, `${label}.targetId`),
+        type: requireString(record.type, `${label}.type`),
+    };
+}
+function parseMetricRow(value, label) {
+    const record = requireRecord(value, label);
+    return {
+        confidence: requireConfidenceLevel(record.confidence, `${label}.confidence`),
+        date: requireString(record.date, `${label}.date`),
+        domain: requireMetricDomain(record.domain, `${label}.domain`),
+        id: requireString(record.id, `${label}.id`),
+        metric: requireString(record.metric, `${label}.metric`),
+        recordIds: requireStringArray(record.recordIds, `${label}.recordIds`),
+        sourceFamily: readNullableString(record.sourceFamily),
+        sourceKind: readNullableString(record.sourceKind),
+        unit: readNullableString(record.unit),
+        value: readNullableFiniteNumber(record.value),
+    };
+}
+function parseMetricDayRow(value, label) {
+    const record = requireRecord(value, label);
+    return {
+        attributes: requireRecord(record.attributes, `${label}.attributes`),
+        confidence: requireConfidenceLevel(record.confidence, `${label}.confidence`),
+        date: requireString(record.date, `${label}.date`),
+        domain: requireMetricDomain(record.domain, `${label}.domain`),
+        id: requireString(record.id, `${label}.id`),
+        metricIds: requireStringArray(record.metricIds, `${label}.metricIds`),
+        metrics: parseMetricMap(record.metrics, `${label}.metrics`),
+        notes: requireStringArray(record.notes, `${label}.notes`),
+    };
+}
+function parseTimelineRow(value, label) {
+    const record = requireRecord(value, label);
+    return {
+        date: requireString(record.date, `${label}.date`),
+        entityId: requireString(record.entityId, `${label}.entityId`),
+        entryType: requireTimelineEntryType(record.entryType, `${label}.entryType`),
+        family: requireString(record.family, `${label}.family`),
+        id: requireString(record.id, `${label}.id`),
+        kind: requireString(record.kind, `${label}.kind`),
+        occurredAt: requireString(record.occurredAt, `${label}.occurredAt`),
+        stream: readNullableString(record.stream),
+        tags: requireStringArray(record.tags, `${label}.tags`),
+        title: requireString(record.title, `${label}.title`),
+    };
+}
+function parseSearchRow(value, label) {
+    const record = requireRecord(value, label);
+    return {
+        date: readNullableString(record.date),
+        entityId: requireString(record.entityId, `${label}.entityId`),
+        family: requireString(record.family, `${label}.family`),
+        id: requireString(record.id, `${label}.id`),
+        kind: requireString(record.kind, `${label}.kind`),
+        occurredAt: readNullableString(record.occurredAt),
+        tags: requireStringArray(record.tags, `${label}.tags`),
+        text: requireString(record.text, `${label}.text`),
+        title: readNullableString(record.title),
+    };
+}
+function parseSourceHealthRow(value, label) {
+    const record = requireRecord(value, label);
+    return {
+        activityDays: requireNonNegativeInteger(record.activityDays, `${label}.activityDays`),
+        bodyStateDays: requireNonNegativeInteger(record.bodyStateDays, `${label}.bodyStateDays`),
+        conflictCount: requireNonNegativeInteger(record.conflictCount, `${label}.conflictCount`),
+        firstDate: readNullableString(record.firstDate),
+        lastDate: readNullableString(record.lastDate),
+        latestRecordedAt: readNullableString(record.latestRecordedAt),
+        provider: requireString(record.provider, `${label}.provider`),
+        providerDisplayName: requireString(record.providerDisplayName, `${label}.providerDisplayName`),
+        recoveryDays: requireNonNegativeInteger(record.recoveryDays, `${label}.recoveryDays`),
+        selectedMetrics: requireNonNegativeInteger(record.selectedMetrics, `${label}.selectedMetrics`),
+        sleepNights: requireNonNegativeInteger(record.sleepNights, `${label}.sleepNights`),
+        stalenessVsNewestDays: readNullableNonNegativeInteger(record.stalenessVsNewestDays, `${label}.stalenessVsNewestDays`),
+    };
+}
+function parseWeeklySampleSummary(value, label) {
+    const record = requireRecord(value, label);
+    return {
+        date: requireString(record.date, `${label}.date`),
+        numericSampleCount: requireNonNegativeInteger(record.numericSampleCount, `${label}.numericSampleCount`),
+        sampleCount: requireNonNegativeInteger(record.sampleCount, `${label}.sampleCount`),
+        stream: requireString(record.stream, `${label}.stream`),
+        sumValue: readNullableFiniteNumber(record.sumValue),
+        unit: readNullableString(record.unit),
+    };
+}
+function parseAssistantSummary(value, label) {
+    const record = requireRecord(value, label);
+    return {
+        highlights: requireStringArray(record.highlights, `${label}.highlights`),
+        latestDate: readNullableString(record.latestDate),
+    };
+}
+function parseMetricMap(value, label) {
+    const record = requireRecord(value, label);
+    const output = {};
+    for (const [key, metricValue] of Object.entries(record)) {
+        output[key] = parseResolvedMetric(metricValue, `${label}.${key}`);
+    }
+    return output;
+}
+function parseResolvedMetric(value, label) {
+    const record = requireRecord(value, label);
+    const selection = requireRecord(record.selection, `${label}.selection`);
+    return {
+        selection: {
+            unit: readNullableString(selection.unit),
+            value: readNullableFiniteNumber(selection.value),
+        },
+    };
+}
+function cloneMetricMap(metrics) {
+    const output = {};
+    for (const [key, value] of Object.entries(metrics)) {
+        output[key] = {
+            selection: {
+                unit: value.selection.unit,
+                value: value.selection.value,
+            },
+        };
+    }
+    return output;
+}
+function requireRecord(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new TypeError(`${label} must be an object.`);
+    }
+    return value;
+}
+function requireArray(value, label) {
+    if (!Array.isArray(value)) {
+        throw new TypeError(`${label} must be an array.`);
+    }
+    return value.slice();
+}
+function requireString(value, label) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new TypeError(`${label} must be a non-empty string.`);
+    }
+    return value;
+}
+function requireStringArray(value, label) {
+    return requireArray(value, label).map((entry, index) => requireString(entry, `${label}[${index}]`));
+}
+function requireFiniteNumber(value, label) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new TypeError(`${label} must be a finite number.`);
+    }
+    return value;
+}
+function readNullableFiniteNumber(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    return requireFiniteNumber(value, "nullable number");
+}
+function requireNonNegativeInteger(value, label) {
+    const parsed = requireFiniteNumber(value, label);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new TypeError(`${label} must be a non-negative integer.`);
+    }
+    return parsed;
+}
+function readNullableNonNegativeInteger(value, label) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    return requireNonNegativeInteger(value, label);
+}
+function readNullableString(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeof value !== "string") {
+        throw new TypeError("Expected nullable string.");
+    }
+    return value;
+}
+function requireIsoDateTime(value, label) {
+    const text = requireString(value, label);
+    const parsed = Date.parse(text);
+    if (Number.isNaN(parsed)) {
+        throw new TypeError(`${label} must be an ISO timestamp.`);
+    }
+    return text;
+}
+function requireRecordClass(value, label) {
+    const text = requireString(value, label);
+    if (text === "bank" || text === "ledger" || text === "sample" || text === "snapshot") {
+        return text;
+    }
+    throw new TypeError(`${label} must be a canonical record class.`);
+}
+function requireMetricDomain(value, label) {
+    const text = requireString(value, label);
+    if (text === "activity" || text === "body_state" || text === "recovery" || text === "sleep") {
+        return text;
+    }
+    throw new TypeError(`${label} must be a browser vault metric domain.`);
+}
+function requireConfidenceLevel(value, label) {
+    const text = requireString(value, label);
+    if (text === "none" || text === "low" || text === "medium" || text === "high") {
+        return text;
+    }
+    throw new TypeError(`${label} must be a wearable confidence level.`);
+}
+function requireTimelineEntryType(value, label) {
+    const text = requireString(value, label);
+    if (text === "assessment" || text === "event" || text === "journal" || text === "sample_summary") {
+        return text;
+    }
+    throw new TypeError(`${label} must be a timeline entry type.`);
+}
+function previewText(value, limit) {
+    if (!value) {
+        return null;
+    }
+    const normalized = value.replace(/\s+/gu, " ").trim();
+    if (normalized.length <= limit) {
+        return normalized;
+    }
+    return `${normalized.slice(0, Math.max(0, limit - 1)).trim()}…`;
+}
+function uniqueStrings(values) {
+    return [...new Set(values.filter((value) => typeof value === "string" && value.length > 0))];
+}
+function readStringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === "string")
+        : [];
+}
+function cloneRecord(value) {
+    const output = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (isBrowserSafeJson(entry)) {
+            output[key] = cloneJson(entry);
+        }
+    }
+    return output;
+}
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function isBrowserSafeJson(value) {
+    if (value === null) {
+        return true;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return value.every(isBrowserSafeJson);
+    }
+    if (typeof value === "object") {
+        return Object.values(value).every(isBrowserSafeJson);
+    }
+    return false;
+}
+function normalizeSearch(value) {
+    return value.trim().toLowerCase();
+}
+function subtractDaysFromIsoDate(value, days) {
+    const parsed = new Date(`${value}T00:00:00.000Z`);
+    if (Number.isNaN(parsed.valueOf())) {
+        throw new TypeError("Browser vault replica generatedAt date must be a valid ISO date.");
+    }
+    parsed.setUTCDate(parsed.getUTCDate() - days);
+    return parsed.toISOString().slice(0, 10);
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(",")}]`;
+    }
+    return `{${Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify(entry)}`)
+        .join(",")}}`;
+}
+export { buildOverviewWeeklyStatsFromDailySampleSummaries, isActiveOverviewExperimentStatus, };
+//# sourceMappingURL=browser-replica.js.map