@murphai/murph 1.3.0 → 1.3.1

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

@@ -1,17 +1,29 @@
 import { createHash } from "node:crypto";
-import { extractIsoDatePrefix, ID_PREFIXES, MEAL_MICRONUTRIENT_KEYS, parseCompanionHrvRmssdAdmissionId, parseCompanionHrvRmssdObservation, serializeCompanionHrvRmssdObservation, toLocalDayKey, } from "@murphai/contracts";
-import { z } from "zod";
+import { extractIsoDatePrefix, ID_PREFIXES, JUNCTION_WEARABLE_TAG_EXTERNAL_REF_FACET, JUNCTION_WEARABLE_TAG_NOTE_TYPE, MEAL_MICRONUTRIENT_KEYS, parseCompanionHrvRmssdAdmissionId, parseCompanionHrvRmssdObservation, serializeCompanionHrvRmssdObservation, toLocalDayKey, } from "@murphai/contracts";
+import * as z from "@murphai/contracts/zod-runtime";
 import { stripUndefined } from "../shared.js";
 import { asArray, asPlainObject, createEvidencePart, finiteNumber, kilojoulesToKilocalories, makeNormalizedDeviceBatch, makeProviderExternalRef, minutesBetween, pushEvidencePart, slugify, stringId, trimToLength, } from "./shared-normalization.js";
-import { JUNCTION_ALLOWED_SUMMARY_RESOURCES, JUNCTION_ALLOWED_TIMESERIES_RESOURCES, JUNCTION_SLEEP_AVERAGE_HEART_RATE_PATHS, JUNCTION_SLEEP_AWAKE_MINUTE_PATHS, JUNCTION_SLEEP_AWAKE_SECOND_PATHS, JUNCTION_SLEEP_CONSISTENCY_PATHS, JUNCTION_SLEEP_DEEP_MINUTE_PATHS, JUNCTION_SLEEP_DEEP_SECOND_PATHS, JUNCTION_SLEEP_DURATION_MILLISECOND_PATHS, JUNCTION_SLEEP_DURATION_MINUTE_PATHS, JUNCTION_SLEEP_DURATION_SECOND_PATHS, JUNCTION_SLEEP_EFFICIENCY_RATIO_PATHS, JUNCTION_SLEEP_END_TIMESTAMP_PATHS, JUNCTION_SLEEP_HRV_PATHS, JUNCTION_SLEEP_LIGHT_MINUTE_PATHS, JUNCTION_SLEEP_LIGHT_SECOND_PATHS, JUNCTION_SLEEP_LOWEST_HEART_RATE_PATHS, JUNCTION_SLEEP_PERFORMANCE_PATHS, JUNCTION_SLEEP_REM_MINUTE_PATHS, JUNCTION_SLEEP_REM_SECOND_PATHS, JUNCTION_SLEEP_RESPIRATORY_RATE_PATHS, JUNCTION_SLEEP_RESTING_HEART_RATE_PATHS, JUNCTION_SLEEP_SCORE_PATHS, JUNCTION_SLEEP_SPO2_PATHS, JUNCTION_SLEEP_STAGE_ARRAY_PATHS, JUNCTION_SLEEP_STAGE_DURATION_MILLISECOND_PATHS, JUNCTION_SLEEP_STAGE_DURATION_MINUTE_PATHS, JUNCTION_SLEEP_STAGE_DURATION_SECOND_PATHS, JUNCTION_SLEEP_STAGE_VALUE_PATHS, JUNCTION_SLEEP_START_TIMESTAMP_PATHS, JUNCTION_SLEEP_TEMPERATURE_DEVIATION_PATHS, JUNCTION_SLEEP_TEMPERATURE_PATHS, JUNCTION_SLEEP_TIME_IN_BED_MINUTE_PATHS, JUNCTION_SLEEP_TIME_IN_BED_SECOND_PATHS, JUNCTION_SLEEP_TOTAL_MINUTE_PATHS, JUNCTION_SLEEP_TOTAL_SECOND_PATHS, isJunctionRawDirectIdentityContainerKey, isJunctionRawDirectIdentityKey, normalizeJunctionRawIdentityKey, normalizeJunctionSleepStageValue, normalizeJunctionResourceName, } from "./junction-resources.js";
+import { JUNCTION_ALLOWED_SUMMARY_RESOURCES, JUNCTION_ALLOWED_TIMESERIES_RESOURCES, JUNCTION_SLEEP_AVERAGE_HEART_RATE_PATHS, JUNCTION_SLEEP_AWAKE_MINUTE_PATHS, JUNCTION_SLEEP_AWAKE_SECOND_PATHS, JUNCTION_SLEEP_CONSISTENCY_PATHS, JUNCTION_SLEEP_DEEP_MINUTE_PATHS, JUNCTION_SLEEP_DEEP_SECOND_PATHS, JUNCTION_SLEEP_DURATION_MILLISECOND_PATHS, JUNCTION_SLEEP_DURATION_MINUTE_PATHS, JUNCTION_SLEEP_DURATION_SECOND_PATHS, JUNCTION_SLEEP_EFFICIENCY_RATIO_PATHS, JUNCTION_SLEEP_END_TIMESTAMP_PATHS, JUNCTION_SLEEP_HRV_PATHS, JUNCTION_SLEEP_LATENCY_MINUTE_PATHS, JUNCTION_SLEEP_LATENCY_SECOND_PATHS, JUNCTION_SLEEP_LIGHT_MINUTE_PATHS, JUNCTION_SLEEP_LIGHT_SECOND_PATHS, JUNCTION_SLEEP_LOWEST_HEART_RATE_PATHS, JUNCTION_SLEEP_PERFORMANCE_PATHS, JUNCTION_SLEEP_REM_MINUTE_PATHS, JUNCTION_SLEEP_REM_SECOND_PATHS, JUNCTION_SLEEP_RESPIRATORY_RATE_PATHS, JUNCTION_SLEEP_RESTING_HEART_RATE_PATHS, JUNCTION_SLEEP_SCORE_PATHS, JUNCTION_SLEEP_SPO2_PATHS, JUNCTION_SLEEP_STAGE_ARRAY_PATHS, JUNCTION_SLEEP_STAGE_DURATION_MILLISECOND_PATHS, JUNCTION_SLEEP_STAGE_DURATION_MINUTE_PATHS, JUNCTION_SLEEP_STAGE_DURATION_SECOND_PATHS, JUNCTION_SLEEP_STAGE_VALUE_PATHS, JUNCTION_SLEEP_START_TIMESTAMP_PATHS, JUNCTION_SLEEP_TEMPERATURE_DEVIATION_PATHS, JUNCTION_SLEEP_TEMPERATURE_PATHS, JUNCTION_SLEEP_TIME_IN_BED_MINUTE_PATHS, JUNCTION_SLEEP_TIME_IN_BED_SECOND_PATHS, JUNCTION_SLEEP_TOTAL_MINUTE_PATHS, JUNCTION_SLEEP_TOTAL_SECOND_PATHS, JUNCTION_TIMESERIES_RESOURCE_POLICIES, isJunctionRawDirectIdentityContainerKey, isJunctionRawDirectIdentityKey, normalizeJunctionRawIdentityKey, normalizeJunctionSleepStageValue, normalizeJunctionResourceName, resolveJunctionTimeseriesResourcePolicy, usesJunctionTimeseriesIntervalStartOwnership, } from "./junction-resources.js";
+import { assertJunctionTimeseriesResponseBound, assertJunctionTimeseriesSourceDayBound, assertJunctionTimeseriesOutputBounds, deriveJunctionTimeseriesFeatureEnvelope, getJunctionDenseFidelityPolicy, getJunctionSparseIntervalPolicy, isJunctionDenseFidelityResource, isJunctionSparseIntervalResource, } from "./junction-timeseries-fidelity.js";
+import { JUNCTION_ECG_VOLTAGE_FEATURE_SCHEMA, JUNCTION_WORKOUT_STREAM_FEATURE_SCHEMA, buildJunctionBoundedFeatureIdentity, reduceJunctionElectrocardiogramVoltageRecords, reduceJunctionWorkoutStreamPayload, resolveJunctionBoundedFeatureRecords, selectJunctionWorkoutStreamCandidates, } from "./junction-bounded-features.js";
 import { normalizeJunctionSourceProviderSlug, readJunctionSourceProviderSlug, resolveJunctionOrigin, } from "./junction-origin.js";
 import { JUNCTION_DEVICE_PROVIDER_DESCRIPTOR } from "./provider-descriptors.js";
+export { JUNCTION_DENSE_FIDELITY_RESOURCES, } from "./junction-timeseries-fidelity.js";
 export { JUNCTION_ALLOWED_SUMMARY_RESOURCES, JUNCTION_ALLOWED_TIMESERIES_RESOURCES, JUNCTION_DEFAULT_SUMMARY_RESOURCES, JUNCTION_DEFAULT_TIMESERIES_RESOURCES, JUNCTION_KNOWN_TIMESERIES_RESOURCES, JUNCTION_OPT_IN_SUMMARY_RESOURCES, JUNCTION_OPT_IN_TIMESERIES_RESOURCES, JUNCTION_RAW_ONLY_SUMMARY_RESOURCES, normalizeJunctionResourceName, } from "./junction-resources.js";
+export { JUNCTION_ECG_VOLTAGE_FEATURE_SCHEMA, JUNCTION_WORKOUT_STREAM_FEATURE_SCHEMA, buildJunctionBoundedFeatureIdentity, reduceJunctionElectrocardiogramVoltageRecords, reduceJunctionWorkoutStreamPayload, resolveJunctionBoundedFeatureRecords, selectJunctionWorkoutStreamCandidates, };
 const junctionSnapshotSchema = z.object({
     accountId: z.union([z.string(), z.number()]).optional(),
     importedAt: z.union([z.string(), z.number(), z.date()]).optional(),
     windowStart: z.union([z.string(), z.number(), z.date()]).optional(),
     windowEnd: z.union([z.string(), z.number(), z.date()]).optional(),
+    timeseriesWindowKind: z.enum(["calendar_day", "precise"]).optional(),
+    strictSparseCalendarRepair: z.object({
+        dayKey: z.string(),
+        resource: z.enum(["caffeine", "water", "mindfulness_minutes"]),
+        sourceInstanceId: z.string().nullable().optional(),
+        sourceProviderSlug: z.string(),
+        sourceType: z.string().nullable().optional(),
+    }).strict().optional(),
     connections: z.array(z.unknown()).optional(),
     summaries: z.record(z.string(), z.unknown()).optional(),
     timeseries: z.record(z.string(), z.unknown()).optional(),
@@ -58,6 +70,27 @@ const ACTIVITY_METRICS = [
         paths: [],
         value: resolveJunctionDailyActivityMinutes,
     },
+    {
+        metric: "low-activity-minutes",
+        unit: "minutes",
+        title: "Junction low activity minutes",
+        paths: [],
+        value: (entry) => resolveJunctionActivityIntensityMinutes(entry, "low"),
+    },
+    {
+        metric: "medium-activity-minutes",
+        unit: "minutes",
+        title: "Junction medium activity minutes",
+        paths: [],
+        value: (entry) => resolveJunctionActivityIntensityMinutes(entry, "medium"),
+    },
+    {
+        metric: "high-activity-minutes",
+        unit: "minutes",
+        title: "Junction high activity minutes",
+        paths: [],
+        value: (entry) => resolveJunctionActivityIntensityMinutes(entry, "high"),
+    },
     { metric: "daily-steps", unit: "count", title: "Junction activity steps", paths: ["steps", "step_count", "daily_steps"] },
     { metric: "active-calories", unit: "kcal", title: "Junction active calories", paths: ["activeCalories", "active_calories", "calories_active"] },
     { metric: "total-calories", unit: "kcal", title: "Junction total calories", paths: ["calories", "totalCalories", "total_calories", "calories_total"] },
@@ -70,6 +103,9 @@ const ACTIVITY_METRICS = [
     { metric: "percent-recorded", unit: "%", title: "Junction activity recording coverage", paths: [], percentRatioPaths: ["percentRecorded", "percent_recorded", "recordingCoverage", "recording_coverage", "recordedRatio", "recorded_ratio", "percentRecordedRatio", "percent_recorded_ratio"] },
     { metric: "workout-strain", unit: "score", title: "Junction workout strain", paths: ["workoutStrain", "workout_strain"] },
     { metric: "day-strain", unit: "score", title: "Junction day strain", paths: ["dayStrain", "day_strain", "strain"] },
+    { metric: "average-heart-rate", unit: "bpm", title: "Junction activity average heart rate", paths: ["heart_rate.avg_bpm"] },
+    { metric: "walking-average-heart-rate", unit: "bpm", title: "Junction activity walking average heart rate", paths: ["heart_rate.avg_walking_bpm"] },
+    { metric: "lowest-heart-rate", unit: "bpm", title: "Junction activity lowest heart rate", paths: ["heart_rate.min_bpm"] },
     { metric: "max-heart-rate", unit: "bpm", title: "Junction activity max heart rate", paths: ["maxHeartRate", "max_heart_rate", "max_hr", "heart_rate.max_bpm"] },
     { metric: "resting-heart-rate", unit: "bpm", title: "Junction activity resting heart rate", paths: ["restingHeartRate", "resting_heart_rate", "resting_hr", "rhr", "heart_rate.resting_bpm"] },
 ];
@@ -77,6 +113,34 @@ const BODY_METRICS = [
     { metric: "weight", unit: "kg", title: "Junction body weight", paths: ["weightKg", "weight_kg", "weight"] },
     { metric: "bmi", unit: "kg_m2", title: "Junction BMI", paths: ["bmi", "body_mass_index"] },
     { metric: "body-fat-percentage", unit: "%", title: "Junction body fat", paths: ["bodyFatPercentage", "body_fat_percentage", "body_fat_percent", "bodyFat", "body_fat", "fat"] },
+    {
+        metric: "bone-mass-percentage",
+        unit: "%",
+        title: "Junction bone mass percentage",
+        paths: [],
+        value: (entry) => firstNumberFromPaths(entry, ["boneMassPercentage", "bone_mass_percentage"]),
+    },
+    {
+        metric: "muscle-mass-percentage",
+        unit: "%",
+        title: "Junction muscle mass percentage",
+        paths: [],
+        value: (entry) => firstNumberFromPaths(entry, ["muscleMassPercentage", "muscle_mass_percentage"]),
+    },
+    {
+        metric: "visceral-fat-index",
+        unit: "index",
+        title: "Junction visceral fat index",
+        paths: [],
+        value: (entry) => firstNumberFromPaths(entry, ["visceralFatIndex", "visceral_fat_index"]),
+    },
+    {
+        metric: "body-water-percentage",
+        unit: "%",
+        title: "Junction body water percentage",
+        paths: [],
+        value: (entry) => firstNumberFromPaths(entry, ["waterPercentage", "water_percentage"]),
+    },
     { metric: "lean-body-mass", unit: "kg", title: "Junction lean body mass", paths: ["leanBodyMassKg", "lean_body_mass_kg", "leanBodyMassKilogram", "lean_body_mass_kilogram", "leanMassKg", "lean_mass_kg"] },
     { metric: "waist-circumference", unit: "cm", title: "Junction waist circumference", paths: ["waistCircumference", "waist_circumference", "waistCircumferenceCentimeter", "waist_circumference_centimeter", "waistCircumferenceCm", "waist_circumference_cm"] },
     { metric: "temperature", unit: "celsius", title: "Junction body temperature", paths: ["temperature", "bodyTemperature", "body_temperature", "temperatureCelsius", "temperature_celsius", "skin_temperature"] },
@@ -96,6 +160,13 @@ const SLEEP_METRICS = [
     { metric: "sleep-awake-minutes", unit: "minutes", title: "Junction awake time", paths: JUNCTION_SLEEP_AWAKE_MINUTE_PATHS, secondsPaths: JUNCTION_SLEEP_AWAKE_SECOND_PATHS },
     { metric: "time-in-bed-minutes", unit: "minutes", title: "Junction time in bed", paths: JUNCTION_SLEEP_TIME_IN_BED_MINUTE_PATHS, secondsPaths: JUNCTION_SLEEP_TIME_IN_BED_SECOND_PATHS },
     { metric: "sleep-efficiency", unit: "%", title: "Junction sleep efficiency", paths: [], percentRatioPaths: JUNCTION_SLEEP_EFFICIENCY_RATIO_PATHS },
+    {
+        metric: "sleep-latency-minutes",
+        unit: "minutes",
+        title: "Junction sleep latency",
+        paths: [],
+        value: resolveJunctionSleepLatencyMinutes,
+    },
     { metric: "sleep-consistency", unit: "%", title: "Junction sleep consistency", paths: JUNCTION_SLEEP_CONSISTENCY_PATHS },
     { metric: "sleep-performance", unit: "%", title: "Junction sleep performance", paths: JUNCTION_SLEEP_PERFORMANCE_PATHS },
     { metric: "hrv", unit: "ms", title: "Junction sleep HRV", paths: JUNCTION_SLEEP_HRV_PATHS },
@@ -153,7 +224,7 @@ const JUNCTION_GENERIC_SUMMARY_ID_PATHS = [
     "providerId",
     "provider_id",
 ];
-const JUNCTION_RECORD_TIMESTAMP_PATHS = [
+const JUNCTION_RECORD_POINT_TIMESTAMP_PATHS = [
     "observedAtRaw",
     "observed_at_raw",
     "observedAt",
@@ -162,6 +233,8 @@ const JUNCTION_RECORD_TIMESTAMP_PATHS = [
     "time",
     "date",
     "day",
+];
+const JUNCTION_RECORD_INTERVAL_END_TIMESTAMP_PATHS = [
     "end",
     "endAt",
     "end_at",
@@ -169,6 +242,8 @@ const JUNCTION_RECORD_TIMESTAMP_PATHS = [
     "time_end",
     "bedtimeStop",
     "bedtime_stop",
+];
+const JUNCTION_RECORD_INTERVAL_START_TIMESTAMP_PATHS = [
     "start",
     "startAt",
     "start_at",
@@ -177,6 +252,48 @@ const JUNCTION_RECORD_TIMESTAMP_PATHS = [
     "bedtimeStart",
     "bedtime_start",
 ];
+const JUNCTION_TIMESERIES_RECORD_ID_PATHS = [
+    "id",
+    "resourceId",
+    "resource_id",
+    "externalId",
+    "external_id",
+    "providerId",
+    "provider_id",
+    "recordId",
+    "record_id",
+    "sampleId",
+    "sample_id",
+];
+const JUNCTION_INTERVAL_START_TIMESTAMP_PATHS = [
+    "start",
+    "startAt",
+    "start_at",
+    "timeStart",
+    "time_start",
+];
+const JUNCTION_INTERVAL_END_TIMESTAMP_PATHS = [
+    "end",
+    "endAt",
+    "end_at",
+    "timeEnd",
+    "time_end",
+];
+const JUNCTION_INTERVAL_UNIT_PATHS = [
+    "unit",
+    "valueUnit",
+    "value_unit",
+];
+const JUNCTION_RECORD_TIMESTAMP_PATHS = [
+    ...JUNCTION_RECORD_POINT_TIMESTAMP_PATHS,
+    ...JUNCTION_RECORD_INTERVAL_END_TIMESTAMP_PATHS,
+    ...JUNCTION_RECORD_INTERVAL_START_TIMESTAMP_PATHS,
+];
+const JUNCTION_INTERVAL_START_OWNED_TIMESTAMP_PATHS = [
+    ...JUNCTION_RECORD_POINT_TIMESTAMP_PATHS,
+    ...JUNCTION_RECORD_INTERVAL_START_TIMESTAMP_PATHS,
+    ...JUNCTION_RECORD_INTERVAL_END_TIMESTAMP_PATHS,
+];
 const JUNCTION_MEAL_PROVIDER_ID_PATHS = [
     "mealId",
     "meal_id",
@@ -482,6 +599,53 @@ const JUNCTION_GLUCOSE_VALUE_PATHS = [
     "bloodGlucose",
     "blood_glucose",
 ];
+const JUNCTION_STEPS_VALUE_PATHS = [
+    "value",
+    "steps",
+    "stepCount",
+    "step_count",
+];
+const JUNCTION_DISTANCE_VALUE_PATHS = [
+    "value",
+    "distance",
+    "distanceMeters",
+    "distance_meters",
+    "distanceKm",
+    "distance_km",
+];
+const JUNCTION_ACTIVE_CALORIES_VALUE_PATHS = [
+    "value",
+    "calories",
+    "activeCalories",
+    "active_calories",
+    "caloriesActive",
+    "calories_active",
+];
+const JUNCTION_HEARTRATE_VALUE_PATHS = [
+    "value",
+    "heartrate",
+    "heartRate",
+    "heart_rate",
+    "bpm",
+];
+const JUNCTION_WEIGHT_VALUE_PATHS = [
+    "value",
+    "weight",
+    "bodyWeight",
+    "body_weight",
+    "weightKg",
+    "weight_kg",
+];
+const JUNCTION_GENERIC_TIMESERIES_VALUE_PATHS = ["value"];
+const JUNCTION_READING_STABLE_ID_PATHS = [
+    "id",
+    "resourceId",
+    "resource_id",
+    "externalId",
+    "external_id",
+    "providerId",
+    "provider_id",
+];
 const JUNCTION_BLOOD_PRESSURE_SYSTOLIC_PATHS = [
     "systolic",
 ];
@@ -597,6 +761,8 @@ export function normalizeJunctionSnapshot(snapshot, providerContext = {}) {
         importedAt,
         windowStart,
         windowEnd,
+        timeseriesWindowKind: snapshot.timeseriesWindowKind,
+        strictSparseCalendarRepair: snapshot.strictSparseCalendarRepair,
         connectionsByKey: buildConnectionsByKey(connections),
         evidenceParts,
         events,
@@ -605,6 +771,10 @@ export function normalizeJunctionSnapshot(snapshot, providerContext = {}) {
     normalizeSummaries(snapshot.summaries, context);
     normalizeTimeseries(snapshot.timeseries, context);
     normalizeCompanionHrvRmssd(companionHrvRmssd, context);
+    assertJunctionTimeseriesOutputBounds({
+        eventCount: events.length,
+        evidencePartCount: evidenceParts.length,
+    });
     return makeNormalizedDeviceBatch({
         provider: "junction",
         accountId: stringId(snapshot.accountId),
@@ -617,6 +787,7 @@ export function normalizeJunctionSnapshot(snapshot, providerContext = {}) {
             normalizerVersion: "junction-normalizer.v1",
             windowStart,
             windowEnd,
+            timeseriesWindowKind: snapshot.timeseriesWindowKind,
             connections: connections.length,
             summaryResources: listAllowedResourceKeys(snapshot.summaries, SUMMARY_RESOURCE_ALLOWLIST),
             timeseriesResources: listAllowedResourceKeys(snapshot.timeseries, TIMESERIES_RESOURCE_ALLOWLIST),
@@ -666,6 +837,81 @@ export function classifyJunctionSummaryNormalizationEvidence(snapshot, evidenceW
     return [...evidenceByKey.values()].sort((left, right) => left.resource.localeCompare(right.resource)
         || left.sourceProviderSlug.localeCompare(right.sourceProviderSlug));
 }
+export function identifyJunctionBloodPressureProviderRecords(snapshot) {
+    const connections = asArray(snapshot.connections).flatMap((connection) => {
+        const normalized = asPlainObject(connection);
+        return normalized ? [normalized] : [];
+    });
+    const context = {
+        importedAt: normalizeTimestamp(snapshot.importedAt),
+        windowStart: normalizeTimestamp(snapshot.windowStart),
+        windowEnd: normalizeTimestamp(snapshot.windowEnd),
+        connectionsByKey: buildConnectionsByKey(connections),
+        evidenceParts: [],
+        events: [],
+        samples: [],
+    };
+    const repairStableExternalRefResourceIds = [];
+    for (const [resource, payload] of allowedResourceEntries(snapshot.timeseries, TIMESERIES_RESOURCE_ALLOWLIST)) {
+        if (resource !== JUNCTION_BLOOD_PRESSURE_RESOURCE) {
+            continue;
+        }
+        const resourceSlug = slugify(resource, "timeseries");
+        const baseArtifactRole = `junction-timeseries-reading-${resourceSlug}`;
+        for (const [index, { entry, originFallback }] of timeseriesResourceEntries(payload).entries()) {
+            const resourceContext = buildResourceContext({
+                entry,
+                originFallback,
+                resource,
+                resourceSlug,
+                identityKind: "timeseries",
+                index,
+                fallbackArtifactRole: baseArtifactRole,
+                context,
+            });
+            repairStableExternalRefResourceIds.push(resourceContext
+                ? buildJunctionBloodPressureRepairStableExternalRefResourceId(entry, resourceContext)
+                : null);
+        }
+    }
+    return {
+        providerRecordCount: repairStableExternalRefResourceIds.length,
+        repairStableExternalRefResourceIds,
+    };
+}
+/** Count provider rows accepted by the canonical daily-aggregate parser. */
+export function countAcceptedJunctionDailyTimeseriesProviderRecords(snapshot) {
+    const connections = asArray(snapshot.connections).flatMap((connection) => {
+        const normalized = asPlainObject(connection);
+        return normalized ? [normalized] : [];
+    });
+    const context = {
+        importedAt: normalizeTimestamp(snapshot.importedAt),
+        windowStart: normalizeTimestamp(snapshot.windowStart),
+        windowEnd: normalizeTimestamp(snapshot.windowEnd),
+        connectionsByKey: buildConnectionsByKey(connections),
+        evidenceParts: [],
+        events: [],
+        samples: [],
+    };
+    let acceptedProviderRecordCount = 0;
+    for (const [resource, payload] of allowedResourceEntries(snapshot.timeseries, TIMESERIES_RESOURCE_ALLOWLIST)) {
+        const descriptor = JUNCTION_DAILY_TIMESERIES_DESCRIPTORS.get(resource);
+        if (!descriptor) {
+            continue;
+        }
+        acceptedProviderRecordCount += buildJunctionDailyTimeseriesAggregates({
+            context,
+            normalizeValue: descriptor.normalizeValue,
+            payload,
+            requireExplicitTimestamp: descriptor.requireExplicitTimestamp === true,
+            resource,
+            resourceSlug: slugify(resource, "timeseries"),
+            valuePaths: descriptor.valuePaths,
+        }).reduce((count, aggregate) => count + aggregate.sampleCount, 0);
+    }
+    return acceptedProviderRecordCount;
+}
 function isJunctionSummaryEvidenceEventInRange(event, evidenceRange) {
     const occurredAtMs = Date.parse(event.occurredAt);
     if (Number.isFinite(occurredAtMs)
@@ -898,21 +1144,41 @@ function buildJunctionMealFallbackIdentityDisambiguators(input) {
     }
     return disambiguators;
 }
-// Every default-enabled timeseries resource must appear here with a bounded
-// daily-aggregate mapping (or, for paired-shape `blood_pressure` only, the
-// dedicated sparse per-reading handler below); raw evidence stays one compact
-// ~430 B `junction.timeseries_daily_aggregate.v1` artifact per day per
-// resource (~160 KB/member-year/resource) no matter how dense the provider
-// stream is: glucose CGM streams (288 samples/day, ~10-15 MB/yr raw) reduce
+// Every daily-aggregate timeseries resource must appear here. `steps` and
+// `distance` use the scheduler's complete UTC-day owner; the other daily
+// resources keep their established bounded mapping. Paired/sparse and
+// feature-shaped resources use dedicated handlers below. Raw evidence stays
+// one compact ~430 B `junction.timeseries_daily_aggregate.v1` artifact per
+// day per resource (~160 KB/member-year/resource) no matter how dense the
+// provider stream is: glucose CGM streams (288 samples/day, ~10-15 MB/yr raw) reduce
 // to the same one artifact per day. Resource classifications and payload
 // field names are verified against docs.junction.com
 // (wearables/providers/resources; api-reference/data/timeseries/*): hrv,
 // respiratory_rate, blood_oxygen, glucose, and stress_level are discrete
 // timeseries; vo2_max, body_temperature(_delta), basal_body_temperature,
 // caffeine, water, mindfulness_minutes, heart_rate_recovery_one_minute,
-// sleep_breathing_disturbance, and afib_burden are interval timeseries. All
-// reduce to daily-grain observations below.
+// sleep_breathing_disturbance, and afib_burden are interval timeseries.
 const JUNCTION_DAILY_TIMESERIES_DESCRIPTOR_ENTRIES = [
+    ["steps", {
+            normalizeValue: normalizeStepCount,
+            observations: [
+                { metric: "daily-steps", statistic: "sum", title: "Junction steps" },
+            ],
+            requireExplicitTimestamp: true,
+            retainSumValue: true,
+            unit: "count",
+            valuePaths: JUNCTION_STEPS_VALUE_PATHS,
+        }],
+    ["distance", {
+            normalizeValue: normalizeDistanceKilometers,
+            observations: [
+                { metric: "distance-km", statistic: "sum", title: "Junction distance" },
+            ],
+            requireExplicitTimestamp: true,
+            retainSumValue: true,
+            unit: "km",
+            valuePaths: JUNCTION_DISTANCE_VALUE_PATHS,
+        }],
     ["blood_oxygen", {
             normalizeValue: normalizeBloodOxygenPercent,
             observations: [
@@ -1038,68 +1304,224 @@ const JUNCTION_DAILY_TIMESERIES_DESCRIPTOR_ENTRIES = [
             unit: "mg/dL",
             valuePaths: JUNCTION_GLUCOSE_VALUE_PATHS,
         }],
+    ["calories_basal", {
+            normalizeValue: normalizeBasalCaloriesKilocalories,
+            observations: [
+                { metric: "basal-calories", statistic: "sum", title: "Junction basal calories" },
+            ],
+            requireExplicitTimestamp: true,
+            retainSumValue: true,
+            unit: "kcal",
+            valuePaths: JUNCTION_GENERIC_TIMESERIES_VALUE_PATHS,
+        }],
+    ["daylight_exposure", {
+            normalizeValue: normalizeDaylightExposureMinutes,
+            observations: [
+                { metric: "daylight-exposure-minutes", statistic: "sum", title: "Junction daylight exposure" },
+            ],
+            requireExplicitTimestamp: true,
+            retainSumValue: true,
+            unit: "minutes",
+            valuePaths: JUNCTION_GENERIC_TIMESERIES_VALUE_PATHS,
+        }],
+    ["floors_climbed", {
+            normalizeValue: normalizeFloorsClimbedCount,
+            observations: [
+                { metric: "floors-climbed", statistic: "sum", title: "Junction floors climbed" },
+            ],
+            requireExplicitTimestamp: true,
+            retainSumValue: true,
+            unit: "count",
+            valuePaths: JUNCTION_GENERIC_TIMESERIES_VALUE_PATHS,
+        }],
+    ["stand_duration", {
+            normalizeValue: normalizeStandDurationMinutes,
+            observations: [
+                { metric: "stand-duration-minutes", statistic: "sum", title: "Junction stand duration" },
+            ],
+            requireExplicitTimestamp: true,
+            retainSumValue: true,
+            unit: "minutes",
+            valuePaths: JUNCTION_GENERIC_TIMESERIES_VALUE_PATHS,
+        }],
+    ["stand_hour", {
+            normalizeValue: normalizeStandHourCount,
+            observations: [
+                { metric: "stand-hours", statistic: "sum", title: "Junction stand hours" },
+            ],
+            requireExplicitTimestamp: true,
+            retainSumValue: true,
+            unit: "count",
+            valuePaths: JUNCTION_GENERIC_TIMESERIES_VALUE_PATHS,
+        }],
+    ["wheelchair_push", {
+            normalizeValue: normalizeWheelchairPushCount,
+            observations: [
+                { metric: "wheelchair-push-count", statistic: "sum", title: "Junction wheelchair pushes" },
+            ],
+            requireExplicitTimestamp: true,
+            retainSumValue: true,
+            unit: "count",
+            valuePaths: JUNCTION_GENERIC_TIMESERIES_VALUE_PATHS,
+        }],
 ];
 const JUNCTION_DAILY_TIMESERIES_DESCRIPTORS = new Map(JUNCTION_DAILY_TIMESERIES_DESCRIPTOR_ENTRIES);
+const JUNCTION_FEATURE_TIMESERIES_DESCRIPTOR_ENTRIES = [
+    ["calories_active", {
+            normalizeValue: normalizeActiveCaloriesKilocalories,
+            observations: [
+                { metric: "active-calories", statistic: "sum", title: "Junction active calories" },
+            ],
+            unit: "kcal",
+            valuePaths: JUNCTION_ACTIVE_CALORIES_VALUE_PATHS,
+        }],
+    ["heartrate", {
+            normalizeValue: normalizeHeartRateBpm,
+            observations: [
+                { metric: "average-heart-rate", statistic: "mean", title: "Junction heart rate average" },
+                { metric: "lowest-heart-rate", statistic: "min", title: "Junction heart rate minimum" },
+                { metric: "max-heart-rate", statistic: "max", title: "Junction heart rate maximum" },
+            ],
+            unit: "bpm",
+            valuePaths: JUNCTION_HEARTRATE_VALUE_PATHS,
+        }],
+    ["handwashing", {
+            normalizeValue: normalizeHandwashingCount,
+            observations: [
+                { metric: "handwashing-count", statistic: "sum", title: "Junction handwashing" },
+            ],
+            unit: "count",
+            valuePaths: JUNCTION_GENERIC_TIMESERIES_VALUE_PATHS,
+        }],
+    ["uv_exposure", {
+            normalizeValue: normalizeUvExposureIndex,
+            observations: [
+                { metric: "uv-exposure-index", statistic: "mean", title: "Junction UV exposure" },
+            ],
+            unit: "index",
+            valuePaths: JUNCTION_GENERIC_TIMESERIES_VALUE_PATHS,
+        }],
+    ["workout_distance", {
+            normalizeValue: normalizeDistanceKilometers,
+            observations: [
+                { metric: "workout-distance-km", statistic: "sum", title: "Junction workout distance" },
+            ],
+            unit: "km",
+            valuePaths: JUNCTION_GENERIC_TIMESERIES_VALUE_PATHS,
+        }],
+    ["workout_duration", {
+            normalizeValue: normalizeWorkoutDurationMinutes,
+            observations: [
+                { metric: "workout-minutes", statistic: "sum", title: "Junction workout duration" },
+            ],
+            unit: "minutes",
+            valuePaths: JUNCTION_GENERIC_TIMESERIES_VALUE_PATHS,
+        }],
+    ["workout_swimming_stroke", {
+            normalizeValue: normalizeWorkoutSwimmingStrokeCount,
+            observations: [
+                { metric: "swimming-stroke-count", statistic: "sum", title: "Junction swimming strokes" },
+            ],
+            unit: "count",
+            valuePaths: JUNCTION_GENERIC_TIMESERIES_VALUE_PATHS,
+        }],
+];
+const JUNCTION_FEATURE_TIMESERIES_DESCRIPTORS = new Map(JUNCTION_FEATURE_TIMESERIES_DESCRIPTOR_ENTRIES);
 // Junction's blood-pressure timeseries pairs `systolic`/`diastolic` per
 // reading (docs.junction.com/api-reference/data/timeseries/blood-pressure),
 // so it cannot reduce through the single-value daily-aggregate descriptors.
 // Readings are sparse (10s-100s per member-year): each one lands as a paired
 // `measurement` event plus one compact per-reading evidence part.
 const JUNCTION_BLOOD_PRESSURE_RESOURCE = "blood_pressure";
-// Derived from the descriptor entries (plus the sparse paired blood-pressure
-// resource) so the raw-snapshot sanitization allowlist cannot drift from the
-// bounded normalization set.
-const COMPACT_TIMESERIES_RESOURCE_ALLOWLIST = new Set([
-    ...JUNCTION_DAILY_TIMESERIES_DESCRIPTOR_ENTRIES.map(([resource]) => resource),
-    JUNCTION_BLOOD_PRESSURE_RESOURCE,
+const JUNCTION_NOTE_RESOURCE = "note";
+const JUNCTION_WEIGHT_RESOURCE = "weight";
+const JUNCTION_SPARSE_TIMESERIES_DESCRIPTORS = new Map([
+    ["body_mass_index", { canonicalUnit: "kg_m2", kind: "observation", maximum: 100, metric: "bmi", minimum: 5, title: "Junction BMI", upstreamUnit: "index" }],
+    ["carbohydrates", { canonicalUnit: "g", kind: "observation", maximum: 2_000, metric: "carbohydrates", minimum: 0, title: "Junction carbohydrates", upstreamUnit: "g" }],
+    ["fat", { canonicalUnit: "%", kind: "observation", maximum: 100, metric: "body-fat-percentage", minimum: 0, title: "Junction body fat", upstreamUnit: "%" }],
+    ["forced_expiratory_volume_1", { canonicalUnit: "L", kind: "observation", maximum: 15, metric: "forced-expiratory-volume-1", minimum: 0.05, title: "Junction FEV1", upstreamUnit: "L" }],
+    ["forced_vital_capacity", { canonicalUnit: "L", kind: "observation", maximum: 20, metric: "forced-vital-capacity", minimum: 0.05, title: "Junction forced vital capacity", upstreamUnit: "L" }],
+    ["heart_rate_alert", { canonicalUnit: "count", kind: "alert", maximum: 10_000, metric: "heart-rate-alert", minimum: 1, requireInteger: true, title: "Junction heart-rate alert", upstreamUnit: "count" }],
+    ["inhaler_usage", { canonicalUnit: "count", kind: "observation", maximum: 1_000, metric: "inhaler-usage", minimum: 1, requireInteger: true, title: "Junction inhaler usage", upstreamUnit: "count" }],
+    ["insulin_injection", { canonicalUnit: "unit", kind: "insulin", maximum: 1_000, minimum: 0.01, title: "Junction insulin injection", upstreamUnit: "unit" }],
+    ["lean_body_mass", { canonicalUnit: "kg", kind: "observation", maximum: 500, metric: "lean-body-mass", minimum: 1, title: "Junction lean body mass", upstreamUnit: "kg" }],
+    ["peak_expiratory_flow_rate", { canonicalUnit: "L/min", kind: "observation", maximum: 2_000, metric: "peak-expiratory-flow-rate", minimum: 1, title: "Junction peak expiratory flow rate", upstreamUnit: "L/min" }],
+    ["sleep_apnea_alert", { canonicalUnit: "count", kind: "alert", maximum: 10_000, metric: "sleep-apnea-alert", minimum: 1, requireInteger: true, title: "Junction sleep-apnea alert", upstreamUnit: "count" }],
+    ["waist_circumference", { canonicalUnit: "cm", kind: "observation", maximum: 300, metric: "waist-circumference", minimum: 20, title: "Junction waist circumference", upstreamUnit: "cm" }],
+    ["fall", { canonicalUnit: "count", kind: "alert", maximum: 1_000, metric: "fall-count", minimum: 1, requireInteger: true, title: "Junction fall", upstreamUnit: "count" }],
+]);
+const JUNCTION_HEART_ALERT_TYPES = new Set([
+    "high",
+    "high_heart_rate",
+    "high_heart_rate_alert",
+    "irregular_rhythm",
+    "low",
+    "low_heart_rate",
+    "low_heart_rate_alert",
 ]);
+// Derived from the contracts-owned storage policy so admitting a new name
+// cannot silently make the raw-snapshot sanitizer retain an unsupported shape.
+const COMPACT_TIMESERIES_RESOURCE_ALLOWLIST = new Set(JUNCTION_TIMESERIES_RESOURCE_POLICIES.map((policy) => policy.resource));
 function normalizeTimeseries(timeseries, context) {
     for (const [resource, payload] of allowedResourceEntries(timeseries, TIMESERIES_RESOURCE_ALLOWLIST)) {
+        if (resource === JUNCTION_NOTE_RESOURCE) {
+            pushJunctionNoteTags(payload, resource, slugify(resource, "timeseries"), context);
+            continue;
+        }
+        if (resource === "electrocardiogram_voltage" || resource === "workout_stream") {
+            pushJunctionBoundedTimeseriesFeatures(payload, resource, context);
+            continue;
+        }
         if (resource === JUNCTION_BLOOD_PRESSURE_RESOURCE) {
             pushJunctionBloodPressureReadings(payload, resource, slugify(resource, "timeseries"), context);
             continue;
         }
-        const descriptor = JUNCTION_DAILY_TIMESERIES_DESCRIPTORS.get(resource);
-        if (descriptor) {
-            pushJunctionDailyTimeseriesObservations(payload, resource, slugify(resource, "timeseries"), context, descriptor);
+        if (resource === JUNCTION_WEIGHT_RESOURCE) {
+            pushJunctionWeightReadings(payload, resource, slugify(resource, "timeseries"), context);
+            continue;
         }
-    }
-}
-function pushJunctionDailyTimeseriesObservations(payload, resource, resourceSlug, context, descriptor) {
-    for (const aggregate of buildJunctionDailyTimeseriesAggregates({
-        payload,
-        resource,
-        resourceSlug,
-        context,
-        valuePaths: descriptor.valuePaths,
-        normalizeValue: descriptor.normalizeValue,
-    })) {
-        for (const observation of descriptor.observations) {
-            pushJunctionDailyTimeseriesObservation(context, aggregate, {
-                metric: observation.metric,
-                title: observation.title,
-                unit: descriptor.unit,
-                value: junctionDailyTimeseriesStatisticValue(aggregate, observation.statistic),
-            });
+        const sparseDescriptor = JUNCTION_SPARSE_TIMESERIES_DESCRIPTORS.get(resource);
+        if (sparseDescriptor) {
+            pushJunctionSparseTimeseriesRecords(payload, resource, slugify(resource, "timeseries"), context, sparseDescriptor);
+            continue;
+        }
+        const dailyDescriptor = JUNCTION_DAILY_TIMESERIES_DESCRIPTORS.get(resource);
+        if (dailyDescriptor) {
+            let selectedSparseRecords;
+            if (isJunctionSparseIntervalResource(resource)) {
+                assertJunctionSparseCalendarRepairRowsValid({
+                    context,
+                    descriptor: dailyDescriptor,
+                    payload,
+                    resource,
+                    resourceSlug: slugify(resource, "timeseries"),
+                });
+                selectedSparseRecords = pushJunctionSparseIntervalReadings(payload, resource, slugify(resource, "timeseries"), context, dailyDescriptor);
+            }
+            if (!isJunctionSparseIntervalResource(resource)
+                || context.timeseriesWindowKind !== "precise") {
+                pushJunctionDailyTimeseriesObservations(payload, resource, slugify(resource, "timeseries"), context, dailyDescriptor, selectedSparseRecords);
+            }
+            continue;
+        }
+        const featureDescriptor = JUNCTION_FEATURE_TIMESERIES_DESCRIPTORS.get(resource);
+        if (featureDescriptor) {
+            pushJunctionFeatureTimeseriesObservations(payload, resource, slugify(resource, "timeseries"), context, featureDescriptor);
         }
     }
 }
-function junctionDailyTimeseriesStatisticValue(aggregate, statistic) {
-    switch (statistic) {
-        case "min":
-            return aggregate.minValue;
-        case "max":
-            return aggregate.maxValue;
-        case "sum":
-            return aggregate.sum;
-        case "mean":
-            return aggregate.sum / aggregate.sampleCount;
+function assertJunctionSparseCalendarRepairRowsValid(input) {
+    const expectation = input.context.strictSparseCalendarRepair;
+    if (!expectation || expectation.resource !== input.resource) {
+        return;
     }
-}
-function buildJunctionDailyTimeseriesAggregates(input) {
-    const evidencePartRole = `junction-timeseries-daily-${input.resourceSlug}`;
-    const aggregates = new Map();
-    for (const [index, { entry, originFallback }] of timeseriesResourceEntries(input.payload).entries()) {
+    const entries = timeseriesResourceEntries(input.payload);
+    assertJunctionTimeseriesResponseBound(input.resource, entries.length);
+    if (entries.length === 1
+        && entries[0]?.entry.authoritativeEmptyCalendarSet === true) {
+        return;
+    }
+    for (const [index, { entry, originFallback }] of entries.entries()) {
         const resourceContext = buildResourceContext({
             entry,
             originFallback,
@@ -1107,44 +1529,1265 @@ function buildJunctionDailyTimeseriesAggregates(input) {
             resourceSlug: input.resourceSlug,
             identityKind: "timeseries",
             index,
-            fallbackArtifactRole: evidencePartRole,
+            fallbackArtifactRole: `junction-timeseries-reading-${input.resourceSlug}`,
             context: input.context,
         });
+        const providerValue = finiteNumber(firstValueFromPaths(entry, input.descriptor.valuePaths));
+        const value = input.descriptor.normalizeValue(providerValue, entry);
+        const startRaw = firstStringFromPaths(entry, JUNCTION_INTERVAL_START_TIMESTAMP_PATHS);
+        const endRaw = firstStringFromPaths(entry, JUNCTION_INTERVAL_END_TIMESTAMP_PATHS);
+        const startAt = resolveSafeTimestamp(startRaw);
+        const endAt = resolveSafeTimestamp(endRaw);
+        const timestamp = resourceContext && startRaw
+            ? resolveJunctionSparseIntervalTimestamp(entry, startRaw, input.context, resourceContext.sourceProviderSlug)
+            : null;
+        const dayKey = timestamp && startAt
+            ? resolveJunctionTimeseriesAggregateDayKey(entry, timestamp, startAt, input.context.defaultTimeZone)
+            : undefined;
+        const valid = resourceContext !== null
+            && providerValue !== undefined
+            && value !== undefined
+            && startRaw !== undefined
+            && endRaw !== undefined
+            && startAt !== undefined
+            && endAt !== undefined
+            && Date.parse(endAt) >= Date.parse(startAt)
+            && dayKey === expectation.dayKey
+            && resourceContext.sourceProviderSlug === expectation.sourceProviderSlug
+            && (expectation.sourceType == null
+                || resourceContext.origin.sourceType === expectation.sourceType)
+            && (expectation.sourceInstanceId == null
+                || resourceContext.origin.sourceInstanceId === expectation.sourceInstanceId);
+        if (!valid) {
+            throw new JunctionSparseCalendarRepairNormalizationError();
+        }
+    }
+}
+export class JunctionSparseCalendarRepairNormalizationError extends Error {
+    code = "JUNCTION_CALENDAR_REFRESH_INCOMPLETE_NORMALIZATION";
+    retryable = true;
+    constructor() {
+        super("Junction calendar refresh contained a row that could not be applied completely.");
+        this.name = "JunctionSparseCalendarRepairNormalizationError";
+    }
+}
+function pushJunctionBoundedTimeseriesFeatures(payload, resource, context) {
+    const features = normalizeJunctionBoundedTimeseriesFeatures(resource, payload);
+    const featureResourceSlug = slugify(resource, "timeseries");
+    features.forEach((entry, index) => {
+        const identity = buildJunctionBoundedFeatureIdentity(resource, entry);
+        const evidenceRole = `junction-timeseries-feature-${featureResourceSlug}:${shortHash([
+            resource,
+            identity,
+        ])}`;
+        pushEvidencePart(context.evidenceParts, withJunctionCompactTimeseriesMetadata(resource, createEvidencePart(evidenceRole, `${evidenceRole}.json`, entry), "timeseries_feature_aggregate"));
+        const resourceContext = buildResourceContext({
+            entry,
+            resource,
+            resourceSlug: featureResourceSlug,
+            identityKind: "timeseries",
+            index,
+            fallbackArtifactRole: evidenceRole,
+            fallbackIdentityDisambiguator: identity,
+            context,
+        });
         if (!resourceContext) {
-            continue;
+            return;
         }
-        const value = input.normalizeValue(firstNumberFromPaths(entry, input.valuePaths));
-        const timestamp = resolveRecordTimestamp(entry, input.context, resourceContext.sourceProviderSlug);
-        const sampleAt = resolveJunctionDailyAggregateSampleAt(timestamp);
-        const dayKey = resolveJunctionTimeseriesAggregateDayKey(entry, timestamp, sampleAt, input.context.defaultTimeZone);
-        const legacyDayKey = resolveLegacyJunctionTimeseriesAggregateDayKey(entry, timestamp, sampleAt);
-        if (value === undefined || !sampleAt || !dayKey) {
-            continue;
+        if (resource === "electrocardiogram_voltage") {
+            pushElectrocardiogramSummary(entry, resourceContext, context);
         }
-        const key = [
-            resourceContext.externalRefResourceType,
-            resourceContext.origin.sourceType ?? "",
-            resourceContext.origin.sourceInstanceId ?? "",
-            dayKey,
-        ].join("\u0000");
-        const existing = aggregates.get(key);
-        const recordedAt = timestamp.recordedAt ?? sampleAt;
-        const timeZone = firstStringFromPaths(entry, ["timeZone", "timezone", "time_zone"]);
-        const legacyDayKeys = new Set();
-        if (legacyDayKey && legacyDayKey !== dayKey) {
-            legacyDayKeys.add(legacyDayKey);
+        else {
+            pushJunctionWorkoutStreamFeature(entry, resourceContext, context);
         }
-        if (!existing) {
-            aggregates.set(key, {
-                dayKey,
-                entry,
-                firstSampleAt: sampleAt,
-                lastRecordedAt: recordedAt,
-                lastSampleAt: sampleAt,
-                legacyDayKeys,
-                maxValue: value,
+    });
+}
+function pushJunctionWorkoutStreamFeature(entry, resourceContext, context) {
+    const startRaw = firstValueFromPaths(entry, ["startAt"]);
+    const occurredAt = resolveSafeTimestamp(startRaw, resourceContext.sourceProviderSlug);
+    if (!occurredAt) {
+        return;
+    }
+    const baseTimestamp = resolveRecordTimestamp(entry, context, resourceContext.sourceProviderSlug);
+    const timestamp = withTimestampOverride(baseTimestamp, {
+        occurredAt,
+        dayKey: extractIsoDatePrefix(occurredAt) ?? baseTimestamp.dayKey,
+        observedAtRaw: stringId(startRaw) ?? occurredAt,
+    });
+    const durationSeconds = firstNonNegativeNumberFromPaths(entry, ["durationSeconds"]);
+    const distanceMeters = firstNonNegativeNumberFromPaths(entry, ["distanceMeters"]);
+    const averageHeartRate = firstNonNegativeNumberFromPaths(entry, ["averageHeartRate"]);
+    const maxHeartRate = firstNonNegativeNumberFromPaths(entry, ["maxHeartRate"]);
+    const measurements = [
+        ...(durationSeconds === undefined
+            ? []
+            : [{ metric: "workout-minutes", value: durationSeconds / 60, unit: "minutes" }]),
+        ...(distanceMeters === undefined
+            ? []
+            : [{ metric: "workout-distance-km", value: distanceMeters / 1_000, unit: "km" }]),
+        ...(averageHeartRate === undefined
+            ? []
+            : [{ metric: "average-heart-rate", value: averageHeartRate, unit: "bpm" }]),
+        ...(maxHeartRate === undefined
+            ? []
+            : [{ metric: "max-heart-rate", value: maxHeartRate, unit: "bpm" }]),
+    ];
+    if (measurements.length === 0) {
+        return;
+    }
+    context.events.push(stripUndefined({
+        kind: "measurement",
+        occurredAt,
+        recordedAt: timestamp.recordedAt,
+        dayKey: timestamp.dayKey,
+        source: "device",
+        title: "Junction workout stream features",
+        evidenceRoles: resourceContext.evidenceRoles,
+        externalRef: makeJunctionExternalRef(resourceContext, entry, timestamp, "workout-stream-feature"),
+        dataOrigin: buildDataOrigin(entry, resourceContext, timestamp),
+        fields: { measurements },
+    }));
+}
+function normalizeJunctionBoundedTimeseriesFeatures(resource, payload) {
+    const records = timeseriesResourceEntries(payload).map(({ entry }) => entry);
+    return resolveJunctionBoundedFeatureRecords(resource, records);
+}
+function pushJunctionSparseTimeseriesRecords(payload, resource, resourceSlug, context, descriptor) {
+    const baseArtifactRole = `junction-timeseries-reading-${resourceSlug}`;
+    const candidates = [];
+    for (const [index, { entry, originFallback }] of timeseriesResourceEntries(payload).entries()) {
+        const resourceContext = buildResourceContext({
+            entry,
+            originFallback,
+            resource,
+            resourceSlug,
+            identityKind: "timeseries",
+            index,
+            fallbackArtifactRole: baseArtifactRole,
+            context,
+        });
+        if (!resourceContext) {
+            continue;
+        }
+        const record = parseJunctionSparseTimeseriesRecord(entry, resource, descriptor);
+        if (!record) {
+            continue;
+        }
+        const timestamp = resolveRecordTimestamp({ ...entry, observedAtRaw: record.observedAtRaw }, context, resourceContext.sourceProviderSlug);
+        const occurredAt = timestamp.occurredAt ?? timestamp.recordedAt;
+        const dayKey = resolveJunctionTimeseriesAggregateDayKey(entry, timestamp, occurredAt, context.defaultTimeZone);
+        if (!occurredAt || !dayKey) {
+            continue;
+        }
+        candidates.push({
+            dayKey,
+            entry,
+            identityHash: buildJunctionSparseTimeseriesIdentityHash({
+                record,
+                resourceContext,
+                resourceSlug,
+            }),
+            occurredAt,
+            record,
+            resourceContext,
+            semanticContentKey: buildJunctionSparseTimeseriesSemanticContentKey({
+                dayKey,
+                entry,
+                occurredAt,
+                record,
+                resourceContext,
+                resourceSlug,
+                timestamp,
+            }),
+            timestamp,
+        });
+    }
+    const semanticContentKeysByProviderIdentity = new Map();
+    for (const candidate of candidates) {
+        if (!candidate.record.providerRowId) {
+            continue;
+        }
+        const contentKeys = semanticContentKeysByProviderIdentity.get(candidate.identityHash)
+            ?? new Set();
+        contentKeys.add(candidate.semanticContentKey);
+        semanticContentKeysByProviderIdentity.set(candidate.identityHash, contentKeys);
+    }
+    const conflictingProviderIdentityHashes = new Set([...semanticContentKeysByProviderIdentity.entries()]
+        .filter(([, contentKeys]) => contentKeys.size > 1)
+        .map(([identityHash]) => identityHash));
+    const seenRecordIdentityHashes = new Set();
+    for (const candidate of candidates) {
+        const { dayKey, entry, identityHash, occurredAt, record, resourceContext, timestamp, } = candidate;
+        if (conflictingProviderIdentityHashes.has(identityHash)
+            || seenRecordIdentityHashes.has(identityHash)) {
+            continue;
+        }
+        seenRecordIdentityHashes.add(identityHash);
+        const role = `${baseArtifactRole}:${dayKey}:${identityHash}`;
+        pushEvidencePart(context.evidenceParts, withJunctionCompactTimeseriesMetadata(resource, createEvidencePart(role, `${role}.json`, stripUndefined({
+            schema: "junction.sparse_timeseries_record.v1",
+            provider: "junction",
+            resource,
+            dayKey,
+            sourceProviderSlug: resourceContext.sourceProviderSlug,
+            sourceType: resourceContext.origin.sourceType,
+            sourceInstanceId: resourceContext.origin.sourceInstanceId,
+            providerRowId: record.providerRowId,
+            observedAtRaw: record.observedAtRaw,
+            occurredAt,
+            recordedAt: timestamp.recordedAt,
+            startAt: record.startAt,
+            endAt: record.endAt,
+            value: record.value,
+            unit: record.unit,
+            upstreamUnit: record.upstreamUnit,
+            alertType: record.alertType,
+            bolusPurpose: record.bolusPurpose,
+            deliveryForm: record.deliveryForm,
+            deliveryMode: record.deliveryMode,
+            insulinType: record.insulinType,
+        })), "timeseries_reading"));
+        const externalRef = makeProviderExternalRef("junction", resourceContext.externalRefResourceType, `${resourceSlug}-${identityHash}`, undefined, descriptor.metric ?? resourceSlug);
+        const dataOrigin = buildDataOrigin(entry, resourceContext, withTimestampOverride(timestamp, {
+            occurredAt,
+            dayKey,
+            observedAtRaw: record.observedAtRaw,
+        }), { normalizerVersion: "junction-sparse-timeseries.v1" });
+        if (descriptor.kind === "insulin") {
+            const insulinTags = [
+                record.bolusPurpose,
+                record.deliveryForm,
+                record.deliveryMode,
+                record.insulinType,
+            ].flatMap((value) => value ? [slugify(value, "insulin")] : []);
+            context.events.push(stripUndefined({
+                kind: "intervention_session",
+                occurredAt,
+                recordedAt: timestamp.recordedAt,
+                dayKey,
+                source: "device",
+                title: descriptor.title,
+                tags: insulinTags.length > 0 ? [...new Set(insulinTags)] : undefined,
+                evidenceRoles: [role],
+                externalRef,
+                dataOrigin,
+                fields: {
+                    interventionType: "insulin-injection",
+                    sessionStatus: "completed",
+                    fields: stripUndefined({
+                        "dose-amount": record.value,
+                        "dose-unit": record.unit,
+                        "start-at": record.startAt,
+                        "end-at": record.endAt,
+                        "bolus-purpose": record.bolusPurpose,
+                        "delivery-form": record.deliveryForm,
+                        "delivery-mode": record.deliveryMode,
+                        "insulin-type": record.insulinType,
+                    }),
+                },
+            }));
+            continue;
+        }
+        if (!descriptor.metric) {
+            continue;
+        }
+        const alertTag = record.alertType
+            ? slugify(`${resource}-${record.alertType}`, "alert")
+            : undefined;
+        context.events.push(stripUndefined({
+            kind: "observation",
+            occurredAt,
+            recordedAt: timestamp.recordedAt,
+            dayKey,
+            source: "device",
+            title: descriptor.title,
+            tags: alertTag ? [alertTag] : undefined,
+            evidenceRoles: [role],
+            externalRef,
+            dataOrigin,
+            fields: {
+                metric: descriptor.metric,
+                observationGrain: "sample",
+                value: record.value,
+                unit: descriptor.canonicalUnit,
+            },
+        }));
+    }
+}
+function parseJunctionSparseTimeseriesRecord(entry, resource, descriptor) {
+    const value = finiteNumber(entry.value);
+    const unit = stringId(entry.unit);
+    if (value === undefined
+        || unit !== descriptor.upstreamUnit
+        || value < descriptor.minimum
+        || value > descriptor.maximum
+        || (descriptor.requireInteger === true && !Number.isSafeInteger(value))) {
+        return null;
+    }
+    const timestampRaw = stringId(entry.timestamp);
+    const startRaw = stringId(entry.start);
+    const endRaw = stringId(entry.end);
+    const requiresTimestamp = resource !== "carbohydrates"
+        && resource !== "heart_rate_alert"
+        && resource !== "insulin_injection";
+    const requiresInterval = resource !== "fat";
+    if ((requiresTimestamp && !timestampRaw) || (requiresInterval && (!startRaw || !endRaw))) {
+        return null;
+    }
+    const timestamp = timestampRaw ? normalizeTimestamp(timestampRaw) : undefined;
+    const startAt = startRaw ? normalizeTimestamp(startRaw) : undefined;
+    const endAt = endRaw ? normalizeTimestamp(endRaw) : undefined;
+    if ((timestampRaw && !timestamp)
+        || (startRaw && !startAt)
+        || (endRaw && !endAt)
+        || (requiresInterval && (!startAt || !endAt))
+        || (startAt && endAt && Date.parse(endAt) < Date.parse(startAt))) {
+        return null;
+    }
+    const observedAtRaw = timestampRaw ?? startRaw;
+    if (!observedAtRaw) {
+        return null;
+    }
+    const alertType = descriptor.kind === "alert" && resource === "heart_rate_alert"
+        ? normalizeJunctionSemanticToken(entry.type)
+        : undefined;
+    if (resource === "heart_rate_alert" && (!alertType || !JUNCTION_HEART_ALERT_TYPES.has(alertType))) {
+        return null;
+    }
+    return stripUndefined({
+        alertType,
+        bolusPurpose: descriptor.kind === "insulin"
+            ? normalizeJunctionSemanticToken(entry.bolus_purpose ?? entry.bolusPurpose)
+            : undefined,
+        deliveryForm: descriptor.kind === "insulin"
+            ? normalizeJunctionSemanticToken(entry.delivery_form ?? entry.deliveryForm)
+            : undefined,
+        deliveryMode: descriptor.kind === "insulin"
+            ? normalizeJunctionSemanticToken(entry.delivery_mode ?? entry.deliveryMode)
+            : undefined,
+        insulinType: descriptor.kind === "insulin"
+            ? normalizeJunctionSemanticToken(entry.type)
+            : undefined,
+        endAt,
+        observedAtRaw,
+        providerRowId: trimOptionalToLength(firstStringFromPaths(entry, JUNCTION_GENERIC_SUMMARY_ID_PATHS), 200),
+        startAt,
+        unit: descriptor.canonicalUnit,
+        upstreamUnit: descriptor.upstreamUnit,
+        value,
+    });
+}
+function normalizeJunctionSemanticToken(value) {
+    const normalized = stringId(value)
+        ?.trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/gu, "_")
+        .replace(/^_+|_+$/gu, "")
+        .slice(0, 80)
+        .replace(/_+$/u, "");
+    return normalized || undefined;
+}
+function buildJunctionSparseTimeseriesIdentityHash(input) {
+    if (input.record.providerRowId) {
+        return shortHash([
+            input.resourceSlug,
+            input.resourceContext.sourceProviderSlug,
+            input.resourceContext.origin.sourceType ?? "",
+            input.resourceContext.origin.sourceInstanceId ?? "",
+            input.record.providerRowId,
+        ]);
+    }
+    return buildJunctionSparseTimeseriesSemanticIdentityHash(input);
+}
+function buildJunctionSparseTimeseriesSemanticIdentityHash(input) {
+    return shortHash(junctionSparseTimeseriesSemanticIdentityParts(input));
+}
+function junctionSparseTimeseriesSemanticIdentityParts(input) {
+    return [
+        input.resourceSlug,
+        input.resourceContext.sourceProviderSlug,
+        input.resourceContext.origin.sourceType ?? "",
+        input.resourceContext.origin.sourceInstanceId ?? "",
+        input.record.providerRowId ?? "",
+        input.record.observedAtRaw,
+        input.record.startAt ?? "",
+        input.record.endAt ?? "",
+        input.record.value,
+        input.record.unit,
+        input.record.upstreamUnit,
+        input.record.alertType ?? "",
+        input.record.bolusPurpose ?? "",
+        input.record.deliveryForm ?? "",
+        input.record.deliveryMode ?? "",
+        input.record.insulinType ?? "",
+    ];
+}
+function buildJunctionSparseTimeseriesSemanticContentKey(input) {
+    return JSON.stringify([
+        ...junctionSparseTimeseriesSemanticIdentityParts(input),
+        input.occurredAt,
+        input.timestamp.recordedAt ?? "",
+        input.dayKey,
+        input.timestamp.timestampSemantics ?? "",
+        readJunctionTimeZoneOffsetMinutes(input.entry) ?? "",
+        input.resourceContext.origin.originConfidence ?? "",
+    ]);
+}
+function pushJunctionNoteTags(payload, resource, resourceSlug, context) {
+    const baseArtifactRole = `junction-timeseries-reading-${resourceSlug}`;
+    const noteSpines = new Map();
+    for (const [index, { entry, originFallback }] of timeseriesResourceEntries(payload).entries()) {
+        const resourceContext = buildResourceContext({
+            entry,
+            originFallback,
+            resource,
+            resourceSlug,
+            identityKind: "timeseries",
+            index,
+            fallbackArtifactRole: baseArtifactRole,
+            context,
+        });
+        if (!resourceContext)
+            continue;
+        // A missing tag field is still a free-text-only provider note and stays
+        // canonical-no-op. An explicit empty tag set is retained so a later replay
+        // can clear the tag state on an existing neutral note spine.
+        if (!Object.hasOwn(entry, "tags"))
+            continue;
+        const tags = normalizeJunctionNoteTags(entry.tags);
+        const start = firstStringFromPaths(entry, ["start", "startAt", "start_at"]);
+        const baseTimestamp = resolveRecordTimestamp(start ? { ...entry, observedAtRaw: start } : entry, context, resourceContext.sourceProviderSlug);
+        const timestamp = withTimestampOverride(baseTimestamp, {
+            dayKey: baseTimestamp.dayKey ?? extractIsoDatePrefix(start) ?? undefined,
+        });
+        if (!timestamp.occurredAt || !timestamp.dayKey)
+            continue;
+        const stableId = firstStringFromPaths(entry, JUNCTION_GENERIC_SUMMARY_ID_PATHS);
+        const resourceId = buildJunctionNoteResourceId(resourceContext, stableId, timestamp);
+        const spineKey = `${resourceContext.externalRefResourceType}:${resourceId}`;
+        const existing = noteSpines.get(spineKey);
+        if (existing) {
+            if (stableId) {
+                // Duplicate rows with an explicit provider identity describe one note.
+                // Keep the final row's current tag state rather than unioning revisions.
+                existing.entry = entry;
+                existing.resourceContext = resourceContext;
+                existing.tags = new Set(tags);
+                existing.timestamp = timestamp;
+            }
+            else {
+                // Without an upstream id, source + timestamp is the narrowest stable
+                // spine available. Preserve every same-time tag while allowing a later
+                // replay to revise or clear that timestamp's aggregate tag state.
+                for (const tag of tags)
+                    existing.tags.add(tag);
+            }
+            continue;
+        }
+        noteSpines.set(spineKey, {
+            entry,
+            resourceContext,
+            resourceId,
+            tags: new Set(tags),
+            timestamp,
+        });
+    }
+    for (const spine of noteSpines.values()) {
+        const tags = [...spine.tags].sort();
+        const dayKey = spine.timestamp.dayKey;
+        const occurredAt = spine.timestamp.occurredAt;
+        if (!dayKey || !occurredAt)
+            continue;
+        const role = `${baseArtifactRole}:${dayKey}:${spine.resourceId}`;
+        pushEvidencePart(context.evidenceParts, withJunctionCompactTimeseriesMetadata(resource, createEvidencePart(role, `${role}.json`, stripUndefined({
+            schema: "junction.note_tags.v1",
+            provider: "junction",
+            resource,
+            dayKey,
+            sourceProviderSlug: spine.resourceContext.sourceProviderSlug,
+            sourceType: spine.resourceContext.origin.sourceType,
+            sourceInstanceId: spine.resourceContext.origin.sourceInstanceId,
+            occurredAt,
+            recordedAt: spine.timestamp.recordedAt,
+            tags,
+        })), "timeseries_reading"));
+        context.events.push(stripUndefined({
+            kind: "note",
+            occurredAt,
+            recordedAt: spine.timestamp.recordedAt,
+            dayKey,
+            source: "device",
+            title: "Wearable tags",
+            // The canonical note body is a product-owned marker. Provider free text
+            // never crosses the sanitizer; normalized tag facts live only in `tags`.
+            note: "Wearable tags",
+            tags,
+            evidenceRoles: [role],
+            // This facet is intentionally distinct from the legacy `tag-*`
+            // intervention facets. Core event spines are kind-stable, so any repair
+            // of already-persisted legacy rows must remain explicit.
+            externalRef: makeProviderExternalRef("junction", spine.resourceContext.externalRefResourceType, spine.resourceId, undefined, JUNCTION_WEARABLE_TAG_EXTERNAL_REF_FACET),
+            dataOrigin: buildDataOrigin(spine.entry, spine.resourceContext, spine.timestamp),
+            fields: {
+                noteType: JUNCTION_WEARABLE_TAG_NOTE_TYPE,
+            },
+        }));
+    }
+}
+function buildJunctionNoteResourceId(resourceContext, stableId, timestamp) {
+    if (stableId) {
+        // Junction ids are provider-local, not globally unique across two devices
+        // or accounts of the same provider. Preserve edit/clear stability while
+        // keeping each source instance on its own kind-stable note spine.
+        return shortHash([
+            resourceContext.externalRefResourceType,
+            resourceContext.origin.sourceType,
+            resourceContext.origin.sourceInstanceId,
+            stableId,
+        ]);
+    }
+    return buildStableTimeseriesResourceId(resourceContext, timestamp);
+}
+function normalizeJunctionNoteTags(value) {
+    return [...new Set(asArray(value).flatMap((entry) => {
+            const label = stringId(entry);
+            if (!label)
+                return [];
+            const tag = slugify(label, "").slice(0, 80).replace(/-+$/u, "");
+            return tag ? [tag] : [];
+        }))].sort();
+}
+function pushJunctionDailyTimeseriesObservations(payload, resource, resourceSlug, context, descriptor, selectedSparseRecords) {
+    for (const aggregate of buildJunctionDailyTimeseriesAggregates({
+        payload,
+        resource,
+        resourceSlug,
+        context,
+        valuePaths: descriptor.valuePaths,
+        normalizeValue: descriptor.normalizeValue,
+        selectedSparseRecords,
+        requireExplicitTimestamp: descriptor.requireExplicitTimestamp === true,
+    })) {
+        for (const observation of descriptor.observations) {
+            pushJunctionDailyTimeseriesObservation(context, aggregate, {
+                metric: observation.metric,
+                title: observation.title,
+                unit: descriptor.unit,
+                value: junctionDailyTimeseriesStatisticValue(aggregate, observation.statistic),
+            });
+        }
+        // Keep the complete feature identity present even when the provider supplied
+        // only date precision, so an empty temporal view clears older clocked facts.
+        if (isJunctionDenseFidelityResource(resource)) {
+            pushJunctionTimeseriesFeatureEnvelope(context, aggregate, resource);
+        }
+    }
+}
+function junctionDailyTimeseriesStatisticValue(aggregate, statistic) {
+    switch (statistic) {
+        case "min":
+            return aggregate.minValue;
+        case "max":
+            return aggregate.maxValue;
+        case "sum":
+            return aggregate.sum;
+        case "mean":
+            return aggregate.sum / aggregate.sampleCount;
+    }
+}
+function buildJunctionTimeseriesFidelityRecordKey(input) {
+    const stableId = firstStringFromPaths(input.entry, JUNCTION_TIMESERIES_RECORD_ID_PATHS);
+    const shared = [
+        input.resource,
+        input.resourceContext.sourceProviderSlug,
+        input.resourceContext.origin.sourceType ?? "",
+        input.resourceContext.origin.sourceInstanceId ?? "",
+        stableId ?? "",
+        input.timestamp.dayKey ?? "",
+        input.timestamp.timestampSemantics ?? "",
+        firstStringFromPaths(input.entry, ["timeZone", "timezone", "time_zone"]) ?? "",
+        readJunctionTimeZoneOffsetSeconds(input.entry) ?? "",
+    ];
+    if (isJunctionSparseIntervalResource(input.resource)) {
+        return JSON.stringify([
+            ...shared,
+            firstStringFromPaths(input.entry, JUNCTION_INTERVAL_START_TIMESTAMP_PATHS) ?? "",
+            firstStringFromPaths(input.entry, JUNCTION_INTERVAL_END_TIMESTAMP_PATHS) ?? "",
+            input.providerUnit ?? "",
+            input.providerValue,
+        ]);
+    }
+    return JSON.stringify([
+        ...shared,
+        input.timestamp.observedAtRaw ?? "",
+        input.providerUnit ?? "",
+        input.providerValue,
+    ]);
+}
+function buildJunctionDenseFidelityStableIdentity(resource, entry, resourceContext) {
+    const stableId = firstStringFromPaths(entry, JUNCTION_TIMESERIES_RECORD_ID_PATHS);
+    return stableId
+        ? JSON.stringify([
+            resource,
+            resourceContext.sourceProviderSlug,
+            resourceContext.origin.sourceType ?? "",
+            resourceContext.origin.sourceInstanceId ?? "",
+            stableId,
+        ])
+        : undefined;
+}
+function resolveJunctionExplicitSourceVersion(entry, sourceProviderSlug) {
+    return resolveSafeTimestamp(firstValueFromPaths(entry, ["recordedAt", "recorded_at", "updatedAt", "updated_at"]), sourceProviderSlug);
+}
+function selectJunctionAuthoritativeRevision(resource, existing, candidate) {
+    if (existing.contentFingerprint === candidate.contentFingerprint) {
+        if (!existing.sourceVersion)
+            return candidate.sourceVersion ? candidate : existing;
+        if (!candidate.sourceVersion)
+            return existing;
+        return candidate.sourceVersion > existing.sourceVersion ? candidate : existing;
+    }
+    if (!existing.sourceVersion
+        || !candidate.sourceVersion
+        || existing.sourceVersion === candidate.sourceVersion) {
+        throw new RangeError(`Junction ${resource} stable-id records with different bodies require distinct explicit provider revisions.`);
+    }
+    return candidate.sourceVersion > existing.sourceVersion ? candidate : existing;
+}
+function selectJunctionDenseFidelityRecordKeys(input) {
+    const selected = new Map();
+    const fallbackArtifactRole = `junction-timeseries-daily-${input.resourceSlug}`;
+    for (const [index, { entry, originFallback }] of input.entries.entries()) {
+        const resourceContext = buildResourceContext({
+            entry,
+            originFallback,
+            resource: input.resource,
+            resourceSlug: input.resourceSlug,
+            identityKind: "timeseries",
+            index,
+            fallbackArtifactRole,
+            context: input.context,
+        });
+        if (!resourceContext)
+            continue;
+        const stableIdentity = buildJunctionDenseFidelityStableIdentity(input.resource, entry, resourceContext);
+        if (!stableIdentity)
+            continue;
+        const providerValue = firstValueFromPaths(entry, input.valuePaths);
+        const value = input.normalizeValue(firstNumberFromPaths(entry, input.valuePaths), entry);
+        const timestamp = resolveRecordTimestamp(entry, input.context, resourceContext.sourceProviderSlug);
+        const sampleAt = resolveJunctionDailyAggregateSampleAt(timestamp, false);
+        if (value === undefined || !sampleAt)
+            continue;
+        const providerUnit = trimOptionalToLength(firstStringFromPaths(entry, JUNCTION_INTERVAL_UNIT_PATHS), 160);
+        const recordKey = buildJunctionTimeseriesFidelityRecordKey({
+            entry,
+            providerUnit,
+            providerValue,
+            resource: input.resource,
+            resourceContext,
+            timestamp,
+        });
+        const candidate = {
+            contentFingerprint: recordKey,
+            recordKey,
+            sourceVersion: resolveJunctionExplicitSourceVersion(entry, resourceContext.sourceProviderSlug),
+        };
+        const existing = selected.get(stableIdentity);
+        selected.set(stableIdentity, existing
+            ? selectJunctionAuthoritativeRevision(input.resource, existing, candidate)
+            : candidate);
+    }
+    return selected;
+}
+function buildJunctionTimeseriesFidelityPoint(input) {
+    if (!input.timestamp.observedAtRaw
+        || isDateOnlyJunctionTimestamp(input.timestamp.observedAtRaw)) {
+        // Calendar precision belongs in the established daily aggregate only.
+        return undefined;
+    }
+    const observedAtMs = resolveJunctionFidelityObservedAtMs(input.timestamp);
+    const localMinute = resolveJunctionFidelityLocalMinute(input.entry, input.timestamp, input.sampleAt, input.defaultTimeZone);
+    if (observedAtMs === undefined || localMinute === undefined)
+        return undefined;
+    return { localMinute, observedAtMs, value: input.value };
+}
+function resolveJunctionFidelityObservedAtMs(timestamp) {
+    const raw = timestamp.observedAtRaw;
+    if (raw && timestamp.timestampSemantics === "floating") {
+        const floating = parseJunctionFloatingDateTime(raw);
+        if (floating) {
+            return Date.UTC(floating.year, floating.month - 1, floating.day, floating.hour, floating.minute, floating.second, floating.millisecond);
+        }
+    }
+    const rawMs = raw ? Date.parse(raw) : Number.NaN;
+    return Number.isFinite(rawMs) ? rawMs : undefined;
+}
+function resolveJunctionFidelityLocalMinute(entry, timestamp, sampleAt, defaultTimeZone) {
+    const rawParts = timestamp.observedAtRaw
+        ? parseJunctionFloatingDateTime(timestamp.observedAtRaw)
+        : undefined;
+    const rawHasNumericOffset = timestamp.observedAtRaw
+        ? /[+-]\d{2}:?\d{2}$/u.test(timestamp.observedAtRaw.trim())
+        : false;
+    if (rawParts
+        && (timestamp.timestampSemantics === "floating" || rawHasNumericOffset)) {
+        return rawParts.hour * 60
+            + rawParts.minute
+            + rawParts.second / 60
+            + rawParts.millisecond / 60_000;
+    }
+    const sampleMs = Date.parse(sampleAt);
+    if (!Number.isFinite(sampleMs))
+        return undefined;
+    const offsetSeconds = readJunctionTimeZoneOffsetSeconds(entry);
+    if (offsetSeconds !== null && offsetSeconds !== undefined) {
+        const shifted = new Date(sampleMs + offsetSeconds * 1000);
+        return shifted.getUTCHours() * 60
+            + shifted.getUTCMinutes()
+            + shifted.getUTCSeconds() / 60
+            + shifted.getUTCMilliseconds() / 60_000;
+    }
+    const timeZone = firstStringFromPaths(entry, ["timeZone", "timezone", "time_zone"])
+        ?? defaultTimeZone;
+    if (timeZone) {
+        try {
+            const parts = new Intl.DateTimeFormat("en-US", {
+                timeZone,
+                hour: "2-digit",
+                minute: "2-digit",
+                second: "2-digit",
+                hourCycle: "h23",
+            }).formatToParts(new Date(sampleMs));
+            const hour = Number(parts.find((part) => part.type === "hour")?.value);
+            const minute = Number(parts.find((part) => part.type === "minute")?.value);
+            const second = Number(parts.find((part) => part.type === "second")?.value);
+            if (Number.isFinite(hour) && Number.isFinite(minute) && Number.isFinite(second)) {
+                return (hour % 24) * 60 + minute + second / 60;
+            }
+        }
+        catch {
+            // Fall through to UTC when a provider/vault timezone label is invalid.
+        }
+    }
+    const utc = new Date(sampleMs);
+    return utc.getUTCHours() * 60
+        + utc.getUTCMinutes()
+        + utc.getUTCSeconds() / 60
+        + utc.getUTCMilliseconds() / 60_000;
+}
+function parseJunctionFloatingDateTime(value) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?)?/u.exec(value.trim());
+    if (!match)
+        return undefined;
+    const [year, month, day, hour = "0", minute = "0", second = "0"] = match.slice(1, 7);
+    const fraction = match[7] ?? "";
+    const parsed = {
+        year: Number(year),
+        month: Number(month),
+        day: Number(day),
+        hour: Number(hour),
+        minute: Number(minute),
+        second: Number(second),
+        millisecond: Number(fraction.padEnd(3, "0").slice(0, 3)),
+    };
+    return Object.values(parsed).every(Number.isFinite) ? parsed : undefined;
+}
+function buildJunctionDailyTimeseriesAggregates(input) {
+    const evidencePartRole = `junction-timeseries-daily-${input.resourceSlug}`;
+    const aggregates = new Map();
+    const entries = timeseriesResourceEntries(input.payload);
+    const fidelityResource = isJunctionDenseFidelityResource(input.resource)
+        ? input.resource
+        : isJunctionSparseIntervalResource(input.resource)
+            ? input.resource
+            : undefined;
+    if (fidelityResource) {
+        assertJunctionTimeseriesResponseBound(fidelityResource, entries.length);
+    }
+    const selectedDenseRecordKeys = isJunctionDenseFidelityResource(input.resource)
+        ? selectJunctionDenseFidelityRecordKeys({
+            context: input.context,
+            entries,
+            normalizeValue: input.normalizeValue,
+            resource: input.resource,
+            resourceSlug: input.resourceSlug,
+            valuePaths: input.valuePaths,
+        })
+        : undefined;
+    const seenFidelityRecords = new Set();
+    for (const [index, { entry, originFallback }] of entries.entries()) {
+        const resourceContext = buildResourceContext({
+            entry,
+            originFallback,
+            resource: input.resource,
+            resourceSlug: input.resourceSlug,
+            identityKind: "timeseries",
+            index,
+            fallbackArtifactRole: evidencePartRole,
+            context: input.context,
+        });
+        if (!resourceContext) {
+            continue;
+        }
+        const providerValue = firstValueFromPaths(entry, input.valuePaths);
+        const value = input.normalizeValue(firstNumberFromPaths(entry, input.valuePaths), entry);
+        const sparseStartRaw = isJunctionSparseIntervalResource(input.resource)
+            ? firstStringFromPaths(entry, JUNCTION_INTERVAL_START_TIMESTAMP_PATHS)
+            : undefined;
+        const timestamp = sparseStartRaw
+            ? resolveJunctionSparseIntervalTimestamp(entry, sparseStartRaw, input.context, resourceContext.sourceProviderSlug)
+            : resolveRecordTimestamp(entry, input.context, resourceContext.sourceProviderSlug, JUNCTION_INTERVAL_START_OWNED_TIMESTAMP_PATHS);
+        const sampleAt = resolveJunctionDailyAggregateSampleAt(timestamp, input.requireExplicitTimestamp);
+        const dayKey = input.requireExplicitTimestamp
+            ? timestamp.timestampSemantics === "floating" && timestamp.dayKey
+                ? timestamp.dayKey
+                : extractIsoDatePrefix(sampleAt) ?? undefined
+            : resolveJunctionTimeseriesAggregateDayKey(entry, timestamp, sampleAt, input.context.defaultTimeZone);
+        const legacyDayKey = input.requireExplicitTimestamp
+            ? dayKey
+            : resolveLegacyJunctionTimeseriesAggregateDayKey(entry, timestamp, sampleAt);
+        if (value === undefined
+            || (input.requireExplicitTimestamp
+                && !hasValidJunctionExplicitTimeseriesTimestamp(timestamp))
+            || !sampleAt
+            || !dayKey) {
+            continue;
+        }
+        const key = [
+            resourceContext.externalRefResourceType,
+            resourceContext.origin.sourceType ?? "",
+            resourceContext.origin.sourceInstanceId ?? "",
+            dayKey,
+        ].join("\u0000");
+        const existing = aggregates.get(key);
+        const recordedAt = timestamp.recordedAt ?? sampleAt;
+        const timeZone = input.requireExplicitTimestamp
+            ? "UTC"
+            : firstStringFromPaths(entry, ["timeZone", "timezone", "time_zone"]);
+        const providerUnit = trimOptionalToLength(firstStringFromPaths(entry, JUNCTION_INTERVAL_UNIT_PATHS), 160);
+        const fidelityRecordKey = fidelityResource
+            ? buildJunctionTimeseriesFidelityRecordKey({
+                entry,
+                providerUnit,
+                providerValue,
+                resource: input.resource,
+                resourceContext,
+                timestamp,
+            })
+            : undefined;
+        const denseStableIdentity = isJunctionDenseFidelityResource(input.resource)
+            ? buildJunctionDenseFidelityStableIdentity(input.resource, entry, resourceContext)
+            : undefined;
+        const denseSelection = denseStableIdentity
+            ? selectedDenseRecordKeys?.get(denseStableIdentity)
+            : undefined;
+        if (denseStableIdentity
+            && fidelityRecordKey
+            && denseSelection?.recordKey !== fidelityRecordKey) {
+            continue;
+        }
+        const sparseSelection = fidelityRecordKey
+            ? input.selectedSparseRecords?.get(fidelityRecordKey)
+            : undefined;
+        if (isJunctionSparseIntervalResource(input.resource)
+            && entry.authoritativeEmptyCalendarSet !== true
+            && fidelityRecordKey
+            && input.selectedSparseRecords
+            && !sparseSelection) {
+            continue;
+        }
+        if (fidelityRecordKey && seenFidelityRecords.has(fidelityRecordKey)) {
+            if (existing) {
+                existing.duplicateSampleCount += 1;
+            }
+            continue;
+        }
+        if (fidelityRecordKey) {
+            seenFidelityRecords.add(fidelityRecordKey);
+        }
+        const fidelitySample = isJunctionDenseFidelityResource(input.resource)
+            ? buildJunctionTimeseriesFidelityPoint({
+                defaultTimeZone: input.context.defaultTimeZone,
+                entry,
+                resource: input.resource,
+                sampleAt,
+                timestamp,
+                value,
+            })
+            : undefined;
+        const legacyDayKeys = new Set();
+        if (legacyDayKey && legacyDayKey !== dayKey) {
+            legacyDayKeys.add(legacyDayKey);
+        }
+        if (!existing) {
+            aggregates.set(key, {
+                authoritativeEmptyCalendarSet: entry.authoritativeEmptyCalendarSet === true,
+                dayKey,
+                duplicateSampleCount: 0,
+                entry,
+                fidelitySamples: fidelitySample ? [fidelitySample] : [],
+                firstSampleAt: sampleAt,
+                lastRecordedAt: recordedAt,
+                lastSampleAt: sampleAt,
+                legacyDayKeys,
+                maxValue: value,
+                minValue: value,
+                evidencePartRole,
+                resourceContext,
+                sampleCount: 1,
+                sum: value,
+                timestamp,
+                timeZone,
+            });
+            if (fidelityResource) {
+                assertJunctionTimeseriesSourceDayBound(fidelityResource, 1);
+            }
+            continue;
+        }
+        existing.sampleCount += 1;
+        existing.authoritativeEmptyCalendarSet ||= entry.authoritativeEmptyCalendarSet === true;
+        if (fidelitySample) {
+            existing.fidelitySamples.push(fidelitySample);
+        }
+        if (fidelityResource) {
+            assertJunctionTimeseriesSourceDayBound(fidelityResource, existing.sampleCount);
+        }
+        existing.sum += value;
+        if (legacyDayKey && legacyDayKey !== dayKey) {
+            existing.legacyDayKeys.add(legacyDayKey);
+        }
+        if (sampleAt < existing.firstSampleAt) {
+            existing.firstSampleAt = sampleAt;
+        }
+        if (sampleAt >= existing.lastSampleAt) {
+            existing.lastSampleAt = sampleAt;
+            existing.lastRecordedAt = recordedAt;
+            existing.timestamp = timestamp;
+        }
+        if (value < existing.minValue) {
+            existing.minValue = value;
+        }
+        if (value > existing.maxValue) {
+            existing.maxValue = value;
+        }
+    }
+    const sortedAggregates = [...aggregates.values()].sort(compareJunctionDailyTimeseriesAggregates);
+    if (sortedAggregates.length === 0) {
+        pushJunctionEmptyDailyTimeseriesAggregateArtifact(input.context, input.resource, input.resourceSlug);
+        return sortedAggregates;
+    }
+    pushJunctionDailyTimeseriesAggregateArtifacts(input.context, input.resource, sortedAggregates);
+    return sortedAggregates;
+}
+function pushJunctionEmptyDailyTimeseriesAggregateArtifact(context, resource, resourceSlug) {
+    const role = `junction-timeseries-daily-${resourceSlug}:no-valid-samples`;
+    pushEvidencePart(context.evidenceParts, withJunctionCompactTimeseriesMetadata(resource, createEvidencePart(role, `${role}.json`, {
+        schema: "junction.timeseries_daily_aggregate.v1",
+        provider: "junction",
+        resource,
+        sampleCount: 0,
+        status: "no_valid_samples",
+    })));
+}
+function pushJunctionDailyTimeseriesAggregateArtifacts(context, resource, aggregates) {
+    for (const aggregate of aggregates) {
+        // The role derives only from the aggregate's stable grouping identity
+        // (resource role + day + source); a sorted-position index here would
+        // churn artifact roles across replays and differently-windowed payloads.
+        const role = `${aggregate.evidencePartRole}:${aggregate.dayKey}:${shortHash([
+            aggregate.resourceContext.sourceProviderSlug,
+            aggregate.resourceContext.origin.sourceType ?? "",
+            aggregate.resourceContext.origin.sourceInstanceId ?? "",
+        ])}`;
+        aggregate.evidencePartRole = role;
+        pushEvidencePart(context.evidenceParts, withJunctionCompactTimeseriesMetadata(resource, createEvidencePart(role, `${role}.json`, stripUndefined({
+            schema: "junction.timeseries_daily_aggregate.v1",
+            provider: "junction",
+            resource,
+            dayKey: aggregate.dayKey,
+            sourceProviderSlug: aggregate.resourceContext.sourceProviderSlug,
+            sourceType: aggregate.resourceContext.origin.sourceType,
+            sourceInstanceId: aggregate.resourceContext.origin.sourceInstanceId,
+            status: aggregate.authoritativeEmptyCalendarSet
+                ? "authoritative_empty_calendar_set"
+                : undefined,
+            sampleCount: aggregate.authoritativeEmptyCalendarSet ? 0 : aggregate.sampleCount,
+            duplicateSampleCount: aggregate.duplicateSampleCount > 0
+                ? aggregate.duplicateSampleCount
+                : undefined,
+            firstSampleAt: aggregate.firstSampleAt,
+            lastSampleAt: aggregate.lastSampleAt,
+            lastRecordedAt: aggregate.lastRecordedAt,
+            legacyDayKeys: aggregate.legacyDayKeys.size > 0
+                ? [...aggregate.legacyDayKeys].sort()
+                : undefined,
+            meanValue: aggregate.authoritativeEmptyCalendarSet
+                ? undefined
+                : roundJunctionTimeseriesAggregateValue(resource, aggregate.sum / aggregate.sampleCount),
+            minValue: aggregate.authoritativeEmptyCalendarSet
+                ? undefined
+                : roundJunctionTimeseriesAggregateValue(resource, aggregate.minValue),
+            maxValue: aggregate.authoritativeEmptyCalendarSet
+                ? undefined
+                : roundJunctionTimeseriesAggregateValue(resource, aggregate.maxValue),
+            sumValue: JUNCTION_DAILY_TIMESERIES_DESCRIPTORS.get(resource)?.retainSumValue === true
+                && !aggregate.authoritativeEmptyCalendarSet
+                ? roundJunctionTimeseriesAggregateValue(resource, aggregate.sum)
+                : undefined,
+            unit: junctionDailyTimeseriesAggregateUnit(resource),
+        }))));
+    }
+}
+function roundJunctionTimeseriesAggregateValue(resource, value) {
+    return JUNCTION_DAILY_TIMESERIES_DESCRIPTORS.has(resource)
+        ? roundJunctionDailyAggregateValue(value)
+        : value;
+}
+function junctionDailyTimeseriesAggregateUnit(resource) {
+    return JUNCTION_DAILY_TIMESERIES_DESCRIPTORS.get(resource)?.unit;
+}
+function withJunctionCompactTimeseriesMetadata(resource, artifact, resourceCategory = "timeseries_daily_aggregate") {
+    if (!artifact) {
+        return null;
+    }
+    return {
+        ...artifact,
+        metadata: {
+            artifactClass: resourceCategory === "timeseries_reading"
+                ? "compact_provider_timeseries_reading"
+                : resourceCategory === "timeseries_feature_envelope"
+                    ? "compact_provider_timeseries_feature_envelope"
+                    : "compact_provider_timeseries_aggregate",
+            provider: "junction",
+            resource,
+            resourceCategory,
+            retentionClass: "provider_evidence",
+        },
+    };
+}
+function pushJunctionDailyTimeseriesObservation(context, aggregate, observation) {
+    const metric = resolveJunctionHrvMetric(observation.metric, aggregate.resourceContext.sourceProviderSlug);
+    const timestamp = withTimestampOverride(aggregate.timestamp, {
+        occurredAt: aggregate.lastSampleAt,
+        recordedAt: aggregate.lastRecordedAt,
+        dayKey: aggregate.dayKey,
+        observedAtRaw: `${aggregate.dayKey}:${aggregate.resourceContext.resource}:daily`,
+    });
+    const legacyExternalRefs = legacyJunctionDailyTimeseriesAggregateExternalRefs(aggregate, observation.metric);
+    context.events.push(stripUndefined({
+        kind: "observation",
+        occurredAt: aggregate.lastSampleAt,
+        recordedAt: aggregate.lastRecordedAt,
+        dayKey: aggregate.dayKey,
+        timeZone: aggregate.timeZone,
+        source: "device",
+        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,
+            observationGrain: "summary",
+            value: roundJunctionDailyAggregateValue(observation.value),
+            unit: observation.unit,
+        },
+    }));
+}
+function legacyJunctionDailyTimeseriesAggregateExternalRefs(aggregate, metric) {
+    if (aggregate.legacyDayKeys.size === 0) {
+        return [];
+    }
+    return [...aggregate.legacyDayKeys].sort().map((legacyDayKey) => makeJunctionExternalRef(aggregate.resourceContext, aggregate.entry, withTimestampOverride(aggregate.timestamp, {
+        occurredAt: aggregate.lastSampleAt,
+        recordedAt: aggregate.lastRecordedAt,
+        dayKey: legacyDayKey,
+        observedAtRaw: `${legacyDayKey}:${aggregate.resourceContext.resource}:daily`,
+    }), metric));
+}
+function pushJunctionTimeseriesFeatureEnvelope(context, aggregate, resource) {
+    const policy = getJunctionDenseFidelityPolicy(resource);
+    const { envelope, facts } = deriveJunctionTimeseriesFeatureEnvelope(resource, aggregate.fidelitySamples);
+    const featureSampleTimes = aggregate.fidelitySamples
+        .map((sample) => sample.observedAtMs)
+        .sort((left, right) => left - right);
+    const firstFeatureSampleAt = featureSampleTimes[0];
+    const lastFeatureSampleAt = featureSampleTimes[featureSampleTimes.length - 1];
+    const identityHash = shortHash([
+        policy.identityVersion,
+        aggregate.resourceContext.resourceSlug,
+        aggregate.resourceContext.sourceProviderSlug,
+        aggregate.resourceContext.origin.sourceType ?? "",
+        aggregate.resourceContext.origin.sourceInstanceId ?? "",
+        aggregate.dayKey,
+    ]);
+    const resourceId = `${aggregate.resourceContext.resourceSlug}-${identityHash}`;
+    const role = [
+        `junction-timeseries-features-${aggregate.resourceContext.resourceSlug}`,
+        aggregate.dayKey,
+        identityHash,
+    ].join(":");
+    pushEvidencePart(context.evidenceParts, withJunctionCompactTimeseriesMetadata(resource, createEvidencePart(role, `${role}.json`, stripUndefined({
+        ...envelope,
+        provider: "junction",
+        resource,
+        dayKey: aggregate.dayKey,
+        sourceProviderSlug: aggregate.resourceContext.sourceProviderSlug,
+        sourceType: aggregate.resourceContext.origin.sourceType,
+        sourceInstanceId: aggregate.resourceContext.origin.sourceInstanceId,
+        firstSampleAt: firstFeatureSampleAt === undefined
+            ? undefined
+            : new Date(firstFeatureSampleAt).toISOString(),
+        lastSampleAt: lastFeatureSampleAt === undefined
+            ? undefined
+            : new Date(lastFeatureSampleAt).toISOString(),
+        duplicateSampleCount: aggregate.duplicateSampleCount > 0
+            ? aggregate.duplicateSampleCount
+            : undefined,
+    })), "timeseries_feature_envelope"));
+    const timestamp = withTimestampOverride(aggregate.timestamp, {
+        occurredAt: aggregate.lastSampleAt,
+        recordedAt: aggregate.lastRecordedAt,
+        dayKey: aggregate.dayKey,
+        observedAtRaw: `${aggregate.dayKey}:${resource}:features:${policy.policyVersion}`,
+    });
+    context.events.push(stripUndefined({
+        kind: "measurement",
+        occurredAt: aggregate.lastSampleAt,
+        recordedAt: aggregate.lastRecordedAt,
+        dayKey: aggregate.dayKey,
+        timeZone: aggregate.timeZone,
+        source: "device",
+        title: `Junction ${resource.replaceAll("_", " ")} temporal features`,
+        evidenceRoles: [role],
+        externalRef: makeProviderExternalRef("junction", aggregate.resourceContext.externalRefResourceType, resourceId, undefined, "features"),
+        dataOrigin: buildDataOrigin(aggregate.entry, aggregate.resourceContext, timestamp, { normalizerVersion: policy.policyVersion }),
+        fields: {
+            measurements: facts.map((fact) => ({
+                metric: fact.metric,
+                value: fact.value,
+                unit: fact.unit,
+                qualifiers: {
+                    "feature-policy-version": policy.policyVersion,
+                },
+            })),
+        },
+    }));
+}
+// Dense timeseries streams never retain provider rows. They collapse into one
+// provider-partitioned feature artifact per UTC hour. The import owner commits
+// closed UTC-day snapshots, so an hour is the broadest feature bucket whose
+// completeness is provable without persisted cross-window aggregation state.
+function pushJunctionFeatureTimeseriesObservations(payload, resource, resourceSlug, context, descriptor) {
+    const aggregates = buildJunctionFeatureTimeseriesAggregates({
+        context,
+        descriptor,
+        payload,
+        resource,
+        resourceSlug,
+    });
+    if (aggregates.length === 0) {
+        const role = `junction-timeseries-feature-${resourceSlug}:no-valid-samples`;
+        pushEvidencePart(context.evidenceParts, withJunctionCompactTimeseriesMetadata(resource, createEvidencePart(role, `${role}.json`, {
+            schema: "junction.timeseries_feature_aggregate.v1",
+            provider: "junction",
+            resource,
+            sampleCount: 0,
+            status: "no_valid_samples",
+        }), "timeseries_feature_aggregate"));
+        return;
+    }
+    for (const aggregate of aggregates) {
+        const role = `${aggregate.evidencePartRole}:${aggregate.bucketKind}:${shortHash([
+            aggregate.resourceContext.externalRefResourceType,
+            aggregate.resourceContext.origin.sourceType ?? "",
+            aggregate.resourceContext.origin.sourceInstanceId ?? "",
+            aggregate.bucketIdentity,
+        ])}`;
+        aggregate.evidencePartRole = role;
+        pushEvidencePart(context.evidenceParts, withJunctionCompactTimeseriesMetadata(resource, createEvidencePart(role, `${role}.json`, stripUndefined({
+            schema: "junction.timeseries_feature_aggregate.v1",
+            provider: "junction",
+            resource,
+            bucketKind: aggregate.bucketKind,
+            bucketStartAt: aggregate.bucketStartAt,
+            bucketEndAt: aggregate.bucketEndAt,
+            dayKey: aggregate.dayKey,
+            sourceProviderSlug: aggregate.resourceContext.sourceProviderSlug,
+            sourceType: aggregate.resourceContext.origin.sourceType,
+            sourceInstanceId: aggregate.resourceContext.origin.sourceInstanceId,
+            sampleCount: aggregate.sampleCount,
+            firstSampleAt: aggregate.firstSampleAt,
+            lastSampleAt: aggregate.lastSampleAt,
+            lastRecordedAt: aggregate.lastRecordedAt,
+            sumValue: roundJunctionDailyAggregateValue(aggregate.sum),
+            meanValue: roundJunctionDailyAggregateValue(aggregate.sum / aggregate.sampleCount),
+            minValue: roundJunctionDailyAggregateValue(aggregate.minValue),
+            maxValue: roundJunctionDailyAggregateValue(aggregate.maxValue),
+            unit: descriptor.unit,
+        })), "timeseries_feature_aggregate"));
+        for (const observation of descriptor.observations) {
+            pushJunctionFeatureTimeseriesObservation(context, aggregate, observation, descriptor.unit);
+        }
+    }
+}
+function buildJunctionFeatureTimeseriesAggregates(input) {
+    const evidencePartRole = `junction-timeseries-feature-${input.resourceSlug}`;
+    const aggregates = new Map();
+    const timestampPaths = usesJunctionTimeseriesIntervalStartOwnership(resolveJunctionTimeseriesResourcePolicy(input.resource))
+        ? JUNCTION_INTERVAL_START_OWNED_TIMESTAMP_PATHS
+        : JUNCTION_RECORD_TIMESTAMP_PATHS;
+    for (const [index, { entry, originFallback }] of timeseriesResourceEntries(input.payload).entries()) {
+        const resourceContext = buildResourceContext({
+            entry,
+            originFallback,
+            resource: input.resource,
+            resourceSlug: input.resourceSlug,
+            identityKind: "timeseries",
+            index,
+            fallbackArtifactRole: evidencePartRole,
+            context: input.context,
+        });
+        if (!resourceContext) {
+            continue;
+        }
+        const value = input.descriptor.normalizeValue(firstNumberFromPaths(entry, input.descriptor.valuePaths), entry);
+        const rawSampleAt = firstValueFromPaths(entry, timestampPaths);
+        const sampleAt = resolveSafeTimestamp(rawSampleAt, resourceContext.sourceProviderSlug);
+        if (value === undefined || !sampleAt) {
+            continue;
+        }
+        const timestamp = resolveRecordTimestamp(entry, input.context, resourceContext.sourceProviderSlug, timestampPaths);
+        const dayKey = extractIsoDatePrefix(sampleAt) ?? undefined;
+        if (!dayKey) {
+            continue;
+        }
+        const bucket = resolveJunctionFeatureTimeseriesBucket(sampleAt);
+        const key = [
+            resourceContext.externalRefResourceType,
+            resourceContext.origin.sourceType ?? "",
+            resourceContext.origin.sourceInstanceId ?? "",
+            bucket.kind,
+            bucket.identity,
+        ].join("\u0000");
+        const existing = aggregates.get(key);
+        const recordedAt = timestamp.recordedAt ?? sampleAt;
+        const timeZone = "UTC";
+        if (!existing) {
+            aggregates.set(key, {
+                bucketEndAt: bucket.endAt,
+                bucketIdentity: bucket.identity,
+                bucketKind: bucket.kind,
+                bucketStartAt: bucket.startAt,
+                dayKey,
+                entry,
+                evidencePartRole,
+                firstSampleAt: sampleAt,
+                lastRecordedAt: recordedAt,
+                lastSampleAt: sampleAt,
+                maxValue: value,
                 minValue: value,
-                evidencePartRole,
                 resourceContext,
                 sampleCount: 1,
                 sum: value,
@@ -1155,109 +2798,52 @@ function buildJunctionDailyTimeseriesAggregates(input) {
         }
         existing.sampleCount += 1;
         existing.sum += value;
-        if (legacyDayKey && legacyDayKey !== dayKey) {
-            existing.legacyDayKeys.add(legacyDayKey);
+        existing.bucketStartAt = earlierIsoTimestamp(existing.bucketStartAt, bucket.startAt);
+        existing.bucketEndAt = laterIsoTimestamp(existing.bucketEndAt, bucket.endAt);
+        if (value < existing.minValue) {
+            existing.minValue = value;
+        }
+        if (value > existing.maxValue) {
+            existing.maxValue = value;
         }
         if (sampleAt < existing.firstSampleAt) {
             existing.firstSampleAt = sampleAt;
         }
         if (sampleAt >= existing.lastSampleAt) {
-            existing.lastSampleAt = sampleAt;
+            existing.dayKey = dayKey;
+            existing.entry = entry;
             existing.lastRecordedAt = recordedAt;
+            existing.lastSampleAt = sampleAt;
             existing.timestamp = timestamp;
+            existing.timeZone = timeZone;
         }
-        if (value < existing.minValue) {
-            existing.minValue = value;
-        }
-        if (value > existing.maxValue) {
-            existing.maxValue = value;
-        }
-    }
-    const sortedAggregates = [...aggregates.values()].sort(compareJunctionDailyTimeseriesAggregates);
-    if (sortedAggregates.length === 0) {
-        pushJunctionEmptyDailyTimeseriesAggregateArtifact(input.context, input.resource, input.resourceSlug);
-        return sortedAggregates;
-    }
-    pushJunctionDailyTimeseriesAggregateArtifacts(input.context, input.resource, sortedAggregates);
-    return sortedAggregates;
-}
-function pushJunctionEmptyDailyTimeseriesAggregateArtifact(context, resource, resourceSlug) {
-    const role = `junction-timeseries-daily-${resourceSlug}:no-valid-samples`;
-    pushEvidencePart(context.evidenceParts, withJunctionCompactTimeseriesMetadata(resource, createEvidencePart(role, `${role}.json`, {
-        schema: "junction.timeseries_daily_aggregate.v1",
-        provider: "junction",
-        resource,
-        sampleCount: 0,
-        status: "no_valid_samples",
-    })));
-}
-function pushJunctionDailyTimeseriesAggregateArtifacts(context, resource, aggregates) {
-    for (const aggregate of aggregates) {
-        // The role derives only from the aggregate's stable grouping identity
-        // (resource role + day + source); a sorted-position index here would
-        // churn artifact roles across replays and differently-windowed payloads.
-        const role = `${aggregate.evidencePartRole}:${aggregate.dayKey}:${shortHash([
-            aggregate.resourceContext.sourceProviderSlug,
-            aggregate.resourceContext.origin.sourceType ?? "",
-            aggregate.resourceContext.origin.sourceInstanceId ?? "",
-        ])}`;
-        aggregate.evidencePartRole = role;
-        pushEvidencePart(context.evidenceParts, withJunctionCompactTimeseriesMetadata(resource, createEvidencePart(role, `${role}.json`, stripUndefined({
-            schema: "junction.timeseries_daily_aggregate.v1",
-            provider: "junction",
-            resource,
-            dayKey: aggregate.dayKey,
-            sourceProviderSlug: aggregate.resourceContext.sourceProviderSlug,
-            sourceType: aggregate.resourceContext.origin.sourceType,
-            sourceInstanceId: aggregate.resourceContext.origin.sourceInstanceId,
-            sampleCount: aggregate.sampleCount,
-            firstSampleAt: aggregate.firstSampleAt,
-            lastSampleAt: aggregate.lastSampleAt,
-            lastRecordedAt: aggregate.lastRecordedAt,
-            legacyDayKeys: aggregate.legacyDayKeys.size > 0
-                ? [...aggregate.legacyDayKeys].sort()
-                : undefined,
-            meanValue: roundJunctionTimeseriesAggregateValue(resource, aggregate.sum / aggregate.sampleCount),
-            minValue: roundJunctionTimeseriesAggregateValue(resource, aggregate.minValue),
-            maxValue: roundJunctionTimeseriesAggregateValue(resource, aggregate.maxValue),
-            unit: junctionDailyTimeseriesAggregateUnit(resource),
-        }))));
     }
+    return [...aggregates.values()].sort(compareJunctionFeatureTimeseriesAggregates);
 }
-function roundJunctionTimeseriesAggregateValue(resource, value) {
-    return JUNCTION_DAILY_TIMESERIES_DESCRIPTORS.has(resource)
-        ? roundJunctionDailyAggregateValue(value)
-        : value;
-}
-function junctionDailyTimeseriesAggregateUnit(resource) {
-    return JUNCTION_DAILY_TIMESERIES_DESCRIPTORS.get(resource)?.unit;
-}
-function withJunctionCompactTimeseriesMetadata(resource, artifact, resourceCategory = "timeseries_daily_aggregate") {
-    if (!artifact) {
-        return null;
-    }
+function resolveJunctionFeatureTimeseriesBucket(sampleAt) {
+    const hourStartMs = Math.floor(Date.parse(sampleAt) / 3_600_000) * 3_600_000;
+    const startAt = new Date(hourStartMs).toISOString();
     return {
-        ...artifact,
-        metadata: {
-            artifactClass: resourceCategory === "timeseries_reading"
-                ? "compact_provider_timeseries_reading"
-                : "compact_provider_timeseries_aggregate",
-            provider: "junction",
-            resource,
-            resourceCategory,
-            retentionClass: "provider_evidence",
-        },
+        endAt: new Date(hourStartMs + 3_600_000).toISOString(),
+        identity: startAt,
+        kind: "hour",
+        startAt,
     };
 }
-function pushJunctionDailyTimeseriesObservation(context, aggregate, observation) {
-    const metric = resolveJunctionHrvMetric(observation.metric, aggregate.resourceContext.sourceProviderSlug);
+function pushJunctionFeatureTimeseriesObservation(context, aggregate, observation, unit) {
+    const value = junctionFeatureTimeseriesStatisticValue(aggregate, observation.statistic);
+    const resourceId = `${aggregate.resourceContext.resourceSlug}-${shortHash([
+        aggregate.resourceContext.externalRefResourceType,
+        aggregate.resourceContext.origin.sourceType ?? "",
+        aggregate.resourceContext.origin.sourceInstanceId ?? "",
+        aggregate.bucketKind,
+        aggregate.bucketIdentity,
+    ])}`;
     const timestamp = withTimestampOverride(aggregate.timestamp, {
         occurredAt: aggregate.lastSampleAt,
         recordedAt: aggregate.lastRecordedAt,
         dayKey: aggregate.dayKey,
-        observedAtRaw: `${aggregate.dayKey}:${aggregate.resourceContext.resource}:daily`,
     });
-    const legacyExternalRefs = legacyJunctionDailyTimeseriesAggregateExternalRefs(aggregate, observation.metric);
     context.events.push(stripUndefined({
         kind: "observation",
         occurredAt: aggregate.lastSampleAt,
@@ -1265,38 +2851,324 @@ function pushJunctionDailyTimeseriesObservation(context, aggregate, observation)
         dayKey: aggregate.dayKey,
         timeZone: aggregate.timeZone,
         source: "device",
-        title: resolveJunctionHrvTitle(metric, observation.title),
+        title: observation.title,
         evidenceRoles: [aggregate.evidencePartRole],
-        externalRef: makeJunctionExternalRef(aggregate.resourceContext, aggregate.entry, timestamp, observation.metric),
-        legacyExternalRefs: legacyExternalRefs.length > 0 ? legacyExternalRefs : undefined,
+        externalRef: makeProviderExternalRef("junction", aggregate.resourceContext.externalRefResourceType, resourceId, undefined, observation.metric),
         dataOrigin: buildDataOrigin(aggregate.entry, aggregate.resourceContext, timestamp),
         fields: {
-            metric,
-            observationGrain: "summary",
-            value: roundJunctionDailyAggregateValue(observation.value),
-            unit: observation.unit,
+            metric: observation.metric,
+            // Hour aggregates are compact derived features, not competing
+            // representations of one provider day. Keeping them non-summary stops
+            // daily and sleep selectors from promoting a single bucket as a day fact.
+            observationGrain: "derived_fact",
+            value: roundJunctionDailyAggregateValue(value),
+            unit,
         },
     }));
 }
-function legacyJunctionDailyTimeseriesAggregateExternalRefs(aggregate, metric) {
-    if (aggregate.legacyDayKeys.size === 0) {
-        return [];
+function pushJunctionSparseIntervalReadings(payload, resource, resourceSlug, context, descriptor) {
+    const policy = getJunctionSparseIntervalPolicy(resource);
+    const entries = timeseriesResourceEntries(payload);
+    assertJunctionTimeseriesResponseBound(resource, entries.length);
+    const readingsByIdentity = new Map();
+    for (const [index, { entry, originFallback }] of entries.entries()) {
+        const resourceContext = buildResourceContext({
+            entry,
+            originFallback,
+            resource,
+            resourceSlug,
+            identityKind: "timeseries",
+            index,
+            fallbackArtifactRole: `junction-timeseries-reading-${resourceSlug}`,
+            context,
+        });
+        if (!resourceContext)
+            continue;
+        const providerValue = finiteNumber(firstValueFromPaths(entry, descriptor.valuePaths));
+        const value = descriptor.normalizeValue(providerValue, entry);
+        const startRaw = firstStringFromPaths(entry, JUNCTION_INTERVAL_START_TIMESTAMP_PATHS);
+        const endRaw = firstStringFromPaths(entry, JUNCTION_INTERVAL_END_TIMESTAMP_PATHS);
+        const startAt = resolveSafeTimestamp(startRaw);
+        const endAt = resolveSafeTimestamp(endRaw);
+        if (providerValue === undefined
+            || value === undefined
+            || !startRaw
+            || !endRaw
+            || !startAt
+            || !endAt
+            || Date.parse(endAt) < Date.parse(startAt)) {
+            continue;
+        }
+        const timestamp = resolveJunctionSparseIntervalTimestamp(entry, startRaw, context, resourceContext.sourceProviderSlug);
+        const dayKey = resolveJunctionTimeseriesAggregateDayKey(entry, timestamp, startAt, context.defaultTimeZone);
+        if (!dayKey)
+            continue;
+        const providerUnit = trimOptionalToLength(firstStringFromPaths(entry, JUNCTION_INTERVAL_UNIT_PATHS), 160);
+        const explicitId = firstStringFromPaths(entry, JUNCTION_TIMESERIES_RECORD_ID_PATHS);
+        const externalIdentityHash = shortHash(explicitId
+            ? [
+                policy.identityVersion,
+                resourceSlug,
+                resourceContext.sourceProviderSlug,
+                resourceContext.origin.sourceType ?? "",
+                resourceContext.origin.sourceInstanceId ?? "",
+                explicitId,
+            ]
+            : [
+                policy.identityVersion,
+                resourceSlug,
+                resourceContext.sourceProviderSlug,
+                resourceContext.origin.sourceType ?? "",
+                resourceContext.origin.sourceInstanceId ?? "",
+                startAt,
+                endAt,
+                providerValue,
+                providerUnit ?? "",
+            ]);
+        const fidelityRecordKey = buildJunctionTimeseriesFidelityRecordKey({
+            entry,
+            providerUnit,
+            providerValue,
+            resource,
+            resourceContext,
+            timestamp,
+        });
+        const durationSeconds = Number(((Date.parse(endAt) - Date.parse(startAt)) / 1000).toFixed(3));
+        const candidate = {
+            contentFingerprint: fidelityRecordKey,
+            dayKey,
+            durationSeconds,
+            endAt,
+            entry,
+            fidelityRecordKey,
+            externalIdentityHash,
+            providerUnit,
+            providerValue,
+            recordedAt: timestamp.recordedAt,
+            resourceContext,
+            startAt,
+            sourceVersion: explicitId
+                ? resolveJunctionExplicitSourceVersion(entry, resourceContext.sourceProviderSlug)
+                : undefined,
+            stableIdentity: explicitId !== undefined,
+            timestamp,
+            timeZone: firstStringFromPaths(entry, ["timeZone", "timezone", "time_zone"]),
+            value,
+        };
+        const existing = readingsByIdentity.get(externalIdentityHash);
+        readingsByIdentity.set(externalIdentityHash, existing && explicitId
+            ? selectJunctionAuthoritativeRevision(resource, existing, candidate)
+            : existing ?? candidate);
+    }
+    const readings = [...readingsByIdentity.values()].sort(compareJunctionSparseIntervalReadingOrder);
+    const sourceDayCounts = new Map();
+    for (const reading of readings) {
+        const sourceDayKey = [
+            reading.resourceContext.externalRefResourceType,
+            reading.resourceContext.origin.sourceType ?? "",
+            reading.resourceContext.origin.sourceInstanceId ?? "",
+            reading.dayKey,
+        ].join("\u0000");
+        const sourceDayCount = (sourceDayCounts.get(sourceDayKey) ?? 0) + 1;
+        assertJunctionTimeseriesSourceDayBound(resource, sourceDayCount);
+        sourceDayCounts.set(sourceDayKey, sourceDayCount);
+        pushJunctionSparseIntervalReading(context, resource, resourceSlug, reading);
+    }
+    return new Map(readings.map((reading) => [reading.fidelityRecordKey, reading]));
+}
+function resolveJunctionSparseIntervalTimestamp(entry, startRaw, context, sourceProviderSlug) {
+    const startAt = resolveSafeTimestamp(startRaw);
+    const timestamp = resolveRecordTimestamp({ ...entry, observedAtRaw: startRaw }, context, sourceProviderSlug);
+    return startAt
+        ? withTimestampOverride(timestamp, {
+            occurredAt: startAt,
+            recordedAt: timestamp.recordedAt ?? startAt,
+            observedAtRaw: startRaw,
+            timestampSemantics: inferTimestampSemantics(startRaw),
+        })
+        : timestamp;
+}
+function compareJunctionSparseIntervalReadingOrder(left, right) {
+    return left.startAt.localeCompare(right.startAt)
+        || left.endAt.localeCompare(right.endAt)
+        || left.resourceContext.sourceProviderSlug.localeCompare(right.resourceContext.sourceProviderSlug)
+        || left.externalIdentityHash.localeCompare(right.externalIdentityHash);
+}
+function pushJunctionSparseIntervalReading(context, resource, resourceSlug, reading) {
+    const policy = getJunctionSparseIntervalPolicy(resource);
+    const role = `junction-timeseries-reading-${resourceSlug}:${reading.dayKey}:${reading.externalIdentityHash}`;
+    const externalRefUpdatePolicy = reading.sourceVersion ? undefined : "immutable";
+    pushEvidencePart(context.evidenceParts, withJunctionCompactTimeseriesMetadata(resource, createEvidencePart(role, `${role}.json`, stripUndefined({
+        schema: "junction.interval_reading.v1",
+        policyVersion: policy.policyVersion,
+        provider: "junction",
+        resource,
+        dayKey: reading.dayKey,
+        sourceProviderSlug: reading.resourceContext.sourceProviderSlug,
+        sourceType: reading.resourceContext.origin.sourceType,
+        sourceInstanceId: reading.resourceContext.origin.sourceInstanceId,
+        startAt: reading.startAt,
+        endAt: reading.endAt,
+        durationSeconds: reading.durationSeconds,
+        providerValue: reading.providerValue,
+        providerUnit: reading.providerUnit,
+        value: reading.value,
+        unit: policy.unit,
+        recordedAt: reading.recordedAt,
+    })), "timeseries_reading"));
+    context.events.push(stripUndefined({
+        kind: "measurement",
+        occurredAt: reading.startAt,
+        recordedAt: reading.recordedAt,
+        dayKey: reading.dayKey,
+        timeZone: reading.timeZone,
+        source: "device",
+        title: policy.title,
+        evidenceRoles: [role],
+        externalRef: makeProviderExternalRef("junction", reading.resourceContext.externalRefResourceType, `${resourceSlug}-${reading.externalIdentityHash}`, reading.sourceVersion, "interval"),
+        externalRefUpdatePolicy,
+        dataOrigin: buildDataOrigin(reading.entry, reading.resourceContext, reading.timestamp, { normalizerVersion: policy.policyVersion }),
+        fields: {
+            measurements: [{
+                    metric: policy.metric,
+                    value: reading.value,
+                    unit: policy.unit,
+                    qualifiers: stripUndefined({
+                        "interval-start-at": reading.startAt,
+                        "interval-end-at": reading.endAt,
+                        "interval-duration-seconds": reading.durationSeconds,
+                        "provider-unit": reading.providerUnit,
+                    }),
+                }],
+        },
+    }));
+}
+function junctionFeatureTimeseriesStatisticValue(aggregate, statistic) {
+    switch (statistic) {
+        case "min":
+            return aggregate.minValue;
+        case "max":
+            return aggregate.maxValue;
+        case "sum":
+            return aggregate.sum;
+        case "mean":
+            return aggregate.sum / aggregate.sampleCount;
+    }
+}
+function compareJunctionFeatureTimeseriesAggregates(left, right) {
+    return left.bucketStartAt.localeCompare(right.bucketStartAt)
+        || left.resourceContext.sourceProviderSlug.localeCompare(right.resourceContext.sourceProviderSlug)
+        || (left.resourceContext.origin.sourceType ?? "").localeCompare(right.resourceContext.origin.sourceType ?? "")
+        || (left.resourceContext.origin.sourceInstanceId ?? "").localeCompare(right.resourceContext.origin.sourceInstanceId ?? "")
+        || left.bucketKind.localeCompare(right.bucketKind)
+        || left.bucketIdentity.localeCompare(right.bucketIdentity);
+}
+// Sparse paired blood-pressure readings land as-is: one canonical
+// `measurement` event (systolic + diastolic mmHg entries, so both flow into
+// the existing blood-pressure catalog metrics) plus one compact per-reading
+// evidence part (~350 B; readings arrive 10s-100s per member-year).
+function pushJunctionBloodPressureReadings(payload, resource, resourceSlug, context) {
+    const baseArtifactRole = `junction-timeseries-reading-${resourceSlug}`;
+    let readingCount = 0;
+    const seenReadingIdentityHashes = new Set();
+    for (const [index, { entry, originFallback }] of timeseriesResourceEntries(payload).entries()) {
+        const resourceContext = buildResourceContext({
+            entry,
+            originFallback,
+            resource,
+            resourceSlug,
+            identityKind: "timeseries",
+            index,
+            fallbackArtifactRole: baseArtifactRole,
+            context,
+        });
+        if (!resourceContext) {
+            continue;
+        }
+        const systolic = normalizeSystolicMmHg(firstNumberFromPaths(entry, JUNCTION_BLOOD_PRESSURE_SYSTOLIC_PATHS));
+        const diastolic = normalizeDiastolicMmHg(firstNumberFromPaths(entry, JUNCTION_BLOOD_PRESSURE_DIASTOLIC_PATHS));
+        const timestamp = resolveRecordTimestamp(entry, context, resourceContext.sourceProviderSlug);
+        const occurredAt = timestamp.occurredAt ?? timestamp.recordedAt;
+        const dayKey = resolveJunctionTimeseriesAggregateDayKey(entry, timestamp, occurredAt, context.defaultTimeZone);
+        if (systolic === undefined || diastolic === undefined || systolic <= diastolic || !occurredAt || !dayKey) {
+            continue;
+        }
+        // A stable provider row id is the primary reading identity (mirroring
+        // the fetch-side dedupe key): two distinct readings with the same
+        // timestamp AND the same values must not collapse when the provider
+        // distinguishes them. Without an id, the identity includes the paired
+        // values so same-second readings from coarse-timestamp providers never
+        // collapse, while true duplicate deliveries still merge via externalRef.
+        const readingIdentityHash = buildJunctionBloodPressureReadingIdentityHash({
+            diastolic,
+            entry,
+            occurredAt,
+            resourceContext,
+            resourceSlug,
+            systolic,
+            timestamp,
+        });
+        // Exact in-payload duplicates are skipped and the raw role is derived
+        // from the same stable identity as the event externalRef (never the
+        // payload index), so replays and reorderings stage identical evidence
+        // instead of minting new artifacts for an event core already dedupes.
+        if (seenReadingIdentityHashes.has(readingIdentityHash)) {
+            continue;
+        }
+        seenReadingIdentityHashes.add(readingIdentityHash);
+        readingCount += 1;
+        const role = `${baseArtifactRole}:${dayKey}:${readingIdentityHash}`;
+        pushEvidencePart(context.evidenceParts, withJunctionCompactTimeseriesMetadata(resource, createEvidencePart(role, `${role}.json`, stripUndefined({
+            schema: "junction.blood_pressure_reading.v1",
+            provider: "junction",
+            resource,
+            dayKey,
+            sourceProviderSlug: resourceContext.sourceProviderSlug,
+            sourceType: resourceContext.origin.sourceType,
+            sourceInstanceId: resourceContext.origin.sourceInstanceId,
+            occurredAt,
+            recordedAt: timestamp.recordedAt,
+            systolic,
+            diastolic,
+            unit: "mmHg",
+        })), "timeseries_reading"));
+        context.events.push(stripUndefined({
+            kind: "measurement",
+            occurredAt,
+            recordedAt: timestamp.recordedAt,
+            dayKey,
+            timeZone: firstStringFromPaths(entry, ["timeZone", "timezone", "time_zone"]),
+            source: "device",
+            title: "Junction blood pressure",
+            evidenceRoles: [role],
+            externalRef: makeProviderExternalRef("junction", resourceContext.externalRefResourceType, `${resourceSlug}-${readingIdentityHash}`, undefined, "blood-pressure"),
+            dataOrigin: buildDataOrigin(entry, resourceContext, timestamp),
+            fields: {
+                measurements: [
+                    { metric: "systolic-blood-pressure", value: systolic, unit: "mmHg" },
+                    { metric: "diastolic-blood-pressure", value: diastolic, unit: "mmHg" },
+                ],
+            },
+        }));
+    }
+    if (readingCount === 0) {
+        const role = `${baseArtifactRole}:no-valid-samples`;
+        pushEvidencePart(context.evidenceParts, withJunctionCompactTimeseriesMetadata(resource, createEvidencePart(role, `${role}.json`, {
+            schema: "junction.blood_pressure_reading.v1",
+            provider: "junction",
+            resource,
+            readingCount: 0,
+            status: "no_valid_samples",
+        }), "timeseries_reading"));
     }
-    return [...aggregate.legacyDayKeys].sort().map((legacyDayKey) => makeJunctionExternalRef(aggregate.resourceContext, aggregate.entry, withTimestampOverride(aggregate.timestamp, {
-        occurredAt: aggregate.lastSampleAt,
-        recordedAt: aggregate.lastRecordedAt,
-        dayKey: legacyDayKey,
-        observedAtRaw: `${legacyDayKey}:${aggregate.resourceContext.resource}:daily`,
-    }), metric));
 }
-// Sparse paired blood-pressure readings land as-is: one canonical
-// `measurement` event (systolic + diastolic mmHg entries, so both flow into
-// the existing blood-pressure catalog metrics) plus one compact per-reading
-// evidence part (~350 B; readings arrive 10s-100s per member-year).
-function pushJunctionBloodPressureReadings(payload, resource, resourceSlug, context) {
+// Sparse weight readings use the same canonical measurement path as
+// other queryable body measurements. Each accepted reading retains only one
+// compact evidence record and a replay-stable external reference.
+function pushJunctionWeightReadings(payload, resource, resourceSlug, context) {
     const baseArtifactRole = `junction-timeseries-reading-${resourceSlug}`;
-    let readingCount = 0;
     const seenReadingIdentityHashes = new Set();
+    let readingCount = 0;
     for (const [index, { entry, originFallback }] of timeseriesResourceEntries(payload).entries()) {
         const resourceContext = buildResourceContext({
             entry,
@@ -1311,34 +3183,33 @@ function pushJunctionBloodPressureReadings(payload, resource, resourceSlug, cont
         if (!resourceContext) {
             continue;
         }
-        const systolic = normalizeSystolicMmHg(firstNumberFromPaths(entry, JUNCTION_BLOOD_PRESSURE_SYSTOLIC_PATHS));
-        const diastolic = normalizeDiastolicMmHg(firstNumberFromPaths(entry, JUNCTION_BLOOD_PRESSURE_DIASTOLIC_PATHS));
-        const timestamp = resolveRecordTimestamp(entry, context, resourceContext.sourceProviderSlug);
-        const occurredAt = timestamp.occurredAt ?? timestamp.recordedAt;
+        const { providerReadingId, weightKilograms } = resolveJunctionWeightProviderRecordIdentity(entry);
+        const rawOccurredAt = firstValueFromPaths(entry, JUNCTION_RECORD_TIMESTAMP_PATHS);
+        const occurredAt = resolveSafeTimestamp(rawOccurredAt, resourceContext.sourceProviderSlug);
+        if (weightKilograms === undefined || !occurredAt) {
+            continue;
+        }
+        const timestamp = withTimestampOverride(resolveRecordTimestamp(entry, context, resourceContext.sourceProviderSlug), { occurredAt });
         const dayKey = resolveJunctionTimeseriesAggregateDayKey(entry, timestamp, occurredAt, context.defaultTimeZone);
-        if (systolic === undefined || diastolic === undefined || systolic <= diastolic || !occurredAt || !dayKey) {
+        if (!dayKey) {
             continue;
         }
-        // A stable provider row id is the primary reading identity (mirroring
-        // the fetch-side dedupe key): two distinct readings with the same
-        // timestamp AND the same values must not collapse when the provider
-        // distinguishes them. Without an id, the identity includes the paired
-        // values so same-second readings from coarse-timestamp providers never
-        // collapse, while true duplicate deliveries still merge via externalRef.
-        const readingRowId = firstStringFromPaths(entry, ["id", "resourceId", "resource_id", "externalId", "external_id"]);
-        const readingIdentityHash = shortHash([
-            resourceSlug,
-            resourceContext.sourceProviderSlug,
-            resourceContext.origin.sourceType ?? "",
-            resourceContext.origin.sourceInstanceId ?? "",
-            ...(readingRowId
-                ? [readingRowId]
-                : [timestamp.observedAtRaw ?? occurredAt, systolic, diastolic]),
-        ]);
-        // Exact in-payload duplicates are skipped and the raw role is derived
-        // from the same stable identity as the event externalRef (never the
-        // payload index), so replays and reorderings stage identical evidence
-        // instead of minting new artifacts for an event core already dedupes.
+        const readingIdentityHash = providerReadingId
+            ? shortHash([
+                resourceSlug,
+                resourceContext.sourceProviderSlug,
+                resourceContext.origin.sourceType ?? "",
+                resourceContext.origin.sourceInstanceId ?? "",
+                providerReadingId,
+            ])
+            : shortHash([
+                resourceSlug,
+                resourceContext.sourceProviderSlug,
+                resourceContext.origin.sourceType ?? "",
+                resourceContext.origin.sourceInstanceId ?? "",
+                timestamp.observedAtRaw ?? occurredAt,
+                weightKilograms,
+            ]);
         if (seenReadingIdentityHashes.has(readingIdentityHash)) {
             continue;
         }
@@ -1346,18 +3217,18 @@ function pushJunctionBloodPressureReadings(payload, resource, resourceSlug, cont
         readingCount += 1;
         const role = `${baseArtifactRole}:${dayKey}:${readingIdentityHash}`;
         pushEvidencePart(context.evidenceParts, withJunctionCompactTimeseriesMetadata(resource, createEvidencePart(role, `${role}.json`, stripUndefined({
-            schema: "junction.blood_pressure_reading.v1",
+            schema: "junction.weight_reading.v1",
             provider: "junction",
             resource,
             dayKey,
             sourceProviderSlug: resourceContext.sourceProviderSlug,
             sourceType: resourceContext.origin.sourceType,
             sourceInstanceId: resourceContext.origin.sourceInstanceId,
+            providerReadingId,
             occurredAt,
             recordedAt: timestamp.recordedAt,
-            systolic,
-            diastolic,
-            unit: "mmHg",
+            weightKilograms,
+            unit: "kg",
         })), "timeseries_reading"));
         context.events.push(stripUndefined({
             kind: "measurement",
@@ -1366,14 +3237,13 @@ function pushJunctionBloodPressureReadings(payload, resource, resourceSlug, cont
             dayKey,
             timeZone: firstStringFromPaths(entry, ["timeZone", "timezone", "time_zone"]),
             source: "device",
-            title: "Junction blood pressure",
+            title: "Junction body weight",
             evidenceRoles: [role],
-            externalRef: makeProviderExternalRef("junction", resourceContext.externalRefResourceType, `${resourceSlug}-${readingIdentityHash}`, undefined, "blood-pressure"),
+            externalRef: makeProviderExternalRef("junction", resourceContext.externalRefResourceType, `${resourceSlug}-${readingIdentityHash}`, undefined, "weight"),
             dataOrigin: buildDataOrigin(entry, resourceContext, timestamp),
             fields: {
                 measurements: [
-                    { metric: "systolic-blood-pressure", value: systolic, unit: "mmHg" },
-                    { metric: "diastolic-blood-pressure", value: diastolic, unit: "mmHg" },
+                    { metric: "weight", value: weightKilograms, unit: "kg" },
                 ],
             },
         }));
@@ -1381,7 +3251,7 @@ function pushJunctionBloodPressureReadings(payload, resource, resourceSlug, cont
     if (readingCount === 0) {
         const role = `${baseArtifactRole}:no-valid-samples`;
         pushEvidencePart(context.evidenceParts, withJunctionCompactTimeseriesMetadata(resource, createEvidencePart(role, `${role}.json`, {
-            schema: "junction.blood_pressure_reading.v1",
+            schema: "junction.weight_reading.v1",
             provider: "junction",
             resource,
             readingCount: 0,
@@ -1389,7 +3259,67 @@ function pushJunctionBloodPressureReadings(payload, resource, resourceSlug, cont
         }), "timeseries_reading"));
     }
 }
+function buildJunctionBloodPressureRepairStableExternalRefResourceId(entry, resourceContext) {
+    const readingRowId = firstStringFromPaths(entry, ["id", "resourceId", "resource_id", "externalId", "external_id"]);
+    if (!readingRowId) {
+        return null;
+    }
+    return `${resourceContext.resourceSlug}-${shortHash([
+        resourceContext.resourceSlug,
+        resourceContext.sourceProviderSlug,
+        resourceContext.origin.sourceType ?? "",
+        resourceContext.origin.sourceInstanceId ?? "",
+        readingRowId,
+    ])}`;
+}
+function buildJunctionBloodPressureReadingIdentityHash(input) {
+    const repairStableResourceId = buildJunctionBloodPressureRepairStableExternalRefResourceId(input.entry, input.resourceContext);
+    if (repairStableResourceId) {
+        return repairStableResourceId.slice(`${input.resourceSlug}-`.length);
+    }
+    return shortHash([
+        input.resourceSlug,
+        input.resourceContext.sourceProviderSlug,
+        input.resourceContext.origin.sourceType ?? "",
+        input.resourceContext.origin.sourceInstanceId ?? "",
+        input.timestamp.observedAtRaw ?? input.occurredAt,
+        input.systolic,
+        input.diastolic,
+    ]);
+}
 function buildRawResourcePayload(resource, payload, connectionsByKey) {
+    if (resource === JUNCTION_NOTE_RESOURCE) {
+        return sanitizeJunctionNoteRawValue(sanitizeJunctionRawPayload(payload));
+    }
+    const policy = resolveJunctionTimeseriesResourcePolicy(resource);
+    if (resource === "electrocardiogram_voltage" || resource === "workout_stream") {
+        return normalizeJunctionBoundedTimeseriesFeatures(resource, payload);
+    }
+    const sparseDescriptor = JUNCTION_SPARSE_TIMESERIES_DESCRIPTORS.get(resource);
+    if (policy
+        && (policy.normalizationMode === "sparse_alert"
+            || policy.normalizationMode === "sparse_intervention"
+            || policy.normalizationMode === "sparse_observation")) {
+        return sparseDescriptor
+            ? sanitizeJunctionSparseTimeseriesRawPayload(resource, payload, sparseDescriptor)
+            : undefined;
+    }
+    if (policy?.normalizationMode === "daily_aggregate"
+        && !JUNCTION_DAILY_TIMESERIES_DESCRIPTORS.has(resource)) {
+        return undefined;
+    }
+    if (policy?.normalizationMode === "hourly_or_session_feature"
+        && !JUNCTION_FEATURE_TIMESERIES_DESCRIPTORS.has(resource)) {
+        return undefined;
+    }
+    if (policy?.normalizationMode === "sparse_reading"
+        && resource !== JUNCTION_BLOOD_PRESSURE_RESOURCE
+        && resource !== JUNCTION_WEIGHT_RESOURCE) {
+        return undefined;
+    }
+    if (policy?.normalizationMode === "note_tags" && resource !== JUNCTION_NOTE_RESOURCE) {
+        return undefined;
+    }
     if (resource !== "profile") {
         return sanitizeJunctionRawPayload(payload);
     }
@@ -1403,11 +3333,65 @@ function buildRawResourcePayload(resource, payload, connectionsByKey) {
     const profile = asPlainObject(payload);
     return sanitizeProfilePayload(payload, profile && connectionsByKey ? resolveEntryConnection(profile, connectionsByKey) : undefined);
 }
+function sanitizeJunctionSparseTimeseriesRawPayload(resource, payload, descriptor) {
+    const recordDigests = new Set();
+    for (const { entry, originFallback } of timeseriesResourceEntries(payload)) {
+        const record = parseJunctionSparseTimeseriesRecord(entry, resource, descriptor);
+        if (!record) {
+            continue;
+        }
+        const origin = resolveJunctionOrigin(entry, originFallback);
+        const sourceProviderSlug = readJunctionSourceProviderSlug(entry, originFallback)
+            ?? origin.sourceProviderSlug;
+        if (!sourceProviderSlug) {
+            continue;
+        }
+        recordDigests.add(shortHash([
+            resource,
+            sourceProviderSlug,
+            origin.sourceType ?? "",
+            origin.sourceInstanceId ?? "",
+            record.providerRowId ?? "",
+            record.observedAtRaw,
+            record.startAt ?? "",
+            record.endAt ?? "",
+            record.value,
+            record.unit,
+            record.upstreamUnit,
+            record.alertType ?? "",
+            record.bolusPurpose ?? "",
+            record.deliveryForm ?? "",
+            record.deliveryMode ?? "",
+            record.insulinType ?? "",
+        ]));
+    }
+    const digests = [...recordDigests].sort();
+    return digests.length > 0
+        ? {
+            schema: "junction.sparse_timeseries_digest.v1",
+            resource,
+            recordCount: digests.length,
+            recordsDigest: shortHash([resource, ...digests]),
+        }
+        : undefined;
+}
+function sanitizeJunctionNoteRawValue(value) {
+    if (Array.isArray(value)) {
+        return value.map(sanitizeJunctionNoteRawValue);
+    }
+    if (!isPlainRecord(value)) {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value)
+        .filter(([key]) => normalizeJunctionRawIdentityKey(key) !== "value")
+        .map(([key, entry]) => [key, sanitizeJunctionNoteRawValue(entry)]));
+}
 function sanitizeJunctionRawSnapshot(snapshot) {
     const sanitized = asPlainObject(sanitizeJunctionRawPayload(snapshot));
     if (!sanitized) {
         return sanitized;
     }
+    const sanitizedSnapshot = Object.fromEntries(Object.entries(sanitized).filter(([key]) => key !== "strictSparseCalendarRepair"));
     const connections = asArray(snapshot.connections).flatMap((connection) => {
         const normalized = asPlainObject(connection);
         return normalized ? [normalized] : [];
@@ -1419,7 +3403,7 @@ function sanitizeJunctionRawSnapshot(snapshot) {
         return {};
     }
     return stripUndefined({
-        ...sanitized,
+        ...sanitizedSnapshot,
         connections: sanitizeJunctionRawConnections(snapshot.connections),
         summaries,
         timeseries,
@@ -1484,9 +3468,17 @@ function sanitizeProfilePayload(payload, connection) {
         return undefined;
     }
     const origin = resolveJunctionOrigin(profile, connection);
+    const gender = firstStringFromPaths(profile, JUNCTION_PROFILE_GENDER_PATHS);
+    const sourceProviderSlug = readJunctionSourceProviderSlug(profile, connection)
+        ?? origin.sourceProviderSlug;
+    const updatedAt = resolveSafeTimestamp(firstValueFromPaths(profile, ["updatedAt", "updated_at", "createdAt", "created_at"]), origin.sourceProviderSlug);
     const sanitized = stripUndefined({
-        sourceProviderSlug: readJunctionSourceProviderSlug(profile, connection) ?? origin.sourceProviderSlug,
+        gender: gender ? trimToLength(gender, 80) : undefined,
+        stableResourceId: buildStableProfileResourceId(profile, sourceProviderSlug, origin.sourceType, origin.sourceInstanceId, updatedAt),
+        sourceProviderSlug,
+        sourceInstanceId: origin.sourceInstanceId,
         sourceType: origin.sourceType,
+        updatedAt,
     });
     return Object.keys(sanitized).length > 0 ? sanitized : undefined;
 }
@@ -2378,10 +4370,12 @@ const JUNCTION_PROFILE_SEX_PATHS = [
     "biologicalSex",
     "biological_sex",
 ];
+const JUNCTION_PROFILE_GENDER_PATHS = ["gender"];
 // Junction profile is a single current-state snapshot per source. Height
-// follows the body-summary observation pattern; birth date, biological sex,
-// and wheelchair use are categorical, so they land as one structured note
-// event keyed by a stable external ref instead of fake numeric observations.
+// follows the body-summary observation pattern; gender is a distinct
+// categorical measurement, while birth date, biological sex, and wheelchair
+// use remain one structured note. Gender must never be folded into or labeled
+// as biological sex.
 function pushProfileSummary(entry, resourceContext, context) {
     const baseTimestamp = resolveRecordTimestamp(entry, context, resourceContext.sourceProviderSlug);
     // Profile entries carry no observed-at timestamp, so the generic resolver
@@ -2403,14 +4397,36 @@ function pushProfileSummary(entry, resourceContext, context) {
         occurredAt: pinnedOccurredAt,
         recordedAt: baseTimestamp.observedAtRaw ? baseTimestamp.recordedAt : providerTimestamp,
         dayKey: extractIsoDatePrefix(pinnedOccurredAt) ?? baseTimestamp.dayKey,
-        observedAtRaw: baseTimestamp.observedAtRaw
-            ?? stringId(providerTimestampRaw)
-            ?? "current",
+        observedAtRaw: pinnedOccurredAt,
     });
-    pushObservationMetrics(entry, resourceContext, context, JUNCTION_PROFILE_METRICS, timestamp);
+    const legacyExternalRefs = (facet) => buildJunctionProfileLegacyExternalRefs(resourceContext, entry, timestamp, providerTimestampRaw, facet);
+    pushObservationMetrics(entry, resourceContext, context, JUNCTION_PROFILE_METRICS, timestamp, legacyExternalRefs);
     if (!timestamp.occurredAt) {
         return;
     }
+    const gender = firstStringFromPaths(entry, JUNCTION_PROFILE_GENDER_PATHS);
+    if (gender) {
+        context.events.push(stripUndefined({
+            kind: "measurement",
+            occurredAt: timestamp.occurredAt,
+            recordedAt: timestamp.recordedAt,
+            dayKey: timestamp.dayKey,
+            source: "device",
+            title: "Junction gender",
+            evidenceRoles: resourceContext.evidenceRoles,
+            externalRef: makeJunctionExternalRef(resourceContext, entry, timestamp, "gender"),
+            legacyExternalRefs: legacyExternalRefs("gender"),
+            dataOrigin: buildDataOrigin(entry, resourceContext, timestamp),
+            fields: {
+                measurements: [{
+                        metric: "gender",
+                        value: 1,
+                        unit: "recording",
+                        qualifiers: { gender: trimToLength(gender, 80) },
+                    }],
+            },
+        }));
+    }
     const birthDate = firstIsoDateFromPaths(entry, JUNCTION_PROFILE_BIRTH_DATE_PATHS);
     const sex = readJunctionProfileSex(entry);
     const wheelchairUse = firstValueFromPaths(entry, ["wheelchairUse", "wheelchair_use"]);
@@ -2432,6 +4448,7 @@ function pushProfileSummary(entry, resourceContext, context) {
         note: trimToLength(segments.join(" "), 4000),
         evidenceRoles: resourceContext.evidenceRoles,
         externalRef: makeJunctionExternalRef(resourceContext, entry, timestamp, "profile-demographics"),
+        legacyExternalRefs: legacyExternalRefs("profile-demographics"),
         dataOrigin: buildDataOrigin(entry, resourceContext, timestamp),
     }));
 }
@@ -2544,6 +4561,54 @@ function pushMenstrualCycleSummary(entry, resourceContext, context) {
             title: "Junction menstrual flow",
         });
     }
+    for (const sub of junctionDatedSubEntries(entry, ["cervicalMucus", "cervical_mucus"])) {
+        const quality = firstStringFromPaths(sub.entry, ["quality"]);
+        if (!quality) {
+            continue;
+        }
+        const boundedQuality = trimToLength(quality, 80);
+        pushJunctionCycleDailyMeasurement(entry, resourceContext, context, baseTimestamp, {
+            date: sub.date,
+            facet: `cervical-mucus-quality-${trimSlugToLength(slugify(boundedQuality, "quality"), 80)}-${sub.date}`,
+            measurement: {
+                metric: "cervical-mucus-quality",
+                value: 1,
+                unit: "recording",
+                qualifiers: { quality: boundedQuality },
+            },
+            title: "Junction cervical mucus quality",
+        });
+    }
+    for (const sub of junctionDatedSubEntries(entry, ["intermenstrualBleeding", "intermenstrual_bleeding"])) {
+        pushJunctionCycleDailyMeasurement(entry, resourceContext, context, baseTimestamp, {
+            date: sub.date,
+            facet: `intermenstrual-bleeding-${sub.date}`,
+            measurement: {
+                metric: "intermenstrual-bleeding",
+                value: 1,
+                unit: "flag",
+            },
+            title: "Junction intermenstrual bleeding",
+        });
+    }
+    for (const sub of junctionDatedSubEntries(entry, ["contraceptive"])) {
+        const contraceptiveType = firstStringFromPaths(sub.entry, ["type"]);
+        if (!contraceptiveType) {
+            continue;
+        }
+        const boundedType = trimToLength(contraceptiveType, 80);
+        pushJunctionCycleDailyMeasurement(entry, resourceContext, context, baseTimestamp, {
+            date: sub.date,
+            facet: `contraceptive-type-${trimSlugToLength(slugify(boundedType, "type"), 80)}-${sub.date}`,
+            measurement: {
+                metric: "contraceptive-type",
+                value: 1,
+                unit: "recording",
+                qualifiers: { type: boundedType },
+            },
+            title: "Junction contraceptive type",
+        });
+    }
     for (const test of [
         { metric: "ovulation-test", paths: ["ovulationTest", "ovulation_test"], title: "Junction ovulation test" },
         { metric: "pregnancy-test", paths: ["homePregnancyTest", "home_pregnancy_test"], title: "Junction pregnancy test" },
@@ -2570,6 +4635,47 @@ function pushMenstrualCycleSummary(entry, resourceContext, context) {
             });
         }
     }
+    for (const sub of junctionDatedSubEntries(entry, ["homeProgesteroneTest", "home_progesterone_test"])) {
+        const result = firstStringFromPaths(sub.entry, ["testResult", "test_result"]);
+        if (!result) {
+            continue;
+        }
+        const boundedResult = trimToLength(result, 80);
+        // This records the provider's categorical result rather than coercing it
+        // into a positive/negative scalar, so indeterminate and unknown remain
+        // truthful queryable values instead of being dropped or guessed.
+        pushJunctionCycleDailyMeasurement(entry, resourceContext, context, baseTimestamp, {
+            date: sub.date,
+            facet: `home-progesterone-test-${trimSlugToLength(slugify(boundedResult, "result"), 80)}-${sub.date}`,
+            measurement: {
+                metric: "home-progesterone-test",
+                value: 1,
+                unit: "recording",
+                qualifiers: { result: boundedResult },
+            },
+            title: "Junction home progesterone test",
+        });
+    }
+    for (const sub of junctionDatedSubEntries(entry, ["sexualActivity", "sexual_activity"])) {
+        const protectionUsedRaw = firstValueFromPaths(sub.entry, ["protectionUsed", "protection_used"]);
+        const protectionUsed = typeof protectionUsedRaw === "boolean" ? protectionUsedRaw : undefined;
+        const protectionFacet = protectionUsed === true
+            ? "protected"
+            : protectionUsed === false
+                ? "unprotected"
+                : "protection-unspecified";
+        pushJunctionCycleDailyMeasurement(entry, resourceContext, context, baseTimestamp, {
+            date: sub.date,
+            facet: `sexual-activity-${protectionFacet}-${sub.date}`,
+            measurement: {
+                metric: "sexual-activity",
+                value: 1,
+                unit: "recording",
+                qualifiers: protectionUsed === undefined ? undefined : { "protection-used": protectionUsed },
+            },
+            title: "Junction sexual activity",
+        });
+    }
     for (const sub of junctionDatedSubEntries(entry, ["detectedDeviations", "detected_deviations"])) {
         const deviation = firstStringFromPaths(sub.entry, ["deviation"]);
         if (!deviation) {
@@ -2612,7 +4718,7 @@ function pushJunctionCycleDailyMeasurement(entry, resourceContext, context, base
         externalRef: makeJunctionExternalRef(resourceContext, entry, timestamp, input.facet),
         dataOrigin: buildDataOrigin(entry, resourceContext, timestamp),
         fields: {
-            measurements: [input.measurement],
+            measurements: [stripUndefined(input.measurement)],
         },
     }));
 }
@@ -2641,10 +4747,9 @@ function inclusiveDaysBetween(startDate, endDate) {
     const days = Math.round((end - start) / 86_400_000) + 1;
     return days >= 1 && days <= 120 ? days : undefined;
 }
-// One Junction ECG summary per recording, dozens-to-hundreds of sub-KB rows
-// per member-year (docs.junction.com/api-reference/data/electrocardiogram/get-summary).
-// The recording lands as one measurement event carrying the classification as
-// a qualifier; the electrocardiogram_voltage waveform stays excluded.
+// Summary and voltage-feature contexts deliberately use different resource
+// identities. Core revisions are whole-record replacements, so sharing an
+// owner here would let a compact voltage feature erase summary classification.
 function pushElectrocardiogramSummary(entry, resourceContext, context) {
     const baseTimestamp = resolveRecordTimestamp(entry, context, resourceContext.sourceProviderSlug);
     const sessionStartRaw = firstValueFromPaths(entry, ["sessionStart", "session_start"]);
@@ -2805,12 +4910,13 @@ function buildJunctionMealNutrition(entry, resourceContext, foodItems) {
     });
 }
 // Micronutrients land bounded and compactly: only the documented Junction
-// micro keys are read, and null/zero entries are skipped.
+// micro keys are read. Preserve an explicit finite zero so downstream coverage
+// can distinguish a recorded zero from an absent provider field.
 function readJunctionMealMicros(entry) {
     const micros = {};
     for (const key of MEAL_MICRONUTRIENT_KEYS) {
         const value = roundMealNutritionValue(finiteNumber(readPath(entry, JUNCTION_MEAL_MICRO_PATHS[key])));
-        if (value !== undefined && value > 0) {
+        if (value !== undefined && value >= 0) {
             micros[key] = value;
         }
     }
@@ -3071,7 +5177,7 @@ function buildWorkoutRouteMetadata(entry) {
     });
     return Object.keys(route).length > 0 ? route : undefined;
 }
-function pushObservationMetrics(entry, resourceContext, context, metrics, timestampOverride) {
+function pushObservationMetrics(entry, resourceContext, context, metrics, timestampOverride, legacyExternalRefs) {
     const timestamp = timestampOverride ?? resolveRecordTimestamp(entry, context, resourceContext.sourceProviderSlug);
     const occurredAt = timestamp.occurredAt;
     if (!occurredAt) {
@@ -3096,6 +5202,7 @@ function pushObservationMetrics(entry, resourceContext, context, metrics, timest
             // supersedes an existing generic Apple HRV event instead of duplicating
             // it under the corrected SDNN metric.
             externalRef: makeJunctionExternalRef(resourceContext, entry, timestamp, metric.metric),
+            legacyExternalRefs: legacyExternalRefs?.(metric.metric),
             dataOrigin: buildDataOrigin(entry, resourceContext, timestamp),
             fields: {
                 metric: metricKey,
@@ -3173,6 +5280,13 @@ function resolveMetricDescriptorValue(entry, metric) {
     }
     return null;
 }
+function resolveJunctionSleepLatencyMinutes(entry) {
+    const explicitlyNamedMinutes = firstNumberFromPaths(entry, JUNCTION_SLEEP_LATENCY_MINUTE_PATHS);
+    if (explicitlyNamedMinutes !== undefined) {
+        return explicitlyNamedMinutes;
+    }
+    return secondsToMinutes(firstNumberFromPaths(entry, JUNCTION_SLEEP_LATENCY_SECOND_PATHS));
+}
 function resolveJunctionDailyActivityMinutes(entry) {
     // Get Summary reports these buckets in minutes and `daily_movement` as
     // deprecated equivalent-walking meters. Sense's `*_second` query columns
@@ -3193,6 +5307,12 @@ function resolveJunctionDailyActivityMinutes(entry) {
         ? totalActivityMinutes
         : undefined;
 }
+function resolveJunctionActivityIntensityMinutes(entry, intensity) {
+    const minutes = firstNumberFromPaths(entry, [intensity]);
+    return minutes !== undefined && minutes >= 0 && minutes <= 24 * 60
+        ? minutes
+        : undefined;
+}
 function buildResourceContext(input) {
     const connection = resolveEntryConnection(input.entry, input.context.connectionsByKey);
     const originFallback = buildJunctionOriginFallback(connection, input.originFallback);
@@ -3259,8 +5379,8 @@ function withTimestampOverride(timestamp, override) {
         timestampSemantics: override.timestampSemantics ?? timestamp.timestampSemantics,
     };
 }
-function makeJunctionExternalRef(resourceContext, entry, timestamp, facet) {
-    return makeProviderExternalRef("junction", resourceContext.externalRefResourceType, buildStableResourceId(resourceContext, entry, timestamp), junctionCompanionExternalRefVersion(resourceContext, entry), slugify(facet, "value"));
+function makeJunctionExternalRef(resourceContext, entry, timestamp, facet, sourceVersion) {
+    return makeProviderExternalRef("junction", resourceContext.externalRefResourceType, buildStableResourceId(resourceContext, entry, timestamp), sourceVersion ?? junctionCompanionExternalRefVersion(resourceContext, entry), slugify(facet, "value"));
 }
 function junctionCompanionExternalRefVersion(resourceContext, entry) {
     if (resourceContext.sourceProviderSlug !== "apple-health-kit"
@@ -3282,6 +5402,12 @@ function buildStableResourceId(resourceContext, entry, timestamp) {
     return buildStableSummaryResourceId(resourceContext, entry, timestamp);
 }
 function buildStableSummaryResourceId(resourceContext, entry, timestamp) {
+    if (resourceContext.resource === "profile") {
+        const profileResourceId = buildStableProfileResourceId(entry, resourceContext.sourceProviderSlug, resourceContext.origin.sourceType, resourceContext.origin.sourceInstanceId, timestamp.occurredAt);
+        if (profileResourceId) {
+            return profileResourceId;
+        }
+    }
     const explicitId = resourceContext.resource === "workouts"
         ? firstStringFromPaths(entry, JUNCTION_WORKOUT_STABLE_ID_PATHS)
         : resourceContext.resource === "meal"
@@ -3301,29 +5427,99 @@ function buildStableSummaryResourceId(resourceContext, entry, timestamp) {
         resourceContext.origin.sourceType,
         resourceContext.origin.sourceInstanceId,
         timestamp.observedAtRaw ?? timestamp.occurredAt,
-        ...(resourceContext.resource === "meal" ? [
-            resolveJunctionMealTitle(entry),
-            ...(resourceContext.fallbackIdentityDisambiguator ? [resourceContext.fallbackIdentityDisambiguator] : []),
-        ] : []),
+        ...(resourceContext.resource === "meal" ? [resolveJunctionMealTitle(entry)] : []),
+        ...(resourceContext.fallbackIdentityDisambiguator
+            ? [resourceContext.fallbackIdentityDisambiguator]
+            : []),
     ])}`;
 }
-function buildStableTimeseriesResourceId(resourceContext, timestamp) {
-    return `${resourceContext.resourceSlug}-${shortHash([
-        resourceContext.resourceSlug,
+function buildStableProfileResourceId(entry, sourceProviderSlug, sourceType, sourceInstanceId, updatedAt) {
+    const retainedResourceId = firstStringFromPaths(entry, ["stableResourceId"]);
+    if (retainedResourceId && /^profile-[a-f0-9]{16}$/u.test(retainedResourceId)) {
+        return retainedResourceId;
+    }
+    const explicitId = firstStringFromPaths(entry, JUNCTION_GENERIC_SUMMARY_ID_PATHS);
+    if (explicitId) {
+        return `profile-${shortHash([
+            sourceProviderSlug,
+            sourceType,
+            sourceInstanceId,
+            explicitId,
+        ])}`;
+    }
+    return updatedAt
+        ? `profile-${shortHash([
+            "profile",
+            sourceProviderSlug,
+            sourceType,
+            sourceInstanceId,
+            updatedAt,
+        ])}`
+        : undefined;
+}
+function buildJunctionProfileLegacyExternalRefs(resourceContext, entry, timestamp, providerTimestampRaw, facet) {
+    if (firstStringFromPaths(entry, ["stableResourceId"])
+        || firstStringFromPaths(entry, JUNCTION_GENERIC_SUMMARY_ID_PATHS)) {
+        return undefined;
+    }
+    const rawTimestamp = stringId(providerTimestampRaw);
+    if (!rawTimestamp) {
+        return undefined;
+    }
+    const primary = makeJunctionExternalRef(resourceContext, entry, timestamp, facet);
+    const legacyResourceId = `profile-${shortHash([
+        "profile",
         resourceContext.sourceProviderSlug,
         resourceContext.origin.sourceType,
         resourceContext.origin.sourceInstanceId,
-        timestamp.observedAtRaw ?? timestamp.occurredAt,
+        rawTimestamp,
+    ])}`;
+    return legacyResourceId === primary.resourceId
+        ? undefined
+        : [{ ...primary, resourceId: legacyResourceId }];
+}
+function buildStableTimeseriesResourceId(resourceContext, timestamp) {
+    if (resourceContext.fallbackIdentityDisambiguator) {
+        return `${resourceContext.resourceSlug}-${shortHash([
+            resourceContext.fallbackIdentityDisambiguator,
+        ])}`;
+    }
+    return buildJunctionTimeseriesResourceId({
+        observedAtRaw: timestamp.observedAtRaw ?? timestamp.occurredAt,
+        resourceSlug: resourceContext.resourceSlug,
+        sourceInstanceId: resourceContext.origin.sourceInstanceId,
+        sourceProviderSlug: resourceContext.sourceProviderSlug,
+        sourceType: resourceContext.origin.sourceType,
+    });
+}
+function buildJunctionTimeseriesResourceId(input) {
+    return `${input.resourceSlug}-${shortHash([
+        input.resourceSlug,
+        input.sourceProviderSlug,
+        input.sourceType,
+        input.sourceInstanceId,
+        input.observedAtRaw,
     ])}`;
 }
+export function buildJunctionDailyTimeseriesAggregateResourceId(input) {
+    const resourceSlug = slugify(input.resource, "timeseries");
+    return buildJunctionTimeseriesResourceId({
+        observedAtRaw: `${input.dayKey}:${input.resource}:daily`,
+        resourceSlug,
+        sourceInstanceId: input.sourceInstanceId,
+        sourceProviderSlug: normalizeJunctionSourceProviderSlug(input.sourceProviderSlug)
+            ?? input.sourceProviderSlug,
+        sourceType: input.sourceType,
+    });
+}
 function shortHash(parts) {
     return createHash("sha256")
         .update(JSON.stringify(parts))
         .digest("hex")
         .slice(0, 16);
 }
-function resolveRecordTimestamp(entry, context, sourceProviderSlug) {
-    const rawObservedAt = firstStringFromPaths(entry, JUNCTION_RECORD_TIMESTAMP_PATHS);
+function resolveRecordTimestamp(entry, context, sourceProviderSlug, timestampPaths = JUNCTION_RECORD_TIMESTAMP_PATHS) {
+    const rawObservedAt = firstStringFromPaths(entry, timestampPaths);
     const localCalendarDayKey = firstIsoDateFromPaths(entry, JUNCTION_LOCAL_CALENDAR_DATE_PATHS);
     const explicitSemantics = firstTimestampSemantics(entry);
     const hasSourceSpecificFloatingTime = hasFloatingTimestampSourceProvider(sourceProviderSlug);
@@ -3738,7 +5934,21 @@ function resolveJunctionTimeseriesAggregateDayKey(entry, timestamp, sampleAt, de
         : undefined;
     return timestamp.dayKey ?? vaultDayKey ?? extractIsoDatePrefix(sampleAt) ?? undefined;
 }
-function resolveJunctionDailyAggregateSampleAt(timestamp) {
+function hasValidJunctionExplicitTimeseriesTimestamp(timestamp) {
+    if (!timestamp.observedAtRaw) {
+        return false;
+    }
+    if (timestamp.timestampSemantics === "floating") {
+        return Boolean(timestamp.dayKey);
+    }
+    return normalizeTimestamp(timestamp.observedAtRaw) !== undefined;
+}
+function resolveJunctionDailyAggregateSampleAt(timestamp, preserveFloatingDay) {
+    if (preserveFloatingDay
+        && timestamp.timestampSemantics === "floating"
+        && timestamp.dayKey) {
+        return `${timestamp.dayKey}T23:59:59.999Z`;
+    }
     return timestamp.occurredAt ?? timestamp.recordedAt ?? (timestamp.timestampSemantics === "floating" && timestamp.dayKey
         ? `${timestamp.dayKey}T00:00:00.000Z`
         : undefined);
@@ -3952,6 +6162,219 @@ function metersToKilometers(value) {
     }
     return numeric / 1000;
 }
+function normalizeStepCount(value) {
+    const numeric = finiteNumber(value);
+    if (numeric === undefined
+        || !Number.isSafeInteger(numeric)
+        || numeric < 0
+        || numeric > 1_000_000) {
+        return undefined;
+    }
+    return numeric;
+}
+function normalizeDistanceKilometers(value, entry) {
+    const numeric = finiteNumber(value);
+    if (numeric === undefined || numeric < 0) {
+        return undefined;
+    }
+    const unit = readJunctionTimeseriesUnit(entry);
+    let kilometers;
+    switch (unit) {
+        case undefined: {
+            const kilometerField = firstNumberFromPaths(entry, ["distanceKm", "distance_km"]);
+            const meterField = firstNumberFromPaths(entry, ["value", "distance", "distanceMeters", "distance_meters"]);
+            kilometers = kilometerField !== undefined && meterField === undefined
+                ? numeric
+                : numeric / 1000;
+            break;
+        }
+        case "m":
+        case "meter":
+        case "meters":
+        case "metre":
+        case "metres":
+            kilometers = numeric / 1000;
+            break;
+        case "km":
+        case "kilometer":
+        case "kilometers":
+        case "kilometre":
+        case "kilometres":
+            kilometers = numeric;
+            break;
+        case "mi":
+        case "mile":
+        case "miles":
+            kilometers = numeric * 1.609344;
+            break;
+        default:
+            return undefined;
+    }
+    if (kilometers === undefined
+        || !Number.isFinite(kilometers)
+        || kilometers < 0
+        || kilometers > 1000) {
+        return undefined;
+    }
+    return roundJunctionDailyAggregateValue(kilometers);
+}
+function normalizeActiveCaloriesKilocalories(value, entry) {
+    const numeric = finiteNumber(value);
+    if (numeric === undefined || numeric < 0) {
+        return undefined;
+    }
+    const unit = readJunctionTimeseriesUnit(entry);
+    const kilocalories = unit === undefined || isJunctionKilocalorieUnit(unit)
+        ? numeric
+        : isJunctionKilojouleUnit(unit)
+            ? kilojoulesToKilocalories(numeric)
+            : undefined;
+    if (kilocalories === undefined || kilocalories < 0 || kilocalories > 20_000) {
+        return undefined;
+    }
+    return roundJunctionDailyAggregateValue(kilocalories);
+}
+function normalizeBasalCaloriesKilocalories(value, entry) {
+    return normalizeActiveCaloriesKilocalories(value, entry);
+}
+function normalizeDaylightExposureMinutes(value, entry) {
+    return normalizeJunctionDurationMinutes(value, entry, 1440);
+}
+function normalizeStandDurationMinutes(value, entry) {
+    return normalizeJunctionDurationMinutes(value, entry, 1440);
+}
+function normalizeWorkoutDurationMinutes(value, entry) {
+    return normalizeJunctionDurationMinutes(value, entry, 7 * 24 * 60);
+}
+function normalizeJunctionDurationMinutes(value, entry, maximum) {
+    const numeric = finiteNumber(value);
+    const unit = readJunctionTimeseriesUnit(entry);
+    if (numeric === undefined || numeric < 0) {
+        return undefined;
+    }
+    let minutes;
+    switch (unit) {
+        case undefined:
+        case "min":
+        case "mins":
+        case "minute":
+        case "minutes":
+            minutes = numeric;
+            break;
+        case "s":
+        case "sec":
+        case "secs":
+        case "second":
+        case "seconds":
+            minutes = numeric / 60;
+            break;
+        case "ms":
+        case "millisecond":
+        case "milliseconds":
+            minutes = numeric / 60_000;
+            break;
+        default:
+            return undefined;
+    }
+    return minutes <= maximum
+        ? roundJunctionDailyAggregateValue(minutes)
+        : undefined;
+}
+function normalizeFloorsClimbedCount(value, entry) {
+    return normalizeJunctionIntegerCount(value, entry, 0, 10_000);
+}
+function normalizeStandHourCount(value, entry) {
+    return normalizeJunctionIntegerCount(value, entry, 0, 24);
+}
+function normalizeWheelchairPushCount(value, entry) {
+    return normalizeJunctionIntegerCount(value, entry, 0, 10_000_000);
+}
+function normalizeHandwashingCount(value, entry) {
+    return normalizeJunctionIntegerCount(value, entry, 1, 1_000);
+}
+function normalizeWorkoutSwimmingStrokeCount(value, entry) {
+    return normalizeJunctionIntegerCount(value, entry, 0, 1_000_000);
+}
+function normalizeJunctionIntegerCount(value, entry, minimum, maximum) {
+    const numeric = finiteNumber(value);
+    const unit = readJunctionTimeseriesUnit(entry);
+    if (numeric === undefined
+        || !Number.isSafeInteger(numeric)
+        || numeric < minimum
+        || numeric > maximum
+        || (unit !== undefined && unit !== "count" && unit !== "counts")) {
+        return undefined;
+    }
+    return numeric;
+}
+function normalizeUvExposureIndex(value, entry) {
+    const numeric = finiteNumber(value);
+    const unit = readJunctionTimeseriesUnit(entry);
+    if (numeric === undefined
+        || numeric < 0
+        || numeric > 100
+        || (unit !== undefined && unit !== "index")) {
+        return undefined;
+    }
+    return roundJunctionDailyAggregateValue(numeric);
+}
+function normalizeHeartRateBpm(value, entry) {
+    const numeric = finiteNumber(value);
+    const unit = readJunctionTimeseriesUnit(entry);
+    if (numeric === undefined
+        || numeric < 20
+        || numeric > 300
+        || (unit !== undefined && !["bpm", "beatperminute", "beatsperminute"].includes(unit))) {
+        return undefined;
+    }
+    return roundJunctionDailyAggregateValue(numeric);
+}
+export function resolveJunctionWeightProviderRecordIdentity(entry) {
+    return {
+        providerReadingId: trimOptionalToLength(firstStringFromPaths(entry, JUNCTION_READING_STABLE_ID_PATHS), 160),
+        weightKilograms: normalizeWeightKilograms(firstNumberFromPaths(entry, JUNCTION_WEIGHT_VALUE_PATHS), entry),
+    };
+}
+function normalizeWeightKilograms(value, entry) {
+    const numeric = finiteNumber(value);
+    if (numeric === undefined || numeric <= 0) {
+        return undefined;
+    }
+    const unit = readJunctionTimeseriesUnit(entry);
+    let kilograms;
+    switch (unit) {
+        case undefined:
+        case "kg":
+        case "kilogram":
+        case "kilograms":
+            kilograms = numeric;
+            break;
+        case "g":
+        case "gram":
+        case "grams":
+            kilograms = numeric / 1000;
+            break;
+        case "lb":
+        case "lbs":
+        case "pound":
+        case "pounds":
+            kilograms = numeric / 2.2046226218;
+            break;
+        default:
+            return undefined;
+    }
+    if (kilograms === undefined
+        || !Number.isFinite(kilograms)
+        || kilograms <= 0
+        || kilograms > 500) {
+        return undefined;
+    }
+    return roundJunctionDailyAggregateValue(kilograms);
+}
+function readJunctionTimeseriesUnit(entry) {
+    const unit = firstStringFromPaths(entry, ["unit", "units", "valueUnit", "value_unit"]);
+    return unit ? normalizeNutritionUnit(unit) : undefined;
+}
 function normalizePercentRatio(value) {
     const numeric = finiteNumber(value);
     if (numeric === undefined) {
@@ -4017,21 +6440,21 @@ function normalizeBodyTemperatureCelsius(value) {
 // implausible single intake.
 function normalizeCaffeineMilligrams(value) {
     const numeric = finiteNumber(value);
-    if (numeric === undefined || numeric <= 0 || numeric > 2) {
+    if (numeric === undefined || numeric < 0 || numeric > 2) {
         return undefined;
     }
     return roundJunctionDailyAggregateValue(numeric * 1000);
 }
 function normalizeWaterMilliliters(value) {
     const numeric = finiteNumber(value);
-    if (numeric === undefined || numeric <= 0 || numeric > 10_000) {
+    if (numeric === undefined || numeric < 0 || numeric > 10_000) {
         return undefined;
     }
     return roundJunctionDailyAggregateValue(numeric);
 }
 function normalizeMindfulnessMinutesValue(value) {
     const numeric = finiteNumber(value);
-    if (numeric === undefined || numeric <= 0 || numeric > 1440) {
+    if (numeric === undefined || numeric < 0 || numeric > 1440) {
         return undefined;
     }
     return roundJunctionDailyAggregateValue(numeric);