@murphai/murph 1.3.1 → 1.3.2

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

@@ -1,23 +1,25 @@
 import { createHmac, createHash, timingSafeEqual } from "node:crypto";
-import { COMPANION_HRV_RMSSD_RESOURCE, JUNCTION_ALLOWED_SUMMARY_RESOURCES, JUNCTION_ALLOWED_TIMESERIES_RESOURCES, JUNCTION_DEFAULT_SUMMARY_RESOURCES, JUNCTION_DEFAULT_TIMESERIES_RESOURCES, JUNCTION_KNOWN_TIMESERIES_RESOURCES, normalizeJunctionResourceName, resolveJunctionTimeseriesResourcePolicy, usesJunctionTimeseriesIntervalStartOwnership, parseCompanionHrvRmssdAdmissionId, parseSerializedCompanionHrvRmssdObservation, serializeCompanionHrvRmssdObservation, } from "@murphai/contracts";
-import { JUNCTION_ECG_VOLTAGE_FEATURE_SCHEMA, JUNCTION_WORKOUT_STREAM_FEATURE_SCHEMA, buildJunctionBoundedFeatureIdentity, buildJunctionDailyTimeseriesAggregateResourceId, canNormalizeJunctionSleepCycleRecordToCompactStages, classifyJunctionSummaryNormalizationEvidence, countAcceptedJunctionDailyTimeseriesProviderRecords, identifyJunctionBloodPressureProviderRecords, JUNCTION_DENSE_FIDELITY_RESOURCES, reduceJunctionElectrocardiogramVoltageRecords, reduceJunctionWorkoutStreamPayload, resolveJunctionBoundedFeatureRecords, resolveJunctionWeightProviderRecordIdentity, selectJunctionWorkoutStreamCandidates, } from "@murphai/importers/device-providers/junction";
+import { performance } from "node:perf_hooks";
+import { COMPANION_HRV_RMSSD_RESOURCE, JUNCTION_ALLOWED_SUMMARY_RESOURCES, JUNCTION_ALLOWED_TIMESERIES_RESOURCES, JUNCTION_DEFAULT_SUMMARY_RESOURCES, JUNCTION_DEFAULT_TIMESERIES_RESOURCES, JUNCTION_KNOWN_TIMESERIES_RESOURCES, normalizeJunctionResourceName, resolveJunctionTimeseriesResourcePolicy, usesJunctionTimeseriesIntervalStartOwnership, parseCompanionHrvRmssdAdmissionId, parseSerializedCompanionHrvRmssdObservation, serializeCompanionHrvRmssdObservation, toLocalDayKey, } from "@murphai/contracts";
+import { JUNCTION_ECG_VOLTAGE_FEATURE_SCHEMA, JUNCTION_WORKOUT_STREAM_FEATURE_SCHEMA, JunctionWorkoutStreamTimestampCardinalityError, buildJunctionBoundedFeatureIdentity, buildJunctionDailyTimeseriesAggregateResourceId, canNormalizeJunctionSleepCycleRecordToCompactStages, classifyJunctionSummaryNormalizationEvidence, countAcceptedJunctionDailyTimeseriesProviderRecords, identifyJunctionBloodPressureProviderRecords, normalizeJunctionCanonicalBodyTimestamp, JUNCTION_DENSE_FIDELITY_RESOURCES, parseJunctionCompleteDayTimestamp, reduceJunctionElectrocardiogramVoltageRecords, reduceJunctionWorkoutStreamPayload, resolveJunctionBoundedFeatureRecords, resolveJunctionWeightProviderRecordIdentity, selectJunctionWorkoutStreamCandidates, } from "@murphai/importers/device-providers/junction";
 import { normalizeJunctionSourceProviderSlug, resolveJunctionOrigin, } from "@murphai/importers/device-providers/junction-origin";
-import { isJunctionRawDirectIdentityContainerKey, isJunctionRawDirectIdentityKey, } from "@murphai/importers/device-providers/junction-resources";
+import { isJunctionRawDirectIdentityContainerKey, isJunctionRawDirectIdentityKey, maxJunctionCanonicalCoverageBoundary, normalizeJunctionCanonicalCoverageBoundary, } from "@murphai/importers/device-providers/junction-resources";
 import { JUNCTION_DEVICE_PROVIDER_DESCRIPTOR } from "@murphai/importers/device-providers/provider-descriptors";
 import { deviceSyncError, isDeviceSyncError } from "../errors.js";
 import { JunctionTimeseriesProgressError } from "../junction-timeseries-progress.js";
 import { isHostedRuntimeIdShapedDiagnosticToken, sanitizeHostedRuntimeDiagnosticText, } from "../hosted-runtime.js";
-import { isJunctionCredentialIndependentInlineImportJob, resolveDeviceSyncJunctionInlineSourceProviderSlug, } from "../junction-inline-authority.js";
-import { addJunctionExtendedTimeseriesHistoryBackfillCoverage, addJunctionHistoricalBackfillEvidence, canRepresentJunctionExtendedTimeseriesHistoryBackfillCoverage, canCurrentRuntimeMutateJunctionExtendedTimeseriesHistoryBackfillCoverage, canCurrentRuntimeMutateJunctionHistoricalBackfillProgress, encodeJunctionHistoricalBackfillStatus, hasJunctionExtendedTimeseriesHistoryBackfillCoverage, hasJunctionHistoricalBackfillEvidence, JUNCTION_HISTORICAL_BACKFILL_COVERAGE_VERSION, JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS, readJunctionHistoricalBackfillEvidence, readJunctionHistoricalBackfillStatus, } from "../junction-historical-backfill-progress.js";
+import { areJunctionProviderSlugsDataEquivalent, classifyDeviceSyncJunctionInlineSourceProviderSlug, isJunctionInlineImportJob, resolveDeviceSyncJunctionInlineSourceProviderSlug, } from "../junction-inline-authority.js";
+import { addJunctionExtendedTimeseriesHistoryBackfillCoverage, addJunctionHistoricalBackfillEvidence, canRepresentJunctionExtendedTimeseriesHistoryBackfillCoverage, canCurrentRuntimeMutateJunctionExtendedTimeseriesHistoryBackfillCoverage, canCurrentRuntimeMutateJunctionHistoricalBackfillProgress, encodeJunctionHistoricalBackfillStatus, hasJunctionExtendedTimeseriesHistoryBackfillCoverage, hasJunctionHistoricalBackfillEvidence, JUNCTION_HISTORICAL_BACKFILL_COVERAGE_VERSION, JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS, readJunctionHistoricalBackfillEvidence, readJunctionHistoricalBackfillStatus, resolveJunctionExtendedTimeseriesHistoryBackfillVersion, } from "../junction-historical-backfill-progress.js";
 import { DEVICE_SYNC_METADATA_MAX_STRING_LENGTH } from "../metadata.js";
-import { DEVICE_SYNC_HISTORICAL_DATA_RECONNECT_REQUIRED_ERROR_CODE, DEVICE_SYNC_SOURCE_USER_DISCONNECTED_ERROR_CODE, resolveDeviceSyncSourceState, isDeviceSyncSourceAdmitted, isDeviceSyncSourceDisconnectFenced, isJunctionHistoricalResetProviderSlug, requiresHistoricalResetDeviceSyncSource, } from "../public-account.js";
+import { buildDeviceSyncSourceCanonicalCoverageBoundaryKey, buildDeviceSyncSourceCanonicalCoverageFinalizedAtKey, DEVICE_SYNC_SOURCE_HISTORICAL_BACKFILL_COMPLETED_AT_KEY, DEVICE_SYNC_SOURCE_PROVIDER_DISCONNECTED_ERROR_CODE, isGoogleHealthFitbitMigrationLegacyTerminal, isGoogleHealthFitbitMigrationLegacyCoverageReady, isDeviceSyncSourceResourceAvailabilityMetadataKey, readDeviceSyncSourceCanonicalCoverageBoundary, readDeviceSyncSourceCanonicalCoverageFinalizedAt, } from "../fitbit-migration.js";
+import { DEVICE_SYNC_HISTORICAL_DATA_RECONNECT_REQUIRED_ERROR_CODE, DEVICE_SYNC_SOURCE_USER_DISCONNECTED_ERROR_CODE, isDeviceSyncSourceAdmitted, isDeviceSyncSourceDisconnectFenced, isJunctionHistoricalResetProviderSlug, resolveDeviceSyncSourceState, requiresHistoricalResetDeviceSyncSource, } from "../public-account.js";
 import { assertValidJunctionClientUserIdSecret, buildJunctionDeviceSyncRuntimeDescriptor, normalizeJunctionClientUserIdNamespace, normalizeJunctionDeviceSyncRuntimeConfig, } from "../configured-provider-runtime-descriptors.js";
 import { addMilliseconds, normalizeString, sha256Text, subtractDays, } from "../shared.js";
 import { JUNCTION_COMPANION_HRV_OBSERVATION_INVALID_CODE, JUNCTION_COMPANION_HRV_SOURCE_PROVIDER, JUNCTION_COMPANION_HEALTH_METADATA_EVENT_TYPE, JUNCTION_COMPANION_HEALTH_METADATA_MAX_BATCH_BYTES, JUNCTION_COMPANION_HEALTH_METADATA_RESOURCE, JUNCTION_COMPANION_HEALTH_METADATA_SOURCE_PROVIDER, JUNCTION_COMPANION_HEALTH_METADATA_SOURCE_TYPE, JUNCTION_CALENDAR_REFRESH_EMPTY_IDENTITY_INVALID_CODE, JUNCTION_CALENDAR_REFRESH_JOB_INVALID_CODE, JunctionCompanionHealthMetadataParseError, parseJunctionCompanionHealthMetadataBatch, } from "../junction-resources.js";
 import { JunctionClient, JUNCTION_MAX_USER_PROVIDERS, } from "./junction-client.js";
-import { areJunctionDeviceConnectProviderSlugsEquivalent, resolveJunctionDeviceConnectRouteByProviderSlug, } from "../config/connect-routes.js";
+import { canonicalizeJunctionProviderSlug, JUNCTION_FITBIT_LEGACY_PROVIDER_SLUG, JUNCTION_GOOGLE_HEALTH_PROVIDER_SLUG, resolveJunctionDeviceConnectRouteByProviderSlug, } from "../config/connect-routes.js";
 import { buildJunctionProviderSourceInstanceKey, JUNCTION_DEFAULT_PROVIDER_FILTER, normalizeJunctionProviderFilter, } from "../config/junction-connect-sources.js";
-import { classifyDeviceSyncWebhookAcceptanceMode } from "../types.js";
+import { classifyDeviceSyncWebhookAcceptanceMode, JUNCTION_TEMPORAL_AUTHORITY_DEDUPE_PREFIX, } from "../types.js";
 import { evaluatePushPrimarySourceStaleness } from "../source-staleness.js";
 import { JUNCTION_PUSH_SOURCE_RECOVERY_JOB_KIND, JUNCTION_PUSH_SOURCE_RECOVERY_METADATA_KEYS, buildJunctionPushSourceRecoveryMetadataPatch, readJunctionPushSourceRecoveryState, resolveJunctionPushSourceRecoveryAttempts, resolveJunctionPushSourceRecoveryStatus, selectDueJunctionPushSourceRecovery, } from "../junction-push-source-recovery.js";
 export { JUNCTION_DEVICE_PROVIDER_DESCRIPTOR };
@@ -39,7 +41,7 @@ const JUNCTION_WEBHOOK_ROOT_FIELDS = Object.freeze({
 const JUNCTION_SDK_ISO_8601_DATE_PATTERN = /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([.,]\d+(?!:))?)?(\17[0-5]\d([.,]\d+)?)?([zZ]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
 const JUNCTION_PROFILE_SUMMARY_RESOURCE = "profile";
 const JUNCTION_PROFILE_SUMMARY_CHECKED_AT_METADATA_KEY = "junctionProfileSummaryCheckedAt";
-const JUNCTION_PROFILE_SUMMARY_NORMALIZATION_REVISION = 1;
+const JUNCTION_PROFILE_SUMMARY_NORMALIZATION_REVISION = 2;
 const JUNCTION_PROFILE_SUMMARY_NORMALIZATION_REVISION_METADATA_KEY = "junctionProfileSummaryNormalizationRevision";
 // `profile` is deliberately excluded: it is a current-state snapshot, so
 // counting it as completion evidence would mark every backfill useful and
@@ -88,7 +90,7 @@ const JUNCTION_KNOWN_WEBHOOK_RESOURCE_NAMES = new Set([
 ]);
 const DEFAULT_SUMMARY_BACKFILL_DAYS = JUNCTION_DEVICE_PROVIDER_DESCRIPTOR.sync.windows.backfillDays;
 const DEFAULT_TIMESERIES_BACKFILL_DAYS = 14;
-const JUNCTION_NOTE_HISTORY_BACKFILL_VERSION = 2;
+const JUNCTION_EXTENDED_TIMESERIES_BACKFILL_DAYS = 180;
 const JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY = Object.freeze({
     history: "bounded",
 });
@@ -96,7 +98,6 @@ const JUNCTION_SPARSE_DAILY_TIMESERIES_BACKFILL_POLICY = Object.freeze({
     anchor: "current_day",
     completion: "daily_aggregate",
     history: "extended",
-    version: 1,
 });
 // This is the history-depth decision for every admitted resource. Only the
 // sparse resources represented by the package-owned source/resource matrix
@@ -109,7 +110,6 @@ const JUNCTION_TIMESERIES_BACKFILL_POLICIES = Object.freeze({
         anchor: "source_first_seen",
         completion: "exact_records",
         history: "extended",
-        version: 1,
     },
     body_temperature: JUNCTION_SPARSE_DAILY_TIMESERIES_BACKFILL_POLICY,
     body_temperature_delta: JUNCTION_SPARSE_DAILY_TIMESERIES_BACKFILL_POLICY,
@@ -125,7 +125,6 @@ const JUNCTION_TIMESERIES_BACKFILL_POLICIES = Object.freeze({
         anchor: "current_day",
         completion: "fetch_complete",
         history: "extended",
-        version: JUNCTION_NOTE_HISTORY_BACKFILL_VERSION,
     },
     respiratory_rate: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
     sleep_breathing_disturbance: JUNCTION_SPARSE_DAILY_TIMESERIES_BACKFILL_POLICY,
@@ -137,7 +136,6 @@ const JUNCTION_TIMESERIES_BACKFILL_POLICIES = Object.freeze({
         anchor: "current_day",
         completion: "exact_records",
         history: "extended",
-        version: 1,
     },
     body_mass_index: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
     carbohydrates: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
@@ -171,7 +169,23 @@ function resolveJunctionExtendedTimeseriesBackfillPolicy(resource) {
         return null;
     }
     const policy = JUNCTION_TIMESERIES_BACKFILL_POLICIES[resource];
-    return policy.history === "extended" ? policy : null;
+    if (policy.history !== "extended") {
+        return null;
+    }
+    const version = resolveJunctionExtendedTimeseriesHistoryBackfillVersion(resource);
+    if (version === null) {
+        throw new TypeError("Junction extended-history policy requires a coverage generation.");
+    }
+    return { ...policy, version };
+}
+function requiresJunctionHistoricalPullReadiness(policy) {
+    return policy?.anchor === "current_day"
+        && (policy.completion === "daily_aggregate" || policy.completion === "exact_records");
+}
+function doesJunctionImportReceiptResolveDeliveredRows(resource) {
+    return isJunctionBodyTimeseriesResource(resource)
+        || resource === "carbohydrates"
+        || resource === "insulin_injection";
 }
 const JUNCTION_DENSE_FIDELITY_RESOURCE_SET = new Set(JUNCTION_DENSE_FIDELITY_RESOURCES);
 const JUNCTION_CALENDAR_DAY_AGGREGATE_RESOURCE_SET = new Set([
@@ -225,6 +239,13 @@ const JUNCTION_FULL_JOB_INVENTORY_COLLECTION_WORK_LIMIT = Object.freeze({
     maxPages: 1,
     requestTimeoutMs: 8_000,
 });
+const JUNCTION_TEMPORAL_AUTHORITY_LAG_MS = TIMESERIES_CHUNK_MS;
+const JUNCTION_TEMPORAL_AUTHORITY_RESOURCES = new Set([
+    "blood_oxygen",
+    "stress_level",
+]);
+const JUNCTION_TEMPORAL_AUTHORITY_JOB_VERSION = 1;
+const JUNCTION_MAX_TEMPORAL_RECONCILE_DAYS = 14;
 const JUNCTION_MAX_DIAGNOSTIC_TIMESERIES_PROBE_DAYS = 14;
 const JUNCTION_DIAGNOSTIC_SHAPE_KEY_LIMIT = 24;
 const JUNCTION_DIAGNOSTIC_RESOURCE_NAME_LIMIT = 64;
@@ -234,20 +255,45 @@ const EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS = Object.freeze([
     6 * 60 * 60_000,
     24 * 60 * 60_000,
 ]);
+const JUNCTION_WORKOUT_STREAM_EMPTY_REPLAY_DELAY_MS = 24 * 60 * 60_000;
 const JUNCTION_HISTORICAL_UNRESOLVED_PROVIDER_RECORD_IDENTITIES_VERSION = 1;
 const JUNCTION_BLOOD_PRESSURE_PROVIDER_RECORD_IDENTITY_PATTERN = /^blood-pressure-[0-9a-f]{16}$/u;
 const JUNCTION_SCHEDULED_RECONCILE_PRIORITY = 40;
 const JUNCTION_HISTORICAL_BACKFILL_PRIORITY = 30;
 const JUNCTION_HISTORICAL_BACKFILL_RETRY_PRIORITY = 50;
+const JUNCTION_REOPENED_HISTORY_PRIORITY_CYCLE_SLOTS = 4;
+/**
+ * Keeps the reopened and ordinary ordinals independent from the 3:1 cadence so
+ * every member of either stable pool remains reachable.
+ */
+export function selectJunctionScheduledHistoryCandidate(input) {
+    if (input.reopenedCandidates.length === 0) {
+        return input.ordinaryCandidates.length === 0
+            ? undefined
+            : input.ordinaryCandidates[input.scheduleSlot % input.ordinaryCandidates.length];
+    }
+    if (input.ordinaryCandidates.length === 0) {
+        return input.reopenedCandidates[input.scheduleSlot % input.reopenedCandidates.length];
+    }
+    const priorityCycle = Math.floor(input.scheduleSlot / JUNCTION_REOPENED_HISTORY_PRIORITY_CYCLE_SLOTS);
+    const priorityCycleOffset = input.scheduleSlot % JUNCTION_REOPENED_HISTORY_PRIORITY_CYCLE_SLOTS;
+    if (priorityCycleOffset === JUNCTION_REOPENED_HISTORY_PRIORITY_CYCLE_SLOTS - 1) {
+        return input.ordinaryCandidates[priorityCycle % input.ordinaryCandidates.length];
+    }
+    const reopenedOrdinal = priorityCycle
+        * (JUNCTION_REOPENED_HISTORY_PRIORITY_CYCLE_SLOTS - 1)
+        + priorityCycleOffset;
+    return input.reopenedCandidates[reopenedOrdinal % input.reopenedCandidates.length];
+}
 export function createJunctionDeviceSyncProvider(config) {
     const runtimeConfig = normalizeJunctionDeviceSyncRuntimeConfig(config);
     const client = new JunctionClient(toClientConfig(config));
     const { clientUserIdNamespace, providerFilter, reconcileIntervalMs, summaryResources, timeseriesResources, } = runtimeConfig;
     const summaryBackfillDays = config.summaryBackfillDays ?? DEFAULT_SUMMARY_BACKFILL_DAYS;
     const timeseriesBackfillDays = config.timeseriesBackfillDays ?? DEFAULT_TIMESERIES_BACKFILL_DAYS;
-    const extendedTimeseriesBackfillDays = config.timeseriesBackfillDays ?? summaryBackfillDays;
     const extendedBackfillTimeseriesResources = timeseriesResources.filter((resource) => resolveJunctionExtendedTimeseriesBackfillPolicy(resource) !== null);
     const reconcileDays = config.reconcileDays ?? DEFAULT_RECONCILE_DAYS;
+    const temporalReconcileDays = normalizeJunctionTemporalReconcileDays(reconcileDays);
     const pushSourceRecoveryEnabled = config.pushSourceRecoveryEnabled === true;
     const webhookTimestampToleranceMs = config.webhookTimestampToleranceMs ?? DEFAULT_WEBHOOK_TIMESTAMP_TOLERANCE_MS;
     async function beginConnection(context) {
@@ -356,6 +402,14 @@ export function createJunctionDeviceSyncProvider(config) {
             });
         }
         const sourceConnectionWork = buildSourceConnectionWork({
+            ...(context.sourceProviderSlug
+                ? {
+                    historicalProofAuthorization: {
+                        firstSeenAt: context.now,
+                        sourceProviderSlug: context.sourceProviderSlug,
+                    },
+                }
+                : {}),
             now: context.now,
             sourceProviderSlug: context.sourceProviderSlug,
         });
@@ -413,10 +467,16 @@ export function createJunctionDeviceSyncProvider(config) {
             });
         }
     }
-    async function revokeSourceAccess(account, sourceProviderSlug) {
+    async function revokeSourceAccess(account, sourceProviderSlug, options) {
         const userId = normalizeString(account.externalAccountId);
-        const targetProviderSlug = normalizeProviderSlug(sourceProviderSlug);
-        if (!userId || !targetProviderSlug) {
+        const targetProviderSlug = canonicalizeJunctionProviderSlug(sourceProviderSlug);
+        const requiredActiveProviderSlug = options?.requiredActiveSourceProviderSlug === undefined
+            ? null
+            : canonicalizeJunctionProviderSlug(options.requiredActiveSourceProviderSlug);
+        if (!userId
+            || !targetProviderSlug
+            || (options?.requiredActiveSourceProviderSlug !== undefined
+                && !requiredActiveProviderSlug)) {
             throw deviceSyncError({
                 code: "JUNCTION_SOURCE_DEREGISTER_INPUT_INVALID",
                 message: "Junction source cleanup requires a stored user and provider slug.",
@@ -425,20 +485,34 @@ export function createJunctionDeviceSyncProvider(config) {
             });
         }
         const providers = await client.listUserProviders(userId);
-        const targetIsRegistered = providers.some((provider) => mapJunctionSourceStatus(provider.status) !== "disconnected"
-            && (normalizeProviderSlug(provider.origin.sourceProviderSlug)
-                ?? normalizeProviderSlug(provider.slug)) === targetProviderSlug);
-        if (!targetIsRegistered) {
+        const targetStatuses = providers
+            .filter((provider) => (canonicalizeJunctionProviderSlug(provider.origin.sourceProviderSlug)
+            ?? canonicalizeJunctionProviderSlug(provider.slug)) === targetProviderSlug)
+            .map((provider) => mapJunctionSourceStatus(provider.status));
+        if (targetStatuses.length === 0
+            || targetStatuses.every((status) => status === "disconnected")) {
             return;
         }
+        if (requiredActiveProviderSlug
+            && (!targetStatuses.includes("connected")
+                || !providers.some((provider) => mapJunctionSourceStatus(provider.status) === "connected"
+                    && (canonicalizeJunctionProviderSlug(provider.origin.sourceProviderSlug)
+                        ?? canonicalizeJunctionProviderSlug(provider.slug)) === requiredActiveProviderSlug))) {
+            throw deviceSyncError({
+                code: "JUNCTION_REQUIRED_SOURCE_NOT_ACTIVE",
+                message: "Junction source cleanup requires an active successor source.",
+                retryable: true,
+                httpStatus: 409,
+            });
+        }
         await client.deregisterProvider({
             providerSlug: targetProviderSlug,
             userId,
         });
     }
-    async function isSourceAccessActive(account, sourceProviderSlug) {
+    async function isSourceAccessActive(account, sourceProviderSlug, options) {
         const userId = normalizeString(account.externalAccountId);
-        const targetProviderSlug = normalizeProviderSlug(sourceProviderSlug);
+        const targetProviderSlug = canonicalizeJunctionProviderSlug(sourceProviderSlug);
         if (!userId || !targetProviderSlug) {
             throw deviceSyncError({
                 code: "JUNCTION_SOURCE_STATUS_INPUT_INVALID",
@@ -447,13 +521,33 @@ export function createJunctionDeviceSyncProvider(config) {
                 httpStatus: 409,
             });
         }
-        return (await client.listUserProviders(userId)).some((provider) => mapJunctionSourceStatus(provider.status) === "connected"
-            && (normalizeProviderSlug(provider.origin.sourceProviderSlug)
-                ?? normalizeProviderSlug(provider.slug)) === targetProviderSlug);
+        const providerStatuses = (await client.listUserProviders(userId))
+            .filter((provider) => (canonicalizeJunctionProviderSlug(provider.origin.sourceProviderSlug)
+            ?? canonicalizeJunctionProviderSlug(provider.slug)) === targetProviderSlug)
+            .map((provider) => provider.status.trim().toLowerCase());
+        // Connection authority is the provider row's literal status. The broader
+        // projection mapper also accepts lifecycle/resource aliases such as `available`.
+        if (providerStatuses.length > 0
+            && providerStatuses.every((status) => status === "connected")) {
+            return true;
+        }
+        const statuses = providerStatuses.map(mapJunctionSourceStatus);
+        if (statuses.length === 0 || statuses.every((status) => status === "disconnected")) {
+            return false;
+        }
+        if (options?.requireDefinitive) {
+            throw deviceSyncError({
+                code: "JUNCTION_SOURCE_STATUS_AMBIGUOUS",
+                message: "Junction source status is not definitive yet. Retry shortly.",
+                retryable: true,
+                httpStatus: 503,
+            });
+        }
+        return false;
     }
-    function createScheduledJobs(account, now) {
+    function createScheduledJobs(account, now, context) {
         const scheduledHistoricalBackfillJobs = buildScheduledHistoricalBackfillJobs(account, now);
-        const scheduledExtendedTimeseriesBackfillJobs = buildScheduledExtendedTimeseriesBackfillJobs(account, now);
+        const scheduledExtendedTimeseriesBackfillJobs = buildScheduledExtendedTimeseriesBackfillJobs(account, now, context);
         const nextReconcileAt = resolveJunctionNextReconcileAt(account, now, addMilliseconds(now, reconcileIntervalMs));
         return {
             jobs: [
@@ -470,8 +564,8 @@ export function createJunctionDeviceSyncProvider(config) {
             nextReconcileAt,
         };
     }
-    function buildScheduledExtendedTimeseriesBackfillJobs(account, now) {
-        return extendedBackfillTimeseriesResources.flatMap((resource) => {
+    function buildScheduledExtendedTimeseriesBackfillJobs(account, now, context) {
+        const candidates = extendedBackfillTimeseriesResources.flatMap((resource) => {
             const policy = resolveJunctionExtendedTimeseriesBackfillPolicy(resource);
             if (!policy) {
                 return [];
@@ -479,11 +573,11 @@ export function createJunctionDeviceSyncProvider(config) {
             if (!canCurrentRuntimeMutateJunctionExtendedTimeseriesHistoryBackfillCoverage(account.metadata, resource, policy.version)) {
                 return [];
             }
-            const scheduledSources = new Map();
+            const scheduledSources = [];
             for (const sourceState of resolveJunctionAccountSourceStates(account.sources ?? [])) {
                 const identitySource = sourceState.identitySource;
                 const lifecycleSource = sourceState.lifecycleSource;
-                const sourceProviderSlug = normalizeProviderSlug(identitySource.sourceProviderSlug);
+                const sourceProviderSlug = canonicalizeJunctionProviderSlug(identitySource.sourceProviderSlug);
                 if (!sourceProviderSlug
                     || !isDeviceSyncSourceAdmitted([lifecycleSource], lifecycleSource.sourceProviderSlug)
                     || !isJunctionResourceAvailableInSummary(lifecycleSource.resourceAvailabilitySummary, resource)
@@ -491,33 +585,62 @@ export function createJunctionDeviceSyncProvider(config) {
                     || !canRepresentJunctionExtendedTimeseriesHistoryBackfillCoverage(account.metadata, sourceProviderSlug, resource, policy.version)) {
                     continue;
                 }
-                const sourceFirstSeenAt = identitySource.firstSeenAt;
-                if (!sourceFirstSeenAt) {
+                const firstSeenAt = identitySource.firstSeenAt;
+                if (!firstSeenAt) {
                     throw junctionSourceStateUnavailableError();
                 }
-                const existingFirstSeenAt = scheduledSources.get(sourceProviderSlug);
-                if (!existingFirstSeenAt || Date.parse(sourceFirstSeenAt) < Date.parse(existingFirstSeenAt)) {
-                    scheduledSources.set(sourceProviderSlug, sourceFirstSeenAt);
-                }
+                scheduledSources.push({
+                    firstSeenAt,
+                    lifecycleEpoch: readJunctionSourceLifecycleEpoch(lifecycleSource),
+                    sourceProviderSlug,
+                });
             }
-            return [...scheduledSources.entries()].map(([sourceProviderSlug, firstSeenAt]) => {
+            return scheduledSources.map((source) => {
                 // Exact blood-pressure history is anchored to source admission. Other
                 // sparse resources catch up the current extended-history window once.
                 const window = buildExtendedTimeseriesBackfillWindow({
-                    anchorAt: policy.anchor === "source_first_seen" ? firstSeenAt : now,
-                    days: extendedTimeseriesBackfillDays,
+                    anchorAt: policy.anchor === "source_first_seen" ? source.firstSeenAt : now,
+                    days: JUNCTION_EXTENDED_TIMESERIES_BACKFILL_DAYS,
                 });
-                return buildExtendedTimeseriesBackfillJob({
+                return {
+                    anchor: policy.anchor,
                     availableAt: now,
-                    ...(resource === "note" ? { historicalBackfillVersion: policy.version } : {}),
+                    historicalBackfillVersion: policy.version,
                     historicalWindowStart: window.windowStart,
                     resource,
-                    sourceProviderSlug,
+                    sourceLifecycleEpoch: source.lifecycleEpoch,
+                    sourceProviderSlug: source.sourceProviderSlug,
                     windowEnd: window.windowEnd,
                     windowStart: window.windowStart,
-                });
+                };
             });
         });
+        if (candidates.length === 0) {
+            return [];
+        }
+        candidates.sort((left, right) => left.resource.localeCompare(right.resource)
+            || left.sourceProviderSlug.localeCompare(right.sourceProviderSlug));
+        const sourceFirstCandidates = candidates.filter((candidate) => candidate.anchor === "source_first_seen");
+        const scheduleTimeCandidates = candidates.filter((candidate) => candidate.anchor === "current_day");
+        const scheduleSlot = Math.floor(Date.parse(now) / reconcileIntervalMs);
+        const scheduleTimeJobs = scheduleTimeCandidates.map((candidate) => [candidate, buildExtendedTimeseriesBackfillJob(candidate)]);
+        const activeDedupeKeys = context?.findActiveDedupeKeys(scheduleTimeJobs.map(([, job]) => job.dedupeKey)) ?? new Set();
+        const inactiveJobs = scheduleTimeJobs.filter(([, job]) => !activeDedupeKeys.has(job.dedupeKey));
+        const reopenedInactiveJobs = context
+            ? inactiveJobs.filter(([candidate]) => candidate.sourceLifecycleEpoch > 1)
+            : [];
+        const ordinaryInactiveJobs = context
+            ? inactiveJobs.filter(([candidate]) => candidate.sourceLifecycleEpoch === 1)
+            : inactiveJobs;
+        const scheduledJob = selectJunctionScheduledHistoryCandidate({
+            ordinaryCandidates: ordinaryInactiveJobs,
+            reopenedCandidates: reopenedInactiveJobs,
+            scheduleSlot,
+        })?.[1];
+        return [
+            ...sourceFirstCandidates.map((candidate) => buildExtendedTimeseriesBackfillJob(candidate)),
+            ...(scheduledJob ? [scheduledJob] : []),
+        ];
     }
     /**
      * A dead push carrier cannot recover on its own and no pull can rediscover
@@ -640,11 +763,11 @@ export function createJunctionDeviceSyncProvider(config) {
     }
     async function loadJunctionHistoricalPullSnapshot(context) {
         try {
-            return await client.introspectHistoricalPull({
+            return await measureJunctionProviderRequest(context, "inventory", () => client.introspectHistoricalPull({
                 signal: context.signal ?? null,
                 userId: context.account.externalAccountId,
                 userLimit: 1,
-            });
+            }));
         }
         catch (error) {
             if (context.signal?.aborted) {
@@ -664,7 +787,7 @@ export function createJunctionDeviceSyncProvider(config) {
      * cannot succeed.
      */
     async function executePushSourceRecoveryJob(context, job) {
-        const sourceProviderSlug = normalizeProviderSlug(job.payload.sourceProviderSlug);
+        const sourceProviderSlug = canonicalizeJunctionProviderSlug(job.payload.sourceProviderSlug);
         const silentSinceAt = normalizeString(job.payload.silentSinceAt);
         if (!sourceProviderSlug || !silentSinceAt) {
             return {};
@@ -715,10 +838,10 @@ export function createJunctionDeviceSyncProvider(config) {
         let endpointUnavailable = false;
         let failureCode = null;
         try {
-            ({ endpointUnavailable } = await client.bulkTriggerHistoricalPull({
+            ({ endpointUnavailable } = await measureJunctionProviderRequest(context, "inventory", () => client.bulkTriggerHistoricalPull({
                 sourceProviderSlug,
                 userIds: [context.account.externalAccountId],
-            }));
+            })));
         }
         catch (error) {
             failureCode = isDeviceSyncError(error)
@@ -748,25 +871,36 @@ export function createJunctionDeviceSyncProvider(config) {
     }
     async function executeJob(context, job) {
         const skippedOptionalResources = [];
+        if (job.kind === JUNCTION_PUSH_SOURCE_RECOVERY_JOB_KIND) {
+            return executePushSourceRecoveryJob(context, job);
+        }
+        const historicalProofAuthorization = readJunctionHistoricalProofAuthorization(job);
+        if (historicalProofAuthorization
+            && !await isJunctionHistoricalProofAuthorizationCurrent(context, historicalProofAuthorization)) {
+            return {
+                nextReconcileAt: resolveJunctionNextReconcileAt(context.account, context.now, addMilliseconds(context.now, reconcileIntervalMs)),
+            };
+        }
         const completedWorkoutStreamIdentities = readJunctionWorkoutStreamCompletedIdentities(job);
         if (job.kind === "resource") {
             return executeResourceJob(context, job, skippedOptionalResources, completedWorkoutStreamIdentities);
         }
-        if (job.kind === JUNCTION_PUSH_SOURCE_RECOVERY_JOB_KIND) {
-            return executePushSourceRecoveryJob(context, job);
-        }
         if (isFullJobTimeseriesContinuation(job)) {
             return executeFullJobTimeseriesContinuation(context, job, skippedOptionalResources, completedWorkoutStreamIdentities);
         }
         const window = resolveJobWindow(job, context.now, job.kind === "backfill" ? summaryBackfillDays : reconcileDays);
+        const sourceProviderSlug = normalizeProviderSlug(job.payload.sourceProviderSlug);
         const isConnectHistoricalBackfill = isConnectHistoricalBackfillWindow(context.account, window);
-        const sourceProviders = await client.listUserProviders(context.account.externalAccountId, {
+        const listedSourceProviders = await measureJunctionProviderRequest(context, "inventory", () => client.listUserProviders(context.account.externalAccountId, {
             ...(job.kind === "reconcile" && context.shouldYield
                 ? { collectionWorkLimit: JUNCTION_FULL_JOB_INVENTORY_COLLECTION_WORK_LIMIT }
                 : {}),
             signal: context.signal ?? null,
-        });
-        await projectJunctionSources(context, sourceProviders);
+        }));
+        await projectJunctionSources(context, listedSourceProviders);
+        const sourceProviders = sourceProviderSlug
+            ? listedSourceProviders.filter((provider) => areJunctionProviderSlugsDataEquivalent(provider.origin.sourceProviderSlug ?? provider.slug, sourceProviderSlug))
+            : listedSourceProviders;
         const isCurrentSummaryReconcile = job.kind === "reconcile" && isCurrentScheduledClosedWindow(window, context.now, reconcileDays);
         const summaryWindow = isCurrentSummaryReconcile
             ? resolveCurrentSummaryWindow(context.now, reconcileDays)
@@ -791,9 +925,21 @@ export function createJunctionDeviceSyncProvider(config) {
             }
         }
         const summaryPhaseComplete = job.kind === "reconcile" && job.payload.summaryPhaseComplete === true;
-        const summaries = summaryPhaseComplete
-            ? {}
-            : await fetchSummarySnapshots(context, summaryWindow.windowStart, summaryWindow.windowEnd, skippedOptionalResources, { dateQueryFormat: summaryDateQueryFormat });
+        const summaryFetchResult = summaryPhaseComplete
+            ? { providerRecordsSeen: false, snapshots: {} }
+            : await fetchSummarySnapshots(context, summaryWindow.windowStart, summaryWindow.windowEnd, skippedOptionalResources, {
+                dateQueryFormat: summaryDateQueryFormat,
+                sourceProviderSlug,
+            });
+        const { providerRecordsSeen: historicalSummaryHasFetchedRecords, snapshots: summaries, } = summaryFetchResult;
+        const sourceScopedHistoricalSummaryHasRecords = job.kind === "backfill" && sourceProviderSlug
+            ? await hasJunctionSourceScopedAdmittedSnapshotRecords({
+                context,
+                snapshots: summaries,
+                sourceProviderSlug,
+                sourceProviders,
+            })
+            : false;
         const profileSummaryResult = summaryPhaseComplete
             ? { checked: false, records: [] }
             : await fetchProfileSummaryOnce(context, skippedOptionalResources);
@@ -818,23 +964,27 @@ export function createJunctionDeviceSyncProvider(config) {
             windowEnd: summaryWindow.windowEnd,
             windowStart: summaryWindow.windowStart,
         });
-        const historicalSummaryHasRecords = hasJunctionHistoricalBackfillSummaryRecords(summaryNormalizationEvidence);
+        const historicalSummaryHasRecords = hasJunctionHistoricalBackfillSummaryRecords(sourceProviderSlug
+            ? summaryNormalizationEvidence.filter((evidence) => areJunctionProviderSlugsDataEquivalent(evidence.sourceProviderSlug, sourceProviderSlug))
+            : summaryNormalizationEvidence);
         const baseTimeseriesWindowStart = job.kind === "backfill"
             ? maxIsoTimestamp(window.windowStart, subtractDays(window.windowEnd, timeseriesBackfillDays))
             : window.windowStart;
         if (job.kind !== "backfill" || summaryHasFetchedRecords) {
-            await context.importSnapshot({
-                provider: "junction",
-                accountId: buildJunctionImportAccountId(context.account.externalAccountId),
-                connectionId: context.account.id,
+            await commitPreparedJunctionCanonicalImport(context, preparedSummaryImport, {
                 importedAt: summaryWindow.windowEnd,
                 windowStart: summaryWindow.windowStart,
                 windowEnd: summaryWindow.windowEnd,
-                connections: importConnections,
                 summaries: importSummaries,
                 timeseries: {},
-            });
-        }
+            }, context.now);
+        }
+        const historicalProviderRecordsSeen = sourceProviderSlug !== null
+            && (job.payload.historicalProviderRecordsSeen === true
+                || historicalSummaryHasFetchedRecords);
+        const historicalRecordsSeen = sourceProviderSlug !== null
+            && (job.payload.historicalRecordsSeen === true
+                || sourceScopedHistoricalSummaryHasRecords);
         // Current records are durable before the optional historical-status probe.
         // An unavailable introspection endpoint must not hold fresh ingestion hostage.
         const historicalPullSnapshot = isConnectHistoricalBackfill && !context.shouldYield?.()
@@ -851,7 +1001,7 @@ export function createJunctionDeviceSyncProvider(config) {
         const dailyTimeseriesResources = timeseriesResources.filter((resource) => JUNCTION_CALENDAR_DAY_AGGREGATE_RESOURCE_SET.has(resource));
         if (dailyTimeseriesResources.length > 0
             && hourlyFidelityWindow) {
-            const timeseriesImport = await importTimeseriesDailyAggregateSnapshots(context, sourceProviders, hourlyFidelityWindow.windowStart, hourlyFidelityWindow.windowEnd, skippedOptionalResources, dailyTimeseriesResources);
+            const timeseriesImport = await importTimeseriesDailyAggregateSnapshots(context, sourceProviders, hourlyFidelityWindow.windowStart, hourlyFidelityWindow.windowEnd, skippedOptionalResources, dailyTimeseriesResources, sourceProviderSlug);
             if (timeseriesImport.yieldedAt) {
                 return withJunctionSkippedResourceMetadata(context, withJunctionMetadataPatch(buildYieldedJunctionJobResult({
                     context,
@@ -873,7 +1023,15 @@ export function createJunctionDeviceSyncProvider(config) {
                     windowEnd: window.windowEnd,
                 })
                 : buildNonConnectHistoricalBackfillFollowUp({
-                    hasRecords: historicalSummaryHasRecords,
+                    hasRecords: sourceProviderSlug
+                        ? historicalRecordsSeen
+                        : historicalSummaryHasRecords,
+                    ...(sourceProviderSlug
+                        ? {
+                            historicalProviderRecordsSeen,
+                            historicalRecordsSeen,
+                        }
+                        : {}),
                     job,
                     now: context.now,
                     windowStart: window.windowStart,
@@ -911,32 +1069,128 @@ export function createJunctionDeviceSyncProvider(config) {
                 await markJunctionHistoricalReconnectRequired(context, historicalSummaryCoverage.reconnectProviderSlugs);
             }
         }
+        const temporalResources = context.vaultTimeZone
+            ? timeseriesResources.filter((resource) => JUNCTION_TEMPORAL_AUTHORITY_RESOURCES.has(resource))
+            : [];
+        const temporalRecoveryWindows = context.vaultTimeZone
+            ? buildLatestAuthoritativeDailyWindows({
+                horizonDays: temporalReconcileDays,
+                now: context.now,
+                timeZone: context.vaultTimeZone,
+                windowEnd: window.windowEnd,
+            })
+            : [];
+        const newestTemporalWindow = temporalRecoveryWindows[0] ?? null;
+        const deferredNewestTemporalResources = new Set();
+        if (newestTemporalWindow && context.vaultTimeZone) {
+            for (const [resourceIndex, resource] of temporalResources.entries()) {
+                if (context.shouldYield?.()) {
+                    for (const remainingResource of temporalResources.slice(resourceIndex)) {
+                        deferredNewestTemporalResources.add(remainingResource);
+                    }
+                    break;
+                }
+                const skippedResourceCountBeforeFetch = skippedOptionalResources.length;
+                try {
+                    await importJunctionTimeseriesResourceSnapshot({
+                        authorizedLocalDay: {
+                            dayKey: newestTemporalWindow.dayKey,
+                            timeZone: context.vaultTimeZone,
+                        },
+                        context,
+                        dateQueryFormat: "datetime",
+                        resource,
+                        skippedOptionalResources,
+                        sourceProviders,
+                        windowEnd: newestTemporalWindow.windowEnd,
+                        windowStart: newestTemporalWindow.windowStart,
+                    });
+                }
+                catch (error) {
+                    if (isRetryableDeviceSyncFailure(error)
+                        || isJunctionJobSignalAbort(error, context.signal)) {
+                        deferredNewestTemporalResources.add(resource);
+                        if (isJunctionJobSignalAbort(error, context.signal)) {
+                            for (const remainingResource of temporalResources.slice(resourceIndex + 1)) {
+                                deferredNewestTemporalResources.add(remainingResource);
+                            }
+                            break;
+                        }
+                        continue;
+                    }
+                    throw error;
+                }
+                if (skippedOptionalResources.length > skippedResourceCountBeforeFetch) {
+                    deferredNewestTemporalResources.add(resource);
+                }
+            }
+        }
+        const temporalContinuationJobs = context.vaultTimeZone
+            ? [
+                ...(newestTemporalWindow && deferredNewestTemporalResources.size > 0
+                    ? buildJunctionTemporalAuthorityJobs({
+                        now: context.now,
+                        resources: [...deferredNewestTemporalResources],
+                        timeZone: context.vaultTimeZone,
+                        windows: [newestTemporalWindow],
+                    })
+                    : []),
+                ...buildJunctionTemporalAuthorityJobs({
+                    now: context.now,
+                    resources: temporalResources,
+                    timeZone: context.vaultTimeZone,
+                    windows: temporalRecoveryWindows.slice(1),
+                }),
+            ]
+            : [];
         const nextReconcileAt = backfillFollowUp.nextReconcileAt ?? resolveJunctionNextReconcileAt(context.account, context.now, addMilliseconds(context.now, reconcileIntervalMs));
         const shouldScheduleTimeseries = timeseriesResources.length > 0
             && (job.kind === "backfill"
                 || shouldImportClosedTimeseriesForReconcile(context.account.lastSyncCompletedAt, window.windowEnd));
-        const timeseriesContinuation = shouldScheduleTimeseries
+        const historicalProofStillCurrent = !historicalProofAuthorization
+            || await isJunctionHistoricalProofAuthorizationCurrent(context, historicalProofAuthorization);
+        const timeseriesContinuation = shouldScheduleTimeseries && historicalProofStillCurrent
             ? buildFullJobTimeseriesContinuationJob({
                 deferredEmptyBackfillAttempts: readDeferredEmptyBackfillAttempts(backfillFollowUp),
+                historicalProviderRecordsSeen,
+                historicalRecordsSeen,
                 job,
                 timeseriesCursor: baseTimeseriesWindowStart,
                 timeseriesResourceCursor: timeseriesResources[0] ?? null,
                 timeseriesWindowHours: 24,
                 window,
                 workoutStreamCursor: null,
+                workoutStreamEmptySeen: false,
             })
             : null;
-        if (timeseriesContinuation) {
+        if (timeseriesContinuation || temporalContinuationJobs.length > 0) {
             return withJunctionSkippedResourceMetadata(context, withJunctionMetadataPatch({
                 ...(backfillFollowUp.metadataPatch
                     ? { metadataPatch: backfillFollowUp.metadataPatch }
                     : {}),
                 nextReconcileAt,
-                scheduledJobs: [{ ...timeseriesContinuation, availableAt: context.now }],
+                scheduledJobs: [
+                    ...temporalContinuationJobs,
+                    ...(timeseriesContinuation
+                        ? [{ ...timeseriesContinuation, availableAt: context.now }]
+                        : []),
+                ],
             }, profileMetadataPatch), skippedOptionalResources);
         }
+        if (job.kind === "backfill"
+            && historicalProofStillCurrent
+            && !backfillFollowUp.scheduledJobs?.length) {
+            await completeSourceScopedHistoricalBackfill({
+                context,
+                historicalProviderRecordsSeen,
+                historicalRecordsSeen,
+                job,
+                sourceProviderSlug,
+                sourceProviders,
+            });
+        }
         return withJunctionSkippedResourceMetadata(context, withJunctionMetadataPatch({
-            ...backfillFollowUp,
+            ...(historicalProofStillCurrent ? backfillFollowUp : {}),
             nextReconcileAt,
         }, profileMetadataPatch), skippedOptionalResources);
     }
@@ -949,7 +1203,7 @@ export function createJunctionDeviceSyncProvider(config) {
             : [];
         const existingByInstanceKey = new Map(existingSources.map((source) => [source.sourceInstanceKey, source]));
         const recoveryProviderSlugs = new Set(pendingProviderSlugs
-            .map(normalizeProviderSlug)
+            .map(canonicalizeJunctionProviderSlug)
             .filter((providerSlug) => providerSlug !== null));
         for (const providerSlug of recoveryProviderSlugs) {
             if (!isJunctionHistoricalResetProviderSlug(providerSlug)) {
@@ -962,7 +1216,7 @@ export function createJunctionDeviceSyncProvider(config) {
             if (!projectedSourceInstanceKey) {
                 continue;
             }
-            const existing = existingByInstanceKey.get(projectedSourceInstanceKey) ?? existingSources.find((source) => normalizeProviderSlug(source.sourceProviderSlug) === providerSlug);
+            const existing = existingByInstanceKey.get(projectedSourceInstanceKey) ?? existingSources.find((source) => canonicalizeJunctionProviderSlug(source.sourceProviderSlug) === providerSlug);
             if (existing?.status === "error"
                 && existing.lastErrorCode === DEVICE_SYNC_HISTORICAL_DATA_RECONNECT_REQUIRED_ERROR_CODE) {
                 continue;
@@ -989,7 +1243,7 @@ export function createJunctionDeviceSyncProvider(config) {
         if (!webhookDataJson) {
             return null;
         }
-        if (!isJunctionCredentialIndependentInlineImportJob({
+        if (!isJunctionInlineImportJob({
             kind: job.kind,
             payload: job.payload,
         })) {
@@ -1345,7 +1599,7 @@ export function createJunctionDeviceSyncProvider(config) {
         const calendarRefreshDay = readJunctionSparseCalendarRefreshDay(job);
         const resource = normalizeJunctionResourceName(job.payload.resource);
         const resourceCategory = normalizeString(job.payload.resourceCategory);
-        const sourceProviderSlug = normalizeProviderSlug(job.payload.sourceProviderSlug);
+        const sourceProviderSlug = canonicalizeJunctionProviderSlug(job.payload.sourceProviderSlug);
         if (!calendarRefreshDay
             && sourceProviderSlug
             && !isJunctionSourceAdmittedForImport(context.account.sources ?? [], sourceProviderSlug)
@@ -1360,9 +1614,9 @@ export function createJunctionDeviceSyncProvider(config) {
             if (listedSourceProviders) {
                 return listedSourceProviders;
             }
-            const sourceProviders = await client.listUserProviders(context.account.externalAccountId, {
+            const sourceProviders = await measureJunctionProviderRequest(context, "inventory", () => client.listUserProviders(context.account.externalAccountId, {
                 signal: context.signal ?? null,
-            });
+            }));
             listedSourceProviders = sourceProviders;
             return sourceProviders;
         };
@@ -1436,6 +1690,63 @@ export function createJunctionDeviceSyncProvider(config) {
             }, skippedOptionalResources);
         }
         const summaries = {};
+        const temporalAuthorityJob = readJunctionTemporalAuthorityJob(job);
+        if (temporalAuthorityJob) {
+            if (context.shouldYield?.()) {
+                throw deviceSyncError({
+                    code: "JUNCTION_TEMPORAL_AUTHORITY_JOB_YIELDED",
+                    message: "Junction temporal catch-up yielded before collection.",
+                    retryable: true,
+                });
+            }
+            if (!context.vaultTimeZone) {
+                throw deviceSyncError({
+                    code: "JUNCTION_TEMPORAL_AUTHORITY_TIMEZONE_UNAVAILABLE",
+                    message: "Junction temporal catch-up requires the vault timezone.",
+                    retryable: true,
+                });
+            }
+            if (context.vaultTimeZone !== temporalAuthorityJob.timeZone) {
+                return {};
+            }
+            const expectedWindow = resolveVaultLocalDayWindow(temporalAuthorityJob.dayKey, temporalAuthorityJob.timeZone);
+            if (!expectedWindow
+                || expectedWindow.windowStart !== window.windowStart
+                || expectedWindow.windowEnd !== window.windowEnd
+                || Date.parse(expectedWindow.windowEnd) + JUNCTION_TEMPORAL_AUTHORITY_LAG_MS
+                    > Date.parse(context.now)) {
+                throw deviceSyncError({
+                    code: "JUNCTION_TEMPORAL_AUTHORITY_JOB_INVALID",
+                    message: "Junction temporal catch-up job did not describe an eligible complete local day.",
+                    retryable: false,
+                });
+            }
+            const skippedResourceCountBeforeFetch = skippedOptionalResources.length;
+            const sourceProviders = await loadAndProjectSourceProviders();
+            await importJunctionTimeseriesResourceSnapshot({
+                authorizedLocalDay: {
+                    dayKey: temporalAuthorityJob.dayKey,
+                    timeZone: temporalAuthorityJob.timeZone,
+                },
+                context,
+                dateQueryFormat: "datetime",
+                resource: temporalAuthorityJob.resource,
+                skippedOptionalResources,
+                sourceProviders,
+                windowEnd: expectedWindow.windowEnd,
+                windowStart: expectedWindow.windowStart,
+            });
+            if (skippedOptionalResources.length > skippedResourceCountBeforeFetch) {
+                throw deviceSyncError({
+                    code: "JUNCTION_TEMPORAL_AUTHORITY_RESOURCE_UNAVAILABLE",
+                    message: "Junction temporal catch-up resource was unavailable.",
+                    retryable: true,
+                });
+            }
+            return {
+                nextReconcileAt: clampWebhookJobNextReconcileAt(context),
+            };
+        }
         if (resource) {
             const directInput = readJunctionDirectResourceJobInput(job, window);
             if (directInput) {
@@ -1522,6 +1833,13 @@ export function createJunctionDeviceSyncProvider(config) {
                         retryable: false,
                     });
                 }
+                const sourceLifecycleEpoch = extendedHistoricalPolicy
+                    ? readSafeInteger(job.payload.sourceLifecycleEpoch)
+                    : null;
+                if (extendedHistoricalPolicy
+                    && (sourceLifecycleEpoch === null || sourceLifecycleEpoch < 1)) {
+                    return {};
+                }
                 const historicalWindowStart = toIsoTimestampIfValid(normalizeString(job.payload.historicalWindowStart))
                     ?? window.windowStart;
                 const dailyAggregateRetryAttempts = readHistoricalBackfillJobEmptyAttempts(job);
@@ -1529,12 +1847,20 @@ export function createJunctionDeviceSyncProvider(config) {
                 let sourceIdentityAuthority;
                 let currentSourceAdmission = "admitted";
                 try {
+                    if (extendedHistoricalBackfill
+                        && sourceProviderSlug
+                        && sourceLifecycleEpoch !== null) {
+                        currentSourceAdmission = await resolveJunctionCurrentSourceAdmission(context, sourceProviderSlug, sourceLifecycleEpoch ?? undefined);
+                        if (currentSourceAdmission === "fenced") {
+                            return {};
+                        }
+                    }
                     sourceProviders = await loadAndProjectSourceProviders();
                     if (extendedHistoricalBackfill && sourceProviderSlug) {
                         sourceIdentityAuthority = context.listConnectionSources
                             ? await context.listConnectionSources()
                             : context.account.sources ?? [];
-                        currentSourceAdmission = resolveJunctionCurrentSourceAdmissionFromSources(sourceIdentityAuthority, sourceProviderSlug, context.connectionSourceAdmissionMode !== "listed_only");
+                        currentSourceAdmission = resolveJunctionCurrentSourceAdmissionFromSources(sourceIdentityAuthority, sourceProviderSlug, context.connectionSourceAdmissionMode !== "listed_only", sourceLifecycleEpoch ?? undefined);
                     }
                 }
                 catch (error) {
@@ -1608,7 +1934,7 @@ export function createJunctionDeviceSyncProvider(config) {
                         window,
                     });
                 }
-                if (extendedHistoricalPolicy?.completion === "daily_aggregate"
+                if (requiresJunctionHistoricalPullReadiness(extendedHistoricalPolicy)
                     && window.windowStart === historicalWindowStart) {
                     const historicalPullReadiness = resolveJunctionHistoricalPullReadiness({
                         resource: effectiveResource,
@@ -1643,12 +1969,8 @@ export function createJunctionDeviceSyncProvider(config) {
                         const retryDelayMs = EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS.at(-1) ?? 0;
                         return {
                             nextReconcileAt: clampWebhookJobNextReconcileAt(context),
-                            scheduledJobs: [buildExtendedTimeseriesBackfillJob({
+                            scheduledJobs: [buildExtendedTimeseriesBackfillFollowUp(job, {
                                     availableAt: addMilliseconds(context.now, retryDelayMs),
-                                    dedupeKey: job.dedupeKey,
-                                    historicalWindowStart,
-                                    resource: effectiveResource,
-                                    sourceProviderSlug,
                                     windowEnd: window.windowEnd,
                                     windowStart: window.windowStart,
                                 })],
@@ -1674,7 +1996,7 @@ export function createJunctionDeviceSyncProvider(config) {
                 if (timeseriesPolicy?.historyWindow === "dense_timeseries"
                     && (timeseriesPolicy.enabledByDefault === false
                         || JUNCTION_CLOSED_DAY_TIMESERIES_RESOURCES.has(effectiveResource))) {
-                    const dailyImport = await importTimeseriesDailySnapshots(context, sourceProviders, window.windowStart, window.windowEnd, skippedOptionalResources, effectiveResource, sourceProviderSlug, completedWorkoutStreamIdentities);
+                    const dailyImport = await importTimeseriesDailySnapshots(context, sourceProviders, window.windowStart, window.windowEnd, skippedOptionalResources, effectiveResource, sourceProviderSlug, completedWorkoutStreamIdentities, job.payload.workoutStreamEmptySeen === true);
                     const result = withJunctionSkippedResourceMetadata(context, dailyImport.yieldedAt
                         ? buildYieldedJunctionJobResult({
                             context,
@@ -1684,9 +2006,41 @@ export function createJunctionDeviceSyncProvider(config) {
                             workoutStreamCursor: effectiveResource === "workout_stream"
                                 ? dailyImport.workoutStreamCursor
                                 : undefined,
+                            workoutStreamEmptySeen: dailyImport.workoutStreamEmptySeen,
+                        })
+                        : { nextReconcileAt: clampWebhookJobNextReconcileAt(context) }, skippedOptionalResources);
+                    return withJunctionWorkoutStreamEmptyReplay({
+                        job,
+                        now: context.now,
+                        replayWindow: dailyImport.emptyWorkoutStreamReplayWindow,
+                        result,
+                        sourceProviderSlug,
+                    });
+                }
+                if (!extendedHistoricalBackfill
+                    && timeseriesPolicy?.maxCanonicalRecordsPerWindow !== undefined) {
+                    const [boundedWindow] = buildPreciseTimeseriesWindows(window.windowStart, window.windowEnd);
+                    if (!boundedWindow) {
+                        return withJunctionSkippedResourceMetadata(context, { nextReconcileAt: clampWebhookJobNextReconcileAt(context) }, skippedOptionalResources);
+                    }
+                    await importJunctionTimeseriesResourceSnapshot({
+                        context,
+                        dateQueryFormat: "datetime",
+                        resource: effectiveResource,
+                        skippedOptionalResources,
+                        sourceProviderSlug,
+                        sourceProviders,
+                        windowEnd: boundedWindow.windowEnd,
+                        windowStart: boundedWindow.windowStart,
+                    });
+                    return withJunctionSkippedResourceMetadata(context, Date.parse(boundedWindow.windowEnd) < Date.parse(window.windowEnd)
+                        ? buildYieldedJunctionJobResult({
+                            context,
+                            job,
+                            windowEnd: window.windowEnd,
+                            windowStart: boundedWindow.windowEnd,
                         })
                         : { nextReconcileAt: clampWebhookJobNextReconcileAt(context) }, skippedOptionalResources);
-                    return result;
                 }
                 const timeseriesImport = await importTimeseriesPreciseSnapshots(context, sourceProviders, window.windowStart, window.windowEnd, skippedOptionalResources, [effectiveResource], sourceProviderSlug, {
                     dateQueryFormat: extendedHistoricalPolicy?.completion === "daily_aggregate"
@@ -1695,6 +2049,9 @@ export function createJunctionDeviceSyncProvider(config) {
                     historicalProviderRecordsSeen: job.payload.historicalProviderRecordsSeen === true,
                     preservePartialRetryableFailure: extendedHistoricalBackfill,
                     ...(sourceIdentityAuthority ? { sourceIdentityAuthority } : {}),
+                    sourceLifecycleEpoch: extendedHistoricalBackfill
+                        ? sourceLifecycleEpoch ?? undefined
+                        : undefined,
                     sourceStatusRequirement: extendedHistoricalBackfill
                         ? "connected"
                         : undefined,
@@ -1732,7 +2089,7 @@ export function createJunctionDeviceSyncProvider(config) {
                 const historicalRecordsSeen = extendedHistoricalBackfill
                     ? job.payload.historicalRecordsSeen === true
                         || timeseriesImport.canonicalEventCount > 0
-                        || (effectiveResource === "weight"
+                        || (doesJunctionImportReceiptResolveDeliveredRows(effectiveResource)
                             && timeseriesImport.providerRecordsExamined)
                     : undefined;
                 const dailyAggregateNeedsRetry = extendedHistoricalPolicy?.completion === "daily_aggregate"
@@ -1744,14 +2101,12 @@ export function createJunctionDeviceSyncProvider(config) {
                     const retryDelayMs = EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS[retryAttempts - 1] ?? 0;
                     return finalizePreciseImportResult(withJunctionSkippedResourceMetadata(context, {
                         nextReconcileAt: clampWebhookJobNextReconcileAt(context),
-                        scheduledJobs: [buildExtendedTimeseriesBackfillJob({
+                        scheduledJobs: [buildExtendedTimeseriesBackfillFollowUp(job, {
                                 availableAt: addMilliseconds(context.now, retryDelayMs),
-                                dedupeKey: job.dedupeKey,
-                                emptyBackfillAttempts: retryAttempts,
-                                historicalRecordsSeen,
-                                historicalWindowStart,
-                                resource: effectiveResource,
-                                sourceProviderSlug,
+                                payload: {
+                                    emptyBackfillAttempts: retryAttempts,
+                                    historicalRecordsSeen,
+                                },
                                 windowEnd: window.windowEnd,
                                 windowStart: window.windowStart,
                             })],
@@ -1759,7 +2114,11 @@ export function createJunctionDeviceSyncProvider(config) {
                 }
                 const historicalUnresolvedProviderRecords = extendedHistoricalBackfill
                     && extendedHistoricalPolicy?.completion !== "daily_aggregate"
-                    ? resolveJunctionHistoricalUnresolvedProviderRecords(job, timeseriesImport)
+                    ? isJunctionBodyTimeseriesResource(effectiveResource)
+                        && timeseriesImport.fetchComplete
+                        && timeseriesImport.unresolvedProviderRecordCount === 0
+                        ? { identities: [], withoutStableIdentity: false }
+                        : resolveJunctionHistoricalUnresolvedProviderRecords(job, timeseriesImport)
                     : undefined;
                 const historicalUnresolvedProviderRecordCount = historicalUnresolvedProviderRecords === undefined
                     ? undefined
@@ -1789,7 +2148,7 @@ export function createJunctionDeviceSyncProvider(config) {
                 const result = withJunctionSkippedResourceMetadata(context, {
                     nextReconcileAt: clampWebhookJobNextReconcileAt(context),
                 }, skippedOptionalResources);
-                const historicalPullReadiness = extendedHistoricalPolicy?.completion === "daily_aggregate"
+                const historicalPullReadiness = requiresJunctionHistoricalPullReadiness(extendedHistoricalPolicy)
                     && timeseriesImport.fetchComplete
                     ? resolveJunctionHistoricalPullReadiness({
                         resource: effectiveResource,
@@ -1797,6 +2156,13 @@ export function createJunctionDeviceSyncProvider(config) {
                         sourceProviderSlug,
                     })
                     : undefined;
+                if (extendedHistoricalBackfill
+                    && extendedHistoricalPolicy?.anchor === "current_day"
+                    && sourceProviderSlug
+                    && sourceLifecycleEpoch !== null
+                    && await resolveJunctionCurrentSourceAdmission(context, sourceProviderSlug, sourceLifecycleEpoch) !== "admitted") {
+                    return {};
+                }
                 return finalizePreciseImportResult(withJunctionHistoricalCoverageVerification(context, job, window, withJunctionExtendedTimeseriesBackfillFollowUp({
                     context,
                     historicalPullReadiness,
@@ -1820,17 +2186,13 @@ export function createJunctionDeviceSyncProvider(config) {
         }
         const sourceProviders = await loadAndProjectSourceProviders();
         const preparedImport = await prepareJunctionImportSnapshot(context, summaries, sourceProviders);
-        await context.importSnapshot({
-            provider: "junction",
-            accountId: buildJunctionImportAccountId(context.account.externalAccountId),
-            connectionId: context.account.id,
+        await commitPreparedJunctionCanonicalImport(context, preparedImport, {
             importedAt: context.now,
             windowStart: window.windowStart,
             windowEnd: window.windowEnd,
-            connections: preparedImport.connections,
             summaries: preparedImport.snapshots,
             timeseries: {},
-        });
+        }, context.now);
         return withJunctionHistoricalCoverageVerification(context, job, window, withJunctionSkippedResourceMetadata(context, {
             nextReconcileAt: clampWebhookJobNextReconcileAt(context),
         }, skippedOptionalResources));
@@ -1881,14 +2243,14 @@ export function createJunctionDeviceSyncProvider(config) {
         if (!policy) {
             return input.result;
         }
-        const sourceProviderSlug = normalizeProviderSlug(input.job.payload.sourceProviderSlug);
+        const sourceProviderSlug = canonicalizeJunctionProviderSlug(input.job.payload.sourceProviderSlug);
         const historicalWindowStart = toIsoTimestampIfValid(normalizeString(input.job.payload.historicalWindowStart))
             ?? input.window.windowStart;
         const recordsSeen = input.job.payload.historicalRecordsSeen === true
             || input.importResult.canonicalEventCount > 0
-            || (input.resource === "weight"
+            || (doesJunctionImportReceiptResolveDeliveredRows(input.resource)
                 && input.importResult.providerRecordsExamined);
-        const unresolvedProviderRecords = input.resource === "weight"
+        const unresolvedProviderRecords = isJunctionBodyTimeseriesResource(input.resource)
             && input.importResult.fetchComplete
             && input.importResult.unresolvedProviderRecordCount === 0
             ? { identities: [], withoutStableIdentity: false }
@@ -1896,22 +2258,20 @@ export function createJunctionDeviceSyncProvider(config) {
         const unresolvedProviderRecordCount = countJunctionHistoricalUnresolvedProviderRecords(unresolvedProviderRecords);
         const unresolvedProviderRecordIdentitiesJson = encodeJunctionHistoricalUnresolvedProviderRecords(unresolvedProviderRecords);
         const unresolvedProviderRecordsSeen = unresolvedProviderRecordCount > 0;
-        if (policy.completion === "daily_aggregate" && input.importResult.fetchComplete) {
+        if (requiresJunctionHistoricalPullReadiness(policy) && input.importResult.fetchComplete) {
             const historicalPullReadiness = input.historicalPullReadiness ?? "unavailable";
             const currentReconcileWindowStart = floorUtcDayTimestamp(subtractDays(floorUtcDayTimestamp(input.context.now), reconcileDays));
             if (historicalPullReadiness === "pending"
-                || (historicalPullReadiness === "unavailable" && !recordsSeen)) {
+                || (policy.completion === "daily_aggregate"
+                    && historicalPullReadiness === "unavailable"
+                    && !recordsSeen)) {
                 const retryDelayMs = EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS.at(-1) ?? 0;
                 return {
                     ...input.result,
                     scheduledJobs: [
                         ...(input.result.scheduledJobs ?? []),
-                        buildExtendedTimeseriesBackfillJob({
+                        buildExtendedTimeseriesBackfillFollowUp(input.job, {
                             availableAt: addMilliseconds(input.context.now, retryDelayMs),
-                            dedupeKey: input.job.dedupeKey,
-                            historicalWindowStart,
-                            resource: input.resource,
-                            sourceProviderSlug,
                             windowEnd: maxIsoTimestamp(input.window.windowEnd, currentReconcileWindowStart),
                             windowStart: historicalWindowStart,
                         }),
@@ -1923,13 +2283,9 @@ export function createJunctionDeviceSyncProvider(config) {
                     ...input.result,
                     scheduledJobs: [
                         ...(input.result.scheduledJobs ?? []),
-                        buildExtendedTimeseriesBackfillJob({
+                        buildExtendedTimeseriesBackfillFollowUp(input.job, {
                             availableAt: input.context.now,
-                            dedupeKey: input.job.dedupeKey,
-                            historicalRecordsSeen: recordsSeen,
-                            historicalWindowStart,
-                            resource: input.resource,
-                            sourceProviderSlug,
+                            payload: { historicalRecordsSeen: recordsSeen },
                             windowEnd: currentReconcileWindowStart,
                             windowStart: input.window.windowEnd,
                         }),
@@ -1939,7 +2295,10 @@ export function createJunctionDeviceSyncProvider(config) {
             if (historicalPullReadiness === "terminal_failure") {
                 return input.result;
             }
-            return withJunctionMetadataPatch(input.result, buildJunctionExtendedTimeseriesBackfillCompletionMetadataPatch(input.context, input.job, input.resource, sourceProviderSlug));
+            if (policy.completion === "daily_aggregate"
+                || historicalPullReadiness !== "unavailable") {
+                return withJunctionMetadataPatch(input.result, buildJunctionExtendedTimeseriesBackfillCompletionMetadataPatch(input.context, input.job, input.resource, sourceProviderSlug));
+            }
         }
         // A complete note scan can close its one-time source coverage even when
         // no action-like tags exist. Neutral wearable-tag notes, including a
@@ -1958,7 +2317,8 @@ export function createJunctionDeviceSyncProvider(config) {
         let retryDelayMs = EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS[emptyBackfillAttempts - 1]
             ?? null;
         if (retryDelayMs === null
-            && (!input.importResult.fetchComplete || unresolvedProviderRecordsSeen)) {
+            && (!input.importResult.fetchComplete
+                || unresolvedProviderRecords.identities.length > 0)) {
             emptyBackfillAttempts = EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS.length;
             retryDelayMs =
                 EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS[emptyBackfillAttempts - 1]
@@ -1971,22 +2331,15 @@ export function createJunctionDeviceSyncProvider(config) {
             ...input.result,
             scheduledJobs: [
                 ...(input.result.scheduledJobs ?? []),
-                buildExtendedTimeseriesBackfillJob({
+                buildExtendedTimeseriesBackfillFollowUp(input.job, {
                     availableAt: addMilliseconds(input.context.now, retryDelayMs),
-                    dedupeKey: input.job.dedupeKey,
-                    emptyBackfillAttempts,
-                    ...(input.resource === "note"
-                        ? {
-                            historicalBackfillVersion: readJunctionNoteHistoryBackfillVersion(input.job.payload),
-                        }
-                        : {}),
-                    historicalProviderRecordsSeen: unresolvedProviderRecordsSeen,
-                    historicalRecordsSeen: recordsSeen,
-                    historicalUnresolvedProviderRecordIdentitiesJson: unresolvedProviderRecordIdentitiesJson,
-                    historicalUnresolvedProviderRecordCount: unresolvedProviderRecordCount,
-                    historicalWindowStart,
-                    resource: input.resource,
-                    sourceProviderSlug,
+                    payload: {
+                        emptyBackfillAttempts,
+                        historicalProviderRecordsSeen: unresolvedProviderRecordsSeen,
+                        historicalRecordsSeen: recordsSeen,
+                        historicalUnresolvedProviderRecordIdentitiesJson: unresolvedProviderRecordIdentitiesJson,
+                        historicalUnresolvedProviderRecordCount: unresolvedProviderRecordCount || undefined,
+                    },
                     windowEnd: input.window.windowEnd,
                     windowStart: input.importResult.fetchComplete
                         ? historicalWindowStart
@@ -2006,9 +2359,7 @@ export function createJunctionDeviceSyncProvider(config) {
         if (!canCurrentRuntimeMutateJunctionExtendedTimeseriesHistoryBackfillCoverage(context.account.metadata, resource, policy.version)) {
             return {};
         }
-        const admittedVersion = resource === "note"
-            ? readJunctionNoteHistoryBackfillVersion(job.payload)
-            : policy.version;
+        const admittedVersion = readJunctionHistoricalBackfillVersion(job.payload);
         if (admittedVersion !== policy.version) {
             // A semantic generation can only certify its own coverage. Older jobs
             // may still import facts without closing the current generation's bit.
@@ -2070,7 +2421,7 @@ export function createJunctionDeviceSyncProvider(config) {
         const acceptedCanonicalDelivery = importResult.durableDeliveryAccepted
             && providerSlug !== null
             && importResult.normalizationEvidence.some((entry) => entry.resource === directInput.resource
-                && canonicalizeJunctionHistoricalProviderSlug(entry.sourceProviderSlug) === providerSlug);
+                && canonicalizeJunctionProviderSlug(entry.sourceProviderSlug) === providerSlug);
         if (!canCurrentRuntimeMutateJunctionHistoricalBackfillProgress(context.account.metadata)
             || !directHistoricalWindow
             || !acceptedCanonicalDelivery
@@ -2124,19 +2475,29 @@ export function createJunctionDeviceSyncProvider(config) {
         const data = readPlainObject(verified.payload[JUNCTION_WEBHOOK_ROOT_FIELDS.data]);
         const externalAccountSelection = requireJunctionWebhookUserIdSelection(verified.payload, data);
         const resource = inferJunctionWebhookResource(eventType, data);
-        const sourceProviderSlug = extractJunctionWebhookSourceProviderSlug(data);
+        const envelopeSourceProviderSlug = extractJunctionWebhookSourceProviderSlug(data);
         const objectId = extractJunctionWebhookObjectId(data);
-        const eventOccurredAt = extractJunctionWebhookOccurredAt(data);
+        const eventOccurredAt = extractJunctionWebhookOccurredAt(data, resource);
         const occurredAt = eventOccurredAt ?? context.now;
         const window = buildJunctionWebhookWindow(data, occurredAt, context.now, resource);
+        const historicalPullCompleted = isJunctionHistoricalDataEvent(eventType)
+            && data !== null
+            && isJunctionHistoricalPullCompletedWebhookData(data, externalAccountSelection.userId);
+        const dataSourceProviderSlug = resolveJunctionWebhookDataSourceProviderSlug({
+            data,
+            envelopeSourceProviderSlug,
+            eventType,
+            historicalPullCompleted,
+        });
         const webhookDataJsons = buildJunctionWebhookDataJobJsons({
             data,
             eventType,
             externalAccountId: externalAccountSelection.userId,
             resource,
             summaryResources,
-            sourceProviderSlug,
+            sourceProviderSlug: dataSourceProviderSlug,
         });
+        const sourceProviderSlug = dataSourceProviderSlug ?? envelopeSourceProviderSlug;
         const jobs = buildJunctionWebhookJobs({
             eventType,
             objectId,
@@ -2160,18 +2521,14 @@ export function createJunctionDeviceSyncProvider(config) {
             // A historical-pull completion is a data-less notification, so accepting
             // its fetch job proves nothing arrived. Treating it as delivery would
             // refresh the arrival signal and hide the very stall this detects.
-            dataSourceProviderSlug: isJunctionDataEvent(eventType)
-                && !(isJunctionHistoricalDataEvent(eventType)
-                    && data !== null
-                    && isJunctionHistoricalPullCompletedWebhookData(data, externalAccountSelection.userId))
-                ? sourceProviderSlug
-                : null,
+            dataSourceProviderSlug,
             jobs,
             unknownAccountAction: "accept",
         };
     }
     async function fetchSummarySnapshots(context, windowStart, windowEnd, skippedOptionalResources, options = {}) {
         const snapshots = {};
+        let providerRecordsSeen = false;
         for (const resource of summaryResources) {
             if (isJunctionProfileSummaryResource(resource)) {
                 continue;
@@ -2179,6 +2536,7 @@ export function createJunctionDeviceSyncProvider(config) {
             const request = {
                 resource,
                 signal: context.signal ?? null,
+                sourceProviderSlug: options.sourceProviderSlug,
                 userId: context.account.externalAccountId,
                 windowStart,
                 windowEnd,
@@ -2186,9 +2544,11 @@ export function createJunctionDeviceSyncProvider(config) {
             if (options.dateQueryFormat) {
                 request.dateQueryFormat = options.dateQueryFormat;
             }
-            snapshots[resource] = await fetchOptionalJunctionResourceRecords(context, "summary", resource, skippedOptionalResources, () => client.listSummary(request));
+            const records = await fetchOptionalJunctionResourceRecords(context, "summary", resource, skippedOptionalResources, () => client.listSummary(request));
+            providerRecordsSeen ||= records.length > 0;
+            snapshots[resource] = scopeJunctionRecordsToSourceProvider(records, options.sourceProviderSlug);
         }
-        return snapshots;
+        return { providerRecordsSeen, snapshots };
     }
     async function executeBoundedSummaryReconcile(input) {
         const profileAlreadyChecked = hasCheckedJunctionProfileSummary(input.context.account.metadata);
@@ -2239,17 +2599,13 @@ export function createJunctionDeviceSyncProvider(config) {
             }
         }
         const preparedSummaryImport = await prepareJunctionImportSnapshot(input.context, summaries, input.sourceProviders);
-        await input.context.importSnapshot({
-            provider: "junction",
-            accountId: buildJunctionImportAccountId(input.context.account.externalAccountId),
-            connectionId: input.context.account.id,
+        await commitPreparedJunctionCanonicalImport(input.context, preparedSummaryImport, {
             importedAt: input.summaryWindow.windowEnd,
             windowStart: input.summaryWindow.windowStart,
             windowEnd: input.summaryWindow.windowEnd,
-            connections: preparedSummaryImport.connections,
             summaries: preparedSummaryImport.snapshots,
             timeseries: {},
-        });
+        }, input.context.now);
         const nextResource = eligibleUnits[cursorIndex >= 0 ? cursorIndex + 1 : 1]?.[0] ?? null;
         const sourceProviderSlug = normalizeProviderSlug(input.job.payload.sourceProviderSlug);
         const continuation = buildExactWindowJob({
@@ -2287,12 +2643,14 @@ export function createJunctionDeviceSyncProvider(config) {
     async function fetchTimeseriesSnapshots(context, windowStart, windowEnd, skippedOptionalResources, resources = timeseriesResources, sourceProviderSlug, options = {}) {
         const snapshots = {};
         for (const resource of resources) {
-            snapshots[resource] = await fetchTimeseriesResourceInChunks(context, resource, windowStart, windowEnd, skippedOptionalResources, sourceProviderSlug, options);
+            const fetched = await fetchTimeseriesResourceInChunks(context, resource, windowStart, windowEnd, skippedOptionalResources, sourceProviderSlug, options);
+            snapshots[resource] = fetched.records;
         }
         return snapshots;
     }
     async function fetchTimeseriesResourceInChunks(context, resource, windowStart, windowEnd, skippedOptionalResources, sourceProviderSlug, options = {}) {
         const records = [];
+        let providerRecordsSeen = false;
         let chunkStart = Date.parse(windowStart);
         const end = Date.parse(windowEnd);
         let optionalFailureLogged = false;
@@ -2317,8 +2675,9 @@ export function createJunctionDeviceSyncProvider(config) {
                 if (options.requireStructurallyCompleteCollection) {
                     request.requireStructurallyCompleteCollection = true;
                 }
-                const chunkRecords = await fetchJunctionTimeseriesWindow(client, request);
-                records.push(...filterJunctionTimeseriesRecordsToWindow(resource, chunkRecords, chunkWindowStart, chunkWindowEnd, options.dateQueryFormat));
+                const chunkRecords = await measureJunctionProviderRequest(context, "resource", () => fetchJunctionTimeseriesWindow(client, request));
+                providerRecordsSeen ||= chunkRecords.length > 0;
+                records.push(...filterJunctionTimeseriesRecordsToWindow(resource, chunkRecords, chunkWindowStart, chunkWindowEnd, options.dateQueryFormat, options.authorizedLocalDay, context.vaultTimeZone));
             }
             catch (error) {
                 const failure = classifyOptionalJunctionResourceFailure(error, "timeseries", resource, context.account.externalAccountId);
@@ -2339,9 +2698,15 @@ export function createJunctionDeviceSyncProvider(config) {
             chunkStart = chunkEnd;
         }
         if (resource === "electrocardiogram_voltage" || resource === "workout_stream") {
-            return resolveJunctionBoundedFeatureRecords(resource, records);
+            return {
+                providerRecordsSeen,
+                records: resolveJunctionBoundedFeatureRecords(resource, records),
+            };
         }
-        return dedupeJunctionTimeseriesRecords(resource, records);
+        return {
+            providerRecordsSeen,
+            records: dedupeJunctionTimeseriesRecords(resource, records),
+        };
     }
     async function importTimeseriesPreciseSnapshots(context, sourceProviders, windowStart, windowEnd, skippedOptionalResources, resources, sourceProviderSlug, options = {}) {
         const accumulatedTimeseries = {};
@@ -2370,9 +2735,8 @@ export function createJunctionDeviceSyncProvider(config) {
             const skippedResourceCountBeforeFetch = skippedOptionalResources.length;
             let timeseries;
             try {
-                timeseries = {
-                    [resource]: await fetchTimeseriesResourceInChunks(context, resource, window.windowStart, window.windowEnd, skippedOptionalResources, sourceProviderSlug, { dateQueryFormat: options.dateQueryFormat ?? "datetime" }),
-                };
+                const fetched = await fetchTimeseriesResourceInChunks(context, resource, window.windowStart, window.windowEnd, skippedOptionalResources, sourceProviderSlug, { dateQueryFormat: options.dateQueryFormat ?? "datetime" });
+                timeseries = { [resource]: fetched.records };
             }
             catch (error) {
                 if (options.preservePartialRetryableFailure === true
@@ -2410,7 +2774,8 @@ export function createJunctionDeviceSyncProvider(config) {
         let unresolvedProviderRecordCount = providerRecordCount;
         let unresolvedProviderRecordsWithoutStableIdentity = providerRecordCount > 0;
         const requiresBloodPressureRecordResolution = resources.includes("blood_pressure");
-        const successfulImportTerminatesWeightRows = resources.length === 1 && resources[0] === "weight";
+        const successfulImportTerminatesDeliveredRows = resources.length === 1
+            && doesJunctionImportReceiptResolveDeliveredRows(resources[0] ?? "");
         if (executionWindowStart && executionWindowEnd) {
             const identifyFetchedProviderRecords = (sourceIdentities) => requiresBloodPressureRecordResolution && providerRecordCount > 0
                 ? identifyJunctionBloodPressureProviderRecords({
@@ -2442,7 +2807,7 @@ export function createJunctionDeviceSyncProvider(config) {
                 const importSourceIdentities = resolveJunctionAccountSourceIdentities(currentSources);
                 if (sourceProviderSlug
                     && options.sourceStatusRequirement === "connected") {
-                    postFetchSourceAdmission = resolveJunctionCurrentSourceAdmissionFromSources(currentSources, sourceProviderSlug, context.connectionSourceAdmissionMode !== "listed_only");
+                    postFetchSourceAdmission = resolveJunctionCurrentSourceAdmissionFromSources(currentSources, sourceProviderSlug, context.connectionSourceAdmissionMode !== "listed_only", options.sourceLifecycleEpoch);
                     if (postFetchSourceAdmission !== "admitted") {
                         return {
                             acceptedProviderRecordCount: 0,
@@ -2477,18 +2842,14 @@ export function createJunctionDeviceSyncProvider(config) {
                     windowStart: executionWindowStart,
                 });
                 if (hasJunctionSnapshotRecords(preparedImport.snapshots)) {
-                    const receipt = await context.importSnapshot({
-                        provider: "junction",
-                        accountId: buildJunctionImportAccountId(context.account.externalAccountId),
-                        connectionId: context.account.id,
+                    const receipt = await commitPreparedJunctionCanonicalImport(context, preparedImport, {
                         importedAt: executionWindowEnd,
                         windowStart: executionWindowStart,
                         windowEnd: executionWindowEnd,
                         timeseriesWindowKind: "precise",
-                        connections: preparedImport.connections,
                         summaries: {},
                         timeseries: preparedImport.snapshots,
-                    });
+                    }, context.now);
                     providerRecordsExamined = true;
                     canonicalEventCount = readProviderSnapshotCanonicalEventCount(receipt);
                     canonicalEventDayKeys = readProviderSnapshotCanonicalEventDayKeys(receipt);
@@ -2510,11 +2871,11 @@ export function createJunctionDeviceSyncProvider(config) {
                             unresolvedProviderRecordIdentities.length
                                 + (unresolvedProviderRecordsWithoutStableIdentity ? 1 : 0);
                     }
-                    else if (successfulImportTerminatesWeightRows) {
-                        // A resolved import receipt means the weight normalizer examined
-                        // every delivered row. Valid readings became canonical events and
-                        // deterministic validation rejects are terminal; delivery errors
-                        // throw before this branch and retain the retry obligation.
+                    else if (successfulImportTerminatesDeliveredRows) {
+                        // A resolved exact-record import receipt means the canonical owner
+                        // examined every delivered row. Valid readings became canonical
+                        // events and deterministic validation rejects are terminal;
+                        // delivery errors throw before this branch and remain retryable.
                         unresolvedProviderRecordCount = 0;
                         unresolvedProviderRecordsWithoutStableIdentity = false;
                     }
@@ -2524,6 +2885,10 @@ export function createJunctionDeviceSyncProvider(config) {
                         unresolvedProviderRecordsWithoutStableIdentity = unresolvedProviderRecordCount > 0;
                     }
                 }
+                if (sourceProviderSlug
+                    && options.sourceStatusRequirement === "connected") {
+                    postFetchSourceAdmission = await resolveJunctionCurrentSourceAdmission(context, sourceProviderSlug, options.sourceLifecycleEpoch);
+                }
             }
             catch (error) {
                 if (options.preservePartialRetryableFailure === true
@@ -2637,10 +3002,7 @@ export function createJunctionDeviceSyncProvider(config) {
                     : [],
             });
             if (hasJunctionSnapshotRecords(preparedImport.snapshots)) {
-                const receipt = await context.importSnapshot({
-                    provider: "junction",
-                    accountId: buildJunctionImportAccountId(context.account.externalAccountId),
-                    connectionId: context.account.id,
+                const receipt = await commitPreparedJunctionCanonicalImport(context, preparedImport, {
                     importedAt: window.windowEnd,
                     windowStart: window.windowStart,
                     windowEnd: window.windowEnd,
@@ -2649,16 +3011,17 @@ export function createJunctionDeviceSyncProvider(config) {
                         ? {
                             strictSparseCalendarRepair: {
                                 dayKey: window.windowStart.slice(0, 10),
-                                resource: windowResources[0],
                                 ...emptySparseCalendarSource,
+                                // Calendar-refresh admission already proved this member of
+                                // the fixed sparse resource set before collection began.
+                                resource: windowResources[0],
                                 sourceProviderSlug: normalizeJunctionSourceProviderSlug(emptySparseCalendarSource.sourceProviderSlug) ?? emptySparseCalendarSource.sourceProviderSlug,
                             },
                         }
                         : {}),
-                    connections: preparedImport.connections,
                     summaries: {},
                     timeseries: preparedImport.snapshots,
-                });
+                }, context.now);
                 for (const resourceId of readProviderSnapshotCanonicalEventExternalRefResourceIds(receipt) ?? []) {
                     appliedDailyAggregateResourceIds.add(resourceId);
                 }
@@ -2669,7 +3032,7 @@ export function createJunctionDeviceSyncProvider(config) {
             yieldedAt: null,
         };
     }
-    async function importTimeseriesDailySnapshots(context, sourceProviders, windowStart, windowEnd, skippedOptionalResources, resource, sourceProviderSlug, completedWorkoutStreamIdentities = new Set()) {
+    async function importTimeseriesDailySnapshots(context, sourceProviders, windowStart, windowEnd, skippedOptionalResources, resource, sourceProviderSlug, completedWorkoutStreamIdentities = new Set(), workoutStreamEmptySeen = false) {
         let resumeWorkoutStreamIdentities = new Set(completedWorkoutStreamIdentities);
         let madeProgress = false;
         for (const window of buildClosedDailyWindows(windowStart, windowEnd)) {
@@ -2680,6 +3043,7 @@ export function createJunctionDeviceSyncProvider(config) {
                 if (madeProgress) {
                     return {
                         workoutStreamCursor,
+                        workoutStreamEmptySeen,
                         yieldedAt: window.windowStart,
                     };
                 }
@@ -2695,20 +3059,37 @@ export function createJunctionDeviceSyncProvider(config) {
                     sourceProviders,
                     windowEnd: window.windowEnd,
                     windowStart: window.windowStart,
+                    workoutStreamEmptySeen,
                 });
                 workoutStreamCursor = workoutImport.workoutStreamCursor;
+                workoutStreamEmptySeen = workoutImport.emptyTimestampArraySeen;
                 madeProgress ||= workoutImport.madeProgress;
                 if (workoutImport.yieldedAt) {
                     return {
                         workoutStreamCursor,
+                        workoutStreamEmptySeen,
                         yieldedAt: workoutImport.yieldedAt,
                     };
                 }
+                if (workoutStreamEmptySeen) {
+                    return {
+                        emptyWorkoutStreamReplayWindow: {
+                            windowEnd: window.windowEnd,
+                            windowStart: window.windowStart,
+                        },
+                        workoutStreamCursor: null,
+                        workoutStreamEmptySeen: false,
+                        yieldedAt: window.windowEnd,
+                    };
+                }
                 madeProgress = true;
             }
             else {
                 try {
                     await importJunctionTimeseriesResourceSnapshot({
+                        collectionWorkLimit: resource === "electrocardiogram_voltage"
+                            ? JUNCTION_FULL_JOB_TIMESERIES_COLLECTION_WORK_LIMIT
+                            : undefined,
                         context,
                         dateQueryFormat: "date",
                         resource,
@@ -2724,6 +3105,7 @@ export function createJunctionDeviceSyncProvider(config) {
                         if (madeProgress) {
                             return {
                                 workoutStreamCursor,
+                                workoutStreamEmptySeen: false,
                                 yieldedAt: window.windowStart,
                             };
                         }
@@ -2741,6 +3123,7 @@ export function createJunctionDeviceSyncProvider(config) {
         }
         return {
             workoutStreamCursor: null,
+            workoutStreamEmptySeen: false,
             yieldedAt: null,
         };
     }
@@ -2766,15 +3149,33 @@ export function createJunctionDeviceSyncProvider(config) {
             : persistedTimeseriesWindowHours;
         const resource = resourceCursor.resource;
         const policy = resolveJunctionTimeseriesResourcePolicy(resource);
+        const sourceProviderSlug = normalizeProviderSlug(job.payload.sourceProviderSlug);
+        let historicalProviderRecordsSeen = sourceProviderSlug !== null
+            && job.payload.historicalProviderRecordsSeen === true;
+        let historicalRecordsSeen = sourceProviderSlug !== null
+            && job.payload.historicalRecordsSeen === true;
         if ((timeseriesWindowHours === 1
             && policy?.normalizationMode !== "hourly_or_session_feature")
             || (!resourceCursor.restartFromWindowStart
                 && resource !== "workout_stream"
-                && job.payload.workoutStreamCursor !== undefined)) {
+                && (job.payload.workoutStreamCursor !== undefined
+                    || job.payload.workoutStreamEmptySeen !== undefined))) {
             throw invalidJunctionTimeseriesResourceProgress();
         }
+        const listedSourceProviders = sourceProviderSlug || resource === "workout_stream"
+            ? await measureJunctionProviderRequest(context, "inventory", () => client.listUserProviders(context.account.externalAccountId, {
+                ...(!sourceProviderSlug && resource === "workout_stream"
+                    ? { collectionWorkLimit: JUNCTION_FULL_JOB_INVENTORY_COLLECTION_WORK_LIMIT }
+                    : {}),
+                signal: context.signal ?? null,
+            }))
+            : [];
+        const sourceProviders = sourceProviderSlug
+            ? listedSourceProviders.filter((provider) => areJunctionProviderSlugsDataEquivalent(provider.origin.sourceProviderSlug ?? provider.slug, sourceProviderSlug))
+            : listedSourceProviders;
         const executionWindowEnd = new Date(Math.min(Date.parse(timeseriesCursor) + timeseriesWindowHours * TIMESERIES_HOUR_MS, Date.parse(window.windowEnd))).toISOString();
         let workoutStreamCursor = null;
+        let workoutStreamReplayWindow;
         if (resource === "workout_stream") {
             try {
                 const workoutImport = await importJunctionWorkoutStreamWindow({
@@ -2783,41 +3184,69 @@ export function createJunctionDeviceSyncProvider(config) {
                     completedIdentities: completedWorkoutStreamIdentities,
                     context,
                     skippedOptionalResources,
-                    sourceProviders: [],
+                    sourceProviderSlug,
+                    sourceProviders,
                     windowEnd: executionWindowEnd,
                     windowStart: timeseriesCursor,
+                    workoutStreamEmptySeen: job.payload.workoutStreamEmptySeen === true,
                 });
+                historicalProviderRecordsSeen ||=
+                    sourceProviderSlug !== null
+                        && workoutImport.historicalProviderRecordsSeen === true;
+                historicalRecordsSeen ||=
+                    sourceProviderSlug !== null
+                        && workoutImport.historicalRecordsSeen === true;
                 workoutStreamCursor = workoutImport.workoutStreamCursor;
                 if (workoutImport.yieldedAt) {
                     return buildFullJobTimeseriesContinuationResult({
                         context,
+                        historicalProviderRecordsSeen,
+                        historicalRecordsSeen,
                         job,
                         skippedOptionalResources,
+                        sourceProviders,
                         continuation: {
                             timeseriesCursor,
                             timeseriesResourceCursor: resource,
                             timeseriesWindowHours,
                             workoutStreamCursor,
+                            workoutStreamEmptySeen: workoutImport.emptyTimestampArraySeen,
                         },
                         window,
                     });
                 }
+                workoutStreamReplayWindow = workoutImport.emptyTimestampArraySeen
+                    ? {
+                        windowEnd: executionWindowEnd,
+                        windowStart: timeseriesCursor,
+                    }
+                    : undefined;
             }
             catch (error) {
                 if (error instanceof JunctionTimeseriesProgressError) {
+                    historicalProviderRecordsSeen ||=
+                        sourceProviderSlug !== null
+                            && error.historicalProviderRecordsSeen;
+                    historicalRecordsSeen ||=
+                        sourceProviderSlug !== null
+                            && error.historicalRecordsSeen;
                     if (!error.workoutStreamCursor
                         || error.workoutStreamCursor === job.payload.workoutStreamCursor) {
                         throw error.failure;
                     }
                     return buildFullJobTimeseriesContinuationResult({
                         context,
+                        historicalProviderRecordsSeen,
+                        historicalRecordsSeen,
                         job,
                         skippedOptionalResources,
+                        sourceProviders,
                         continuation: {
                             timeseriesCursor,
                             timeseriesResourceCursor: resource,
                             timeseriesWindowHours,
                             workoutStreamCursor: error.workoutStreamCursor,
+                            workoutStreamEmptySeen: error.workoutStreamEmptySeen,
                         },
                         window,
                     });
@@ -2838,16 +3267,23 @@ export function createJunctionDeviceSyncProvider(config) {
                         windowStart: timeseriesCursor,
                     };
                 if (Date.parse(importWindow.windowStart) < Date.parse(importWindow.windowEnd)) {
-                    await importJunctionTimeseriesResourceSnapshot({
+                    const timeseriesImport = await importJunctionTimeseriesResourceSnapshot({
                         collectionWorkLimit: JUNCTION_FULL_JOB_TIMESERIES_COLLECTION_WORK_LIMIT,
                         context,
                         dateQueryFormat: timeseriesWindowHours === 1 ? "datetime" : "date",
                         resource,
                         skippedOptionalResources,
-                        sourceProviders: [],
+                        sourceProviderSlug,
+                        sourceProviders,
                         windowEnd: importWindow.windowEnd,
                         windowStart: importWindow.windowStart,
                     });
+                    historicalProviderRecordsSeen ||=
+                        sourceProviderSlug !== null
+                            && timeseriesImport.historicalProviderRecordsSeen === true;
+                    historicalRecordsSeen ||=
+                        sourceProviderSlug !== null
+                            && timeseriesImport.historicalRecordsSeen === true;
                 }
             }
             catch (error) {
@@ -2856,13 +3292,17 @@ export function createJunctionDeviceSyncProvider(config) {
                     && policy?.normalizationMode === "hourly_or_session_feature") {
                     return buildFullJobTimeseriesContinuationResult({
                         context,
+                        historicalProviderRecordsSeen,
+                        historicalRecordsSeen,
                         job,
                         skippedOptionalResources,
+                        sourceProviders,
                         continuation: {
                             timeseriesCursor,
                             timeseriesResourceCursor: resource,
                             timeseriesWindowHours: 1,
                             workoutStreamCursor: null,
+                            workoutStreamEmptySeen: false,
                         },
                         window,
                     });
@@ -2872,8 +3312,12 @@ export function createJunctionDeviceSyncProvider(config) {
         }
         return buildFullJobTimeseriesContinuationResult({
             context,
+            historicalProviderRecordsSeen,
+            historicalRecordsSeen,
             job,
+            replayWindow: workoutStreamReplayWindow,
             skippedOptionalResources,
+            sourceProviders,
             continuation: resolveNextFullJobTimeseriesContinuation({
                 baseTimeseriesWindowStart,
                 executionWindowEnd,
@@ -2887,38 +3331,110 @@ export function createJunctionDeviceSyncProvider(config) {
     }
     async function importJunctionTimeseriesResourceSnapshot(input) {
         const calendarDayAggregate = JUNCTION_CALENDAR_DAY_AGGREGATE_RESOURCE_SET.has(input.resource);
-        if (calendarDayAggregate) {
+        // Temporal-authority fetches carry complete vault-local-day authority with
+        // their own conservative closure lag; the provider calendar-day closure
+        // gate owns only ordinary calendar-day imports.
+        if (calendarDayAggregate && !input.authorizedLocalDay) {
             const windowEndMs = Date.parse(input.windowEnd);
             const globallyClosedProviderDayEnd = resolveGloballyClosedProviderDayEnd(input.windowEnd, input.context.now);
             if (!Number.isFinite(windowEndMs)
                 || !Number.isFinite(globallyClosedProviderDayEnd)
                 || windowEndMs > globallyClosedProviderDayEnd) {
-                return;
+                return { yieldedAt: null };
             }
         }
-        const records = await fetchTimeseriesResourceInChunks(input.context, input.resource, input.windowStart, input.windowEnd, input.skippedOptionalResources, input.sourceProviderSlug, {
+        const skippedResourceCountBeforeFetch = input.skippedOptionalResources.length;
+        const sourceLifecycleFence = resolveJunctionTimeseriesResourcePolicy(input.resource)
+            ?.maxCanonicalRecordsPerWindow !== undefined
+            && input.context.listConnectionSources
+            ? captureJunctionSourceLifecycleFence(input.context.account.sources ?? [])
+            : null;
+        const fetched = await fetchTimeseriesResourceInChunks(input.context, input.resource, input.windowStart, input.windowEnd, input.skippedOptionalResources, input.sourceProviderSlug, {
+            ...(input.authorizedLocalDay
+                ? {
+                    authorizedLocalDay: input.authorizedLocalDay,
+                    // A lossy successful response must never be certified as an
+                    // authoritative empty or partial complete-day replacement.
+                    requireStructurallyCompleteCollection: true,
+                }
+                : {}),
             collectionWorkLimit: input.collectionWorkLimit,
             dateQueryFormat: input.dateQueryFormat,
         });
-        if (records.length === 0) {
-            return;
+        const { providerRecordsSeen } = fetched;
+        const records = scopeJunctionRecordsToSourceProvider(fetched.records, input.sourceProviderSlug);
+        if (input.skippedOptionalResources.length > skippedResourceCountBeforeFetch) {
+            return {
+                historicalProviderRecordsSeen: providerRecordsSeen,
+                historicalRecordsSeen: false,
+                yieldedAt: null,
+            };
         }
-        const preparedImport = await prepareJunctionImportSnapshot(input.context, { [input.resource]: records }, input.sourceProviders, { projectAccountSourceIdentities: calendarDayAggregate });
-        if (!hasJunctionSnapshotRecords(preparedImport.snapshots)) {
-            return;
+        const currentSources = sourceLifecycleFence && input.context.listConnectionSources
+            ? await input.context.listConnectionSources()
+            : null;
+        if (sourceLifecycleFence
+            && (!currentSources
+                || !isJunctionSourceLifecycleFenceCurrent(sourceLifecycleFence, currentSources))) {
+            throw junctionTimeseriesSourceLifecycleSuperseded();
         }
-        await input.context.importSnapshot({
-            provider: "junction",
-            accountId: buildJunctionImportAccountId(input.context.account.externalAccountId),
-            connectionId: input.context.account.id,
+        if (records.length === 0 && !input.authorizedLocalDay) {
+            return {
+                historicalProviderRecordsSeen: providerRecordsSeen,
+                historicalRecordsSeen: false,
+                yieldedAt: null,
+            };
+        }
+        const sourceScopedHistoricalRecordsSeen = input.sourceProviderSlug
+            ? await hasJunctionSourceScopedAdmittedSnapshotRecords({
+                context: input.context,
+                ...(currentSources ? { listedSources: currentSources } : {}),
+                options: { projectAccountSourceIdentities: calendarDayAggregate },
+                snapshots: { [input.resource]: records },
+                sourceProviderSlug: input.sourceProviderSlug,
+                sourceProviders: input.sourceProviders,
+            })
+            : false;
+        const preparedImport = currentSources
+            ? prepareJunctionImportSnapshotForSources({ [input.resource]: records }, input.sourceProviders, currentSources, calendarDayAggregate
+                ? { sourceIdentities: resolveJunctionAccountSourceIdentities(currentSources) }
+                : {}, {
+                allowUnlistedSources: input.context.connectionSourceAdmissionMode !== "listed_only",
+                sourceStatusRequirement: "not_disconnected",
+            })
+            : await prepareJunctionImportSnapshot(input.context, { [input.resource]: records }, input.sourceProviders, { projectAccountSourceIdentities: calendarDayAggregate });
+        if (!hasJunctionSnapshotRecords(preparedImport.snapshots) && !input.authorizedLocalDay) {
+            return {
+                historicalProviderRecordsSeen: providerRecordsSeen,
+                historicalRecordsSeen: sourceScopedHistoricalRecordsSeen,
+                yieldedAt: null,
+            };
+        }
+        await commitPreparedJunctionCanonicalImport(input.context, preparedImport, {
             importedAt: input.windowEnd,
             windowStart: input.windowStart,
             windowEnd: input.windowEnd,
-            ...(calendarDayAggregate ? { timeseriesWindowKind: "calendar_day" } : {}),
-            connections: preparedImport.connections,
+            ...(calendarDayAggregate && !input.authorizedLocalDay
+                ? { timeseriesWindowKind: "calendar_day" }
+                : {}),
             summaries: {},
             timeseries: preparedImport.snapshots,
-        });
+        }, input.context.now, input.authorizedLocalDay
+            ? {
+                completeSourceDay: {
+                    connectionId: buildJunctionImportAccountId(input.context.account.externalAccountId),
+                    dayKey: input.authorizedLocalDay.dayKey,
+                    resources: [input.resource],
+                    revisionAt: input.context.now,
+                    timeZone: input.authorizedLocalDay.timeZone,
+                },
+            }
+            : undefined);
+        return {
+            historicalProviderRecordsSeen: providerRecordsSeen,
+            historicalRecordsSeen: sourceScopedHistoricalRecordsSeen,
+            yieldedAt: null,
+        };
     }
     async function importJunctionWorkoutStreamWindow(input) {
         const policy = resolveJunctionTimeseriesResourcePolicy("workout_stream");
@@ -2928,11 +3444,17 @@ export function createJunctionDeviceSyncProvider(config) {
             throw new TypeError("Junction workout_stream policy did not define bounded limits.");
         }
         let completedIdentities = new Set(input.completedIdentities);
+        let historicalProviderRecordsSeen = false;
+        let historicalRecordsSeen = false;
         let madeProgress = false;
+        let workoutStreamEmptySeen = input.workoutStreamEmptySeen === true;
         const carryTerminalProgressOrThrow = (error) => {
             if (isJunctionJobSignalAbort(error, input.context.signal)) {
                 if (input.allowImmediateYield || madeProgress) {
                     return {
+                        emptyTimestampArraySeen: workoutStreamEmptySeen,
+                        historicalProviderRecordsSeen,
+                        historicalRecordsSeen,
                         madeProgress,
                         workoutStreamCursor: encodeJunctionWorkoutStreamCompletedIdentities(completedIdentities),
                         yieldedAt: input.windowStart,
@@ -2941,13 +3463,40 @@ export function createJunctionDeviceSyncProvider(config) {
                 throw error;
             }
             if (isRetryableDeviceSyncFailure(error)) {
-                throw new JunctionTimeseriesProgressError(error, input.windowStart, encodeJunctionWorkoutStreamCompletedIdentities(completedIdentities));
+                throw new JunctionTimeseriesProgressError(error, input.windowStart, encodeJunctionWorkoutStreamCompletedIdentities(completedIdentities), {
+                    historicalProviderRecordsSeen,
+                    historicalRecordsSeen,
+                    workoutStreamEmptySeen,
+                });
             }
             throw error;
         };
-        let candidates;
+        let eligibleSourceProviderSlugs;
         try {
-            candidates = await listJunctionWorkoutStreamCandidates(client, {
+            eligibleSourceProviderSlugs = await resolveJunctionWorkoutStreamEligibleSources(input.context, input.sourceProviders);
+        }
+        catch (error) {
+            return carryTerminalProgressOrThrow(error);
+        }
+        const sourceScopeProvided = input.sourceProviderSlug !== undefined
+            && input.sourceProviderSlug !== null;
+        const scopedSourceProviderSlug = canonicalizeJunctionProviderSlug(input.sourceProviderSlug);
+        if (eligibleSourceProviderSlugs.size === 0
+            || (sourceScopeProvided
+                && (!scopedSourceProviderSlug
+                    || !eligibleSourceProviderSlugs.has(scopedSourceProviderSlug)))) {
+            return {
+                emptyTimestampArraySeen: workoutStreamEmptySeen,
+                historicalProviderRecordsSeen,
+                historicalRecordsSeen,
+                madeProgress,
+                workoutStreamCursor: null,
+                yieldedAt: null,
+            };
+        }
+        let candidateListing;
+        try {
+            candidateListing = await listJunctionWorkoutStreamCandidates(client, {
                 collectionWorkLimit: input.collectionWorkLimit,
                 resource: "workout_stream",
                 signal: input.context.signal ?? null,
@@ -2955,11 +3504,13 @@ export function createJunctionDeviceSyncProvider(config) {
                 userId: input.context.account.externalAccountId,
                 windowEnd: input.windowEnd,
                 windowStart: input.windowStart,
-            });
+            }, true, eligibleSourceProviderSlugs);
         }
         catch (error) {
             return carryTerminalProgressOrThrow(error);
         }
+        const { candidates } = candidateListing;
+        historicalProviderRecordsSeen = candidateListing.providerRecordsSeen;
         const candidateIdentities = new Set(candidates.map((candidate) => candidate.identity));
         completedIdentities = new Set([...completedIdentities].filter((identity) => candidateIdentities.has(identity)));
         for (const [candidateIndex, candidate] of candidates.entries()) {
@@ -2969,6 +3520,9 @@ export function createJunctionDeviceSyncProvider(config) {
             if (input.context.shouldYield?.()) {
                 if (input.allowImmediateYield || madeProgress) {
                     return {
+                        emptyTimestampArraySeen: workoutStreamEmptySeen,
+                        historicalProviderRecordsSeen,
+                        historicalRecordsSeen,
                         madeProgress,
                         workoutStreamCursor: encodeJunctionWorkoutStreamCompletedIdentities(completedIdentities),
                         yieldedAt: input.windowStart,
@@ -2976,12 +3530,12 @@ export function createJunctionDeviceSyncProvider(config) {
                 }
                 input.context.throwIfAborted?.();
             }
-            let feature;
+            let fetchedFeature;
             try {
-                feature = await fetchJunctionWorkoutStreamFeature(client, candidate, maxSamples, input.context.signal ?? null, input.collectionWorkLimit);
+                fetchedFeature = await fetchJunctionWorkoutStreamFeature(client, candidate, maxSamples, input.context.signal ?? null, input.collectionWorkLimit);
             }
             catch (error) {
-                const failure = classifyOptionalJunctionResourceFailure(error, "timeseries", "workout_stream", input.context.account.externalAccountId);
+                const failure = classifyOptionalJunctionWorkoutStreamCandidateFailure(error, input.context.account.externalAccountId);
                 if (!failure) {
                     return carryTerminalProgressOrThrow(addJunctionWorkoutStreamCandidateFailureContext(error, {
                         aliasSource: candidate.workoutIdAliasSource,
@@ -2999,8 +3553,21 @@ export function createJunctionDeviceSyncProvider(config) {
                 madeProgress = true;
                 continue;
             }
+            const feature = fetchedFeature.feature;
+            if (fetchedFeature.emptyTimestampArray) {
+                input.context.logger.warn?.("Deferring Junction workout with an empty stream.", {
+                    errorCode: "JUNCTION_WORKOUT_STREAM_EMPTY",
+                    provider: "junction",
+                    resource: "workout_stream",
+                    resourceCategory: "timeseries",
+                });
+                completedIdentities.add(candidate.identity);
+                madeProgress = true;
+                workoutStreamEmptySeen = true;
+                continue;
+            }
             if (feature === undefined) {
-                input.context.logger.warn?.("Skipping Junction workout with unaligned metric cardinality.", {
+                input.context.logger.warn?.("Skipping Junction workout without an importable stream feature.", {
                     errorCode: "JUNCTION_WORKOUT_STREAM_CARDINALITY_MISMATCH",
                     provider: "junction",
                     resource: "workout_stream",
@@ -3011,19 +3578,26 @@ export function createJunctionDeviceSyncProvider(config) {
                 continue;
             }
             try {
-                const preparedImport = await prepareJunctionImportSnapshot(input.context, { workout_stream: [feature] }, input.sourceProviders);
+                const sourceScopedFeature = input.sourceProviderSlug
+                    ? withJunctionSourceProviderFallback(feature, input.sourceProviderSlug)
+                    : feature;
+                historicalRecordsSeen ||= input.sourceProviderSlug
+                    ? await hasJunctionSourceScopedAdmittedSnapshotRecords({
+                        context: input.context,
+                        snapshots: { workout_stream: [sourceScopedFeature] },
+                        sourceProviderSlug: input.sourceProviderSlug,
+                        sourceProviders: input.sourceProviders,
+                    })
+                    : false;
+                const preparedImport = await prepareJunctionImportSnapshot(input.context, { workout_stream: [sourceScopedFeature] }, input.sourceProviders);
                 if (hasJunctionSnapshotRecords(preparedImport.snapshots)) {
-                    await input.context.importSnapshot({
-                        provider: "junction",
-                        accountId: buildJunctionImportAccountId(input.context.account.externalAccountId),
-                        connectionId: input.context.account.id,
+                    await commitPreparedJunctionCanonicalImport(input.context, preparedImport, {
                         importedAt: input.windowEnd,
                         windowStart: input.windowStart,
                         windowEnd: input.windowEnd,
-                        connections: preparedImport.connections,
                         summaries: {},
                         timeseries: preparedImport.snapshots,
-                    });
+                    }, input.context.now);
                 }
             }
             catch (error) {
@@ -3033,6 +3607,9 @@ export function createJunctionDeviceSyncProvider(config) {
             madeProgress = true;
         }
         return {
+            emptyTimestampArraySeen: workoutStreamEmptySeen,
+            historicalProviderRecordsSeen,
+            historicalRecordsSeen,
             madeProgress,
             workoutStreamCursor: encodeJunctionWorkoutStreamCompletedIdentities(completedIdentities),
             yieldedAt: null,
@@ -3058,14 +3635,10 @@ export function createJunctionDeviceSyncProvider(config) {
                 normalizationEvidence,
             };
         }
-        const receipt = await context.importSnapshot({
-            provider: "junction",
-            accountId: buildJunctionImportAccountId(context.account.externalAccountId),
-            connectionId: context.account.id,
+        const receipt = await commitPreparedJunctionCanonicalImport(context, preparedImport, {
             importedAt: context.now,
             windowStart,
             windowEnd,
-            connections,
             summaries,
             timeseries: {},
         });
@@ -3100,7 +3673,7 @@ export function createJunctionDeviceSyncProvider(config) {
     }
     async function fetchOptionalJunctionResourceRecords(context, resourceCategory, resource, skippedOptionalResources, load) {
         try {
-            return await load();
+            return await measureJunctionProviderRequest(context, "resource", load);
         }
         catch (error) {
             const failure = classifyOptionalJunctionResourceFailure(error, resourceCategory, resource, context.account.externalAccountId);
@@ -3116,6 +3689,15 @@ export function createJunctionDeviceSyncProvider(config) {
             return [];
         }
     }
+    async function measureJunctionProviderRequest(context, category, load) {
+        const startedAt = performance.now();
+        try {
+            return await load();
+        }
+        finally {
+            context.recordProviderRequestTiming?.(category, Math.max(0, performance.now() - startedAt));
+        }
+    }
     function logSkippedOptionalJunctionResource(context, resourceCategory, resource, failure) {
         context.logger.warn?.("Skipping unavailable Junction resource response.", {
             errorCode: "JUNCTION_API_REQUEST_FAILED",
@@ -3161,8 +3743,26 @@ export function createJunctionDeviceSyncProvider(config) {
         if (retryDelayMs === null) {
             return null;
         }
+        const sourceProviderSlug = normalizeProviderSlug(input.job.payload.sourceProviderSlug);
+        const historicalProofAuthorization = readJunctionHistoricalProofAuthorization(input.job);
         const retryJob = buildExactWindowJob({
             kind: "backfill",
+            payload: {
+                emptyBackfillAttempts,
+                ...(sourceProviderSlug ? { sourceProviderSlug } : {}),
+                ...(historicalProofAuthorization
+                    ? {
+                        historicalProofFirstSeenAt: historicalProofAuthorization.firstSeenAt,
+                        historicalProofSourceProviderSlug: historicalProofAuthorization.sourceProviderSlug,
+                    }
+                    : {}),
+                ...(input.historicalProviderRecordsSeen
+                    ? { historicalProviderRecordsSeen: true }
+                    : {}),
+                ...(input.historicalRecordsSeen
+                    ? { historicalRecordsSeen: true }
+                    : {}),
+            },
             priority: Math.max(input.job.priority, JUNCTION_HISTORICAL_BACKFILL_RETRY_PRIORITY),
             windowEnd: input.window.windowEnd,
             windowStart: input.window.windowStart,
@@ -3170,33 +3770,67 @@ export function createJunctionDeviceSyncProvider(config) {
         return {
             ...retryJob,
             availableAt: addMilliseconds(input.now, retryDelayMs),
-            payload: {
-                ...(retryJob.payload ?? {}),
-                emptyBackfillAttempts,
-            },
         };
     }
-    function buildFullJobTimeseriesContinuationResult(input) {
-        const continuationJob = input.continuation
+    async function completeSourceScopedHistoricalBackfill(input) {
+        const historicalProofAuthorization = readJunctionHistoricalProofAuthorization(input.job);
+        if (!input.sourceProviderSlug
+            || !historicalProofAuthorization
+            || !await isJunctionHistoricalProofAuthorizationCurrent(input.context, historicalProofAuthorization)
+            || (input.historicalProviderRecordsSeen && !input.historicalRecordsSeen)
+            || !input.sourceProviders.some((provider) => areJunctionProviderSlugsDataEquivalent(provider.origin.sourceProviderSlug ?? provider.slug, input.sourceProviderSlug))) {
+            return;
+        }
+        await projectJunctionSources(input.context, input.sourceProviders, {
+            historicalBackfillCompletedProviderSlug: input.sourceProviderSlug,
+        });
+    }
+    async function buildFullJobTimeseriesContinuationResult(input) {
+        const historicalProofAuthorization = readJunctionHistoricalProofAuthorization(input.job);
+        const historicalProofStillCurrent = !historicalProofAuthorization
+            || await isJunctionHistoricalProofAuthorizationCurrent(input.context, historicalProofAuthorization);
+        const continuationJob = input.continuation && historicalProofStillCurrent
             ? buildFullJobTimeseriesContinuationJob({
                 deferredEmptyBackfillAttempts: readHistoricalBackfillJobEmptyAttempts(input.job),
+                historicalProviderRecordsSeen: input.historicalProviderRecordsSeen,
+                historicalRecordsSeen: input.historicalRecordsSeen,
                 job: input.job,
                 ...input.continuation,
                 window: input.window,
             })
             : null;
-        const scheduledJob = continuationJob
-            ? { ...continuationJob, availableAt: input.context.now }
-            : buildDeferredNonConnectHistoricalBackfillRetry({
-                account: input.context.account,
+        const scheduledJob = !historicalProofStillCurrent
+            ? null
+            : continuationJob
+                ? { ...continuationJob, availableAt: input.context.now }
+                : buildDeferredNonConnectHistoricalBackfillRetry({
+                    account: input.context.account,
+                    historicalProviderRecordsSeen: input.historicalProviderRecordsSeen,
+                    historicalRecordsSeen: input.historicalRecordsSeen,
+                    job: input.job,
+                    now: input.context.now,
+                    window: input.window,
+                });
+        if (!scheduledJob && input.job.kind === "backfill") {
+            await completeSourceScopedHistoricalBackfill({
+                context: input.context,
+                historicalProviderRecordsSeen: input.historicalProviderRecordsSeen,
+                historicalRecordsSeen: input.historicalRecordsSeen,
                 job: input.job,
-                now: input.context.now,
-                window: input.window,
+                sourceProviderSlug: normalizeProviderSlug(input.job.payload.sourceProviderSlug),
+                sourceProviders: input.sourceProviders,
             });
-        return withJunctionSkippedResourceMetadata(input.context, {
-            ...(scheduledJob ? { scheduledJobs: [scheduledJob] } : {}),
-            nextReconcileAt: resolveJunctionNextReconcileAt(input.context.account, input.context.now, addMilliseconds(input.context.now, reconcileIntervalMs)),
-        }, input.skippedOptionalResources);
+        }
+        return withJunctionWorkoutStreamEmptyReplay({
+            job: input.job,
+            now: input.context.now,
+            replayWindow: input.replayWindow,
+            result: withJunctionSkippedResourceMetadata(input.context, {
+                ...(scheduledJob ? { scheduledJobs: [scheduledJob] } : {}),
+                nextReconcileAt: resolveJunctionNextReconcileAt(input.context.account, input.context.now, addMilliseconds(input.context.now, reconcileIntervalMs)),
+            }, input.skippedOptionalResources),
+            sourceProviderSlug: normalizeProviderSlug(input.job.payload.sourceProviderSlug),
+        });
     }
     function buildFullJobTimeseriesContinuationJob(input) {
         if (input.job.kind !== "backfill" && input.job.kind !== "reconcile") {
@@ -3212,7 +3846,12 @@ export function createJunctionDeviceSyncProvider(config) {
             })) {
             return null;
         }
-        const sourceProviderSlug = normalizeProviderSlug(input.job.payload.sourceProviderSlug);
+        const sourceProviderSlug = canonicalizeJunctionProviderSlug(input.job.payload.sourceProviderSlug);
+        const historicalProofAuthorization = readJunctionHistoricalProofAuthorization(input.job);
+        const historicalProviderRecordsSeen = input.historicalProviderRecordsSeen === true
+            || input.job.payload.historicalProviderRecordsSeen === true;
+        const historicalRecordsSeen = input.historicalRecordsSeen === true
+            || input.job.payload.historicalRecordsSeen === true;
         return buildExactWindowJob({
             kind: input.job.kind,
             payload: {
@@ -3220,12 +3859,27 @@ export function createJunctionDeviceSyncProvider(config) {
                     ? { emptyBackfillAttempts: input.deferredEmptyBackfillAttempts }
                     : {}),
                 ...(sourceProviderSlug ? { sourceProviderSlug } : {}),
+                ...(historicalProofAuthorization
+                    ? {
+                        historicalProofFirstSeenAt: historicalProofAuthorization.firstSeenAt,
+                        historicalProofSourceProviderSlug: historicalProofAuthorization.sourceProviderSlug,
+                    }
+                    : {}),
+                ...(input.job.kind === "backfill" && historicalProviderRecordsSeen
+                    ? { historicalProviderRecordsSeen: true }
+                    : {}),
+                ...(input.job.kind === "backfill" && historicalRecordsSeen
+                    ? { historicalRecordsSeen: true }
+                    : {}),
                 timeseriesCursor: input.timeseriesCursor,
                 timeseriesResourceCursor,
                 ...(input.timeseriesWindowHours === 1 ? { timeseriesWindowHours: 1 } : {}),
                 ...(input.workoutStreamCursor
                     ? { workoutStreamCursor: input.workoutStreamCursor }
                     : {}),
+                ...(input.workoutStreamEmptySeen
+                    ? { workoutStreamEmptySeen: true }
+                    : {}),
             },
             priority: input.job.priority,
             windowEnd: input.window.windowEnd,
@@ -3236,7 +3890,7 @@ export function createJunctionDeviceSyncProvider(config) {
         if (Date.parse(input.windowStart) >= Date.parse(input.windowEnd)) {
             return null;
         }
-        const sourceProviderSlug = normalizeProviderSlug(input.job.payload.sourceProviderSlug);
+        const sourceProviderSlug = canonicalizeJunctionProviderSlug(input.job.payload.sourceProviderSlug);
         if (input.job.kind !== "resource") {
             return null;
         }
@@ -3264,6 +3918,9 @@ export function createJunctionDeviceSyncProvider(config) {
             windowEnd: input.windowEnd,
             windowStart: input.windowStart,
             workoutStreamCursor: input.workoutStreamCursor || undefined,
+            workoutStreamEmptySeen: input.workoutStreamEmptySeen === true
+                ? true
+                : undefined,
         });
         return {
             kind: "resource",
@@ -3300,31 +3957,41 @@ export function createJunctionDeviceSyncProvider(config) {
             && normalizeString(account.metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.windowStart]) === connectWindow.windowStart
             && normalizeString(account.metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.windowEnd]) === connectWindow.windowEnd;
     }
-    function buildInitialJobs(now, sourceProviderSlug) {
-        const normalizedSourceProviderSlug = normalizeProviderSlug(sourceProviderSlug);
-        const payload = normalizedSourceProviderSlug
-            ? { sourceProviderSlug: normalizedSourceProviderSlug }
+    function buildInitialJobs(now, sourceProviderSlug, historicalProofAuthorization) {
+        const normalizedSourceProviderSlug = canonicalizeJunctionProviderSlug(sourceProviderSlug);
+        const sourcePayload = normalizedSourceProviderSlug
+            ? {
+                sourceProviderSlug: normalizedSourceProviderSlug,
+            }
             : undefined;
         return [
             buildWindowJob({
                 kind: "backfill",
                 now,
-                payload,
+                payload: sourcePayload && historicalProofAuthorization
+                    ? {
+                        ...sourcePayload,
+                        historicalProofFirstSeenAt: historicalProofAuthorization.firstSeenAt,
+                        historicalProofSourceProviderSlug: historicalProofAuthorization.sourceProviderSlug,
+                    }
+                    : sourcePayload,
                 windowStart: subtractDays(now, summaryBackfillDays),
                 priority: JUNCTION_HISTORICAL_BACKFILL_PRIORITY,
             }),
             buildWindowJob({
                 kind: "reconcile",
                 now,
-                payload,
+                payload: sourcePayload,
                 windowStart: subtractDays(now, reconcileDays),
                 priority: JUNCTION_SCHEDULED_RECONCILE_PRIORITY,
             }),
         ];
     }
     function buildSourceConnectionWork(input) {
+        const sourceProviderSlug = normalizeProviderSlug(input.sourceProviderSlug);
+        const historicalProofAuthorization = normalizeJunctionHistoricalProofAuthorization(input.historicalProofAuthorization);
         return {
-            initialJobs: buildInitialJobs(input.now, input.sourceProviderSlug),
+            initialJobs: buildInitialJobs(input.now, sourceProviderSlug, historicalProofAuthorization),
             nextReconcileAt: addMilliseconds(input.now, reconcileIntervalMs),
         };
     }
@@ -3370,32 +4037,207 @@ async function fetchJunctionTimeseriesWindow(junctionClient, input) {
         if (!maxSamples) {
             throw new TypeError("Junction workout_stream policy did not define bounded limits.");
         }
-        const candidates = await listJunctionWorkoutStreamCandidates(junctionClient, input);
+        const { candidates } = await listJunctionWorkoutStreamCandidates(junctionClient, input);
         const features = [];
         for (const candidate of candidates) {
-            const feature = await fetchJunctionWorkoutStreamFeature(junctionClient, candidate, maxSamples, input.signal ?? null);
+            const { feature } = await fetchJunctionWorkoutStreamFeature(junctionClient, candidate, maxSamples, input.signal ?? null);
             if (feature !== undefined) {
                 features.push(feature);
             }
         }
         return features;
     }
+    if (policy.normalizationMode === "ecg_recording_feature") {
+        if (!policy.maxRecordsPerWindow || !policy.maxSamplesPerWindow) {
+            throw new TypeError("Junction ECG voltage policy did not define bounded limits.");
+        }
+        return fetchJunctionElectrocardiogramVoltageFeatures(junctionClient, input, {
+            maxRecordings: policy.maxRecordsPerWindow,
+            maxSamples: policy.maxSamplesPerWindow,
+        });
+    }
     const records = await junctionClient.listTimeseries({
         ...input,
         maxRecords: input.maxRecords ?? policy.maxSamplesPerWindow,
     });
-    if (policy.normalizationMode !== "ecg_recording_feature") {
-        return records;
+    return records;
+}
+async function fetchJunctionElectrocardiogramVoltageFeatures(junctionClient, input, limits) {
+    const summaries = await junctionClient.listSummary({
+        collectionWorkLimit: input.collectionWorkLimit,
+        maxRecords: limits.maxRecordings + 1,
+        resource: "electrocardiogram",
+        signal: input.signal ?? null,
+        sourceProviderSlug: input.sourceProviderSlug,
+        userId: input.userId,
+        windowEnd: input.windowEnd,
+        windowStart: input.windowStart,
+    });
+    const candidates = selectJunctionElectrocardiogramRecordingCandidates(summaries, {
+        maxRecordings: limits.maxRecordings,
+        requestedSourceProviderSlug: input.sourceProviderSlug,
+        windowEnd: input.windowEnd,
+        windowStart: input.windowStart,
+    });
+    const expectedSampleCount = candidates.reduce((total, candidate) => total + candidate.voltageSampleCount, 0);
+    if (expectedSampleCount > limits.maxSamples) {
+        throw junctionElectrocardiogramBindingError("sample_limit_exceeded", {
+            expectedSampleCount,
+            maxSampleCount: limits.maxSamples,
+        });
+    }
+    const features = [];
+    for (const candidate of candidates) {
+        if (candidate.voltageSampleCount === 0) {
+            continue;
+        }
+        const samples = await junctionClient.listElectrocardiogramVoltage({
+            collectionWorkLimit: input.collectionWorkLimit,
+            maxRecords: candidate.voltageSampleCount + 1,
+            recordingId: candidate.recordingId,
+            signal: input.signal ?? null,
+            sourceInstanceId: candidate.sourceInstanceId,
+            sourceProviderSlug: candidate.sourceProviderSlug,
+            sourceType: candidate.sourceType,
+            userId: input.userId,
+            windowEnd: candidate.sessionEnd,
+            windowStart: candidate.sessionStart,
+        });
+        let candidateFeatures;
+        try {
+            candidateFeatures = reduceJunctionElectrocardiogramVoltageRecords(samples, { maxRecordings: 1, maxSamples: limits.maxSamples });
+        }
+        catch (error) {
+            if (isDeviceSyncError(error)) {
+                throw error;
+            }
+            throw junctionElectrocardiogramBindingError("sample_normalization_invalid");
+        }
+        const feature = candidateFeatures[0];
+        if (!feature || candidateFeatures.length !== 1) {
+            throw junctionElectrocardiogramBindingError("feature_cardinality_mismatch", {
+                actualRecordingCount: candidateFeatures.length,
+                expectedRecordingCount: 1,
+            });
+        }
+        const actualSampleCount = readJunctionElectrocardiogramSampleCount(feature);
+        if (actualSampleCount !== candidate.voltageSampleCount) {
+            throw junctionElectrocardiogramBindingError("sample_count_mismatch", {
+                actualSampleCount: actualSampleCount ?? 0,
+                expectedSampleCount: candidate.voltageSampleCount,
+            });
+        }
+        features.push(feature);
+    }
+    return features;
+}
+function selectJunctionElectrocardiogramRecordingCandidates(summaries, input) {
+    const windowStartMs = Date.parse(input.windowStart);
+    const windowEndMs = Date.parse(input.windowEnd);
+    if (!Number.isFinite(windowStartMs)
+        || !Number.isFinite(windowEndMs)
+        || windowEndMs <= windowStartMs) {
+        throw new TypeError("Junction ECG collection window was invalid.");
+    }
+    const selected = new Map();
+    for (const value of summaries) {
+        const summary = readPlainObject(value);
+        const recordingId = normalizeString(summary?.id);
+        const sessionStart = readJunctionElectrocardiogramTimestamp(summary, ["sessionStart", "session_start"]);
+        const sessionEnd = readJunctionElectrocardiogramTimestamp(summary, ["sessionEnd", "session_end"]);
+        const voltageSampleCount = readJunctionElectrocardiogramSampleCount(summary);
+        if (!summary || !recordingId || !sessionStart || !sessionEnd || voltageSampleCount === null) {
+            throw junctionElectrocardiogramBindingError("summary_identity_incomplete");
+        }
+        const sessionStartMs = Date.parse(sessionStart);
+        const sessionEndMs = Date.parse(sessionEnd);
+        if (sessionEndMs < sessionStartMs) {
+            throw junctionElectrocardiogramBindingError("summary_window_invalid");
+        }
+        if (sessionStartMs < windowStartMs || sessionStartMs >= windowEndMs) {
+            continue;
+        }
+        const unresolvedOrigin = resolveJunctionOrigin(summary);
+        const canonicalSourceProviderSlug = canonicalizeJunctionProviderSlug(unresolvedOrigin.sourceProviderSlug);
+        const origin = resolveJunctionOrigin({
+            ...summary,
+            sourceProviderSlug: canonicalSourceProviderSlug
+                ?? unresolvedOrigin.sourceProviderSlug,
+        });
+        const sourceProviderSlug = normalizeJunctionSourceProviderSlug(origin.sourceProviderSlug);
+        if (!sourceProviderSlug
+            || (input.requestedSourceProviderSlug
+                && !areJunctionProviderSlugsDataEquivalent(sourceProviderSlug, input.requestedSourceProviderSlug))) {
+            throw junctionElectrocardiogramBindingError("summary_source_inconsistent");
+        }
+        const candidate = {
+            recordingId,
+            sessionEnd,
+            sessionStart,
+            sourceInstanceId: normalizeString(origin.sourceInstanceId),
+            sourceProviderSlug,
+            sourceType: normalizeString(origin.sourceType),
+            voltageSampleCount,
+        };
+        const existing = selected.get(recordingId);
+        if (existing && JSON.stringify(existing) !== JSON.stringify(candidate)) {
+            throw junctionElectrocardiogramBindingError("summary_identity_conflict");
+        }
+        selected.set(recordingId, candidate);
+    }
+    if (selected.size > input.maxRecordings) {
+        throw junctionElectrocardiogramBindingError("recording_limit_exceeded", {
+            actualRecordingCount: selected.size,
+            maxRecordingCount: input.maxRecordings,
+        });
     }
-    if (!policy.maxRecordsPerWindow || !policy.maxSamplesPerWindow) {
-        throw new TypeError("Junction ECG voltage policy did not define bounded limits.");
+    const candidates = [...selected.values()].sort((left, right) => left.sessionStart.localeCompare(right.sessionStart)
+        || left.recordingId.localeCompare(right.recordingId));
+    const latestEndBySource = new Map();
+    for (const candidate of candidates) {
+        const sourceIdentity = JSON.stringify([
+            candidate.sourceProviderSlug,
+            candidate.sourceType ?? null,
+            candidate.sourceInstanceId ?? null,
+        ]);
+        const latestEnd = latestEndBySource.get(sourceIdentity);
+        if (latestEnd !== undefined && Date.parse(candidate.sessionStart) < latestEnd) {
+            throw junctionElectrocardiogramBindingError("summary_windows_ambiguous");
+        }
+        latestEndBySource.set(sourceIdentity, Date.parse(candidate.sessionEnd));
     }
-    return reduceJunctionElectrocardiogramVoltageRecords(records, {
-        maxRecordings: policy.maxRecordsPerWindow,
-        maxSamples: policy.maxSamplesPerWindow,
+    return candidates;
+}
+function readJunctionElectrocardiogramTimestamp(summary, keys) {
+    for (const key of keys) {
+        const value = summary?.[key];
+        const timestamp = value instanceof Date
+            ? value.getTime()
+            : Date.parse(normalizeString(value) ?? "");
+        if (Number.isFinite(timestamp)) {
+            return new Date(timestamp).toISOString();
+        }
+    }
+    return null;
+}
+function readJunctionElectrocardiogramSampleCount(summary) {
+    const value = summary?.voltageSampleCount ?? summary?.voltage_sample_count;
+    return typeof value === "number"
+        && Number.isSafeInteger(value)
+        && value >= 0
+        ? value
+        : null;
+}
+function junctionElectrocardiogramBindingError(reason, details = {}) {
+    return deviceSyncError({
+        code: "JUNCTION_ECG_RECORDING_BINDING_INCOMPLETE",
+        details: { reason, ...details },
+        message: "Junction ECG summary and voltage response were inconsistent.",
+        retryable: true,
+        httpStatus: 502,
     });
 }
-async function listJunctionWorkoutStreamCandidates(junctionClient, input) {
+async function listJunctionWorkoutStreamCandidates(junctionClient, input, strictSourceScope = false, eligibleSourceProviderSlugs) {
     const maxWorkouts = resolveJunctionTimeseriesResourcePolicy("workout_stream")
         ?.maxRecordsPerWindow;
     if (!maxWorkouts) {
@@ -3409,10 +4251,25 @@ async function listJunctionWorkoutStreamCandidates(junctionClient, input) {
         userId: input.userId,
         windowStart: input.windowStart,
         windowEnd: input.windowEnd,
-        maxRecords: maxWorkouts + 1,
     });
-    const summaries = indexRecords.map((record) => withJunctionSourceProviderFallback(record, input.sourceProviderSlug));
-    return selectJunctionWorkoutStreamCandidates(summaries, maxWorkouts);
+    const summaries = strictSourceScope
+        ? scopeJunctionRecordsToSourceProvider(indexRecords, input.sourceProviderSlug)
+        : indexRecords.map((record) => withJunctionSourceProviderFallback(record, input.sourceProviderSlug));
+    const eligibleSummaries = eligibleSourceProviderSlugs === undefined
+        ? summaries
+        : summaries.filter((summary) => {
+            const summaryRecord = readPlainObject(summary);
+            if (!summaryRecord) {
+                return false;
+            }
+            const sourceProviderSlug = canonicalizeJunctionProviderSlug(resolveJunctionOrigin(summaryRecord).sourceProviderSlug);
+            return sourceProviderSlug !== null
+                && eligibleSourceProviderSlugs.has(sourceProviderSlug);
+        });
+    return {
+        candidates: selectJunctionWorkoutStreamCandidates(eligibleSummaries, maxWorkouts),
+        providerRecordsSeen: indexRecords.length > 0,
+    };
 }
 async function fetchJunctionWorkoutStreamFeature(junctionClient, candidate, maxSamples, signal, collectionWorkLimit) {
     const stream = await junctionClient.getWorkoutStream({
@@ -3420,11 +4277,26 @@ async function fetchJunctionWorkoutStreamFeature(junctionClient, candidate, maxS
         signal,
         workoutId: candidate.workoutId,
     });
-    return reduceJunctionWorkoutStreamPayload({
-        maxSamples,
-        stream,
-        summary: candidate.summary,
-    });
+    try {
+        return {
+            emptyTimestampArray: false,
+            feature: reduceJunctionWorkoutStreamPayload({
+                maxSamples,
+                stream,
+                summary: candidate.summary,
+            }),
+        };
+    }
+    catch (error) {
+        if (error instanceof JunctionWorkoutStreamTimestampCardinalityError
+            && error.diagnostic.kind === "empty") {
+            return {
+                emptyTimestampArray: true,
+                feature: undefined,
+            };
+        }
+        throw error;
+    }
 }
 function withJunctionSourceProviderFallback(value, sourceProviderSlug) {
     const record = readPlainObject(value);
@@ -3434,6 +4306,24 @@ function withJunctionSourceProviderFallback(value, sourceProviderSlug) {
     }
     return { ...record, sourceProviderSlug: normalizedSource };
 }
+function scopeJunctionRecordsToSourceProvider(records, sourceProviderSlug) {
+    const normalizedSource = normalizeProviderSlug(sourceProviderSlug);
+    if (!normalizedSource) {
+        return [...records];
+    }
+    return records.flatMap((record) => {
+        const scopedRecord = withJunctionSourceProviderFallback(record, normalizedSource);
+        const scopedRecordObject = readPlainObject(scopedRecord);
+        if (!scopedRecordObject) {
+            return [];
+        }
+        const recordSourceProviderSlug = normalizeProviderSlug(resolveJunctionOrigin(scopedRecordObject).sourceProviderSlug);
+        return recordSourceProviderSlug
+            && areJunctionProviderSlugsDataEquivalent(recordSourceProviderSlug, normalizedSource)
+            ? [scopedRecord]
+            : [];
+    });
+}
 function withJunctionSkippedResourceMetadata(context, result, skippedOptionalResources) {
     if (skippedOptionalResources.length === 0) {
         return result;
@@ -3558,6 +4448,24 @@ function classifyOptionalJunctionResourceFailure(error, resourceCategory, resour
         ...(responseDetail ? { responseDetail } : {}),
     };
 }
+function classifyOptionalJunctionWorkoutStreamCandidateFailure(error, accountExternalId) {
+    const existing = classifyOptionalJunctionResourceFailure(error, "timeseries", "workout_stream", accountExternalId);
+    if (existing) {
+        return existing;
+    }
+    if (!isDeviceSyncError(error)
+        || error.code !== "JUNCTION_API_REQUEST_FAILED"
+        || error.details?.status !== 400) {
+        return null;
+    }
+    const reason = classifyClearOptionalJunctionResourceFailureReason({
+        responseErrorCode: readJunctionDiagnosticString(error.details.responseErrorCode),
+        responseErrorDescription: readJunctionDiagnosticString(error.details.responseErrorDescription),
+    });
+    return reason === "unsupported"
+        ? { reason, responseStatus: 400 }
+        : null;
+}
 function isRetryableDeviceSyncFailure(error) {
     return isDeviceSyncError(error) && error.retryable;
 }
@@ -4486,13 +5394,6 @@ function resolveJunctionProviderRouteSlug(value) {
     return resolveJunctionDeviceConnectRouteByProviderSlug(normalized)?.route.sourceProviderSlug
         ?? normalized;
 }
-function areJunctionProviderSlugsRouteEquivalent(left, right) {
-    const normalizedLeft = normalizeProviderSlug(left);
-    const normalizedRight = normalizeProviderSlug(right);
-    return normalizedLeft !== null
-        && normalizedRight !== null
-        && areJunctionDeviceConnectProviderSlugsEquivalent(normalizedLeft, normalizedRight);
-}
 function resolveJunctionAccountSourceIdentities(sources) {
     const identities = [];
     for (const source of sources) {
@@ -4507,7 +5408,7 @@ function resolveJunctionAccountSourceIdentities(sources) {
 function resolveJunctionAccountSourceStates(sources) {
     const states = [];
     for (const source of sources) {
-        if (states.some((state) => areJunctionProviderSlugsRouteEquivalent(state.identitySource.sourceProviderSlug, source.sourceProviderSlug))) {
+        if (states.some((state) => areJunctionProviderSlugsDataEquivalent(state.identitySource.sourceProviderSlug, source.sourceProviderSlug))) {
             continue;
         }
         const state = resolveJunctionAccountSourceState(sources, source.sourceProviderSlug);
@@ -4520,7 +5421,7 @@ function resolveJunctionAccountSourceStates(sources) {
 function mergeJunctionAccountSourceIdentities(accountSourceIdentities, requestedSourceIdentities) {
     return [
         ...accountSourceIdentities,
-        ...requestedSourceIdentities.filter((requestedIdentity) => !accountSourceIdentities.some((accountIdentity) => areJunctionProviderSlugsRouteEquivalent(requestedIdentity.sourceProviderSlug, accountIdentity.sourceProviderSlug))),
+        ...requestedSourceIdentities.filter((requestedIdentity) => !accountSourceIdentities.some((accountIdentity) => areJunctionProviderSlugsDataEquivalent(requestedIdentity.sourceProviderSlug, accountIdentity.sourceProviderSlug))),
     ];
 }
 function resolveJunctionAccountSourceIdentity(sources, sourceProviderSlug, allowUnlistedSource = false) {
@@ -4559,7 +5460,7 @@ function findJunctionAccountSource(sources, sourceProviderSlug) {
         ?.identitySource;
 }
 function findJunctionAccountSources(sources, sourceProviderSlug) {
-    return sources.filter((source) => areJunctionProviderSlugsRouteEquivalent(source.sourceProviderSlug, sourceProviderSlug));
+    return sources.filter((source) => areJunctionProviderSlugsDataEquivalent(source.sourceProviderSlug, sourceProviderSlug));
 }
 function resolveJunctionAccountSourceState(sources, sourceProviderSlug) {
     const [first, ...rest] = findJunctionAccountSources(sources, sourceProviderSlug);
@@ -4574,7 +5475,7 @@ function stripUndefined(value) {
 function sanitizeJunctionImportConnections(providers, sourceIdentities = []) {
     return providers.map((provider) => {
         const sourceProviderSlug = provider.origin.sourceProviderSlug ?? provider.slug;
-        const projectedSourceIdentity = sourceIdentities.find((identity) => areJunctionProviderSlugsRouteEquivalent(sourceProviderSlug, identity.sourceProviderSlug));
+        const projectedSourceIdentity = sourceIdentities.find((identity) => areJunctionProviderSlugsDataEquivalent(sourceProviderSlug, identity.sourceProviderSlug));
         return stripUndefined({
             sourceProviderSlug: projectedSourceIdentity?.sourceProviderSlug ?? sourceProviderSlug,
             sourceInstanceId: projectedSourceIdentity?.sourceInstanceId ?? provider.origin.sourceInstanceId,
@@ -4593,11 +5494,40 @@ async function prepareJunctionImportSnapshot(context, snapshots, providers, opti
         sourceStatusRequirement,
     });
 }
+async function hasJunctionSourceScopedAdmittedSnapshotRecords(input) {
+    const listedSources = input.listedSources
+        ?? (input.context.listConnectionSources
+            ? await input.context.listConnectionSources({
+                sourceProviderSlug: input.sourceProviderSlug,
+            })
+            : input.context.account.sources ?? []);
+    const sourceAuthorities = listedSources.filter((source) => areJunctionProviderSlugsDataEquivalent(source.sourceProviderSlug, input.sourceProviderSlug));
+    const sourceProviders = input.sourceProviders.filter((provider) => areJunctionProviderSlugsDataEquivalent(provider.origin.sourceProviderSlug ?? provider.slug, input.sourceProviderSlug));
+    if (sourceAuthorities.length === 0 || sourceProviders.length === 0) {
+        return false;
+    }
+    const options = input.options ?? {};
+    const sourceIdentities = options.projectAccountSourceIdentities
+        ? mergeJunctionAccountSourceIdentities(resolveJunctionAccountSourceIdentities(sourceAuthorities), options.sourceIdentities ?? [])
+        : options.sourceIdentities;
+    const prepared = prepareJunctionImportSnapshotForSources(input.snapshots, sourceProviders, sourceAuthorities, {
+        ...options,
+        ...(sourceIdentities ? { sourceIdentities } : {}),
+    }, {
+        allowUnlistedSources: false,
+        sourceStatusRequirement: "not_disconnected",
+    });
+    // This is evidence that the source-scoped historical pull produced an
+    // admitted record. Canonical import still evaluates every account source,
+    // preserving the Fitbit writer fence until cutover is actually ready.
+    return hasJunctionSnapshotRecords(prepared.snapshots);
+}
 function prepareJunctionImportSnapshotForSources(snapshots, providers, currentSources, options = {}, admission = {}) {
     const allowUnlistedSources = admission.allowUnlistedSources ?? true;
     const sourceStatusRequirement = admission.sourceStatusRequirement ?? "not_disconnected";
     const sourceProviders = providers.filter((provider) => isJunctionSourceAdmittedForImport(currentSources, provider.origin.sourceProviderSlug ?? provider.slug, allowUnlistedSources, sourceStatusRequirement));
     return {
+        canonicalCoverageFence: buildJunctionGoogleHealthCanonicalCoverageFence(currentSources),
         connections: sanitizeJunctionImportConnections(sourceProviders, options.sourceIdentities),
         sourceProviders,
         snapshots: sanitizeJunctionImportSnapshots(filterJunctionImportSnapshots(snapshots, providers, currentSources, allowUnlistedSources, sourceStatusRequirement), providers, options),
@@ -4614,15 +5544,133 @@ function filterJunctionImportSnapshots(snapshots, providers, sources, allowUnlis
         records.filter((record) => isJunctionImportRecordAdmitted(record, sourceReferences, sources, hasPendingSourceAdmission, allowUnlistedSources, sourceStatusRequirement)),
     ]));
 }
+async function commitPreparedJunctionCanonicalImport(context, preparedImport, snapshot, providerPulledAt, importOptions) {
+    const receipt = await context.importSnapshot({
+        provider: "junction",
+        accountId: buildJunctionImportAccountId(context.account.externalAccountId),
+        connectionId: context.account.id,
+        ...snapshot,
+        connections: preparedImport.connections,
+        canonicalCoverageFence: preparedImport.canonicalCoverageFence,
+        ...(providerPulledAt
+            ? { canonicalCoverageProviderPulledAt: providerPulledAt }
+            : {}),
+    }, importOptions);
+    await recordAcceptedJunctionFitbitCoverage(context, receipt);
+    return receipt;
+}
+async function recordAcceptedJunctionFitbitCoverage(context, receipt) {
+    const canonicalCoverage = readProviderSnapshotJunctionCanonicalCoverage(receipt);
+    if (!readProviderSnapshotDurableDeliveryAccepted(receipt)
+        || canonicalCoverage.length === 0
+        || !context.upsertConnectionSource) {
+        return;
+    }
+    const coverageByResource = new Map();
+    for (const evidence of canonicalCoverage) {
+        if (normalizeProviderSlug(evidence.sourceProviderSlug)
+            !== JUNCTION_FITBIT_LEGACY_PROVIDER_SLUG
+            || !buildDeviceSyncSourceCanonicalCoverageBoundaryKey(evidence.resource)) {
+            continue;
+        }
+        const existing = coverageByResource.get(evidence.resource);
+        const coverageBoundary = existing
+            ? maxJunctionCanonicalCoverageBoundary(evidence.resource, existing.coverageBoundary, evidence.coverageBoundary)
+            : evidence.coverageBoundary;
+        coverageByResource.set(evidence.resource, {
+            coverageBoundary,
+            coverageFinalizedAt: coverageBoundary === evidence.coverageBoundary
+                ? evidence.coverageFinalizedAt ?? existing?.coverageFinalizedAt
+                : existing?.coverageFinalizedAt,
+        });
+    }
+    if (coverageByResource.size === 0) {
+        return;
+    }
+    const sources = context.listConnectionSources
+        ? await context.listConnectionSources({
+            sourceProviderSlug: JUNCTION_FITBIT_LEGACY_PROVIDER_SLUG,
+        })
+        : context.account.sources ?? [];
+    const legacy = sources.find((source) => normalizeProviderSlug(source.sourceProviderSlug)
+        === JUNCTION_FITBIT_LEGACY_PROVIDER_SLUG);
+    if (!legacy || legacy.status === "disconnected") {
+        return;
+    }
+    const resourceAvailabilitySummary = {
+        ...(legacy.resourceAvailabilitySummary ?? {}),
+    };
+    let changed = false;
+    for (const [resource, coverage] of coverageByResource) {
+        const key = buildDeviceSyncSourceCanonicalCoverageBoundaryKey(resource);
+        if (!key) {
+            continue;
+        }
+        const existingCoverage = readDeviceSyncSourceCanonicalCoverageBoundary(resourceAvailabilitySummary, resource);
+        const coverageAdvanced = !existingCoverage
+            || maxJunctionCanonicalCoverageBoundary(resource, existingCoverage, coverage.coverageBoundary) !== existingCoverage;
+        if (coverageAdvanced) {
+            resourceAvailabilitySummary[key] = coverage.coverageBoundary;
+            changed = true;
+        }
+        const finalizedAtKey = buildDeviceSyncSourceCanonicalCoverageFinalizedAtKey(resource);
+        if (!finalizedAtKey) {
+            continue;
+        }
+        const existingFinalizedAt = readDeviceSyncSourceCanonicalCoverageFinalizedAt(resourceAvailabilitySummary, resource);
+        if (coverageAdvanced) {
+            resourceAvailabilitySummary[finalizedAtKey] = coverage.coverageFinalizedAt ?? null;
+            continue;
+        }
+        if (existingCoverage !== coverage.coverageBoundary
+            || !coverage.coverageFinalizedAt
+            || existingFinalizedAt) {
+            continue;
+        }
+        resourceAvailabilitySummary[finalizedAtKey] = coverage.coverageFinalizedAt;
+        changed = true;
+    }
+    if (!changed) {
+        return;
+    }
+    const sourceInstanceKey = legacy.sourceInstanceKey
+        ?? buildJunctionProviderSourceInstanceKey({
+            connectionId: context.account.id,
+            sourceProviderSlug: JUNCTION_FITBIT_LEGACY_PROVIDER_SLUG,
+        });
+    if (!sourceInstanceKey) {
+        return;
+    }
+    await context.upsertConnectionSource({
+        sourceInstanceKey,
+        sourceProviderSlug: legacy.sourceProviderSlug,
+        ...(legacy.displayName === undefined
+            ? {}
+            : { displayName: legacy.displayName }),
+        status: legacy.status,
+        resourceAvailabilitySummary,
+        ...(legacy.lastErrorCode === undefined
+            ? {}
+            : { lastErrorCode: legacy.lastErrorCode }),
+        ...(legacy.lastErrorMessage === undefined
+            ? {}
+            : { lastErrorMessage: legacy.lastErrorMessage }),
+        ...(legacy.firstSeenAt ? { firstSeenAt: legacy.firstSeenAt } : {}),
+        lastSeenAt: context.now,
+    });
+}
 function isJunctionImportRecordAdmitted(value, sourceReferences, sources, hasPendingSourceAdmission, allowUnlistedSources, sourceStatusRequirement) {
     const record = readPlainObject(value);
     if (!record) {
         return true;
     }
     const fallback = readJunctionSourceReference(record, sourceReferences);
-    const sourceProviderSlug = normalizeProviderSlug(resolveJunctionOrigin(record, fallback).sourceProviderSlug);
+    const sourceProviderSlug = canonicalizeJunctionProviderSlug(resolveJunctionOrigin(record, fallback).sourceProviderSlug);
     if (sourceProviderSlug) {
-        return isJunctionSourceAdmittedForImport(sources, sourceProviderSlug, allowUnlistedSources, sourceStatusRequirement);
+        if (!isJunctionSourceAdmittedForImport(sources, sourceProviderSlug, allowUnlistedSources, sourceStatusRequirement)) {
+            return false;
+        }
+        return true;
     }
     return !hasPendingSourceAdmission || !hasJunctionSourceReferenceIdentity(record);
 }
@@ -4678,7 +5726,7 @@ function sanitizeJunctionImportSnapshotValue(value, sourceReferences, options =
         (unresolvedPreservedSourceReference ? undefined : origin.sourceInstanceId);
     const sourceProviderSlug = normalizeProviderSlug(origin.sourceProviderSlug);
     const projectedSourceIdentity = options.sourceIdentities
-        ?.find((identity) => areJunctionProviderSlugsRouteEquivalent(sourceProviderSlug, identity.sourceProviderSlug));
+        ?.find((identity) => areJunctionProviderSlugsDataEquivalent(sourceProviderSlug, identity.sourceProviderSlug));
     return stripUndefined({
         ...sanitized,
         sourceProviderSlug: projectedSourceIdentity?.sourceProviderSlug
@@ -4791,24 +5839,28 @@ function dedupeJunctionTimeseriesRecords(resource, records) {
         providerRowKey: buildJunctionTimeseriesProviderRowKey(resource, record),
         record,
     }));
-    const contentKeysByProviderRow = new Map();
+    const contentKeysByStableIdentity = new Map();
     for (const candidate of candidates) {
-        if (!candidate.providerRowKey || !candidate.contentKey) {
+        const stableIdentity = candidate.providerRowKey
+            ?? (isJunctionBodyTimeseriesResource(resource) ? candidate.key : null);
+        if (!stableIdentity || !candidate.contentKey) {
             continue;
         }
-        const contentKeys = contentKeysByProviderRow.get(candidate.providerRowKey)
+        const contentKeys = contentKeysByStableIdentity.get(stableIdentity)
             ?? new Set();
         contentKeys.add(candidate.contentKey);
-        contentKeysByProviderRow.set(candidate.providerRowKey, contentKeys);
+        contentKeysByStableIdentity.set(stableIdentity, contentKeys);
     }
-    const conflictingProviderRows = new Set([...contentKeysByProviderRow.entries()]
+    const conflictingStableIdentities = new Set([...contentKeysByStableIdentity.entries()]
         .filter(([, contentKeys]) => contentKeys.size > 1)
-        .map(([providerRowKey]) => providerRowKey));
+        .map(([stableIdentity]) => stableIdentity));
     const seen = new Set();
     const deduped = [];
     for (const candidate of candidates) {
-        if (candidate.providerRowKey
-            && conflictingProviderRows.has(candidate.providerRowKey)) {
+        const stableIdentity = candidate.providerRowKey
+            ?? (isJunctionBodyTimeseriesResource(resource) ? candidate.key : null);
+        if (stableIdentity
+            && conflictingStableIdentities.has(stableIdentity)) {
             continue;
         }
         if (candidate.key && seen.has(candidate.key)) {
@@ -4828,7 +5880,7 @@ function dedupeJunctionTimeseriesSnapshotRecords(snapshot) {
     }
     return deduped;
 }
-function filterJunctionTimeseriesRecordsToWindow(resource, records, windowStart, windowEnd, dateQueryFormat) {
+function filterJunctionTimeseriesRecordsToWindow(resource, records, windowStart, windowEnd, dateQueryFormat, authorizedLocalDay, vaultTimeZone) {
     const startMs = Date.parse(windowStart);
     const endMs = Date.parse(windowEnd);
     if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || startMs >= endMs) {
@@ -4841,9 +5893,41 @@ function filterJunctionTimeseriesRecordsToWindow(resource, records, windowStart,
         if (!entry) {
             return true;
         }
-        const rawTimestamp = resolveJunctionTimeseriesRecordRawTimestamp(entry, preferIntervalStart);
+        const rawTimestamp = isJunctionBodyTimeseriesResource(resource)
+            ? resolveJunctionTimeseriesRecordTimestampForResource(resource, entry)
+            : resolveJunctionTimeseriesRecordRawTimestamp(entry, preferIntervalStart);
         if (!rawTimestamp) {
-            return true;
+            return !isJunctionBodyTimeseriesResource(resource);
+        }
+        if (authorizedLocalDay) {
+            // Drop only rows the strict complete-day parse proves belong to a
+            // different valid calendar day, and only when the raw shape and the
+            // record's declared semantics agree on absoluteness. Anything the
+            // parse rejects — and any raw-versus-semantics disagreement, which the
+            // importer must see to fail the day closed — stays in the collection
+            // so a contradictory row can never be laundered into a partial or
+            // empty replacement by being discarded as adjacent-day overlap.
+            const parsed = parseJunctionCompleteDayTimestamp(rawTimestamp);
+            if (!parsed) {
+                return true;
+            }
+            if ((parsed.kind === "absolute")
+                !== hasAbsoluteJunctionTimeseriesTimestamp(rawTimestamp, entry)) {
+                return true;
+            }
+            if (parsed.kind === "absolute") {
+                return toLocalDayKey(parsed.instant, authorizedLocalDay.timeZone)
+                    === authorizedLocalDay.dayKey;
+            }
+            return parsed.dayKey === authorizedLocalDay.dayKey;
+        }
+        if (!hasAbsoluteJunctionTimeseriesTimestamp(rawTimestamp, entry) && vaultTimeZone) {
+            const rawDayKey = /^\d{4}-\d{2}-\d{2}/u.exec(rawTimestamp)?.[0];
+            const windowStartDayKey = toLocalDayKey(windowStart, vaultTimeZone);
+            const windowEndDayKey = toLocalDayKey(new Date(endMs - 1).toISOString(), vaultTimeZone);
+            return Boolean(rawDayKey
+                && rawDayKey >= windowStartDayKey
+                && rawDayKey <= windowEndDayKey);
         }
         if (dateQueryFormat === "date"
             && policy?.normalizationMode === "daily_aggregate") {
@@ -4886,7 +5970,7 @@ function buildJunctionTimeseriesRecordKey(resource, record) {
     }
     const origin = resolveJunctionOrigin(entry);
     const sourceProviderSlug = normalizeProviderSlug(origin.sourceProviderSlug);
-    const timestamp = resolveJunctionTimeseriesRecordTimestamp(entry);
+    const timestamp = resolveJunctionTimeseriesRecordTimestampForResource(resource, entry);
     if (!sourceProviderSlug || !timestamp) {
         return null;
     }
@@ -4936,7 +6020,7 @@ function buildJunctionTimeseriesRecordContentKey(resource, record) {
     }
     return JSON.stringify([
         "junction-timeseries-content",
-        resolveJunctionTimeseriesRecordTimestamp(entry) ?? "",
+        resolveJunctionTimeseriesRecordTimestampForResource(resource, entry) ?? "",
         normalizeString(entry.recordedAt ?? entry.recorded_at ?? entry.updatedAt ?? entry.updated_at)
             ?? "",
         String(entry.timeZoneOffsetMinutes
@@ -4988,10 +6072,50 @@ function readJunctionTimeseriesProviderRowId(resource, entry) {
 // Sparse records without stable provider row ids retain their semantic tuple
 // identity so same-time rows remain distinct when their canonical bodies differ.
 function junctionTimeseriesRecordValueIdentity(resource, entry, includeProviderRowId = true) {
+    if (JUNCTION_TEMPORAL_AUTHORITY_RESOURCES.has(resource)) {
+        const providerRowId = [
+            "id",
+            "resourceId",
+            "resource_id",
+            "externalId",
+            "external_id",
+            "providerId",
+            "provider_id",
+            "recordId",
+            "record_id",
+            "sampleId",
+            "sample_id",
+        ].map((key) => normalizeString(entry[key])).find(Boolean) ?? "";
+        const value = resource === "blood_oxygen"
+            ? firstJunctionTimeseriesIdentityValue(entry, [
+                "value",
+                "spo2",
+                "spO2",
+                "bloodOxygen",
+                "blood_oxygen",
+                "oxygenSaturation",
+                "oxygen_saturation",
+            ])
+            : firstJunctionTimeseriesIdentityValue(entry, [
+                "value",
+                "stressLevel",
+                "stress_level",
+                "averageStressLevel",
+                "average_stress_level",
+                "stress.average",
+                "stressLevelValue",
+                "stress_level_value",
+                "score",
+            ]);
+        return [providerRowId, value];
+    }
     if (!junctionTimeseriesRecordNeedsSemanticIdentity(resource)) {
         return [];
     }
     const providerRowId = readJunctionTimeseriesProviderRowId(resource, entry) ?? "";
+    if (isJunctionBodyTimeseriesResource(resource) && includeProviderRowId) {
+        return providerRowId ? [providerRowId] : [];
+    }
     if (resource === "weight") {
         if (includeProviderRowId && providerRowId) {
             return [providerRowId];
@@ -5121,12 +6245,63 @@ function junctionTimeseriesRecordValueIdentity(resource, entry, includeProviderR
         String(entry.delivery_mode ?? entry.deliveryMode ?? ""),
     ];
 }
+function firstJunctionTimeseriesIdentityValue(entry, paths) {
+    for (const path of paths) {
+        let value = entry;
+        for (const segment of path.split(".")) {
+            value = readPlainObject(value)?.[segment];
+        }
+        const numericValue = typeof value === "number"
+            ? value
+            : Number(normalizeString(value));
+        if (Number.isFinite(numericValue)) {
+            return String(numericValue);
+        }
+    }
+    return "";
+}
 function resolveJunctionTimeseriesRecordTimestamp(record, preferIntervalStart = false) {
     const rawTimestamp = resolveJunctionTimeseriesRecordRawTimestamp(record, preferIntervalStart);
     return rawTimestamp
         ? toIsoTimestampIfValid(rawTimestamp) ?? rawTimestamp
         : null;
 }
+const JUNCTION_INSTANT_BODY_TIMESERIES_RESOURCES = new Set([
+    "fat",
+    "weight",
+]);
+const JUNCTION_INTERVAL_BODY_TIMESERIES_RESOURCES = new Set([
+    "body_mass_index",
+    "lean_body_mass",
+    "waist_circumference",
+]);
+function isJunctionBodyTimeseriesResource(resource) {
+    return resource !== null
+        && resource !== undefined
+        && (JUNCTION_INSTANT_BODY_TIMESERIES_RESOURCES.has(resource)
+            || JUNCTION_INTERVAL_BODY_TIMESERIES_RESOURCES.has(resource));
+}
+function resolveJunctionTimeseriesRecordTimestampForResource(resource, record) {
+    if (JUNCTION_TEMPORAL_AUTHORITY_RESOURCES.has(resource)) {
+        const rawTimestamp = resolveJunctionTimeseriesRecordRawTimestamp(record);
+        if (!rawTimestamp || !hasAbsoluteJunctionTimeseriesTimestamp(rawTimestamp, record)) {
+            return rawTimestamp;
+        }
+        return toIsoTimestampIfValid(rawTimestamp) ?? rawTimestamp;
+    }
+    if (JUNCTION_INSTANT_BODY_TIMESERIES_RESOURCES.has(resource)) {
+        return normalizeJunctionCanonicalBodyTimestamp(record.timestamp) ?? null;
+    }
+    if (JUNCTION_INTERVAL_BODY_TIMESERIES_RESOURCES.has(resource)) {
+        const start = normalizeJunctionCanonicalBodyTimestamp(record.start);
+        const end = normalizeJunctionCanonicalBodyTimestamp(record.end);
+        if (!start || !end || Date.parse(end) <= Date.parse(start)) {
+            return null;
+        }
+        return start;
+    }
+    return resolveJunctionTimeseriesRecordTimestamp(record);
+}
 function resolveJunctionTimeseriesRecordRawTimestamp(record, preferIntervalStart = false) {
     const intervalKeys = preferIntervalStart
         ? ["sessionStart", "session_start", "timeStart", "time_start", "start", "startAt", "start_at", "sessionEnd", "session_end", "timeEnd", "time_end", "end", "endAt", "end_at"]
@@ -5159,6 +6334,16 @@ function isJunctionFloatingCalendarTimestamp(value) {
     }
     return /^\d{4}-\d{2}-\d{2}(?:$|[ t]\d{2}:\d{2})/iu.test(normalized);
 }
+function hasAbsoluteJunctionTimeseriesTimestamp(timestamp, record) {
+    const explicitSemantics = normalizeString(record.timestampSemantics ?? record.timestamp_semantics);
+    if (explicitSemantics === "floating") {
+        return false;
+    }
+    if (explicitSemantics === "utc" || explicitSemantics === "offset") {
+        return true;
+    }
+    return /(?:z|[+-]\d{2}:?\d{2})$/iu.test(timestamp.trim());
+}
 function buildJunctionRedirectUrl(callbackUrl, state) {
     const url = new URL(callbackUrl);
     url.searchParams.set("murph_state", state);
@@ -5318,6 +6503,7 @@ function resolveNextFullJobTimeseriesContinuation(input) {
             timeseriesResourceCursor: input.resource,
             timeseriesWindowHours: input.timeseriesWindowHours,
             workoutStreamCursor: null,
+            workoutStreamEmptySeen: false,
         };
     }
     const nextResource = input.resources[input.resources.indexOf(input.resource) + 1] ?? null;
@@ -5327,6 +6513,7 @@ function resolveNextFullJobTimeseriesContinuation(input) {
             timeseriesResourceCursor: nextResource,
             timeseriesWindowHours: 24,
             workoutStreamCursor: null,
+            workoutStreamEmptySeen: false,
         }
         : null;
 }
@@ -5339,12 +6526,6 @@ function readDeferredEmptyBackfillAttempts(followUp) {
     }
     return 0;
 }
-function readBackfillTimeseriesCursor(job, ownerWindow) {
-    const cursor = toIsoTimestampIfValid(job.payload.timeseriesCursor);
-    return cursor && isTimestampInHalfOpenWindow(cursor, ownerWindow)
-        ? cursor
-        : null;
-}
 function isTimestampInHalfOpenWindow(timestamp, window) {
     const timestampMs = Date.parse(timestamp);
     const windowStartMs = Date.parse(window.windowStart);
@@ -5382,6 +6563,96 @@ function shouldImportClosedTimeseriesForReconcile(lastSyncCompletedAt, windowEnd
         || !Number.isFinite(windowEndMs)
         || lastCompletedClosedDayMs < windowEndMs;
 }
+function normalizeJunctionTemporalReconcileDays(value) {
+    if (!Number.isFinite(value)) {
+        return DEFAULT_RECONCILE_DAYS;
+    }
+    return Math.max(1, Math.min(Math.floor(value), JUNCTION_MAX_TEMPORAL_RECONCILE_DAYS));
+}
+function buildLatestAuthoritativeDailyWindows(input) {
+    const nowMs = Date.parse(input.now);
+    const windowEndMs = Date.parse(input.windowEnd);
+    if (!Number.isFinite(nowMs) || !Number.isFinite(windowEndMs)) {
+        return [];
+    }
+    const latestAuthoritativeDayKey = latestAuthoritativeVaultDayKey(input.now, input.timeZone);
+    if (!latestAuthoritativeDayKey) {
+        return [];
+    }
+    let latestWindowBoundDayKey = toLocalDayKey(new Date(windowEndMs - 1).toISOString(), input.timeZone);
+    for (let offset = 0; offset < 4; offset += 1) {
+        const candidate = resolveVaultLocalDayWindow(latestWindowBoundDayKey, input.timeZone);
+        if (candidate && Date.parse(candidate.windowEnd) <= windowEndMs) {
+            break;
+        }
+        latestWindowBoundDayKey = addIsoDateDays(latestWindowBoundDayKey, -1);
+    }
+    const newestDayKey = latestAuthoritativeDayKey < latestWindowBoundDayKey
+        ? latestAuthoritativeDayKey
+        : latestWindowBoundDayKey;
+    const newestWindow = resolveVaultLocalDayWindow(newestDayKey, input.timeZone);
+    if (!newestWindow || Date.parse(newestWindow.windowEnd) > windowEndMs) {
+        return [];
+    }
+    const windows = [];
+    for (let offset = 0; offset < input.horizonDays; offset += 1) {
+        const dayKey = addIsoDateDays(newestDayKey, -offset);
+        const window = resolveVaultLocalDayWindow(dayKey, input.timeZone);
+        if (!window) {
+            continue;
+        }
+        windows.push({
+            dayKey,
+            ...window,
+        });
+    }
+    return windows;
+}
+function buildJunctionTemporalAuthorityJobs(input) {
+    const temporalResources = input.resources.filter((resource) => JUNCTION_TEMPORAL_AUTHORITY_RESOURCES.has(resource));
+    return input.windows.flatMap((window, windowIndex) => temporalResources.map((resource) => {
+        const payload = {
+            resource,
+            resourceCategory: "timeseries",
+            temporalAuthorityTimeZone: input.timeZone,
+            windowEnd: window.windowEnd,
+            windowStart: window.windowStart,
+        };
+        return {
+            // The store orders equal-priority work by availability. Give each older
+            // day a stable millisecond tier so restarts drain the newest missing day
+            // first without outranking webhook work or introducing another cursor.
+            availableAt: addMilliseconds(input.now, windowIndex),
+            dedupeKey: `${JUNCTION_TEMPORAL_AUTHORITY_DEDUPE_PREFIX}v${JUNCTION_TEMPORAL_AUTHORITY_JOB_VERSION}:${sha256Text(JSON.stringify([input.timeZone, resource, window.dayKey]))}`,
+            kind: "resource",
+            payload,
+            priority: JUNCTION_HISTORICAL_BACKFILL_PRIORITY,
+        };
+    }));
+}
+function readJunctionTemporalAuthorityJob(job) {
+    if (job.kind !== "resource") {
+        return null;
+    }
+    // The retained authority timezone is the only persisted authority state;
+    // the day key derives from the stored exact window so hosted wake hints
+    // cannot restore a temporal child with partial authority. Legacy payloads
+    // may still carry temporalAuthorityDayKey; it is ignored.
+    const timeZone = normalizeString(job.payload.temporalAuthorityTimeZone);
+    const resource = normalizeJunctionResourceName(job.payload.resource);
+    const windowStart = normalizeString(job.payload.windowStart);
+    if (!timeZone
+        || !resource
+        || !JUNCTION_TEMPORAL_AUTHORITY_RESOURCES.has(resource)
+        || !windowStart) {
+        return null;
+    }
+    const dayKey = toLocalDayKey(windowStart, timeZone);
+    if (!dayKey || !/^\d{4}-\d{2}-\d{2}$/u.test(dayKey)) {
+        return null;
+    }
+    return { dayKey, resource, timeZone };
+}
 function resolveLatestGloballyClosedProviderDayWindow(windowStart, windowEnd, asOf) {
     const flooredWindowStartMs = Date.parse(floorUtcDayTimestamp(windowStart));
     const globallyClosedEndMs = resolveGloballyClosedProviderDayEnd(windowEnd, asOf);
@@ -5414,14 +6685,76 @@ function buildClosedDailyWindows(windowStart, windowEnd) {
         if (chunkEndMs <= chunkStartMs) {
             break;
         }
+        const dailyWindowStart = new Date(chunkStartMs).toISOString();
         windows.push({
-            windowStart: new Date(chunkStartMs).toISOString(),
+            dayKey: dailyWindowStart.slice(0, 10),
+            windowStart: dailyWindowStart,
             windowEnd: new Date(chunkEndMs).toISOString(),
         });
         chunkStartMs = chunkEndMs;
     }
     return windows;
 }
+function latestAuthoritativeVaultDayKey(at, timeZone) {
+    const atMs = Date.parse(at);
+    if (!Number.isFinite(atMs)) {
+        return null;
+    }
+    let candidateDayKey = toLocalDayKey(at, timeZone);
+    for (let offset = 0; offset < 4; offset += 1) {
+        const candidate = resolveVaultLocalDayWindow(candidateDayKey, timeZone);
+        if (candidate
+            && Date.parse(candidate.windowEnd) + JUNCTION_TEMPORAL_AUTHORITY_LAG_MS <= atMs) {
+            return candidateDayKey;
+        }
+        candidateDayKey = addIsoDateDays(candidateDayKey, -1);
+    }
+    return null;
+}
+function resolveVaultLocalDayWindow(dayKey, timeZone) {
+    const startMs = findVaultLocalDayStartMs(dayKey, timeZone);
+    const endMs = findVaultLocalDayStartMs(addIsoDateDays(dayKey, 1), timeZone);
+    return startMs === null || endMs === null || startMs >= endMs
+        ? null
+        : {
+            windowStart: new Date(startMs).toISOString(),
+            windowEnd: new Date(endMs).toISOString(),
+        };
+}
+function findVaultLocalDayStartMs(dayKey, timeZone) {
+    const anchorMs = Date.parse(`${dayKey}T00:00:00.000Z`);
+    if (!Number.isFinite(anchorMs)) {
+        return null;
+    }
+    const searchStartMs = anchorMs - 2 * TIMESERIES_CHUNK_MS;
+    const searchEndMs = anchorMs + 2 * TIMESERIES_CHUNK_MS;
+    let matchingMs = null;
+    for (let candidateMs = searchStartMs; candidateMs <= searchEndMs; candidateMs += 60 * 60_000) {
+        if (toLocalDayKey(new Date(candidateMs).toISOString(), timeZone) === dayKey) {
+            matchingMs = candidateMs;
+            break;
+        }
+    }
+    if (matchingMs === null) {
+        return null;
+    }
+    let lowerMs = matchingMs - 60 * 60_000;
+    let upperMs = matchingMs;
+    while (upperMs - lowerMs > 1) {
+        const middleMs = Math.floor((lowerMs + upperMs) / 2);
+        if (toLocalDayKey(new Date(middleMs).toISOString(), timeZone) < dayKey) {
+            lowerMs = middleMs;
+        }
+        else {
+            upperMs = middleMs;
+        }
+    }
+    return upperMs;
+}
+function addIsoDateDays(dayKey, days) {
+    const value = Date.parse(`${dayKey}T00:00:00.000Z`);
+    return new Date(value + days * TIMESERIES_CHUNK_MS).toISOString().slice(0, 10);
+}
 function resolveGloballyClosedProviderDayEnd(windowEnd, asOf) {
     const requestedClosedEndMs = Date.parse(floorUtcDayTimestamp(windowEnd));
     const asOfMs = Date.parse(asOf);
@@ -5480,13 +6813,11 @@ function hasJunctionHistoricalBackfillSummaryRecords(evidence) {
     return evidence.some(({ resource }) => isJunctionHistoricalBackfillCompletionSummaryResource(resource));
 }
 function resolveJunctionHistoricalPullReadiness(input) {
-    const sourceProviderSlug = canonicalizeJunctionHistoricalProviderSlug(input.sourceProviderSlug)
-        ?? normalizeProviderSlug(input.sourceProviderSlug);
+    const sourceProviderSlug = canonicalizeJunctionProviderSlug(input.sourceProviderSlug);
     if (!sourceProviderSlug || !input.snapshot?.matchedUser) {
         return "unavailable";
     }
-    const source = input.snapshot.sources.find((entry) => (canonicalizeJunctionHistoricalProviderSlug(entry.sourceProviderSlug)
-        ?? normalizeProviderSlug(entry.sourceProviderSlug)) === sourceProviderSlug);
+    const source = input.snapshot.sources.find((entry) => canonicalizeJunctionProviderSlug(entry.sourceProviderSlug) === sourceProviderSlug);
     if (!source) {
         return "unavailable";
     }
@@ -5586,7 +6917,7 @@ function evaluateJunctionHistoricalBackfillCoverage(summaryEvidence, sourceProvi
                 continue;
             }
             const coveredBySummary = summaryEvidence.some((entry) => entry.resource === resource
-                && canonicalizeJunctionHistoricalProviderSlug(entry.sourceProviderSlug) === providerSlug);
+                && canonicalizeJunctionProviderSlug(entry.sourceProviderSlug) === providerSlug);
             const coveredByPush = hasJunctionHistoricalBackfillEvidence(historicalPushEvidence, providerSlug, resource, window.windowStart, window.windowEnd);
             if (!coveredBySummary && !coveredByPush) {
                 hasPendingResource = true;
@@ -5610,16 +6941,8 @@ function evaluateJunctionHistoricalBackfillCoverage(summaryEvidence, sourceProvi
             .sort((left, right) => left.localeCompare(right)),
     };
 }
-function canonicalizeJunctionHistoricalProviderSlug(value) {
-    const providerSlug = normalizeProviderSlug(value);
-    if (!providerSlug) {
-        return null;
-    }
-    return resolveJunctionDeviceConnectRouteByProviderSlug(providerSlug)?.route.sourceProviderSlug
-        ?? null;
-}
 function resolveJunctionHistoricalCoverageProviderSlug(value, providerFilter) {
-    const providerSlug = canonicalizeJunctionHistoricalProviderSlug(value);
+    const providerSlug = canonicalizeJunctionProviderSlug(value);
     if (!providerSlug) {
         return null;
     }
@@ -5639,7 +6962,7 @@ function readJunctionDirectHistoricalEvidenceWindow(input, connectWindow, eviden
     if (!providerSlug
         || !isJunctionHistoricalBackfillRequiredSummaryResource(input.resource)
         || !evidence.some((entry) => entry.resource === input.resource
-            && canonicalizeJunctionHistoricalProviderSlug(entry.sourceProviderSlug) === providerSlug)) {
+            && canonicalizeJunctionProviderSlug(entry.sourceProviderSlug) === providerSlug)) {
         return null;
     }
     return connectWindow;
@@ -5666,11 +6989,23 @@ function isJunctionResourceAvailableInSummary(availabilitySummary, resource) {
     return Object.entries(availabilitySummary).some(([candidate, availability]) => normalizeJunctionResourceName(candidate) === normalizedResource
         && isJunctionResourceAdvertisedAvailable(availability));
 }
+async function resolveJunctionWorkoutStreamEligibleSources(context, providers) {
+    if (!context.listConnectionSources) {
+        return new Set();
+    }
+    const sources = await context.listConnectionSources();
+    return new Set(projectJunctionSourcesByProviderSlug(context.account.id, providers).flatMap((source) => isJunctionSourceAdmittedForImport(sources, source.sourceProviderSlug, context.connectionSourceAdmissionMode !== "listed_only")
+        && source.status === "connected"
+        && isJunctionResourceAvailableInSummary(source.resourceAvailabilitySummary, "workout_stream")
+        ? [source.sourceProviderSlug]
+        : []));
+}
 function isJunctionSourceResourceCurrentlyAvailable(input) {
-    if (!input.sourceProviderSlug) {
+    const sourceProviderSlug = canonicalizeJunctionProviderSlug(input.sourceProviderSlug);
+    if (!sourceProviderSlug) {
         return false;
     }
-    return projectJunctionSourcesByProviderSlug(input.connectionId, input.providers).some((source) => source.sourceProviderSlug === input.sourceProviderSlug
+    return projectJunctionSourcesByProviderSlug(input.connectionId, input.providers).some((source) => source.sourceProviderSlug === sourceProviderSlug
         && source.status === "connected"
         && isJunctionResourceAvailableInSummary(source.resourceAvailabilitySummary, input.resource));
 }
@@ -5760,8 +7095,16 @@ function buildNonConnectHistoricalBackfillFollowUp(input) {
         return {};
     }
     const retryAt = addMilliseconds(input.now, retryDelayMs);
+    const sourceProviderSlug = normalizeProviderSlug(input.job.payload.sourceProviderSlug);
     const retryJob = buildExactWindowJob({
         kind: "backfill",
+        payload: stripUndefined({
+            ...(sourceProviderSlug ? { sourceProviderSlug } : {}),
+            ...(input.historicalProviderRecordsSeen
+                ? { historicalProviderRecordsSeen: true }
+                : {}),
+            ...(input.historicalRecordsSeen ? { historicalRecordsSeen: true } : {}),
+        }),
         priority: Math.max(input.job.priority, JUNCTION_HISTORICAL_BACKFILL_RETRY_PRIORITY),
         windowStart: input.windowStart,
         windowEnd: input.windowEnd,
@@ -5952,7 +7295,7 @@ function resolveJunctionHistoricalUnresolvedProviderRecords(job, importResult) {
     }
     return {
         identities: [...identities].sort(),
-        withoutStableIdentity: carried.withoutStableIdentity
+        withoutStableIdentity: (!importResult.fetchComplete && carried.withoutStableIdentity)
             || importResult.unresolvedProviderRecordsWithoutStableIdentity,
     };
 }
@@ -5972,6 +7315,32 @@ function buildConnectHistoricalBackfillWindow(account, summaryBackfillDays) {
         windowEnd: floorUtcDayTimestamp(account.connectedAt),
     };
 }
+function normalizeJunctionHistoricalProofAuthorization(input) {
+    const firstSeenAt = normalizeString(input?.firstSeenAt);
+    const sourceProviderSlug = normalizeProviderSlug(input?.sourceProviderSlug);
+    if (!firstSeenAt
+        || !Number.isFinite(Date.parse(firstSeenAt))
+        || !sourceProviderSlug) {
+        return null;
+    }
+    return { firstSeenAt, sourceProviderSlug };
+}
+function readJunctionHistoricalProofAuthorization(job) {
+    if (job.kind !== "backfill") {
+        return null;
+    }
+    return normalizeJunctionHistoricalProofAuthorization({
+        firstSeenAt: normalizeString(job.payload.historicalProofFirstSeenAt) ?? "",
+        sourceProviderSlug: normalizeProviderSlug(job.payload.historicalProofSourceProviderSlug) ?? "",
+    });
+}
+async function isJunctionHistoricalProofAuthorizationCurrent(context, authorization) {
+    const sources = context.listConnectionSources
+        ? await context.listConnectionSources()
+        : context.account.sources ?? [];
+    return sources.some((source) => source.firstSeenAt === authorization.firstSeenAt
+        && areJunctionProviderSlugsDataEquivalent(source.sourceProviderSlug, authorization.sourceProviderSlug));
+}
 function buildWindowJob(input) {
     const windowEnd = floorUtcDayTimestamp(input.now);
     const windowStart = floorUtcDayTimestamp(input.windowStart);
@@ -5986,13 +7355,26 @@ function buildWindowJob(input) {
 }
 function buildExactWindowJob(input) {
     const windowPayload = input.payload;
-    const sourceProviderSlug = normalizeString(windowPayload?.sourceProviderSlug);
+    const sourceProviderSlug = canonicalizeJunctionProviderSlug(windowPayload?.sourceProviderSlug);
+    const historicalProofAuthorization = normalizeJunctionHistoricalProofAuthorization(windowPayload?.historicalProofFirstSeenAt
+        && windowPayload.historicalProofSourceProviderSlug
+        ? {
+            firstSeenAt: windowPayload.historicalProofFirstSeenAt,
+            sourceProviderSlug: windowPayload.historicalProofSourceProviderSlug,
+        }
+        : null);
     const dedupeIdentity = [
         "junction",
         input.kind,
         input.windowStart,
         input.windowEnd,
         ...(sourceProviderSlug ? [sourceProviderSlug] : []),
+        ...(historicalProofAuthorization
+            ? [
+                historicalProofAuthorization.sourceProviderSlug,
+                historicalProofAuthorization.firstSeenAt,
+            ]
+            : []),
     ];
     return {
         kind: input.kind,
@@ -6006,6 +7388,50 @@ function buildExactWindowJob(input) {
         dedupeKey: sha256Text(JSON.stringify(dedupeIdentity)),
     };
 }
+function withJunctionWorkoutStreamEmptyReplay(input) {
+    if (!input.replayWindow
+        || (input.job.kind === "resource"
+            && input.job.payload.workoutStreamEmptyReplay === true)) {
+        return input.result;
+    }
+    const replayJob = buildJunctionWorkoutStreamEmptyReplayJob({
+        availableAt: addMilliseconds(input.now, JUNCTION_WORKOUT_STREAM_EMPTY_REPLAY_DELAY_MS),
+        sourceProviderSlug: input.sourceProviderSlug,
+        windowEnd: input.replayWindow.windowEnd,
+        windowStart: input.replayWindow.windowStart,
+    });
+    return {
+        ...input.result,
+        scheduledJobs: [
+            ...(input.result.scheduledJobs ?? []),
+            replayJob,
+        ],
+    };
+}
+function buildJunctionWorkoutStreamEmptyReplayJob(input) {
+    const sourceProviderSlug = canonicalizeJunctionProviderSlug(input.sourceProviderSlug);
+    const payload = {
+        resource: "workout_stream",
+        resourceCategory: "timeseries",
+        ...(sourceProviderSlug ? { sourceProviderSlug } : {}),
+        windowEnd: input.windowEnd,
+        windowStart: input.windowStart,
+        workoutStreamEmptyReplay: true,
+    };
+    return {
+        availableAt: input.availableAt,
+        dedupeKey: sha256Text(JSON.stringify([
+            "junction",
+            "workout-stream-empty-replay",
+            input.windowStart,
+            input.windowEnd,
+            sourceProviderSlug,
+        ])),
+        kind: "resource",
+        payload,
+        priority: JUNCTION_HISTORICAL_BACKFILL_RETRY_PRIORITY,
+    };
+}
 function buildJunctionSparseCalendarRefreshJobs(input) {
     const targets = [...new Map(input.targets.map((target) => [
             JSON.stringify([
@@ -6116,7 +7542,7 @@ function filterJunctionSparseCalendarRecordsToSource(records, source) {
         if (!recordSourceProviderSlug) {
             throw incompleteJunctionSparseCalendarCollectionError();
         }
-        if (!areJunctionProviderSlugsRouteEquivalent(recordSourceProviderSlug, sourceProviderSlug)) {
+        if (!areJunctionProviderSlugsDataEquivalent(recordSourceProviderSlug, sourceProviderSlug)) {
             return [];
         }
         const recordSourceType = normalizeString(origin.sourceType);
@@ -6183,28 +7609,59 @@ function buildJunctionExtendedTimeseriesBackfillDedupeKey(payload) {
         || !policy) {
         return null;
     }
-    if (!["blood_pressure", "weight"].includes(resource)) {
-        const coverageVersion = resource === "note"
-            ? readJunctionNoteHistoryBackfillVersion(payload)
-            : policy.version;
+    const sourceLifecycleEpoch = readSafeInteger(payload.sourceLifecycleEpoch);
+    if (sourceLifecycleEpoch === null
+        || sourceLifecycleEpoch < 1) {
+        return null;
+    }
+    const coverageVersion = readJunctionHistoricalBackfillVersion(payload);
+    if (policy.completion !== "exact_records") {
         return sha256Text(JSON.stringify([
             "junction",
             "extended-timeseries-backfill",
-            normalizeProviderSlug(payload.sourceProviderSlug),
+            canonicalizeJunctionProviderSlug(payload.sourceProviderSlug),
             resource,
+            sourceLifecycleEpoch,
             coverageVersion,
         ]));
     }
     return sha256Text(JSON.stringify([
         "junction",
         "extended-timeseries-backfill",
-        normalizeProviderSlug(payload.sourceProviderSlug),
+        canonicalizeJunctionProviderSlug(payload.sourceProviderSlug),
         resource,
+        sourceLifecycleEpoch,
+        coverageVersion,
         historicalWindowStart,
         windowEnd,
     ]));
 }
+function buildExtendedTimeseriesBackfillFollowUp(job, input) {
+    const payload = stripUndefined({
+        ...job.payload,
+        ...input.payload,
+        ...(input.payload?.historicalProviderRecordsSeen === false
+            ? { historicalProviderRecordsSeen: undefined }
+            : {}),
+        ...(input.payload?.historicalRecordsSeen === false
+            ? { historicalRecordsSeen: undefined }
+            : {}),
+        sourceProviderSlug: canonicalizeJunctionProviderSlug(input.payload?.sourceProviderSlug ?? job.payload.sourceProviderSlug) ?? undefined,
+        windowEnd: input.windowEnd,
+        windowStart: input.windowStart,
+    });
+    return {
+        kind: "resource",
+        payload,
+        availableAt: input.availableAt,
+        priority: job.priority,
+        dedupeKey: job.dedupeKey
+            ?? buildJunctionExtendedTimeseriesBackfillDedupeKey(payload)
+            ?? undefined,
+    };
+}
 function buildExtendedTimeseriesBackfillJob(input) {
+    const sourceProviderSlug = canonicalizeJunctionProviderSlug(input.sourceProviderSlug);
     const payload = {
         ...(input.emptyBackfillAttempts && input.emptyBackfillAttempts > 0
             ? { emptyBackfillAttempts: input.emptyBackfillAttempts }
@@ -6233,8 +7690,11 @@ function buildExtendedTimeseriesBackfillJob(input) {
         historicalWindowStart: input.historicalWindowStart,
         resource: input.resource,
         resourceCategory: "timeseries",
-        ...(input.sourceProviderSlug
-            ? { sourceProviderSlug: input.sourceProviderSlug }
+        ...(input.sourceLifecycleEpoch === undefined
+            ? {}
+            : { sourceLifecycleEpoch: input.sourceLifecycleEpoch }),
+        ...(sourceProviderSlug
+            ? { sourceProviderSlug }
             : {}),
         windowEnd: input.windowEnd,
         windowStart: input.windowStart,
@@ -6252,13 +7712,14 @@ function buildExtendedTimeseriesBackfillJob(input) {
         dedupeKey,
     };
 }
-function readJunctionNoteHistoryBackfillVersion(payload) {
+function readJunctionHistoricalBackfillVersion(payload) {
     const version = payload.historicalBackfillVersion;
     return typeof version === "number" && Number.isSafeInteger(version) && version >= 1
         ? version
         : 1;
 }
 function buildJunctionWebhookJobs(input) {
+    const sourceProviderSlug = canonicalizeJunctionProviderSlug(input.sourceProviderSlug);
     if (isJunctionProviderConnectionEvent(input.eventType)) {
         const backfillWindowStart = subtractDays(input.window.windowEnd, input.summaryBackfillDays);
         return [
@@ -6294,7 +7755,7 @@ function buildJunctionWebhookJobs(input) {
                 occurredAt: input.occurredAt,
                 resource: input.resource?.name ?? "",
                 resourceCategory: input.resource?.category ?? "",
-                sourceProviderSlug: input.sourceProviderSlug ?? "",
+                sourceProviderSlug: sourceProviderSlug ?? "",
                 ...(webhookDataJson ? { webhookDataJson } : {}),
                 windowStart: input.window.windowStart,
                 windowEnd: input.window.windowEnd,
@@ -6304,7 +7765,7 @@ function buildJunctionWebhookJobs(input) {
                 ? sha256Text(JSON.stringify([
                     "junction-webhook",
                     "resource-data",
-                    input.sourceProviderSlug,
+                    sourceProviderSlug,
                     input.resource?.category,
                     input.resource?.name,
                     input.objectId ?? "",
@@ -6315,7 +7776,7 @@ function buildJunctionWebhookJobs(input) {
                 : sha256Text(JSON.stringify([
                     "junction-webhook",
                     "resource",
-                    input.sourceProviderSlug,
+                    sourceProviderSlug,
                     input.resource?.category,
                     input.resource?.name,
                     input.window.windowStart,
@@ -6437,10 +7898,32 @@ function buildJunctionWebhookDataJobJsons(input) {
     }
     const withSource = stripUndefined({
         ...record,
-        sourceProviderSlug: normalizeProviderSlug(record.sourceProviderSlug) ?? input.sourceProviderSlug ?? undefined,
+        sourceProviderSlug: input.sourceProviderSlug ?? undefined,
     });
     return [serializeJunctionWebhookDataJobRecord(withSource)];
 }
+function resolveJunctionWebhookDataSourceProviderSlug(input) {
+    if (!input.data
+        || !isJunctionDataEvent(input.eventType)
+        || input.historicalPullCompleted) {
+        return null;
+    }
+    const classification = classifyDeviceSyncJunctionInlineSourceProviderSlug(input.data);
+    if (classification.status === "ambiguous") {
+        throw junctionWebhookSourceNotReadyError();
+    }
+    return classification.status === "resolved"
+        ? classification.sourceProviderSlug
+        : input.envelopeSourceProviderSlug;
+}
+function junctionWebhookSourceNotReadyError() {
+    return deviceSyncError({
+        code: "WEBHOOK_SOURCE_NOT_READY",
+        message: "Junction webhook data source provenance was ambiguous. Retry later.",
+        retryable: true,
+        httpStatus: 503,
+    });
+}
 function serializeJunctionWebhookDataJobRecord(record) {
     return JSON.stringify(record);
 }
@@ -6619,7 +8102,7 @@ function readJunctionWebhookResourceFromEventType(eventType) {
     return null;
 }
 function extractJunctionWebhookSourceProviderSlug(data) {
-    return (normalizeProviderSlug(resolveJunctionOrigin(data ?? undefined).sourceProviderSlug)
+    return canonicalizeJunctionProviderSlug(resolveJunctionOrigin(data ?? undefined).sourceProviderSlug
         ?? extractJunctionWebhookSourceProviderSlugFallback(data));
 }
 function extractJunctionWebhookSourceProviderSlugFallback(data) {
@@ -6675,7 +8158,10 @@ function extractJunctionWebhookRootTimestamp(data) {
     }
     return null;
 }
-function extractJunctionWebhookOccurredAt(data) {
+function extractJunctionWebhookOccurredAt(data, resource) {
+    if (isJunctionBodyTimeseriesResource(resource?.name)) {
+        return readJunctionWebhookDataTimestampRange(data, resource?.name)?.firstTimestamp ?? null;
+    }
     const rootTimestamp = extractJunctionWebhookRootTimestamp(data);
     if (rootTimestamp) {
         return rootTimestamp;
@@ -6684,16 +8170,21 @@ function extractJunctionWebhookOccurredAt(data) {
     if (nestedTimestamp) {
         return nestedTimestamp;
     }
-    return readJunctionWebhookDataTimestampRange(data)?.firstTimestamp ?? null;
+    return readJunctionWebhookDataTimestampRange(data, resource?.name)?.firstTimestamp ?? null;
 }
 function buildJunctionWebhookWindow(data, occurredAt, now, resource) {
+    const bodyTimeseriesResource = isJunctionBodyTimeseriesResource(resource?.name);
     const explicitStart = toJunctionWebhookWindowBoundaryTimestampIfValid(data?.window_start, "start")
         ?? toJunctionWebhookWindowBoundaryTimestampIfValid(data?.start_date, "start")
-        ?? toJunctionWebhookWindowBoundaryTimestampIfValid(data?.start, "start")
+        ?? (bodyTimeseriesResource
+            ? null
+            : toJunctionWebhookWindowBoundaryTimestampIfValid(data?.start, "start"))
         ?? toJunctionWebhookWindowBoundaryTimestampIfValid(data?.from, "start");
     const explicitEnd = toJunctionWebhookWindowBoundaryTimestampIfValid(data?.window_end, "end")
         ?? toJunctionWebhookWindowBoundaryTimestampIfValid(data?.end_date, "end")
-        ?? toJunctionWebhookWindowBoundaryTimestampIfValid(data?.end, "end")
+        ?? (bodyTimeseriesResource
+            ? null
+            : toJunctionWebhookWindowBoundaryTimestampIfValid(data?.end, "end"))
         ?? toJunctionWebhookWindowBoundaryTimestampIfValid(data?.to, "end");
     if (explicitStart && explicitEnd) {
         return {
@@ -6701,7 +8192,7 @@ function buildJunctionWebhookWindow(data, occurredAt, now, resource) {
             windowEnd: minIsoTimestamp(explicitEnd, now),
         };
     }
-    const dataTimestampRange = readJunctionWebhookDataTimestampRange(data);
+    const dataTimestampRange = readJunctionWebhookDataTimestampRange(data, resource?.name);
     if (dataTimestampRange) {
         const windowStart = floorUtcDayTimestamp(dataTimestampRange.firstTimestamp);
         const windowEnd = minIsoTimestamp(addMilliseconds(floorUtcDayTimestamp(dataTimestampRange.lastTimestamp), TIMESERIES_CHUNK_MS), now);
@@ -6743,11 +8234,13 @@ function toJunctionWebhookWindowBoundaryTimestampIfValid(value, boundary) {
     }
     return toIsoTimestampIfValid(normalized);
 }
-function readJunctionWebhookDataTimestampRange(data) {
+function readJunctionWebhookDataTimestampRange(data, resource) {
     const record = data ? readPlainObject(data) : null;
     const timestamps = record
-        ? expandJunctionWebhookTimeseriesDataRecords(record).slice(1).flatMap((entry) => {
-            const timestamp = toIsoTimestampIfValid(resolveJunctionTimeseriesRecordTimestamp(entry));
+        ? expandJunctionWebhookTimeseriesDataRecords(record)
+            .slice(isJunctionBodyTimeseriesResource(resource) ? 0 : 1)
+            .flatMap((entry) => {
+            const timestamp = resolveJunctionTimeseriesRecordTimestampForResource(resource ?? "", entry);
             return timestamp ? [timestamp] : [];
         })
         : [];
@@ -7064,7 +8557,9 @@ async function projectJunctionSources(context, providers, options = {}) {
             && historicalState.status !== "complete"));
     const preserveHistoricalReconnectProviderSlugs = options.preserveHistoricalReconnectProviderSlugs === undefined
         ? null
-        : new Set(options.preserveHistoricalReconnectProviderSlugs);
+        : new Set(options.preserveHistoricalReconnectProviderSlugs
+            .map(canonicalizeJunctionProviderSlug)
+            .filter((providerSlug) => providerSlug !== null));
     const projectedSources = projectJunctionSourcesByProviderSlug(context.account.id, providers);
     if (projectedSources.length > JUNCTION_MAX_USER_PROVIDERS) {
         throw deviceSyncError({
@@ -7099,6 +8594,10 @@ async function projectJunctionSources(context, providers, options = {}) {
                     && existing.lastErrorCode === DEVICE_SYNC_HISTORICAL_DATA_RECONNECT_REQUIRED_ERROR_CODE
                 : requiresHistoricalResetDeviceSyncSource(existing));
         const historicalReconnectError = keepHistoricalReconnect ? existing : null;
+        const historicalBackfillCompletedAt = source.sourceProviderSlug === options.historicalBackfillCompletedProviderSlug
+            ? context.now
+            : existing?.resourceAvailabilitySummary?.[DEVICE_SYNC_SOURCE_HISTORICAL_BACKFILL_COMPLETED_AT_KEY];
+        const existingSourceMetadata = Object.fromEntries(Object.entries(existing?.resourceAvailabilitySummary ?? {}).filter(([key]) => isDeviceSyncSourceResourceAvailabilityMetadataKey(key)));
         const persistedSource = await context.upsertConnectionSource({
             sourceInstanceKey: accountSourceIdentity?.sourceInstanceKey ?? source.sourceInstanceKey,
             sourceProviderSlug: accountSourceIdentity?.sourceProviderSlug ?? source.sourceProviderSlug,
@@ -7107,7 +8606,15 @@ async function projectJunctionSources(context, providers, options = {}) {
             status: keepHistoricalReconnect
                 ? "error"
                 : source.status,
-            resourceAvailabilitySummary: source.resourceAvailabilitySummary,
+            resourceAvailabilitySummary: {
+                ...source.resourceAvailabilitySummary,
+                ...existingSourceMetadata,
+                ...(typeof historicalBackfillCompletedAt === "string"
+                    ? {
+                        [DEVICE_SYNC_SOURCE_HISTORICAL_BACKFILL_COMPLETED_AT_KEY]: historicalBackfillCompletedAt,
+                    }
+                    : {}),
+            },
             // Only assert error fields when this projection saw an errored entry;
             // omitting the keys lets the store preserve existing detail while the
             // status stays "error" and auto-clear it once the status recovers.
@@ -7130,11 +8637,138 @@ async function projectJunctionSources(context, providers, options = {}) {
         }
     }
 }
+function buildJunctionGoogleHealthCanonicalCoverageFence(sources) {
+    const legacySources = sources.filter((source) => normalizeProviderSlug(source.sourceProviderSlug) === JUNCTION_FITBIT_LEGACY_PROVIDER_SLUG);
+    if (legacySources.length === 0
+        || legacySources.some((source) => !isGoogleHealthFitbitMigrationLegacyTerminal(source))) {
+        return undefined;
+    }
+    const coverageBoundaryByResource = {};
+    for (const resource of [
+        ...JUNCTION_ALLOWED_SUMMARY_RESOURCES,
+        ...JUNCTION_ALLOWED_TIMESERIES_RESOURCES,
+    ]) {
+        const coverageKey = buildDeviceSyncSourceCanonicalCoverageBoundaryKey(resource);
+        if (!coverageKey) {
+            continue;
+        }
+        const summariesWithCoverage = legacySources.flatMap((source) => {
+            const summary = source.resourceAvailabilitySummary;
+            return summary && coverageKey in summary ? [summary] : [];
+        });
+        if (summariesWithCoverage.length === 0) {
+            continue;
+        }
+        const coverageValues = summariesWithCoverage.map((summary) => readDeviceSyncSourceCanonicalCoverageBoundary(summary, resource));
+        if (coverageValues.some((coverage) => coverage === null)) {
+            coverageBoundaryByResource[resource] = null;
+            continue;
+        }
+        const validCoverage = coverageValues.filter((coverage) => coverage !== null);
+        coverageBoundaryByResource[resource] = validCoverage.reduce((latest, coverage) => maxJunctionCanonicalCoverageBoundary(resource, latest, coverage));
+    }
+    return Object.keys(coverageBoundaryByResource).length > 0
+        ? {
+            coverageBoundaryByResource,
+            sourceProviderSlug: JUNCTION_GOOGLE_HEALTH_PROVIDER_SLUG,
+        }
+        : undefined;
+}
+function readJunctionSourceLifecycleEpoch(source) {
+    const lifecycleEpoch = source.lifecycleEpoch;
+    return typeof lifecycleEpoch === "number" && Number.isSafeInteger(lifecycleEpoch) && lifecycleEpoch >= 1
+        ? lifecycleEpoch
+        : 1;
+}
+function captureJunctionSourceLifecycleFence(sources) {
+    return new Map([...buildJunctionCurrentLifecycleSourceMap(sources)]
+        .map(([sourceProviderSlug, sources]) => [
+        sourceProviderSlug,
+        readJunctionSourceLifecycleEpoch(sources[0]),
+    ]));
+}
+function isJunctionSourceLifecycleFenceCurrent(expected, currentSources) {
+    const current = captureJunctionSourceLifecycleFence(currentSources);
+    return current.size === expected.size
+        && [...expected].every(([sourceProviderSlug, lifecycleEpoch]) => current.get(sourceProviderSlug) === lifecycleEpoch);
+}
+function junctionTimeseriesSourceLifecycleSuperseded() {
+    return deviceSyncError({
+        code: "JUNCTION_TIMESERIES_SOURCE_LIFECYCLE_SUPERSEDED",
+        message: "Junction source authorization changed during collection. Retry shortly.",
+        retryable: true,
+        httpStatus: 503,
+    });
+}
+function buildJunctionCurrentLifecycleSourceMap(sources) {
+    const currentByProviderSlug = new Map();
+    for (const source of sources) {
+        const sourceProviderSlug = canonicalizeJunctionProviderSlug(source.sourceProviderSlug);
+        if (!sourceProviderSlug) {
+            continue;
+        }
+        const lifecycleEpoch = readJunctionSourceLifecycleEpoch(source);
+        const current = currentByProviderSlug.get(sourceProviderSlug);
+        const currentLifecycleEpoch = current?.[0]
+            ? readJunctionSourceLifecycleEpoch(current[0])
+            : 0;
+        if (!current || lifecycleEpoch > currentLifecycleEpoch) {
+            currentByProviderSlug.set(sourceProviderSlug, [source]);
+        }
+        else if (lifecycleEpoch === currentLifecycleEpoch) {
+            current.push(source);
+        }
+    }
+    return currentByProviderSlug;
+}
+function selectCurrentJunctionLifecycleSources(sources, sourceProviderSlug) {
+    const canonicalSourceProviderSlug = canonicalizeJunctionProviderSlug(sourceProviderSlug);
+    if (!canonicalSourceProviderSlug) {
+        return [];
+    }
+    return buildJunctionCurrentLifecycleSourceMap(sources).get(canonicalSourceProviderSlug) ?? [];
+}
+function isJunctionLifecycleSourceGroupAdmitted(sources, sourceStatusRequirement) {
+    if (sources.length === 0 || sources.some(isDeviceSyncSourceDisconnectFenced)) {
+        return false;
+    }
+    const status = sources
+        .map((source) => source.status)
+        .reduce(mergeJunctionSourceStatus);
+    return sourceStatusRequirement === "connected"
+        ? status === "connected"
+        : status !== "disconnected";
+}
 function isJunctionSourceAdmittedForImport(sources, sourceProviderSlug, allowUnlistedSources = true, sourceStatusRequirement = "not_disconnected") {
-    const normalizedSourceProviderSlug = normalizeProviderSlug(sourceProviderSlug);
+    const normalizedSourceProviderSlug = canonicalizeJunctionProviderSlug(sourceProviderSlug);
     if (!normalizedSourceProviderSlug) {
         return true;
     }
+    // Junction does not deduplicate equivalent Fitbit and Google Health records.
+    // During migration, keep legacy Fitbit as the sole canonical writer until its
+    // access is explicitly terminal through local cutover or provider-confirmed absence.
+    // A disconnect-in-progress fence blocks both sides so a failed revoke cannot
+    // leave a brief dual-writer interval before the legacy row is restored.
+    if (normalizedSourceProviderSlug === JUNCTION_GOOGLE_HEALTH_PROVIDER_SLUG) {
+        const legacySources = sources.filter((source) => normalizeProviderSlug(source.sourceProviderSlug)
+            === JUNCTION_FITBIT_LEGACY_PROVIDER_SLUG);
+        if (legacySources.length > 0) {
+            const canonicalFence = buildJunctionGoogleHealthCanonicalCoverageFence(sources);
+            const successor = sources.find((source) => normalizeProviderSlug(source.sourceProviderSlug)
+                === JUNCTION_GOOGLE_HEALTH_PROVIDER_SLUG);
+            if (legacySources.some((source) => !isGoogleHealthFitbitMigrationLegacyTerminal(source))
+                || !successor
+                || legacySources.some((source) => !isGoogleHealthFitbitMigrationLegacyCoverageReady({
+                    legacyAccessTerminal: true,
+                    legacySummary: source.resourceAvailabilitySummary,
+                    successorSummary: successor.resourceAvailabilitySummary,
+                }))
+                || (canonicalFence
+                    && Object.values(canonicalFence.coverageBoundaryByResource).some((boundary) => boundary === null))) {
+                return false;
+            }
+        }
+    }
     const accountSourceIdentity = resolveJunctionAccountSourceIdentity(sources, normalizedSourceProviderSlug, allowUnlistedSources);
     if (!accountSourceIdentity) {
         return false;
@@ -7150,7 +8784,7 @@ function isJunctionSourceAdmittedForImport(sources, sourceProviderSlug, allowUnl
             && !isDeviceSyncSourceDisconnectFenced(lifecycleSource);
 }
 function isJunctionSourceProjectionFenced(sources, sourceProviderSlug) {
-    const normalizedSourceProviderSlug = normalizeProviderSlug(sourceProviderSlug);
+    const normalizedSourceProviderSlug = canonicalizeJunctionProviderSlug(sourceProviderSlug);
     if (!normalizedSourceProviderSlug) {
         return false;
     }
@@ -7163,28 +8797,36 @@ function isJunctionSourceProjectionFenced(sources, sourceProviderSlug) {
         && isDeviceSyncSourceDisconnectFenced(sourceState.lifecycleSource);
 }
 function hasJunctionSourceListing(sources, sourceProviderSlug) {
-    const normalizedSourceProviderSlug = normalizeProviderSlug(sourceProviderSlug);
+    const normalizedSourceProviderSlug = canonicalizeJunctionProviderSlug(sourceProviderSlug);
     if (!normalizedSourceProviderSlug) {
         return true;
     }
-    return sources.some((source) => areJunctionProviderSlugsRouteEquivalent(source.sourceProviderSlug, normalizedSourceProviderSlug));
+    return sources.some((source) => areJunctionProviderSlugsDataEquivalent(source.sourceProviderSlug, normalizedSourceProviderSlug));
 }
-async function resolveJunctionCurrentSourceAdmission(context, sourceProviderSlug) {
+async function resolveJunctionCurrentSourceAdmission(context, sourceProviderSlug, expectedLifecycleEpoch) {
     const sources = context.listConnectionSources
-        ? await context.listConnectionSources()
+        ? await context.listConnectionSources({ sourceProviderSlug })
         : context.account.sources ?? [];
-    return resolveJunctionCurrentSourceAdmissionFromSources(sources, sourceProviderSlug, context.connectionSourceAdmissionMode !== "listed_only");
+    return resolveJunctionCurrentSourceAdmissionFromSources(sources, sourceProviderSlug, context.connectionSourceAdmissionMode !== "listed_only", expectedLifecycleEpoch);
 }
-function resolveJunctionCurrentSourceAdmissionFromSources(sources, sourceProviderSlug, allowUnlistedSources) {
+function resolveJunctionCurrentSourceAdmissionFromSources(sources, sourceProviderSlug, allowUnlistedSources, expectedLifecycleEpoch) {
     if (isJunctionSourceProjectionFenced(sources, sourceProviderSlug)) {
         return "fenced";
     }
+    const sourceState = resolveJunctionAccountSourceState(sources, sourceProviderSlug);
+    if (expectedLifecycleEpoch !== undefined
+        && (sourceState === null
+            ? !allowUnlistedSources
+            : readJunctionSourceLifecycleEpoch(sourceState.lifecycleSource)
+                !== expectedLifecycleEpoch)) {
+        return "fenced";
+    }
     return isJunctionSourceAdmittedForImport(sources, sourceProviderSlug, allowUnlistedSources, "connected")
         ? "admitted"
         : "pending";
 }
 async function isJunctionCompanionSourceCurrentlyAdmitted(context, sourceProviderSlug) {
-    const normalizedSourceProviderSlug = normalizeProviderSlug(sourceProviderSlug);
+    const normalizedSourceProviderSlug = canonicalizeJunctionProviderSlug(sourceProviderSlug);
     if (!context.listConnectionSources) {
         throw junctionCompanionSourceStateUnavailableError();
     }
@@ -7203,7 +8845,7 @@ async function isJunctionCompanionSourceCurrentlyAdmitted(context, sourceProvide
         }
         throw junctionCompanionSourceStateUnavailableError(error);
     }
-    if (isDeviceSyncSourceAdmitted(sources, normalizedSourceProviderSlug)) {
+    if (isJunctionSourceAdmittedForImport(sources, normalizedSourceProviderSlug, true, "connected")) {
         return true;
     }
     if (sources.some((source) => source.lastErrorCode === DEVICE_SYNC_SOURCE_USER_DISCONNECTED_ERROR_CODE)) {
@@ -7249,7 +8891,8 @@ function projectJunctionSourcesByProviderSlug(connectionId, providers) {
             sourceProviderSlug: provider.origin.sourceProviderSlug,
             sourceInstanceId: provider.origin.sourceInstanceId,
         });
-        const sourceProviderSlug = normalizeProviderSlug(origin.sourceProviderSlug) ?? normalizeProviderSlug(provider.slug);
+        const sourceProviderSlug = canonicalizeJunctionProviderSlug(origin.sourceProviderSlug)
+            ?? canonicalizeJunctionProviderSlug(provider.slug);
         if (!sourceProviderSlug) {
             continue;
         }
@@ -7264,7 +8907,10 @@ function projectJunctionSourcesByProviderSlug(connectionId, providers) {
         const status = mapJunctionSourceStatus(provider.status);
         const lastErrorCode = status === "error"
             ? truncateJunctionSourceErrorText(provider.errorDetails?.errorType, JUNCTION_SOURCE_ERROR_CODE_MAX_LENGTH)
-            : null;
+            : status === "disconnected"
+                && sourceProviderSlug === JUNCTION_FITBIT_LEGACY_PROVIDER_SLUG
+                ? DEVICE_SYNC_SOURCE_PROVIDER_DISCONNECTED_ERROR_CODE
+                : null;
         const lastErrorMessage = status === "error"
             ? truncateJunctionSourceErrorText(provider.errorDetails?.errorMessage, JUNCTION_SOURCE_ERROR_MESSAGE_MAX_LENGTH)
             : null;
@@ -7272,11 +8918,17 @@ function projectJunctionSourcesByProviderSlug(connectionId, providers) {
         if (existing) {
             mergeJunctionResourceAvailabilitySummary(existing.resourceAvailabilitySummary, resourceAvailabilitySummary);
             existing.status = mergeJunctionSourceStatus(existing.status, status);
-            if (existing.status !== "error") {
+            if (existing.status === "disconnected"
+                && sourceProviderSlug === JUNCTION_FITBIT_LEGACY_PROVIDER_SLUG) {
+                existing.lastErrorCode = DEVICE_SYNC_SOURCE_PROVIDER_DISCONNECTED_ERROR_CODE;
+                existing.lastErrorMessage = null;
+            }
+            else if (existing.status !== "error") {
                 existing.lastErrorCode = null;
                 existing.lastErrorMessage = null;
             }
-            else if (existing.lastErrorCode === null && existing.lastErrorMessage === null) {
+            else if (existing.lastErrorCode === DEVICE_SYNC_SOURCE_PROVIDER_DISCONNECTED_ERROR_CODE
+                || (existing.lastErrorCode === null && existing.lastErrorMessage === null)) {
                 existing.lastErrorCode = lastErrorCode;
                 existing.lastErrorMessage = lastErrorMessage;
             }
@@ -7318,8 +8970,8 @@ function mergeJunctionResourceAvailabilityValue(existing, next) {
     return existing;
 }
 function mergeJunctionSourceStatus(existing, next) {
-    if (existing === "connected" || next === "connected") {
-        return "connected";
+    if (existing === "disconnected" || next === "disconnected") {
+        return "disconnected";
     }
     if (existing === "error" || next === "error") {
         return "error";
@@ -7327,7 +8979,7 @@ function mergeJunctionSourceStatus(existing, next) {
     if (existing === "unavailable" || next === "unavailable") {
         return "unavailable";
     }
-    return "disconnected";
+    return "connected";
 }
 // Derive import identity from the stable Junction user id, never from the
 // local device-sync account row id: row ids are re-minted whenever the
@@ -7496,6 +9148,32 @@ function readProviderSnapshotCanonicalEventExternalRefResourceIds(value) {
         ? resourceIds
         : null;
 }
+function readProviderSnapshotJunctionCanonicalCoverage(value) {
+    const entries = readPlainObject(value)?.junctionCanonicalCoverage;
+    if (!Array.isArray(entries)) {
+        return [];
+    }
+    return entries.flatMap((entry) => {
+        const evidence = readPlainObject(entry);
+        const resource = typeof evidence?.resource === "string" ? evidence.resource : "";
+        const coverageBoundary = normalizeJunctionCanonicalCoverageBoundary(resource, evidence?.coverageBoundary);
+        if (!evidence
+            || !coverageBoundary
+            || !resource
+            || typeof evidence.sourceProviderSlug !== "string") {
+            return [];
+        }
+        const coverageFinalizedAt = toIsoTimestampIfValid(evidence.coverageFinalizedAt);
+        return [{
+                coverageBoundary,
+                ...(coverageFinalizedAt
+                    ? { coverageFinalizedAt }
+                    : {}),
+                resource,
+                sourceProviderSlug: evidence.sourceProviderSlug,
+            }];
+    });
+}
 function uniqueJunctionProviderRecordIdentities(identities) {
     return [...new Set(identities.filter((identity) => identity !== null && JUNCTION_BLOOD_PRESSURE_PROVIDER_RECORD_IDENTITY_PATTERN.test(identity)))].sort();
 }