@murphai/murph 1.2.0 → 1.2.4

package/node_modules/@murphai/importers/dist/device-providers/junction.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { extractIsoDatePrefix, ID_PREFIXES, MEAL_MICRONUTRIENT_KEYS, toLocalDayKey, } from "@murphai/contracts";
+import { extractIsoDatePrefix, ID_PREFIXES, MEAL_MICRONUTRIENT_KEYS, parseCompanionHrvRmssdAdmissionId, parseCompanionHrvRmssdObservation, serializeCompanionHrvRmssdObservation, toLocalDayKey, } from "@murphai/contracts";
 import { deterministicContractId } from "@murphai/core";
 import { z } from "zod";
 import { stripUndefined } from "../shared.js";
@@ -16,7 +16,12 @@ const junctionSnapshotSchema = z.object({
     connections: z.array(z.unknown()).optional(),
     summaries: z.record(z.string(), z.unknown()).optional(),
     timeseries: z.record(z.string(), z.unknown()).optional(),
+    companionHrvRmssd: z.array(z.unknown()).max(100).optional(),
 }).catchall(z.unknown());
+const junctionCompanionHrvRmssdSnapshotEntrySchema = z.object({
+    admissionId: z.unknown(),
+    observation: z.unknown(),
+}).strict();
 const SUMMARY_RESOURCE_ALLOWLIST = new Set(JUNCTION_ALLOWED_SUMMARY_RESOURCES);
 const TIMESERIES_RESOURCE_ALLOWLIST = new Set(JUNCTION_ALLOWED_TIMESERIES_RESOURCES);
 const FLOATING_TIMESTAMP_SOURCE_PROVIDER_SLUGS = new Set([
@@ -96,6 +101,15 @@ const SLEEP_METRICS = [
     { metric: "temperature", unit: "celsius", title: "Junction sleep skin temperature", paths: JUNCTION_SLEEP_TEMPERATURE_PATHS },
     { metric: "temperature-deviation", unit: "celsius", title: "Junction sleep temperature delta", paths: JUNCTION_SLEEP_TEMPERATURE_DEVIATION_PATHS },
 ];
+const SLEEP_STAGE_METRIC_NAMES = new Set([
+    "sleep-awake-minutes",
+    "sleep-light-minutes",
+    "sleep-deep-minutes",
+    "sleep-rem-minutes",
+]);
+const SLEEP_STAGE_METRICS = SLEEP_METRICS.filter((metric) => SLEEP_STAGE_METRIC_NAMES.has(metric.metric));
+const SLEEP_NON_STAGE_METRICS = SLEEP_METRICS.filter((metric) => !SLEEP_STAGE_METRIC_NAMES.has(metric.metric));
+const SLEEP_SUMMARY_OWNER_METRICS = SLEEP_METRICS.filter((metric) => metric.metric === "sleep-total-minutes" || SLEEP_STAGE_METRIC_NAMES.has(metric.metric));
 const WORKOUT_SESSION_METRICS = [
     { key: "activeCalories", nonnegative: true, paths: ["activeCalories", "active_calories", "calories"] },
     { key: "totalCalories", nonnegative: true, paths: ["totalCalories", "total_calories"] },
@@ -133,6 +147,30 @@ const JUNCTION_GENERIC_SUMMARY_ID_PATHS = [
     "providerId",
     "provider_id",
 ];
+const JUNCTION_RECORD_TIMESTAMP_PATHS = [
+    "observedAtRaw",
+    "observed_at_raw",
+    "observedAt",
+    "observed_at",
+    "timestamp",
+    "time",
+    "date",
+    "day",
+    "end",
+    "endAt",
+    "end_at",
+    "timeEnd",
+    "time_end",
+    "bedtimeStop",
+    "bedtime_stop",
+    "start",
+    "startAt",
+    "start_at",
+    "timeStart",
+    "time_start",
+    "bedtimeStart",
+    "bedtime_start",
+];
 const JUNCTION_MEAL_PROVIDER_ID_PATHS = [
     "mealId",
     "meal_id",
@@ -363,9 +401,9 @@ const JUNCTION_STRESS_LEVEL_VALUE_PATHS = [
     "stress_level_value",
     "score",
 ];
-// Junction's hrv timeseries is rmssd-defined ("HRV calculated using rmssd
-// during sleep"); explicit SDNN keys are deliberately not read here so SDNN
-// values never mix into the rmssd-semantics `hrv` metric.
+// Junction's generic hrv timeseries is RMSSD-defined for wearable providers,
+// while HealthKit's HRV quantity is SDNN. Source-aware metric selection below
+// keeps Apple Health observations out of the RMSSD series.
 const JUNCTION_HRV_VALUE_PATHS = [
     "value",
     "hrv",
@@ -482,8 +520,54 @@ const JUNCTION_SLEEP_STAGE_TYPE_ARRAY_PATHS = [
     "sleepStageType",
     "sleep_stage_type",
 ];
+const JUNCTION_SLEEP_COVERAGE_START_TIMESTAMP_PATHS = [
+    ...JUNCTION_SLEEP_START_TIMESTAMP_PATHS,
+    "sessionStart",
+    "session_start",
+];
+const JUNCTION_SLEEP_COVERAGE_END_TIMESTAMP_PATHS = [
+    ...JUNCTION_SLEEP_END_TIMESTAMP_PATHS,
+    "sessionEnd",
+    "session_end",
+];
+const SLEEP_STAGE_COVERAGE_TOLERANCE_MS = 1000;
+const JUNCTION_SLEEP_STAGES = ["awake", "light", "deep", "rem"];
+const APPLE_HEALTH_KIT_SOURCE_PROVIDER_SLUG = "apple-health-kit";
+const HRV_RMSSD_METRIC = "hrv-rmssd";
+const HRV_SDNN_METRIC = "hrv-sdnn";
+const SLEEP_ZEROED_SUMMARY_SUPPRESSED_METRIC_NAMES = new Set([
+    "sleep-total-minutes",
+    "sleep-efficiency",
+    "sleep-light-minutes",
+    "sleep-deep-minutes",
+    "sleep-rem-minutes",
+]);
+const SLEEP_ASLEEP_STAGE_METRIC_NAMES = new Set([
+    "sleep-light-minutes",
+    "sleep-deep-minutes",
+    "sleep-rem-minutes",
+]);
+const JUNCTION_SLEEP_STAGE_SUMMARY_NORMALIZER_VERSION = "junction-sleep-stage-summary.v1";
+const JUNCTION_SLEEP_STAGE_CYCLE_FALLBACK_NORMALIZER_VERSION = "junction-sleep-stage-cycle-fallback.v1";
+const JUNCTION_SLEEP_UNSPECIFIED_TOTAL_NORMALIZER_VERSION = "junction-sleep-unspecified-total.v1";
 function parseJunctionSnapshot(snapshot) {
-    return junctionSnapshotSchema.parse(snapshot);
+    const parsed = junctionSnapshotSchema.parse(snapshot);
+    return {
+        ...parsed,
+        companionHrvRmssd: parsed.companionHrvRmssd?.map((entry) => parseJunctionCompanionHrvRmssdSnapshotEntry(entry)),
+    };
+}
+function parseJunctionCompanionHrvRmssdSnapshotEntry(value) {
+    const parsed = junctionCompanionHrvRmssdSnapshotEntrySchema.parse(value);
+    const admissionId = parseCompanionHrvRmssdAdmissionId(parsed.admissionId);
+    const observation = parseCompanionHrvRmssdObservation(parsed.observation);
+    const expectedAdmissionId = createHash("sha256")
+        .update(serializeCompanionHrvRmssdObservation(observation))
+        .digest("hex");
+    if (admissionId !== expectedAdmissionId) {
+        throw new TypeError("Companion HRV admission identity did not match its observation.");
+    }
+    return { admissionId, observation };
 }
 export function normalizeJunctionSnapshot(snapshot, providerContext = {}) {
     const importedAt = normalizeTimestamp(snapshot.importedAt);
@@ -492,6 +576,7 @@ export function normalizeJunctionSnapshot(snapshot, providerContext = {}) {
     const evidenceParts = [];
     const events = [];
     const samples = [];
+    const companionHrvRmssd = snapshot.companionHrvRmssd?.map((entry) => parseJunctionCompanionHrvRmssdSnapshotEntry(entry));
     const connections = asArray(snapshot.connections).flatMap((connection) => {
         const normalized = asPlainObject(connection);
         return normalized ? [normalized] : [];
@@ -508,6 +593,7 @@ export function normalizeJunctionSnapshot(snapshot, providerContext = {}) {
     };
     normalizeSummaries(snapshot.summaries, context);
     normalizeTimeseries(snapshot.timeseries, context);
+    normalizeCompanionHrvRmssd(companionHrvRmssd, context);
     return makeNormalizedDeviceBatch({
         provider: "junction",
         accountId: stringId(snapshot.accountId),
@@ -523,11 +609,128 @@ export function normalizeJunctionSnapshot(snapshot, providerContext = {}) {
             connections: connections.length,
             summaryResources: listAllowedResourceKeys(snapshot.summaries, SUMMARY_RESOURCE_ALLOWLIST),
             timeseriesResources: listAllowedResourceKeys(snapshot.timeseries, TIMESERIES_RESOURCE_ALLOWLIST),
+            companionHrvRmssdObservations: companionHrvRmssd?.length ?? 0,
         }),
     });
 }
+export function classifyJunctionSummaryNormalizationEvidence(snapshot, evidenceWindow) {
+    const evidenceRange = evidenceWindow
+        ? {
+            endMs: Date.parse(evidenceWindow.windowEnd),
+            startMs: Date.parse(evidenceWindow.windowStart),
+        }
+        : null;
+    if (evidenceRange
+        && (!Number.isFinite(evidenceRange.startMs)
+            || !Number.isFinite(evidenceRange.endMs)
+            || evidenceRange.startMs >= evidenceRange.endMs)) {
+        return [];
+    }
+    const evidenceByKey = new Map();
+    for (const [resource, payload] of allowedResourceEntries(snapshot.summaries, SUMMARY_RESOURCE_ALLOWLIST)) {
+        const normalized = normalizeJunctionSnapshot({
+            connections: snapshot.connections,
+            importedAt: snapshot.importedAt,
+            summaries: { [resource]: payload },
+            windowEnd: snapshot.windowEnd,
+            windowStart: snapshot.windowStart,
+        });
+        for (const event of normalized.events ?? []) {
+            if (evidenceRange
+                && !isJunctionSummaryEvidenceEventInRange(event, evidenceRange)) {
+                continue;
+            }
+            const sourceProviderSlug = normalizeJunctionSourceProviderSlug(event.dataOrigin?.sourceProviderSlug);
+            if (!sourceProviderSlug) {
+                continue;
+            }
+            const summaryResource = resource;
+            const key = `${summaryResource}\u0000${sourceProviderSlug}`;
+            evidenceByKey.set(key, {
+                resource: summaryResource,
+                sourceProviderSlug,
+            });
+        }
+    }
+    return [...evidenceByKey.values()].sort((left, right) => left.resource.localeCompare(right.resource)
+        || left.sourceProviderSlug.localeCompare(right.sourceProviderSlug));
+}
+function isJunctionSummaryEvidenceEventInRange(event, evidenceRange) {
+    const occurredAtMs = Date.parse(event.occurredAt);
+    if (Number.isFinite(occurredAtMs)
+        && occurredAtMs >= evidenceRange.startMs
+        && occurredAtMs < evidenceRange.endMs) {
+        return true;
+    }
+    // Daily summaries and overnight sessions can canonically occur at or after
+    // the UTC window end while still belonging to its final calendar day. The
+    // importer-owned dayKey is the stable ownership signal for that case; a
+    // connection-day record has the next dayKey and remains outside the window.
+    if (typeof event.dayKey !== "string" || !isDateOnlyJunctionTimestamp(event.dayKey)) {
+        return false;
+    }
+    const dayStartMs = Date.parse(`${event.dayKey}T00:00:00.000Z`);
+    return Number.isFinite(dayStartMs)
+        && dayStartMs >= evidenceRange.startMs
+        && dayStartMs < evidenceRange.endMs;
+}
+function normalizeCompanionHrvRmssd(entries, context) {
+    for (const { admissionId, observation } of entries ?? []) {
+        const contentVersion = `${observation.methodVersion}:${createHash("sha256")
+            .update(serializeCompanionHrvRmssdObservation(observation))
+            .digest("hex")}`;
+        const identity = createHash("sha256")
+            .update(admissionId)
+            .digest("hex")
+            .slice(0, 16);
+        const evidenceRole = `companion-hrv-rmssd:${identity}`;
+        pushEvidencePart(context.evidenceParts, createEvidencePart(evidenceRole, `companion-hrv-rmssd-${identity}.json`, observation));
+        context.events.push({
+            kind: "observation",
+            occurredAt: observation.observedAt,
+            dayKey: resolveVaultLocalDayKey(observation.observedAt, context.defaultTimeZone)
+                ?? extractIsoDatePrefix(observation.observedAt)
+                ?? undefined,
+            source: "device",
+            title: "WHOOP BLE spot RMSSD",
+            evidenceRoles: [evidenceRole],
+            externalRef: makeProviderExternalRef("whoop", "ble-hrv-rmssd", admissionId, contentVersion, HRV_RMSSD_METRIC),
+            externalRefUpdatePolicy: "immutable",
+            dataOrigin: {
+                version: 1,
+                aggregatorProvider: "murph-companion",
+                sourceProviderSlug: "whoop",
+                sourceType: "ble-pulse-interval",
+                observedAtRaw: observation.observedAt,
+                timestampSemantics: "utc",
+                originConfidence: observation.quality === "good" ? "medium" : "low",
+                normalizerVersion: "companion-hrv-rmssd-normalizer.v1",
+            },
+            fields: {
+                metric: HRV_RMSSD_METRIC,
+                observationGrain: "derived_fact",
+                value: observation.rmssdMs,
+                unit: "ms",
+            },
+        });
+    }
+}
+export function canNormalizeJunctionSleepCycleRecordToCompactStages(record, sourceProviderSlug) {
+    const entries = resourceEntries(record, "sleep_cycle");
+    return entries.length > 0 && entries.every(({ entry }) => {
+        if (!hasSleepCycleCompactParentIdentity(entry, sourceProviderSlug)) {
+            return false;
+        }
+        const coverageWindow = resolveSleepStageCoverageWindow(entry, sourceProviderSlug);
+        return coverageWindow
+            ? sleepStageCoverageIntervalsCoverWindow(collectSleepStageCoverageIntervals(entry, sourceProviderSlug), coverageWindow)
+            : false;
+    });
+}
 function normalizeSummaries(summaries, context) {
-    for (const [resource, payload] of allowedResourceEntries(summaries, SUMMARY_RESOURCE_ALLOWLIST)) {
+    const summaryEntries = allowedResourceEntries(summaries, SUMMARY_RESOURCE_ALLOWLIST);
+    const sleepSummaryMetricOwners = collectJunctionSleepSummaryMetricOwners(summaryEntries, context);
+    for (const [resource, payload] of summaryEntries) {
         const entries = resourceEntries(payload, resource);
         const resourceSlug = slugify(resource, "summary");
         const evidencePartRole = `junction-summary-${resourceSlug}`;
@@ -541,7 +744,7 @@ function normalizeSummaries(summaries, context) {
             })
             : new Map();
         pushEvidencePart(context.evidenceParts, createEvidencePart(evidencePartRole, `${evidencePartRole}.json`, buildRawResourcePayload(resource, payload, context.connectionsByKey)));
-        entries.forEach(({ entry, originFallback }, index) => {
+        const resolvedEntries = entries.flatMap(({ entry, originFallback }, index) => {
             const resourceContext = buildResourceContext({
                 entry,
                 originFallback,
@@ -554,8 +757,15 @@ function normalizeSummaries(summaries, context) {
                 context,
             });
             if (!resourceContext) {
-                return;
+                return [];
             }
+            return [{ entry, resourceContext }];
+        });
+        if (resource === "sleep_cycle") {
+            pushSleepCycleEntries(resolvedEntries, context, sleepSummaryMetricOwners);
+            continue;
+        }
+        resolvedEntries.forEach(({ entry, resourceContext }) => {
             switch (resource) {
                 case "activity":
                     pushObservationMetrics(entry, resourceContext, context, ACTIVITY_METRICS);
@@ -566,9 +776,6 @@ function normalizeSummaries(summaries, context) {
                 case "sleep":
                     pushSleepSummary(entry, resourceContext, context);
                     break;
-                case "sleep_cycle":
-                    pushSleepCycle(entry, resourceContext, context);
-                    break;
                 case "workouts":
                     pushWorkoutSummary(entry, resourceContext, context);
                     break;
@@ -588,6 +795,55 @@ function normalizeSummaries(summaries, context) {
         });
     }
 }
+function collectJunctionSleepSummaryMetricOwners(summaryEntries, context) {
+    const sleepEntry = summaryEntries.find(([resource]) => resource === "sleep");
+    if (!sleepEntry) {
+        return [];
+    }
+    const [resource, payload] = sleepEntry;
+    const resourceSlug = slugify(resource, "summary");
+    const evidencePartRole = `junction-summary-${resourceSlug}`;
+    const owners = [];
+    resourceEntries(payload, resource).forEach(({ entry, originFallback }, index) => {
+        const resourceContext = buildResourceContext({
+            entry,
+            originFallback,
+            resource,
+            resourceSlug,
+            identityKind: "summary",
+            index,
+            fallbackArtifactRole: evidencePartRole,
+            context,
+        });
+        if (!resourceContext) {
+            return;
+        }
+        const startAt = resolveSafeTimestamp(firstValueFromPaths(entry, JUNCTION_SLEEP_START_TIMESTAMP_PATHS), resourceContext.sourceProviderSlug);
+        const endAt = resolveSafeTimestamp(firstValueFromPaths(entry, JUNCTION_SLEEP_END_TIMESTAMP_PATHS), resourceContext.sourceProviderSlug);
+        if (!startAt || !endAt) {
+            return;
+        }
+        const durationMinutes = resolveSleepSummaryDurationMinutes(entry, startAt, endAt);
+        const zeroedSummary = isZeroedAppleHealthKitSleepSummary(entry, resourceContext, durationMinutes);
+        for (const metric of SLEEP_SUMMARY_OWNER_METRICS) {
+            if (zeroedSummary && SLEEP_ZEROED_SUMMARY_SUPPRESSED_METRIC_NAMES.has(metric.metric)) {
+                continue;
+            }
+            if (!resolveMetricDescriptorValue(entry, metric)) {
+                continue;
+            }
+            owners.push(stripUndefined({
+                endAt,
+                metric: metric.metric,
+                sourceInstanceId: resourceContext.origin.sourceInstanceId ?? undefined,
+                sourceProviderSlug: resourceContext.sourceProviderSlug,
+                sourceType: resourceContext.origin.sourceType,
+                startAt,
+            }));
+        }
+    });
+    return owners;
+}
 function buildJunctionMealFallbackIdentityDisambiguators(input) {
     const fallbackRecords = [];
     input.entries.forEach(({ entry, originFallback }, index) => {
@@ -984,6 +1240,7 @@ function withJunctionCompactTimeseriesMetadata(resource, artifact, resourceCateg
     };
 }
 function pushJunctionDailyTimeseriesObservation(context, aggregate, observation) {
+    const metric = resolveJunctionHrvMetric(observation.metric, aggregate.resourceContext.sourceProviderSlug);
     const timestamp = withTimestampOverride(aggregate.timestamp, {
         occurredAt: aggregate.lastSampleAt,
         recordedAt: aggregate.lastRecordedAt,
@@ -998,13 +1255,13 @@ function pushJunctionDailyTimeseriesObservation(context, aggregate, observation)
         dayKey: aggregate.dayKey,
         timeZone: aggregate.timeZone,
         source: "device",
-        title: observation.title,
+        title: resolveJunctionHrvTitle(metric, observation.title),
         evidenceRoles: [aggregate.evidencePartRole],
         externalRef: makeJunctionExternalRef(aggregate.resourceContext, aggregate.entry, timestamp, observation.metric),
         legacyExternalRefs: legacyExternalRefs.length > 0 ? legacyExternalRefs : undefined,
         dataOrigin: buildDataOrigin(aggregate.entry, aggregate.resourceContext, timestamp),
         fields: {
-            metric: observation.metric,
+            metric,
             observationGrain: "summary",
             value: roundJunctionDailyAggregateValue(observation.value),
             unit: observation.unit,
@@ -1227,13 +1484,11 @@ function pushSleepSummary(entry, resourceContext, context) {
     const timestamp = resolveRecordTimestamp(entry, context, resourceContext.sourceProviderSlug);
     const startAt = resolveSafeTimestamp(firstValueFromPaths(entry, JUNCTION_SLEEP_START_TIMESTAMP_PATHS), resourceContext.sourceProviderSlug);
     const endAt = resolveSafeTimestamp(firstValueFromPaths(entry, JUNCTION_SLEEP_END_TIMESTAMP_PATHS), resourceContext.sourceProviderSlug);
-    const durationMinutes = normalizePositiveIntegerMinutes(firstNumberFromPaths(entry, JUNCTION_SLEEP_DURATION_MINUTE_PATHS)) ??
-        normalizePositiveIntegerMinutes(secondsToMinutes(firstNumberFromPaths(entry, JUNCTION_SLEEP_DURATION_SECOND_PATHS))) ??
-        normalizePositiveIntegerMinutes(millisecondsToMinutes(firstNumberFromPaths(entry, JUNCTION_SLEEP_DURATION_MILLISECOND_PATHS))) ??
-        normalizePositiveIntegerMinutes(minutesBetween(startAt, endAt));
+    const durationMinutes = resolveSleepSummaryDurationMinutes(entry, startAt, endAt);
     const sleepTimestamp = withTimestampOverride(timestamp, {
         occurredAt: endAt ?? startAt ?? timestamp.occurredAt,
     });
+    const zeroedSummary = isZeroedAppleHealthKitSleepSummary(entry, resourceContext, durationMinutes);
     if (startAt && endAt && durationMinutes !== undefined) {
         const occurredAt = sleepTimestamp.occurredAt ?? startAt;
         context.events.push(stripUndefined({
@@ -1254,13 +1509,584 @@ function pushSleepSummary(entry, resourceContext, context) {
             },
         }));
     }
-    pushObservationMetrics(entry, resourceContext, context, SLEEP_METRICS, sleepTimestamp);
+    pushObservationMetrics(entry, resourceContext, context, zeroedSummary
+        ? SLEEP_NON_STAGE_METRICS.filter((metric) => !SLEEP_ZEROED_SUMMARY_SUPPRESSED_METRIC_NAMES.has(metric.metric))
+        : SLEEP_NON_STAGE_METRICS, sleepTimestamp);
+    pushSleepSummaryStageMetrics(entry, resourceContext, context, sleepTimestamp, startAt, endAt, zeroedSummary);
     pushJunctionRecoveryReadinessScore(entry, resourceContext, context, sleepTimestamp);
 }
-function pushSleepCycle(entry, resourceContext, context) {
+function resolveSleepSummaryDurationMinutes(entry, startAt, endAt) {
+    return normalizePositiveIntegerMinutes(firstNumberFromPaths(entry, JUNCTION_SLEEP_DURATION_MINUTE_PATHS)) ??
+        normalizePositiveIntegerMinutes(secondsToMinutes(firstNumberFromPaths(entry, JUNCTION_SLEEP_DURATION_SECOND_PATHS))) ??
+        normalizePositiveIntegerMinutes(millisecondsToMinutes(firstNumberFromPaths(entry, JUNCTION_SLEEP_DURATION_MILLISECOND_PATHS))) ??
+        normalizePositiveIntegerMinutes(minutesBetween(startAt, endAt));
+}
+function isZeroedAppleHealthKitSleepSummary(entry, resourceContext, durationMinutes) {
+    if (normalizeJunctionSourceProviderSlug(resourceContext.sourceProviderSlug) !== APPLE_HEALTH_KIT_SOURCE_PROVIDER_SLUG) {
+        return false;
+    }
+    const totalMinutes = resolveSleepSummaryMetricValue(entry, "sleep-total-minutes");
+    const awakeMinutes = resolveSleepSummaryMetricValue(entry, "sleep-awake-minutes");
+    if (durationMinutes === undefined ||
+        totalMinutes !== 0 ||
+        awakeMinutes === undefined ||
+        awakeMinutes <= 0 ||
+        awakeMinutes >= durationMinutes - 1) {
+        return false;
+    }
+    return isSleepSummaryMetricMissingOrZero(entry, "sleep-efficiency") &&
+        isSleepSummaryMetricMissingOrZero(entry, "sleep-light-minutes") &&
+        isSleepSummaryMetricMissingOrZero(entry, "sleep-deep-minutes") &&
+        isSleepSummaryMetricMissingOrZero(entry, "sleep-rem-minutes");
+}
+function isSleepSummaryMetricMissingOrZero(entry, metricName) {
+    const value = resolveSleepSummaryMetricValue(entry, metricName);
+    return value === undefined || value === 0;
+}
+function resolveSleepSummaryMetricValue(entry, metricName) {
+    const metric = SLEEP_METRICS.find((candidate) => candidate.metric === metricName);
+    const resolved = metric ? resolveMetricDescriptorValue(entry, metric) : null;
+    return resolved?.value;
+}
+function pushSleepSummaryStageMetrics(entry, resourceContext, context, timestamp, startAt, endAt, zeroedSummary = false) {
+    const occurredAt = timestamp.occurredAt;
+    if (!occurredAt) {
+        return;
+    }
+    const timeZone = resolveSleepStageCanonicalTimeZone(entry);
+    const dayKey = startAt && endAt
+        ? resolveSleepStageAnchorDayKey(endAt, timeZone, timestamp)
+        : timestamp.dayKey ?? extractIsoDatePrefix(occurredAt) ?? undefined;
+    for (const metric of SLEEP_STAGE_METRICS) {
+        if (zeroedSummary && SLEEP_ASLEEP_STAGE_METRIC_NAMES.has(metric.metric)) {
+            continue;
+        }
+        const resolved = resolveMetricDescriptorValue(entry, metric);
+        if (!resolved) {
+            continue;
+        }
+        const externalRef = startAt && endAt
+            ? makeJunctionCanonicalSleepStageExternalRef(resourceContext, {
+                coverageEndAt: endAt,
+                coverageStartAt: startAt,
+                dayKey,
+                metric: metric.metric,
+                timeZone,
+            })
+            : makeJunctionExternalRef(resourceContext, entry, timestamp, metric.metric);
+        const legacyExternalRef = startAt && endAt
+            ? makeJunctionExternalRef(resourceContext, entry, timestamp, metric.metric)
+            : undefined;
+        context.events.push(stripUndefined({
+            kind: "observation",
+            occurredAt,
+            recordedAt: timestamp.recordedAt,
+            dayKey,
+            timeZone,
+            source: "device",
+            title: metric.title,
+            evidenceRoles: resourceContext.evidenceRoles,
+            externalRef,
+            legacyExternalRefs: legacyExternalRef ? [legacyExternalRef] : undefined,
+            dataOrigin: buildDataOrigin(entry, resourceContext, timestamp, {
+                normalizerVersion: JUNCTION_SLEEP_STAGE_SUMMARY_NORMALIZER_VERSION,
+            }),
+            fields: {
+                metric: metric.metric,
+                observationGrain: "summary",
+                value: resolved.value,
+                unit: resolved.unit,
+            },
+        }));
+    }
+}
+function resolveSleepStageCanonicalTimeZone(...entries) {
+    const explicitTimeZone = entries
+        .map((entry) => firstStringFromPaths(entry, ["timeZone", "timezone", "time_zone"]))
+        .find((timeZone) => timeZone !== undefined);
+    if (explicitTimeZone) {
+        return explicitTimeZone;
+    }
+    const hasOffsetOnlyEvidence = entries.some((entry) => {
+        const offsetSeconds = readJunctionTimeZoneOffsetSeconds(entry);
+        return offsetSeconds !== null && offsetSeconds !== undefined;
+    });
+    if (hasOffsetOnlyEvidence) {
+        return undefined;
+    }
+    return entries.some(hasUtcSleepStageWindow)
+        ? "UTC"
+        : undefined;
+}
+function hasUtcSleepStageWindow(entry) {
+    const rawStartAt = firstStringFromPaths(entry, JUNCTION_SLEEP_COVERAGE_START_TIMESTAMP_PATHS);
+    const rawEndAt = firstStringFromPaths(entry, JUNCTION_SLEEP_COVERAGE_END_TIMESTAMP_PATHS);
+    return inferTimestampSemantics(rawStartAt) === "utc" && inferTimestampSemantics(rawEndAt) === "utc";
+}
+function pushSleepCycleEntries(entries, context, sleepSummaryStageMetricOwners) {
+    const aggregates = new Map();
+    const totalAggregates = new Map();
+    for (const { entry, resourceContext } of entries) {
+        collectJunctionSleepStageAggregates(entry, resourceContext, context, aggregates, totalAggregates);
+    }
+    for (const aggregate of totalAggregates.values()) {
+        if (isSleepMetricOwnedBySleepSummary(aggregate, "sleep-total-minutes", sleepSummaryStageMetricOwners)) {
+            continue;
+        }
+        context.events.push(stripUndefined({
+            kind: "observation",
+            occurredAt: aggregate.endAt,
+            recordedAt: aggregate.recordedAt,
+            dayKey: aggregate.timestamp.dayKey,
+            timeZone: aggregate.timeZone,
+            source: "device",
+            title: "Junction total sleep",
+            evidenceRoles: aggregate.resourceContext.evidenceRoles,
+            externalRef: makeJunctionSleepAggregateExternalRef(aggregate.resourceContext, aggregate, "sleep-total-minutes"),
+            dataOrigin: buildDataOrigin(aggregate.dataOriginEntry, aggregate.resourceContext, aggregate.timestamp, {
+                normalizerVersion: JUNCTION_SLEEP_UNSPECIFIED_TOTAL_NORMALIZER_VERSION,
+            }),
+            fields: {
+                metric: "sleep-total-minutes",
+                observationGrain: "summary",
+                value: Number(aggregate.durationMinutes.toFixed(4)),
+                unit: "minutes",
+            },
+        }));
+    }
+    for (const aggregate of aggregates.values()) {
+        const metric = sleepStageMetricDescriptor(aggregate.stage);
+        if (isSleepMetricOwnedBySleepSummary(aggregate, metric.metric, sleepSummaryStageMetricOwners)) {
+            continue;
+        }
+        context.events.push(stripUndefined({
+            kind: "observation",
+            occurredAt: aggregate.endAt,
+            recordedAt: aggregate.recordedAt,
+            dayKey: aggregate.timestamp.dayKey,
+            timeZone: aggregate.timeZone,
+            source: "device",
+            title: metric.title,
+            evidenceRoles: aggregate.resourceContext.evidenceRoles,
+            externalRef: makeJunctionSleepAggregateExternalRef(aggregate.resourceContext, aggregate, metric.metric),
+            dataOrigin: buildDataOrigin(aggregate.dataOriginEntry, aggregate.resourceContext, aggregate.timestamp, {
+                normalizerVersion: JUNCTION_SLEEP_STAGE_CYCLE_FALLBACK_NORMALIZER_VERSION,
+            }),
+            fields: {
+                metric: metric.metric,
+                observationGrain: "summary",
+                value: Number(aggregate.durationMinutes.toFixed(4)),
+                unit: "minutes",
+            },
+        }));
+    }
+}
+function isSleepMetricOwnedBySleepSummary(aggregate, metric, sleepSummaryStageMetricOwners) {
+    return sleepSummaryStageMetricOwners.some((owner) => owner.metric === metric &&
+        sleepStageOwnerSourceMatchesAggregate(owner, aggregate) &&
+        sleepStageOwnerWindowMatchesAggregate(owner, aggregate));
+}
+function sleepStageOwnerSourceMatchesAggregate(owner, aggregate) {
+    if (owner.sourceProviderSlug !== aggregate.resourceContext.sourceProviderSlug) {
+        return false;
+    }
+    const aggregateSourceType = aggregate.resourceContext.origin.sourceType;
+    if (owner.sourceType !== aggregateSourceType) {
+        return false;
+    }
+    const aggregateSourceInstanceId = aggregate.resourceContext.origin.sourceInstanceId;
+    return owner.sourceInstanceId === aggregateSourceInstanceId;
+}
+function sleepStageOwnerWindowMatchesAggregate(owner, aggregate) {
+    return owner.startAt === aggregate.coverageStartAt &&
+        owner.endAt === aggregate.coverageEndAt;
+}
+function collectJunctionSleepStageAggregates(entry, resourceContext, context, aggregates, totalAggregates) {
     const parentTimestamp = resolveRecordTimestamp(entry, context, resourceContext.sourceProviderSlug);
-    for (const [index, intervalEntry] of sleepStageIntervalEntries(entry).entries()) {
-        const stage = firstSleepStageFromPaths(intervalEntry, JUNCTION_SLEEP_STAGE_VALUE_PATHS);
+    const intervals = collectJunctionSleepStageIntervals(entry, resourceContext, context, parentTimestamp);
+    const parentResourceId = resolveSleepCycleParentResourceId(resourceContext, entry, parentTimestamp);
+    const covered = collectCoveredSleepStageIntervals(entry, resourceContext, intervals);
+    if (!parentResourceId || !covered) {
+        return;
+    }
+    const buckets = new Map();
+    const entryAggregates = new Map();
+    const entryTotalAggregates = new Map();
+    const hasGenericAsleepStage = covered.intervals.some((interval) => interval.stage === "asleep_unspecified");
+    const hasDetailedAsleepStage = covered.intervals.some((interval) => isDetailedAsleepStage(interval.stage));
+    for (const interval of covered.intervals) {
+        const stageTimestamp = withTimestampOverride(interval.timestamp, {
+            occurredAt: covered.coverageWindow.endAt,
+            dayKey: resolveSleepStageAnchorDayKey(covered.coverageWindow.endAt, interval.timeZone, interval.timestamp, parentTimestamp),
+        });
+        const bucketKey = sleepStageBucketKey(resourceContext, covered.coverageWindow.startAt, covered.coverageWindow.endAt);
+        const totalAggregateKey = sleepTotalAggregateKey(resourceContext, covered.coverageWindow.startAt, covered.coverageWindow.endAt);
+        if (hasGenericAsleepStage && isSleepTotalStage(interval.stage)) {
+            addSleepTotalAggregateDuration(entryTotalAggregates, totalAggregateKey, {
+                coverageEndAt: covered.coverageWindow.endAt,
+                coverageStartAt: covered.coverageWindow.startAt,
+                dataOriginEntry: interval.dataOriginEntry,
+                durationMinutes: interval.durationMinutes,
+                endAt: covered.coverageWindow.endAt,
+                parentResourceId,
+                recordedAt: stageTimestamp.recordedAt,
+                resourceContext,
+                startAt: covered.coverageWindow.startAt,
+                timestamp: stageTimestamp,
+                timeZone: interval.timeZone,
+            });
+        }
+        if (interval.stage === "asleep_unspecified") {
+            continue;
+        }
+        const aggregateKey = sleepStageAggregateKey(resourceContext, interval.stage, covered.coverageWindow.startAt, covered.coverageWindow.endAt);
+        if (hasDetailedAsleepStage) {
+            const bucketCandidate = {
+                coverageEndAt: covered.coverageWindow.endAt,
+                coverageStartAt: covered.coverageWindow.startAt,
+                dataOriginEntry: interval.dataOriginEntry,
+                endAt: covered.coverageWindow.endAt,
+                parentResourceId,
+                recordedAt: stageTimestamp.recordedAt,
+                resourceContext,
+                startAt: covered.coverageWindow.startAt,
+                timestamp: stageTimestamp,
+                timeZone: interval.timeZone,
+            };
+            const existingBucket = buckets.get(bucketKey);
+            if (existingBucket) {
+                existingBucket.recordedAt = laterOptionalIsoTimestamp(existingBucket.recordedAt, stageTimestamp.recordedAt);
+                const preferredBucket = compareSleepStageBucketPreference(bucketCandidate, existingBucket) > 0
+                    ? { ...bucketCandidate, recordedAt: existingBucket.recordedAt }
+                    : existingBucket;
+                buckets.set(bucketKey, {
+                    ...preferredBucket,
+                    recordedAt: existingBucket.recordedAt,
+                    timestamp: withTimestampOverride(preferredBucket.timestamp, {
+                        recordedAt: existingBucket.recordedAt,
+                    }),
+                });
+            }
+            else {
+                buckets.set(bucketKey, bucketCandidate);
+            }
+        }
+        addSleepStageAggregateDuration(entryAggregates, aggregateKey, {
+            coverageEndAt: covered.coverageWindow.endAt,
+            coverageStartAt: covered.coverageWindow.startAt,
+            dataOriginEntry: interval.dataOriginEntry,
+            durationMinutes: interval.durationMinutes,
+            endAt: covered.coverageWindow.endAt,
+            parentResourceId,
+            recordedAt: stageTimestamp.recordedAt,
+            resourceContext,
+            stage: interval.stage,
+            startAt: covered.coverageWindow.startAt,
+            timestamp: stageTimestamp,
+            timeZone: interval.timeZone,
+        });
+    }
+    for (const bucket of buckets.values()) {
+        for (const stage of JUNCTION_SLEEP_STAGES) {
+            const aggregateKey = sleepStageAggregateKey(bucket.resourceContext, stage, bucket.coverageStartAt, bucket.coverageEndAt);
+            if (entryAggregates.has(aggregateKey)) {
+                continue;
+            }
+            entryAggregates.set(aggregateKey, {
+                coverageEndAt: bucket.coverageEndAt,
+                coverageStartAt: bucket.coverageStartAt,
+                dataOriginEntry: bucket.dataOriginEntry,
+                durationMinutes: 0,
+                endAt: bucket.endAt,
+                parentResourceId: bucket.parentResourceId,
+                recordedAt: bucket.recordedAt,
+                resourceContext: bucket.resourceContext,
+                stage,
+                startAt: bucket.startAt,
+                timestamp: bucket.timestamp,
+                timeZone: bucket.timeZone,
+            });
+        }
+    }
+    for (const aggregate of entryAggregates.values()) {
+        mergeSleepStageAggregateCandidate(aggregates, aggregate);
+    }
+    for (const aggregate of entryTotalAggregates.values()) {
+        mergeSleepTotalAggregateCandidate(totalAggregates, aggregate);
+    }
+}
+function sleepStageBucketKey(resourceContext, coverageStartAt, coverageEndAt) {
+    return [
+        resourceContext.externalRefResourceType,
+        resourceContext.sourceProviderSlug,
+        resourceContext.origin.sourceType,
+        resourceContext.origin.sourceInstanceId,
+        coverageStartAt,
+        coverageEndAt,
+    ].join("|");
+}
+function sleepStageAggregateKey(resourceContext, stage, coverageStartAt, coverageEndAt) {
+    return [
+        resourceContext.externalRefResourceType,
+        resourceContext.sourceProviderSlug,
+        resourceContext.origin.sourceType,
+        resourceContext.origin.sourceInstanceId,
+        coverageStartAt,
+        coverageEndAt,
+        stage,
+    ].join("|");
+}
+function sleepTotalAggregateKey(resourceContext, coverageStartAt, coverageEndAt) {
+    return [
+        resourceContext.externalRefResourceType,
+        resourceContext.sourceProviderSlug,
+        resourceContext.origin.sourceType,
+        resourceContext.origin.sourceInstanceId,
+        coverageStartAt,
+        coverageEndAt,
+        "sleep-total-minutes",
+    ].join("|");
+}
+function addSleepStageAggregateDuration(aggregates, aggregateKey, candidate) {
+    const existing = aggregates.get(aggregateKey);
+    if (!existing) {
+        aggregates.set(aggregateKey, candidate);
+        return;
+    }
+    const recordedAt = laterOptionalIsoTimestamp(existing.recordedAt, candidate.recordedAt);
+    const preferred = compareSleepStageAggregatePreference(candidate, existing) > 0 ? candidate : existing;
+    aggregates.set(aggregateKey, {
+        ...preferred,
+        durationMinutes: existing.durationMinutes + candidate.durationMinutes,
+        recordedAt,
+        timestamp: withTimestampOverride(preferred.timestamp, { recordedAt }),
+    });
+}
+function addSleepTotalAggregateDuration(aggregates, aggregateKey, candidate) {
+    const existing = aggregates.get(aggregateKey);
+    if (!existing) {
+        aggregates.set(aggregateKey, candidate);
+        return;
+    }
+    const recordedAt = laterOptionalIsoTimestamp(existing.recordedAt, candidate.recordedAt);
+    const preferred = compareSleepAggregatePreference(candidate, existing) > 0 ? candidate : existing;
+    aggregates.set(aggregateKey, {
+        ...preferred,
+        durationMinutes: existing.durationMinutes + candidate.durationMinutes,
+        recordedAt,
+        timestamp: withTimestampOverride(preferred.timestamp, { recordedAt }),
+    });
+}
+function mergeSleepStageAggregateCandidate(aggregates, candidate) {
+    const aggregateKey = sleepStageAggregateKey(candidate.resourceContext, candidate.stage, candidate.coverageStartAt, candidate.coverageEndAt);
+    const existing = aggregates.get(aggregateKey);
+    if (!existing) {
+        aggregates.set(aggregateKey, candidate);
+        return;
+    }
+    const recordedAt = laterOptionalIsoTimestamp(existing.recordedAt, candidate.recordedAt);
+    const preferred = compareSleepStageAggregatePreference(candidate, existing) > 0 ? candidate : existing;
+    aggregates.set(aggregateKey, {
+        ...preferred,
+        recordedAt,
+        timestamp: withTimestampOverride(preferred.timestamp, { recordedAt }),
+    });
+}
+function mergeSleepTotalAggregateCandidate(aggregates, candidate) {
+    const aggregateKey = sleepTotalAggregateKey(candidate.resourceContext, candidate.coverageStartAt, candidate.coverageEndAt);
+    const existing = aggregates.get(aggregateKey);
+    if (!existing) {
+        aggregates.set(aggregateKey, candidate);
+        return;
+    }
+    const recordedAt = laterOptionalIsoTimestamp(existing.recordedAt, candidate.recordedAt);
+    const preferred = compareSleepAggregatePreference(candidate, existing) > 0 ? candidate : existing;
+    aggregates.set(aggregateKey, {
+        ...preferred,
+        recordedAt,
+        timestamp: withTimestampOverride(preferred.timestamp, { recordedAt }),
+    });
+}
+function compareSleepStageBucketPreference(left, right) {
+    return compareSleepStageDisplayPreference({
+        dayKey: left.timestamp.dayKey,
+        parentResourceId: left.parentResourceId,
+        timeZone: left.timeZone,
+    }, {
+        dayKey: right.timestamp.dayKey,
+        parentResourceId: right.parentResourceId,
+        timeZone: right.timeZone,
+    });
+}
+function compareSleepStageAggregatePreference(left, right) {
+    return compareSleepAggregatePreference(left, right);
+}
+function compareSleepAggregatePreference(left, right) {
+    const durationPreference = Number(left.durationMinutes > 0) - Number(right.durationMinutes > 0);
+    if (durationPreference !== 0) {
+        return durationPreference;
+    }
+    return compareSleepStageDisplayPreference({
+        dayKey: left.timestamp.dayKey,
+        parentResourceId: left.parentResourceId,
+        timeZone: left.timeZone,
+    }, {
+        dayKey: right.timestamp.dayKey,
+        parentResourceId: right.parentResourceId,
+        timeZone: right.timeZone,
+    });
+}
+function compareSleepStageDisplayPreference(left, right) {
+    const timeZonePreference = sleepStageTimeZonePreference(left.timeZone) -
+        sleepStageTimeZonePreference(right.timeZone);
+    if (timeZonePreference !== 0) {
+        return timeZonePreference;
+    }
+    const timeZoneOrder = compareOptionalSleepStageDisplayValue(left.timeZone, right.timeZone);
+    if (timeZoneOrder !== 0) {
+        return timeZoneOrder;
+    }
+    const dayKeyOrder = compareOptionalSleepStageDisplayValue(left.dayKey, right.dayKey);
+    if (dayKeyOrder !== 0) {
+        return dayKeyOrder;
+    }
+    return compareOptionalSleepStageDisplayValue(left.parentResourceId, right.parentResourceId);
+}
+function isDetailedAsleepStage(stage) {
+    return stage === "light" || stage === "deep" || stage === "rem";
+}
+function isSleepTotalStage(stage) {
+    return stage !== "awake";
+}
+function sleepStageTimeZonePreference(timeZone) {
+    if (!timeZone) {
+        return 0;
+    }
+    return timeZone === "UTC" ? 1 : 2;
+}
+function compareOptionalSleepStageDisplayValue(left, right) {
+    const leftValue = left ?? "";
+    const rightValue = right ?? "";
+    if (leftValue === rightValue) {
+        return 0;
+    }
+    return leftValue < rightValue ? 1 : -1;
+}
+function collectCoveredSleepStageIntervals(entry, resourceContext, intervals) {
+    const coverageWindow = resolveSleepStageCoverageWindow(entry, resourceContext.sourceProviderSlug);
+    if (!coverageWindow || intervals.length === 0) {
+        return undefined;
+    }
+    const coveredIntervals = clipSleepStageIntervalsToWindow(intervals, coverageWindow);
+    return coveredIntervals ? { coverageWindow, intervals: coveredIntervals } : undefined;
+}
+function resolveSleepStageCoverageWindow(entry, sourceProviderSlug) {
+    const startAt = resolveSafeTimestamp(firstValueFromPaths(entry, JUNCTION_SLEEP_COVERAGE_START_TIMESTAMP_PATHS), sourceProviderSlug);
+    const endAt = resolveSafeTimestamp(firstValueFromPaths(entry, JUNCTION_SLEEP_COVERAGE_END_TIMESTAMP_PATHS), sourceProviderSlug);
+    if (!startAt || !endAt || Date.parse(endAt) <= Date.parse(startAt)) {
+        return undefined;
+    }
+    return { endAt, startAt };
+}
+function collectSleepStageCoverageIntervals(entry, sourceProviderSlug) {
+    return sleepStageIntervalEntries(entry, sourceProviderSlug).flatMap((intervalEntry) => {
+        const stage = firstSleepStageFromPaths(intervalEntry, JUNCTION_SLEEP_STAGE_VALUE_PATHS, sourceProviderSlug);
+        if (!stage) {
+            return [];
+        }
+        const startAt = resolveSafeTimestamp(firstValueFromPaths(intervalEntry, JUNCTION_SLEEP_START_TIMESTAMP_PATHS), sourceProviderSlug);
+        const endAt = resolveSafeTimestamp(firstValueFromPaths(intervalEntry, JUNCTION_SLEEP_END_TIMESTAMP_PATHS), sourceProviderSlug);
+        const durationMinutes = normalizePositiveMinutes(firstNumberFromPaths(intervalEntry, JUNCTION_SLEEP_STAGE_DURATION_MINUTE_PATHS)) ??
+            normalizePositiveMinutes(secondsToMinutes(firstNumberFromPaths(intervalEntry, JUNCTION_SLEEP_STAGE_DURATION_SECOND_PATHS))) ??
+            normalizePositiveMinutes(millisecondsToMinutes(firstNumberFromPaths(intervalEntry, JUNCTION_SLEEP_STAGE_DURATION_MILLISECOND_PATHS))) ??
+            exactPositiveMinutesBetween(startAt, endAt);
+        const resolvedStartAt = startAt ?? subtractMinutes(endAt, durationMinutes);
+        const resolvedEndAt = endAt ?? addMinutes(startAt, durationMinutes);
+        return resolvedStartAt && resolvedEndAt && durationMinutes !== undefined
+            ? [{ endAt: resolvedEndAt, startAt: resolvedStartAt }]
+            : [];
+    });
+}
+function sleepStageCoverageIntervalsCoverWindow(intervals, coverageWindow) {
+    const windowStartMs = Date.parse(coverageWindow.startAt);
+    const windowEndMs = Date.parse(coverageWindow.endAt);
+    if (!Number.isFinite(windowStartMs) || !Number.isFinite(windowEndMs) || windowEndMs <= windowStartMs) {
+        return false;
+    }
+    let coveredUntilMs = windowStartMs;
+    const orderedIntervals = [...intervals].sort((left, right) => Date.parse(left.startAt) - Date.parse(right.startAt));
+    for (const interval of orderedIntervals) {
+        const rawStartMs = Date.parse(interval.startAt);
+        const rawEndMs = Date.parse(interval.endAt);
+        if (!Number.isFinite(rawStartMs) || !Number.isFinite(rawEndMs)) {
+            continue;
+        }
+        const intervalStartMs = Math.max(rawStartMs, windowStartMs);
+        const intervalEndMs = Math.min(rawEndMs, windowEndMs);
+        if (intervalEndMs <= intervalStartMs) {
+            continue;
+        }
+        if (intervalStartMs - coveredUntilMs > SLEEP_STAGE_COVERAGE_TOLERANCE_MS) {
+            return false;
+        }
+        if (intervalStartMs < coveredUntilMs - SLEEP_STAGE_COVERAGE_TOLERANCE_MS) {
+            return false;
+        }
+        const clippedStartMs = Math.max(intervalStartMs, coveredUntilMs);
+        if (intervalEndMs <= clippedStartMs) {
+            continue;
+        }
+        coveredUntilMs = intervalEndMs;
+    }
+    return windowEndMs - coveredUntilMs <= SLEEP_STAGE_COVERAGE_TOLERANCE_MS;
+}
+function clipSleepStageIntervalsToWindow(intervals, coverageWindow) {
+    const windowStartMs = Date.parse(coverageWindow.startAt);
+    const windowEndMs = Date.parse(coverageWindow.endAt);
+    if (!Number.isFinite(windowStartMs) || !Number.isFinite(windowEndMs) || windowEndMs <= windowStartMs) {
+        return undefined;
+    }
+    let coveredUntilMs = windowStartMs;
+    const coveredIntervals = [];
+    const orderedIntervals = [...intervals].sort((left, right) => Date.parse(left.startAt) - Date.parse(right.startAt));
+    for (const interval of orderedIntervals) {
+        const rawStartMs = Date.parse(interval.startAt);
+        const rawEndMs = Date.parse(interval.endAt);
+        if (!Number.isFinite(rawStartMs) || !Number.isFinite(rawEndMs)) {
+            continue;
+        }
+        const intervalStartMs = Math.max(rawStartMs, windowStartMs);
+        const intervalEndMs = Math.min(rawEndMs, windowEndMs);
+        if (intervalEndMs <= intervalStartMs) {
+            continue;
+        }
+        if (intervalStartMs - coveredUntilMs > SLEEP_STAGE_COVERAGE_TOLERANCE_MS) {
+            return undefined;
+        }
+        if (intervalStartMs < coveredUntilMs - SLEEP_STAGE_COVERAGE_TOLERANCE_MS) {
+            return undefined;
+        }
+        const clippedStartMs = Math.max(intervalStartMs, coveredUntilMs);
+        const clippedEndMs = intervalEndMs;
+        if (clippedEndMs <= clippedStartMs) {
+            continue;
+        }
+        coveredIntervals.push({
+            ...interval,
+            durationMinutes: (clippedEndMs - clippedStartMs) / 60000,
+            endAt: new Date(clippedEndMs).toISOString(),
+            startAt: new Date(clippedStartMs).toISOString(),
+        });
+        coveredUntilMs = clippedEndMs;
+    }
+    return windowEndMs - coveredUntilMs <= SLEEP_STAGE_COVERAGE_TOLERANCE_MS
+        ? coveredIntervals
+        : undefined;
+}
+function collectJunctionSleepStageIntervals(entry, resourceContext, context, parentTimestamp) {
+    const intervals = [];
+    for (const intervalEntry of sleepStageIntervalEntries(entry, resourceContext.sourceProviderSlug)) {
+        const stage = firstSleepStageFromPaths(intervalEntry, JUNCTION_SLEEP_STAGE_VALUE_PATHS, resourceContext.sourceProviderSlug);
         if (!stage) {
             continue;
         }
@@ -1268,10 +2094,10 @@ function pushSleepCycle(entry, resourceContext, context) {
         const endAtRaw = firstValueFromPaths(intervalEntry, JUNCTION_SLEEP_END_TIMESTAMP_PATHS);
         const startAt = resolveSafeTimestamp(startAtRaw, resourceContext.sourceProviderSlug);
         const endAt = resolveSafeTimestamp(endAtRaw, resourceContext.sourceProviderSlug);
-        const durationMinutes = normalizePositiveIntegerMinutes(firstNumberFromPaths(intervalEntry, JUNCTION_SLEEP_STAGE_DURATION_MINUTE_PATHS)) ??
-            normalizePositiveIntegerMinutes(secondsToMinutes(firstNumberFromPaths(intervalEntry, JUNCTION_SLEEP_STAGE_DURATION_SECOND_PATHS))) ??
-            normalizePositiveIntegerMinutes(millisecondsToMinutes(firstNumberFromPaths(intervalEntry, JUNCTION_SLEEP_STAGE_DURATION_MILLISECOND_PATHS))) ??
-            normalizePositiveIntegerMinutes(minutesBetween(startAt, endAt));
+        const durationMinutes = normalizePositiveMinutes(firstNumberFromPaths(intervalEntry, JUNCTION_SLEEP_STAGE_DURATION_MINUTE_PATHS)) ??
+            normalizePositiveMinutes(secondsToMinutes(firstNumberFromPaths(intervalEntry, JUNCTION_SLEEP_STAGE_DURATION_SECOND_PATHS))) ??
+            normalizePositiveMinutes(millisecondsToMinutes(firstNumberFromPaths(intervalEntry, JUNCTION_SLEEP_STAGE_DURATION_MILLISECOND_PATHS))) ??
+            exactPositiveMinutesBetween(startAt, endAt);
         const resolvedStartAt = startAt ?? subtractMinutes(endAt, durationMinutes);
         const resolvedEndAt = endAt ?? addMinutes(startAt, durationMinutes);
         if (!resolvedStartAt || !resolvedEndAt || durationMinutes === undefined) {
@@ -1279,49 +2105,106 @@ function pushSleepCycle(entry, resourceContext, context) {
         }
         const intervalTimestamp = resolveRecordTimestamp(intervalEntry, context, resourceContext.sourceProviderSlug);
         const originEntry = { ...entry, ...intervalEntry };
+        const timeZone = resolveSleepStageCanonicalTimeZone(intervalEntry, entry);
         const stageTimestamp = withTimestampOverride(intervalTimestamp, {
-            occurredAt: resolvedStartAt,
             recordedAt: intervalTimestamp.recordedAt ?? parentTimestamp.recordedAt ?? resolvedStartAt,
-            dayKey: resolveSleepStageDayKey(intervalEntry, entry, resolvedStartAt, context.defaultTimeZone) ??
-                intervalTimestamp.dayKey ??
-                parentTimestamp.dayKey,
             observedAtRaw: stringId(startAtRaw) ?? intervalTimestamp.observedAtRaw ?? parentTimestamp.observedAtRaw ?? resolvedStartAt,
             timestampSemantics: intervalTimestamp.timestampSemantics ?? parentTimestamp.timestampSemantics,
         });
-        context.samples.push(stripUndefined({
-            stream: "sleep_stage",
-            unit: "stage",
+        intervals.push({
+            dataOriginEntry: originEntry,
+            durationMinutes,
+            endAt: resolvedEndAt,
             recordedAt: stageTimestamp.recordedAt,
-            dayKey: stageTimestamp.dayKey,
-            timeZone: firstStringFromPaths(intervalEntry, ["timeZone", "timezone", "time_zone"])
-                ?? firstStringFromPaths(entry, ["timeZone", "timezone", "time_zone"]),
-            source: "device",
-            quality: "normalized",
-            externalRef: makeJunctionSleepStageExternalRef(resourceContext, originEntry, stageTimestamp, stage, index),
-            dataOrigin: buildDataOrigin(originEntry, resourceContext, stageTimestamp),
-            sample: {
-                recordedAt: stageTimestamp.recordedAt,
-                occurredAt: stageTimestamp.occurredAt,
-                stage,
-                startAt: resolvedStartAt,
-                endAt: resolvedEndAt,
-                durationMinutes,
-            },
-        }));
+            stage,
+            startAt: resolvedStartAt,
+            intervalEntry,
+            timestamp: stageTimestamp,
+            timeZone,
+        });
     }
+    return intervals;
 }
-function resolveSleepStageDayKey(intervalEntry, parentEntry, resolvedStartAt, defaultTimeZone) {
-    const explicitTimeZone = firstStringFromPaths(intervalEntry, ["timeZone", "timezone", "time_zone"])
-        ?? firstStringFromPaths(parentEntry, ["timeZone", "timezone", "time_zone"]);
-    // Samples do not yet have event-style legacyExternalRefs, so offset-only
-    // sleep-stage rows keep their historic UTC-day identity for stable replay.
-    const hasOffsetOnlyEvidence = !explicitTimeZone && (readJunctionTimeZoneOffsetSeconds(intervalEntry) !== undefined ||
-        readJunctionTimeZoneOffsetSeconds(parentEntry) !== undefined);
-    const timeZone = explicitTimeZone ?? (hasOffsetOnlyEvidence ? undefined : defaultTimeZone);
-    return firstIsoDateFromPaths(intervalEntry, JUNCTION_LOCAL_CALENDAR_DATE_PATHS) ??
-        resolveVaultLocalDayKey(resolvedStartAt, timeZone) ??
-        extractIsoDatePrefix(resolvedStartAt) ??
-        undefined;
+function resolveSleepCycleParentResourceId(resourceContext, entry, parentTimestamp) {
+    const explicitParentId = firstStringFromPaths(entry, JUNCTION_GENERIC_SUMMARY_ID_PATHS);
+    if ((parentTimestamp.observedAtRaw || explicitParentId) &&
+        !isDirectSleepStageIntervalEntry(entry, resourceContext.sourceProviderSlug)) {
+        return buildStableResourceId(resourceContext, entry, parentTimestamp);
+    }
+    return undefined;
+}
+function hasSleepCycleCompactParentIdentity(entry, sourceProviderSlug) {
+    return !isDirectSleepStageIntervalEntry(entry, sourceProviderSlug) &&
+        Boolean(firstStringFromPaths(entry, JUNCTION_GENERIC_SUMMARY_ID_PATHS) ||
+            firstStringFromPaths(entry, JUNCTION_RECORD_TIMESTAMP_PATHS));
+}
+function makeJunctionSleepAggregateExternalRef(resourceContext, aggregate, metric) {
+    return makeJunctionCanonicalSleepStageExternalRef(resourceContext, {
+        coverageEndAt: aggregate.coverageEndAt,
+        coverageStartAt: aggregate.coverageStartAt,
+        dayKey: aggregate.timestamp.dayKey,
+        metric,
+        timeZone: aggregate.timeZone,
+    });
+}
+function makeJunctionCanonicalSleepStageExternalRef(resourceContext, input) {
+    return makeProviderExternalRef("junction", buildJunctionResourceType(resourceContext.sourceProviderSlug, "sleep"), `sleep-stage-${shortHash([
+        resourceContext.sourceProviderSlug,
+        resourceContext.origin.sourceType,
+        resourceContext.origin.sourceInstanceId,
+        input.coverageStartAt,
+        input.coverageEndAt,
+    ])}`, undefined, slugify(input.metric, "value"));
+}
+function sleepStageMetricDescriptor(stage) {
+    switch (stage) {
+        case "awake":
+            return { metric: "sleep-awake-minutes", title: "Junction awake time" };
+        case "light":
+            return { metric: "sleep-light-minutes", title: "Junction light sleep" };
+        case "deep":
+            return { metric: "sleep-deep-minutes", title: "Junction deep sleep" };
+        case "rem":
+            return { metric: "sleep-rem-minutes", title: "Junction REM sleep" };
+    }
+    const exhaustive = stage;
+    return exhaustive;
+}
+function earlierIsoTimestamp(left, right) {
+    return Date.parse(right) < Date.parse(left) ? right : left;
+}
+function laterIsoTimestamp(left, right) {
+    return Date.parse(right) > Date.parse(left) ? right : left;
+}
+function laterOptionalIsoTimestamp(left, right) {
+    if (!left) {
+        return right;
+    }
+    if (!right) {
+        return left;
+    }
+    return laterIsoTimestamp(left, right);
+}
+function resolveSleepStageAnchorDayKey(coverageEndAt, timeZone, timestamp, parentTimestamp) {
+    const coverageEndMs = Date.parse(coverageEndAt);
+    const localDayKey = Number.isFinite(coverageEndMs) && timeZone
+        ? localDayKeyAtMs(coverageEndMs, timeZone)
+        : undefined;
+    return localDayKey ?? timestamp.dayKey ?? parentTimestamp?.dayKey ?? extractIsoDatePrefix(coverageEndAt) ?? undefined;
+}
+function resolveSleepStageBucketTimeZone(intervalEntry, parentEntry, _defaultTimeZone) {
+    // Only provider-supplied zones (or explicit UTC timestamps) can define
+    // durable stage buckets. The vault default timezone is mutable profile
+    // state, so missing/null provider zones keep stable UTC-day identity.
+    return resolveSleepStageCanonicalTimeZone(intervalEntry, parentEntry);
+}
+function localDayKeyAtMs(timestampMs, timeZone) {
+    try {
+        return toLocalDayKey(new Date(timestampMs), timeZone);
+    }
+    catch {
+        return undefined;
+    }
 }
 function pushWorkoutSummary(entry, resourceContext, context) {
     const timestamp = resolveRecordTimestamp(entry, context, resourceContext.sourceProviderSlug);
@@ -2159,6 +3042,7 @@ function pushObservationMetrics(entry, resourceContext, context, metrics, timest
         if (!resolved) {
             continue;
         }
+        const metricKey = resolveJunctionHrvMetric(metric.metric, resourceContext.sourceProviderSlug);
         context.events.push(stripUndefined({
             kind: "observation",
             occurredAt,
@@ -2166,12 +3050,15 @@ function pushObservationMetrics(entry, resourceContext, context, metrics, timest
             dayKey: timestamp.dayKey,
             timeZone: firstStringFromPaths(entry, ["timeZone", "timezone", "time_zone"]),
             source: "device",
-            title: metric.title,
+            title: resolveJunctionHrvTitle(metricKey, metric.title),
             evidenceRoles: resourceContext.evidenceRoles,
+            // Keep the pre-separation provider identity facet so a re-import
+            // supersedes an existing generic Apple HRV event instead of duplicating
+            // it under the corrected SDNN metric.
             externalRef: makeJunctionExternalRef(resourceContext, entry, timestamp, metric.metric),
             dataOrigin: buildDataOrigin(entry, resourceContext, timestamp),
             fields: {
-                metric: metric.metric,
+                metric: metricKey,
                 observationGrain: "summary",
                 value: resolved.value,
                 unit: resolved.unit,
@@ -2179,6 +3066,18 @@ function pushObservationMetrics(entry, resourceContext, context, metrics, timest
         }));
     }
 }
+function resolveJunctionHrvMetric(metric, sourceProviderSlug) {
+    if (metric !== "hrv") {
+        return metric;
+    }
+    return normalizeJunctionSourceProviderSlug(sourceProviderSlug)
+        === APPLE_HEALTH_KIT_SOURCE_PROVIDER_SLUG
+        ? HRV_SDNN_METRIC
+        : metric;
+}
+function resolveJunctionHrvTitle(metric, fallback) {
+    return metric === HRV_SDNN_METRIC ? "Apple Health HRV (SDNN)" : fallback;
+}
 function pushJunctionRecoveryReadinessScore(entry, resourceContext, context, timestampOverride) {
     const value = firstNumberFromPaths(entry, ["recoveryReadinessScore", "recovery_readiness_score"]);
     if (value === undefined) {
@@ -2278,13 +3177,13 @@ function withGroupedSourceProviderFallback(originFallback) {
         sourceType: groupedSourceType,
     });
 }
-function buildDataOrigin(entry, resourceContext, timestamp) {
+function buildDataOrigin(entry, resourceContext, timestamp, options = {}) {
     return stripUndefined({
         ...resourceContext.origin,
         observedAtRaw: timestamp.observedAtRaw,
         timeZoneOffsetMinutes: readJunctionTimeZoneOffsetMinutes(entry),
         timestampSemantics: timestamp.timestampSemantics,
-        normalizerVersion: "junction-normalizer.v1",
+        normalizerVersion: options.normalizerVersion ?? "junction-normalizer.v1",
     });
 }
 function withTimestampOverride(timestamp, override) {
@@ -2297,10 +3196,17 @@ function withTimestampOverride(timestamp, override) {
     };
 }
 function makeJunctionExternalRef(resourceContext, entry, timestamp, facet) {
-    return makeProviderExternalRef("junction", resourceContext.externalRefResourceType, buildStableResourceId(resourceContext, entry, timestamp), undefined, slugify(facet, "value"));
+    return makeProviderExternalRef("junction", resourceContext.externalRefResourceType, buildStableResourceId(resourceContext, entry, timestamp), junctionCompanionExternalRefVersion(resourceContext, entry), slugify(facet, "value"));
 }
-function makeJunctionSleepStageExternalRef(resourceContext, entry, timestamp, stage, index) {
-    return makeProviderExternalRef("junction", resourceContext.externalRefResourceType, buildStableSleepStageResourceId(resourceContext, entry, timestamp, stage, index), undefined, `sleep-stage-${stage}`);
+function junctionCompanionExternalRefVersion(resourceContext, entry) {
+    if (resourceContext.sourceProviderSlug !== "apple-health-kit"
+        || resourceContext.origin.sourceType !== "companion-whoop-metadata-unverified") {
+        return undefined;
+    }
+    const version = entry.companionSyncVersion;
+    return typeof version === "number" && Number.isSafeInteger(version) && version >= 0
+        ? String(version)
+        : undefined;
 }
 function buildJunctionResourceType(sourceProviderSlug, resourceSlug) {
     return `junction-${slugify(sourceProviderSlug, "source")}-${slugify(resourceSlug, "resource")}`;
@@ -2346,27 +3252,6 @@ function buildStableTimeseriesResourceId(resourceContext, timestamp) {
         timestamp.observedAtRaw ?? timestamp.occurredAt,
     ])}`;
 }
-function buildStableSleepStageResourceId(resourceContext, entry, timestamp, stage, index) {
-    const explicitId = firstStringFromPaths(entry, [
-        "id",
-        "stageId",
-        "stage_id",
-        "resourceId",
-        "resource_id",
-        "externalId",
-        "external_id",
-    ]);
-    return `${resourceContext.resourceSlug}-stage-${shortHash([
-        resourceContext.resourceSlug,
-        resourceContext.sourceProviderSlug,
-        resourceContext.origin.sourceType,
-        resourceContext.origin.sourceInstanceId,
-        explicitId,
-        timestamp.observedAtRaw ?? timestamp.occurredAt,
-        stage,
-        index,
-    ])}`;
-}
 function shortHash(parts) {
     return createHash("sha256")
         .update(JSON.stringify(parts))
@@ -2374,30 +3259,7 @@ function shortHash(parts) {
         .slice(0, 16);
 }
 function resolveRecordTimestamp(entry, context, sourceProviderSlug) {
-    const rawObservedAt = firstStringFromPaths(entry, [
-        "observedAtRaw",
-        "observed_at_raw",
-        "observedAt",
-        "observed_at",
-        "timestamp",
-        "time",
-        "date",
-        "day",
-        "end",
-        "endAt",
-        "end_at",
-        "timeEnd",
-        "time_end",
-        "bedtimeStop",
-        "bedtime_stop",
-        "start",
-        "startAt",
-        "start_at",
-        "timeStart",
-        "time_start",
-        "bedtimeStart",
-        "bedtime_start",
-    ]);
+    const rawObservedAt = firstStringFromPaths(entry, JUNCTION_RECORD_TIMESTAMP_PATHS);
     const localCalendarDayKey = firstIsoDateFromPaths(entry, JUNCTION_LOCAL_CALENDAR_DATE_PATHS);
     const explicitSemantics = firstTimestampSemantics(entry);
     const hasSourceSpecificFloatingTime = hasFloatingTimestampSourceProvider(sourceProviderSlug);
@@ -2588,21 +3450,26 @@ function groupedTimeseriesResourceEntries(payload) {
         }));
     }));
 }
-function sleepStageIntervalEntries(entry) {
+function sleepStageIntervalEntries(entry, sourceProviderSlug) {
+    const seen = new Set();
     return [
-        ...collectSleepStageIntervalEntries(entry),
-        ...parallelSleepStageIntervalEntries(entry),
+        ...collectSleepStageIntervalEntries(entry, seen, sourceProviderSlug),
+        ...parallelSleepStageIntervalEntries(entry, sourceProviderSlug),
     ];
 }
-function collectSleepStageIntervalEntries(value) {
+function collectSleepStageIntervalEntries(value, seen, sourceProviderSlug) {
     if (Array.isArray(value)) {
-        return value.flatMap((entry) => collectSleepStageIntervalEntries(entry));
+        return value.flatMap((entry) => collectSleepStageIntervalEntries(entry, seen, sourceProviderSlug));
     }
     const entry = asPlainObject(value);
     if (!entry) {
         return [];
     }
-    if (firstSleepStageFromPaths(entry, JUNCTION_SLEEP_STAGE_VALUE_PATHS)) {
+    if (seen.has(entry)) {
+        return [];
+    }
+    seen.add(entry);
+    if (firstSleepStageFromPaths(entry, JUNCTION_SLEEP_STAGE_VALUE_PATHS, sourceProviderSlug)) {
         return [entry];
     }
     return JUNCTION_SLEEP_STAGE_ARRAY_PATHS.flatMap((path) => {
@@ -2610,10 +3477,10 @@ function collectSleepStageIntervalEntries(value) {
         if (nested === value) {
             return [];
         }
-        return collectSleepStageIntervalEntries(nested);
+        return collectSleepStageIntervalEntries(nested, seen, sourceProviderSlug);
     });
 }
-function parallelSleepStageIntervalEntries(entry) {
+function parallelSleepStageIntervalEntries(entry, sourceProviderSlug) {
     const sessionStartRaw = firstValueFromPaths(entry, [
         "sessionStart",
         "session_start",
@@ -2631,7 +3498,7 @@ function parallelSleepStageIntervalEntries(entry) {
     }
     const timeZone = firstStringFromPaths(entry, ["timeZone", "timezone", "time_zone"]);
     return stageValues.flatMap((stageValue, index) => {
-        const stage = normalizeJunctionSleepStageValue(stageValue);
+        const stage = normalizeJunctionSleepStageValueForSource(stageValue, sourceProviderSlug);
         const startOffsetSeconds = startOffsets[index];
         const endOffsetSeconds = endOffsets[index];
         if (!stage || startOffsetSeconds === undefined || endOffsetSeconds === undefined) {
@@ -2668,6 +3535,9 @@ function expandResourceEntry(value, resource) {
     }));
 }
 function readNestedResourceEntries(envelope, resource) {
+    const sourceProviderSlug = resource === "sleep_cycle"
+        ? readJunctionSourceProviderSlug(envelope, undefined)
+        : undefined;
     for (const key of nestedResourceEntryKeys(resource)) {
         const directEntry = asPlainObject(envelope[key]);
         const entries = directEntry
@@ -2677,11 +3547,18 @@ function readNestedResourceEntries(envelope, resource) {
                 return normalized ? [normalized] : [];
             });
         if (entries.length > 0) {
+            if (resource === "sleep_cycle" &&
+                entries.some((entry) => isDirectSleepStageIntervalEntry(entry, readJunctionSourceProviderSlug(entry, envelope) ?? sourceProviderSlug))) {
+                return null;
+            }
             return entries;
         }
     }
     return null;
 }
+function isDirectSleepStageIntervalEntry(entry, sourceProviderSlug) {
+    return firstSleepStageFromPaths(entry, JUNCTION_SLEEP_STAGE_VALUE_PATHS, sourceProviderSlug) !== undefined;
+}
 function nestedResourceEntryKeys(resource) {
     switch (resource) {
         case "meal":
@@ -2703,15 +3580,30 @@ function mergeNestedResourceEntry(envelope, nestedEntry) {
 function listAllowedResourceKeys(resources, allowlist) {
     return allowedResourceEntries(resources, allowlist).map(([resource]) => resource);
 }
-function firstSleepStageFromPaths(source, paths) {
+function firstSleepStageFromPaths(source, paths, sourceProviderSlug) {
     for (const path of paths) {
-        const stage = normalizeJunctionSleepStageValue(readPath(source, path));
+        const stage = normalizeJunctionSleepStageValueForSource(readPath(source, path), sourceProviderSlug);
         if (stage) {
             return stage;
         }
     }
     return undefined;
 }
+function normalizeJunctionSleepStageValueForSource(value, sourceProviderSlug) {
+    const normalized = normalizeJunctionSleepStageValue(value);
+    if (normalized) {
+        return normalized;
+    }
+    return isAppleHealthKitSourceProvider(sourceProviderSlug) && isJunctionAppleGenericAsleepStageValue(value)
+        ? "asleep_unspecified"
+        : null;
+}
+function isAppleHealthKitSourceProvider(sourceProviderSlug) {
+    return normalizeJunctionSourceProviderSlug(sourceProviderSlug) === APPLE_HEALTH_KIT_SOURCE_PROVIDER_SLUG;
+}
+function isJunctionAppleGenericAsleepStageValue(value) {
+    return value === -1 || (typeof value === "string" && value.trim() === "-1");
+}
 function normalizeTimestamp(value) {
     if (value instanceof Date && Number.isFinite(value.getTime())) {
         return value.toISOString();
@@ -2944,6 +3836,17 @@ function normalizePositiveIntegerMinutes(value) {
     }
     return Math.max(1, Math.round(numeric));
 }
+function normalizePositiveMinutes(value) {
+    const numeric = finiteNumber(value);
+    return numeric !== undefined && numeric > 0 ? numeric : undefined;
+}
+function exactPositiveMinutesBetween(startAt, endAt) {
+    if (!startAt || !endAt) {
+        return undefined;
+    }
+    const durationMs = Date.parse(endAt) - Date.parse(startAt);
+    return Number.isFinite(durationMs) && durationMs > 0 ? durationMs / 60000 : undefined;
+}
 function secondsToMinutes(value) {
     const numeric = finiteNumber(value);
     if (numeric === undefined) {