@murphai/murph 1.3.0 → 1.3.1

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

@@ -1,21 +1,21 @@
 import { createHmac, createHash, timingSafeEqual } from "node:crypto";
-import { HistoricalPullCompleted as JunctionHistoricalPullCompletedSchema } from "@junction-api/sdk/serialization";
-import { COMPANION_HRV_RMSSD_RESOURCE, parseCompanionHrvRmssdAdmissionId, parseSerializedCompanionHrvRmssdObservation, serializeCompanionHrvRmssdObservation, } from "@murphai/contracts";
-import { canNormalizeJunctionSleepCycleRecordToCompactStages, classifyJunctionSummaryNormalizationEvidence, } from "@murphai/importers/device-providers/junction";
-import { resolveJunctionOrigin } from "@murphai/importers/device-providers/junction-origin";
-import { JUNCTION_ALLOWED_SUMMARY_RESOURCES, JUNCTION_ALLOWED_TIMESERIES_RESOURCES, JUNCTION_DEFAULT_SUMMARY_RESOURCES, JUNCTION_DEFAULT_TIMESERIES_RESOURCES, JUNCTION_KNOWN_TIMESERIES_RESOURCES, isJunctionRawDirectIdentityContainerKey, isJunctionRawDirectIdentityKey, normalizeJunctionResourceName, } from "@murphai/importers/device-providers/junction-resources";
+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 { normalizeJunctionSourceProviderSlug, resolveJunctionOrigin, } from "@murphai/importers/device-providers/junction-origin";
+import { isJunctionRawDirectIdentityContainerKey, isJunctionRawDirectIdentityKey, } 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 { addJunctionHistoricalBackfillEvidence, canCurrentRuntimeMutateJunctionHistoricalBackfillProgress, encodeJunctionHistoricalBackfillStatus, hasJunctionHistoricalBackfillEvidence, JUNCTION_HISTORICAL_BACKFILL_COVERAGE_VERSION, JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS, readJunctionHistoricalBackfillEvidence, readJunctionHistoricalBackfillStatus, } from "../junction-historical-backfill-progress.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 { DEVICE_SYNC_METADATA_MAX_STRING_LENGTH } from "../metadata.js";
-import { DEVICE_SYNC_HISTORICAL_DATA_RECONNECT_REQUIRED_ERROR_CODE, isJunctionHistoricalResetProviderSlug, requiresHistoricalResetDeviceSyncSource, } from "../public-account.js";
-import { assertValidJunctionClientUserIdSecret, normalizeJunctionDeviceSyncRuntimeConfig, } from "../configured-provider-runtime-descriptors.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 { 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_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, JunctionCompanionHealthMetadataParseError, parseJunctionCompanionHealthMetadataBatch, } from "../junction-resources.js";
-import { JunctionClient, } from "./junction-client.js";
-import { resolveJunctionDeviceConnectRouteByProviderSlug } from "../config/connect-routes.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 { buildJunctionProviderSourceInstanceKey, JUNCTION_DEFAULT_PROVIDER_FILTER, normalizeJunctionProviderFilter, } from "../config/junction-connect-sources.js";
 import { classifyDeviceSyncWebhookAcceptanceMode } from "../types.js";
 import { evaluatePushPrimarySourceStaleness } from "../source-staleness.js";
@@ -24,14 +24,23 @@ export { JUNCTION_DEVICE_PROVIDER_DESCRIPTOR };
 export { JUNCTION_CONNECT_SOURCE_TARGETS, JUNCTION_DEFAULT_PROVIDER_FILTER, JUNCTION_LINK_PROVIDER_SLUGS, normalizeJunctionProviderFilter, resolveJunctionConnectSourceLabel, resolveJunctionConnectTargetForSourceId, } from "../config/junction-connect-sources.js";
 export const JUNCTION_PROVIDER_CONFIG_KEY = "junction";
 export { JUNCTION_DEFAULT_SUMMARY_RESOURCES, JUNCTION_DEFAULT_TIMESERIES_RESOURCES, };
+const JUNCTION_WORKOUT_STREAM_PROGRESS_VERSION = 1;
+const JUNCTION_DEPLOYED_FULL_JOB_PROGRESS_VERSION = 1;
+const JUNCTION_ALLOWED_TIMESERIES_RESOURCE_SET = new Set(JUNCTION_ALLOWED_TIMESERIES_RESOURCES);
 const JUNCTION_WEBHOOK_ROOT_FIELDS = Object.freeze({
     eventType: "event_type",
     userId: "user_id",
     clientUserId: "client_user_id",
     data: "data",
 });
+// Mirrors the pinned Junction SDK's `serialization.date()` wire validation.
+// Keeping this predicate local avoids loading the SDK's generated runtime tree
+// merely to identify one five-field completion envelope.
+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_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
 // defeat empty-history detection. The provider fetches it through the separate
@@ -66,6 +75,12 @@ const JUNCTION_WEBHOOK_NESTED_RECORD_KEYS = Object.freeze([
 const JUNCTION_TIMESERIES_RESOURCE_NAMES = new Set([
     ...JUNCTION_KNOWN_TIMESERIES_RESOURCES,
 ]);
+const JUNCTION_CLOSED_DAY_TIMESERIES_RESOURCES = new Set([
+    "steps",
+    "distance",
+    "calories_active",
+    "heartrate",
+]);
 const JUNCTION_KNOWN_WEBHOOK_RESOURCE_NAMES = new Set([
     ...JUNCTION_ALLOWED_SUMMARY_RESOURCES,
     ...JUNCTION_ALLOWED_TIMESERIES_RESOURCES,
@@ -73,12 +88,143 @@ 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_BOUNDED_TIMESERIES_BACKFILL_POLICY = Object.freeze({
+    history: "bounded",
+});
+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
+// receive extended history; all other resources use the bounded sync window.
+const JUNCTION_TIMESERIES_BACKFILL_POLICIES = Object.freeze({
+    afib_burden: JUNCTION_SPARSE_DAILY_TIMESERIES_BACKFILL_POLICY,
+    basal_body_temperature: JUNCTION_SPARSE_DAILY_TIMESERIES_BACKFILL_POLICY,
+    blood_oxygen: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    blood_pressure: {
+        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,
+    caffeine: JUNCTION_SPARSE_DAILY_TIMESERIES_BACKFILL_POLICY,
+    calories_active: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    distance: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    glucose: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    heartrate: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    heart_rate_recovery_one_minute: JUNCTION_SPARSE_DAILY_TIMESERIES_BACKFILL_POLICY,
+    hrv: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    mindfulness_minutes: JUNCTION_SPARSE_DAILY_TIMESERIES_BACKFILL_POLICY,
+    note: {
+        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,
+    steps: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    stress_level: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    vo2_max: JUNCTION_SPARSE_DAILY_TIMESERIES_BACKFILL_POLICY,
+    water: JUNCTION_SPARSE_DAILY_TIMESERIES_BACKFILL_POLICY,
+    weight: {
+        anchor: "current_day",
+        completion: "exact_records",
+        history: "extended",
+        version: 1,
+    },
+    body_mass_index: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    carbohydrates: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    fat: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    forced_expiratory_volume_1: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    forced_vital_capacity: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    heart_rate_alert: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    inhaler_usage: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    insulin_injection: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    lean_body_mass: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    peak_expiratory_flow_rate: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    sleep_apnea_alert: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    waist_circumference: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    calories_basal: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    daylight_exposure: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    fall: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    floors_climbed: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    handwashing: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    stand_duration: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    stand_hour: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    uv_exposure: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    wheelchair_push: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    workout_distance: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    workout_duration: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    workout_swimming_stroke: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    electrocardiogram_voltage: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+    workout_stream: JUNCTION_BOUNDED_TIMESERIES_BACKFILL_POLICY,
+});
+function resolveJunctionExtendedTimeseriesBackfillPolicy(resource) {
+    if (!Object.prototype.hasOwnProperty.call(JUNCTION_TIMESERIES_BACKFILL_POLICIES, resource)) {
+        return null;
+    }
+    const policy = JUNCTION_TIMESERIES_BACKFILL_POLICIES[resource];
+    return policy.history === "extended" ? policy : null;
+}
+const JUNCTION_DENSE_FIDELITY_RESOURCE_SET = new Set(JUNCTION_DENSE_FIDELITY_RESOURCES);
+const JUNCTION_CALENDAR_DAY_AGGREGATE_RESOURCE_SET = new Set([
+    ...JUNCTION_DENSE_FIDELITY_RESOURCES,
+    "caffeine",
+    "water",
+    "mindfulness_minutes",
+]);
 const DEFAULT_RECONCILE_DAYS = JUNCTION_DEVICE_PROVIDER_DESCRIPTOR.sync.windows.reconcileDays;
-const DEFAULT_RECONCILE_INTERVAL_MS = JUNCTION_DEVICE_PROVIDER_DESCRIPTOR.sync.windows.reconcileIntervalMs;
 const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
 const DEFAULT_SETUP_TTL_MS = 30 * 60_000;
 const DEFAULT_WEBHOOK_TIMESTAMP_TOLERANCE_MS = 5 * 60_000;
 const TIMESERIES_CHUNK_MS = 24 * 60 * 60_000;
+// A date-only provider query can contain source-local records from UTC-12.
+// Delay calendar-day ownership until that date has closed in every admitted
+// civil offset instead of treating UTC midnight as globally complete.
+const JUNCTION_PROVIDER_CALENDAR_DAY_CLOSE_LAG_MS = 12 * 60 * 60_000;
+const JUNCTION_MAX_SPARSE_CALENDAR_REFRESH_DAYS = 64;
+const JUNCTION_SPARSE_CALENDAR_AGGREGATE_RESOURCE_SET = new Set([
+    "caffeine",
+    "water",
+    "mindfulness_minutes",
+]);
+const TIMESERIES_HOUR_MS = 60 * 60_000;
+// Three single-attempt pages allow ordinary pagination while capping provider
+// wait at 24 seconds, below the hosted job's 45-second outer budget.
+const JUNCTION_FULL_JOB_TIMESERIES_COLLECTION_WORK_LIMIT = Object.freeze({
+    maxAttemptsPerPage: 1,
+    maxPages: 3,
+    requestTimeoutMs: 8_000,
+});
+// Most hosted summary continuation units contain one resource. Match the
+// bounded timeseries contract so a complete three-page unit remains below the
+// 45-second outer maintenance budget and can persist its next cursor.
+const JUNCTION_FULL_JOB_SUMMARY_COLLECTION_WORK_LIMIT = Object.freeze({
+    maxAttemptsPerPage: 1,
+    maxPages: 3,
+    requestTimeoutMs: 8_000,
+});
+// Sleep summaries and sleep cycles share canonical stage ownership, so they
+// must be normalized in one import. Keep their combined worst-case provider
+// wait at 30 seconds to leave room for projection/import inside the hosted
+// worker's 45-second outer maintenance budget.
+const JUNCTION_FULL_JOB_COUPLED_SUMMARY_COLLECTION_WORK_LIMIT = Object.freeze({
+    maxAttemptsPerPage: 1,
+    maxPages: 3,
+    requestTimeoutMs: 5_000,
+});
+const JUNCTION_FULL_JOB_INVENTORY_COLLECTION_WORK_LIMIT = Object.freeze({
+    maxAttemptsPerPage: 1,
+    maxPages: 1,
+    requestTimeoutMs: 8_000,
+});
 const JUNCTION_MAX_DIAGNOSTIC_TIMESERIES_PROBE_DAYS = 14;
 const JUNCTION_DIAGNOSTIC_SHAPE_KEY_LIMIT = 24;
 const JUNCTION_DIAGNOSTIC_RESOURCE_NAME_LIMIT = 64;
@@ -88,18 +234,21 @@ const EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS = Object.freeze([
     6 * 60 * 60_000,
     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;
 export function createJunctionDeviceSyncProvider(config) {
     const runtimeConfig = normalizeJunctionDeviceSyncRuntimeConfig(config);
     const client = new JunctionClient(toClientConfig(config));
-    const { providerFilter, summaryResources, timeseriesResources } = runtimeConfig;
+    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 pushSourceRecoveryEnabled = config.pushSourceRecoveryEnabled === true;
-    const reconcileIntervalMs = config.reconcileIntervalMs ?? DEFAULT_RECONCILE_INTERVAL_MS;
     const webhookTimestampToleranceMs = config.webhookTimestampToleranceMs ?? DEFAULT_WEBHOOK_TIMESTAMP_TOLERANCE_MS;
     async function beginConnection(context) {
         const ownerId = normalizeString(context.ownerId);
@@ -112,7 +261,7 @@ export function createJunctionDeviceSyncProvider(config) {
             });
         }
         const linkProvider = resolveJunctionLinkDirectProvider(providerFilter, context.sourceProviderSlug);
-        const clientUserId = buildJunctionClientUserId(config.clientUserIdSecret, ownerId);
+        const clientUserId = buildJunctionClientUserId(config.clientUserIdSecret, ownerId, clientUserIdNamespace);
         const user = await client.createOrResolveUser(clientUserId);
         const linkToken = await client.createLinkToken({
             userId: user.userId,
@@ -152,7 +301,7 @@ export function createJunctionDeviceSyncProvider(config) {
                 httpStatus: 400,
             });
         }
-        const clientUserId = buildJunctionClientUserId(config.clientUserIdSecret, ownerId);
+        const clientUserId = buildJunctionClientUserId(config.clientUserIdSecret, ownerId, clientUserIdNamespace);
         const user = await client.createOrResolveUser(clientUserId);
         return {
             externalAccountId: user.userId,
@@ -206,6 +355,10 @@ export function createJunctionDeviceSyncProvider(config) {
                 httpStatus: 400,
             });
         }
+        const sourceConnectionWork = buildSourceConnectionWork({
+            now: context.now,
+            sourceProviderSlug: context.sourceProviderSlug,
+        });
         return {
             externalAccountId,
             displayName: "Junction",
@@ -215,8 +368,7 @@ export function createJunctionDeviceSyncProvider(config) {
                 providerConfigKey: JUNCTION_PROVIDER_CONFIG_KEY,
             },
             setupPhase: "link_returned",
-            initialJobs: buildInitialJobs(context.now),
-            nextReconcileAt: addMilliseconds(context.now, reconcileIntervalMs),
+            ...sourceConnectionWork,
         };
     }
     async function revokeAccess(account) {
@@ -261,8 +413,47 @@ export function createJunctionDeviceSyncProvider(config) {
             });
         }
     }
+    async function revokeSourceAccess(account, sourceProviderSlug) {
+        const userId = normalizeString(account.externalAccountId);
+        const targetProviderSlug = normalizeProviderSlug(sourceProviderSlug);
+        if (!userId || !targetProviderSlug) {
+            throw deviceSyncError({
+                code: "JUNCTION_SOURCE_DEREGISTER_INPUT_INVALID",
+                message: "Junction source cleanup requires a stored user and provider slug.",
+                retryable: false,
+                httpStatus: 409,
+            });
+        }
+        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) {
+            return;
+        }
+        await client.deregisterProvider({
+            providerSlug: targetProviderSlug,
+            userId,
+        });
+    }
+    async function isSourceAccessActive(account, sourceProviderSlug) {
+        const userId = normalizeString(account.externalAccountId);
+        const targetProviderSlug = normalizeProviderSlug(sourceProviderSlug);
+        if (!userId || !targetProviderSlug) {
+            throw deviceSyncError({
+                code: "JUNCTION_SOURCE_STATUS_INPUT_INVALID",
+                message: "Junction source status requires a stored user and provider slug.",
+                retryable: false,
+                httpStatus: 409,
+            });
+        }
+        return (await client.listUserProviders(userId)).some((provider) => mapJunctionSourceStatus(provider.status) === "connected"
+            && (normalizeProviderSlug(provider.origin.sourceProviderSlug)
+                ?? normalizeProviderSlug(provider.slug)) === targetProviderSlug);
+    }
     function createScheduledJobs(account, now) {
         const scheduledHistoricalBackfillJobs = buildScheduledHistoricalBackfillJobs(account, now);
+        const scheduledExtendedTimeseriesBackfillJobs = buildScheduledExtendedTimeseriesBackfillJobs(account, now);
         const nextReconcileAt = resolveJunctionNextReconcileAt(account, now, addMilliseconds(now, reconcileIntervalMs));
         return {
             jobs: [
@@ -273,11 +464,61 @@ export function createJunctionDeviceSyncProvider(config) {
                     priority: JUNCTION_SCHEDULED_RECONCILE_PRIORITY,
                 }),
                 ...scheduledHistoricalBackfillJobs,
+                ...scheduledExtendedTimeseriesBackfillJobs,
                 ...buildPushSourceRecoveryJobs(account, now),
             ],
             nextReconcileAt,
         };
     }
+    function buildScheduledExtendedTimeseriesBackfillJobs(account, now) {
+        return extendedBackfillTimeseriesResources.flatMap((resource) => {
+            const policy = resolveJunctionExtendedTimeseriesBackfillPolicy(resource);
+            if (!policy) {
+                return [];
+            }
+            if (!canCurrentRuntimeMutateJunctionExtendedTimeseriesHistoryBackfillCoverage(account.metadata, resource, policy.version)) {
+                return [];
+            }
+            const scheduledSources = new Map();
+            for (const sourceState of resolveJunctionAccountSourceStates(account.sources ?? [])) {
+                const identitySource = sourceState.identitySource;
+                const lifecycleSource = sourceState.lifecycleSource;
+                const sourceProviderSlug = normalizeProviderSlug(identitySource.sourceProviderSlug);
+                if (!sourceProviderSlug
+                    || !isDeviceSyncSourceAdmitted([lifecycleSource], lifecycleSource.sourceProviderSlug)
+                    || !isJunctionResourceAvailableInSummary(lifecycleSource.resourceAvailabilitySummary, resource)
+                    || hasJunctionExtendedTimeseriesHistoryBackfillCoverage(account.metadata, sourceProviderSlug, resource, policy.version)
+                    || !canRepresentJunctionExtendedTimeseriesHistoryBackfillCoverage(account.metadata, sourceProviderSlug, resource, policy.version)) {
+                    continue;
+                }
+                const sourceFirstSeenAt = identitySource.firstSeenAt;
+                if (!sourceFirstSeenAt) {
+                    throw junctionSourceStateUnavailableError();
+                }
+                const existingFirstSeenAt = scheduledSources.get(sourceProviderSlug);
+                if (!existingFirstSeenAt || Date.parse(sourceFirstSeenAt) < Date.parse(existingFirstSeenAt)) {
+                    scheduledSources.set(sourceProviderSlug, sourceFirstSeenAt);
+                }
+            }
+            return [...scheduledSources.entries()].map(([sourceProviderSlug, firstSeenAt]) => {
+                // 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,
+                });
+                return buildExtendedTimeseriesBackfillJob({
+                    availableAt: now,
+                    ...(resource === "note" ? { historicalBackfillVersion: policy.version } : {}),
+                    historicalWindowStart: window.windowStart,
+                    resource,
+                    sourceProviderSlug,
+                    windowEnd: window.windowEnd,
+                    windowStart: window.windowStart,
+                });
+            });
+        });
+    }
     /**
      * A dead push carrier cannot recover on its own and no pull can rediscover
      * its data, so the scheduler turns a detected stall into a bounded recovery
@@ -507,15 +748,22 @@ export function createJunctionDeviceSyncProvider(config) {
     }
     async function executeJob(context, job) {
         const skippedOptionalResources = [];
+        const completedWorkoutStreamIdentities = readJunctionWorkoutStreamCompletedIdentities(job);
         if (job.kind === "resource") {
-            return executeResourceJob(context, job, skippedOptionalResources);
+            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 isConnectHistoricalBackfill = isConnectHistoricalBackfillWindow(context.account, window);
         const sourceProviders = await 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);
@@ -526,16 +774,43 @@ export function createJunctionDeviceSyncProvider(config) {
         const summaryDateQueryFormat = job.kind === "reconcile" && !isCurrentSummaryReconcile && isFullUtcDayWindow(summaryWindow)
             ? "date"
             : "datetime";
-        const summaries = await fetchSummarySnapshots(context, summaryWindow.windowStart, summaryWindow.windowEnd, skippedOptionalResources, { dateQueryFormat: summaryDateQueryFormat });
-        const profileSummaryResult = await fetchProfileSummaryOnce(context, skippedOptionalResources);
+        if (job.kind === "reconcile"
+            && context.shouldYield
+            && job.payload.summaryPhaseComplete !== true) {
+            const boundedSummaryResult = await executeBoundedSummaryReconcile({
+                context,
+                dateQueryFormat: summaryDateQueryFormat,
+                job,
+                skippedOptionalResources,
+                sourceProviders,
+                summaryWindow,
+                window,
+            });
+            if (boundedSummaryResult) {
+                return boundedSummaryResult;
+            }
+        }
+        const summaryPhaseComplete = job.kind === "reconcile" && job.payload.summaryPhaseComplete === true;
+        const summaries = summaryPhaseComplete
+            ? {}
+            : await fetchSummarySnapshots(context, summaryWindow.windowStart, summaryWindow.windowEnd, skippedOptionalResources, { dateQueryFormat: summaryDateQueryFormat });
+        const profileSummaryResult = summaryPhaseComplete
+            ? { checked: false, records: [] }
+            : await fetchProfileSummaryOnce(context, skippedOptionalResources);
         const profileMetadataPatch = profileSummaryResult.checked
             ? buildJunctionProfileSummaryCheckedMetadataPatch(context)
             : {};
         if (profileSummaryResult.records.length > 0) {
             summaries[JUNCTION_PROFILE_SUMMARY_RESOURCE] = profileSummaryResult.records;
         }
-        const importConnections = sanitizeJunctionImportConnections(sourceProviders);
-        const importSummaries = sanitizeJunctionImportSnapshots(summaries, sourceProviders);
+        const summaryHasFetchedRecords = hasJunctionSnapshotRecords(summaries);
+        const preparedSummaryImport = job.kind === "backfill"
+            && !summaryHasFetchedRecords
+            && context.shouldYield?.() === true
+            ? prepareJunctionImportSnapshotForSources(summaries, sourceProviders, context.account.sources ?? [])
+            : await prepareJunctionImportSnapshot(context, summaries, sourceProviders);
+        const importConnections = preparedSummaryImport.connections;
+        const importSummaries = preparedSummaryImport.snapshots;
         const summaryNormalizationEvidence = classifyJunctionSummaryNormalizationEvidence({
             connections: importConnections,
             importedAt: summaryWindow.windowEnd,
@@ -544,16 +819,9 @@ export function createJunctionDeviceSyncProvider(config) {
             windowStart: summaryWindow.windowStart,
         });
         const historicalSummaryHasRecords = hasJunctionHistoricalBackfillSummaryRecords(summaryNormalizationEvidence);
-        const summaryHasFetchedRecords = hasJunctionSnapshotRecords(summaries);
         const baseTimeseriesWindowStart = job.kind === "backfill"
             ? maxIsoTimestamp(window.windowStart, subtractDays(window.windowEnd, timeseriesBackfillDays))
             : window.windowStart;
-        const timeseriesCursor = job.kind === "backfill"
-            ? readBackfillTimeseriesCursor(job, window)
-            : null;
-        const timeseriesWindowStart = timeseriesCursor
-            ? maxIsoTimestamp(baseTimeseriesWindowStart, timeseriesCursor)
-            : baseTimeseriesWindowStart;
         if (job.kind !== "backfill" || summaryHasFetchedRecords) {
             await context.importSnapshot({
                 provider: "junction",
@@ -572,19 +840,24 @@ export function createJunctionDeviceSyncProvider(config) {
         const historicalPullSnapshot = isConnectHistoricalBackfill && !context.shouldYield?.()
             ? await loadJunctionHistoricalPullSnapshot(context)
             : null;
-        const historicalSummaryCoverage = evaluateJunctionHistoricalBackfillCoverage(summaryNormalizationEvidence, sourceProviders, summaryResources, providerFilter, historicalPullSnapshot, isConnectHistoricalBackfill
+        const historicalSummaryCoverage = evaluateJunctionHistoricalBackfillCoverage(summaryNormalizationEvidence, preparedSummaryImport.sourceProviders, summaryResources, providerFilter, historicalPullSnapshot, isConnectHistoricalBackfill
             ? readJunctionHistoricalBackfillEvidence(context.account.metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.evidence])
             : null, window);
-        if (job.kind === "backfill"
-            || shouldImportClosedTimeseriesForReconcile(context.account.lastSyncCompletedAt, window.windowEnd)) {
-            const timeseriesImport = await importTimeseriesDailySnapshots(context, sourceProviders, timeseriesWindowStart, window.windowEnd, skippedOptionalResources);
+        const shouldImportBroadClosedTimeseries = job.kind === "backfill"
+            || shouldImportClosedTimeseriesForReconcile(context.account.lastSyncCompletedAt, window.windowEnd);
+        const hourlyFidelityWindow = shouldImportBroadClosedTimeseries
+            ? null
+            : resolveLatestGloballyClosedProviderDayWindow(baseTimeseriesWindowStart, window.windowEnd, context.now);
+        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);
             if (timeseriesImport.yieldedAt) {
                 return withJunctionSkippedResourceMetadata(context, withJunctionMetadataPatch(buildYieldedJunctionJobResult({
                     context,
                     job,
                     windowEnd: window.windowEnd,
-                    windowStart: job.kind === "backfill" ? window.windowStart : timeseriesImport.yieldedAt,
-                    timeseriesCursor: job.kind === "backfill" ? timeseriesImport.yieldedAt : null,
+                    windowStart: timeseriesImport.yieldedAt,
                 }), profileMetadataPatch), skippedOptionalResources);
             }
         }
@@ -623,7 +896,7 @@ export function createJunctionDeviceSyncProvider(config) {
                 || (historicalSummaryCoverage.complete
                     && historicalStatusBeforeJob?.status === "exhausted"))) {
             const pendingProviderSlugs = new Set(historicalSummaryCoverage.pendingProviderSlugs);
-            const hasCoveredProvider = sourceProviders.some((provider) => {
+            const hasCoveredProvider = preparedSummaryImport.sourceProviders.some((provider) => {
                 const providerSlug = resolveJunctionHistoricalCoverageProviderSlug(provider.origin.sourceProviderSlug ?? provider.slug, providerFilter);
                 return providerSlug !== null
                     && mapJunctionSourceStatus(provider.status) !== "disconnected"
@@ -639,6 +912,29 @@ export function createJunctionDeviceSyncProvider(config) {
             }
         }
         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
+            ? buildFullJobTimeseriesContinuationJob({
+                deferredEmptyBackfillAttempts: readDeferredEmptyBackfillAttempts(backfillFollowUp),
+                job,
+                timeseriesCursor: baseTimeseriesWindowStart,
+                timeseriesResourceCursor: timeseriesResources[0] ?? null,
+                timeseriesWindowHours: 24,
+                window,
+                workoutStreamCursor: null,
+            })
+            : null;
+        if (timeseriesContinuation) {
+            return withJunctionSkippedResourceMetadata(context, withJunctionMetadataPatch({
+                ...(backfillFollowUp.metadataPatch
+                    ? { metadataPatch: backfillFollowUp.metadataPatch }
+                    : {}),
+                nextReconcileAt,
+                scheduledJobs: [{ ...timeseriesContinuation, availableAt: context.now }],
+            }, profileMetadataPatch), skippedOptionalResources);
+        }
         return withJunctionSkippedResourceMetadata(context, withJunctionMetadataPatch({
             ...backfillFollowUp,
             nextReconcileAt,
@@ -772,7 +1068,7 @@ export function createJunctionDeviceSyncProvider(config) {
         const timeseriesDiagnostics = [];
         if (timeseriesProbeWindow) {
             for (const resource of timeseriesResources) {
-                const resourceResult = await runJunctionDiagnosticCall(() => client.listTimeseries({
+                const resourceResult = await runJunctionDiagnosticCall(() => fetchJunctionTimeseriesWindow(client, {
                     resource,
                     userId: context.account.externalAccountId,
                     windowStart: timeseriesProbeWindow.windowStart,
@@ -969,7 +1265,7 @@ export function createJunctionDeviceSyncProvider(config) {
         const sourceProviderSlug = normalizeProviderSlug(context.sourceProviderSlug);
         const resourceCategory = endpoint;
         const resourceResult = await runJunctionDiagnosticCall(() => resourceCategory === "timeseries"
-            ? client.listTimeseries({
+            ? fetchJunctionTimeseriesWindow(client, {
                 resource: normalizedResource,
                 sourceProviderSlug,
                 userId: context.account.externalAccountId,
@@ -990,9 +1286,7 @@ export function createJunctionDeviceSyncProvider(config) {
                 request: {
                     configuredResource: isConfiguredJunctionResource(resourceCategory, normalizedResource),
                     endpoint: resourceCategory,
-                    endpointKind: resourceCategory === "timeseries"
-                        ? "junction_timeseries_collection"
-                        : "junction_summary_collection",
+                    endpointKind: resolveJunctionDiagnosticEndpointKind(resourceCategory, normalizedResource),
                     queryParameterNames: resolveJunctionDiagnosticResourceQueryParameterNames(resourceCategory, normalizedResource, sourceProviderSlug),
                     resource: normalizedResource,
                     resourceCategory,
@@ -1003,8 +1297,9 @@ export function createJunctionDeviceSyncProvider(config) {
             },
         };
     }
-    async function executeResourceJob(context, job, skippedOptionalResources) {
-        if (normalizeString(job.payload.resource) === COMPANION_HRV_RMSSD_RESOURCE) {
+    async function executeResourceJob(context, job, skippedOptionalResources, completedWorkoutStreamIdentities) {
+        const resourceName = normalizeString(job.payload.resource);
+        if (resourceName === COMPANION_HRV_RMSSD_RESOURCE) {
             let observation;
             let admissionId;
             try {
@@ -1024,6 +1319,9 @@ export function createJunctionDeviceSyncProvider(config) {
                     retryable: false,
                 });
             }
+            if (!await isJunctionCompanionSourceCurrentlyAdmitted(context, JUNCTION_COMPANION_HRV_SOURCE_PROVIDER)) {
+                return {};
+            }
             await context.importSnapshot({
                 provider: "junction",
                 accountId: buildJunctionImportAccountId(context.account.externalAccountId),
@@ -1036,14 +1334,26 @@ export function createJunctionDeviceSyncProvider(config) {
         const window = resolveJobWindow(job, context.now, reconcileDays);
         if (normalizeString(job.payload.resource) === JUNCTION_COMPANION_HEALTH_METADATA_RESOURCE) {
             const records = parseJunctionCompanionHealthMetadataJob(job);
+            if (!await isJunctionCompanionSourceCurrentlyAdmitted(context, JUNCTION_COMPANION_HEALTH_METADATA_SOURCE_PROVIDER)) {
+                return {};
+            }
             await importJunctionCompanionHealthMetadataSnapshot(context, records);
             return {
                 nextReconcileAt: clampWebhookJobNextReconcileAt(context),
             };
         }
+        const calendarRefreshDay = readJunctionSparseCalendarRefreshDay(job);
         const resource = normalizeJunctionResourceName(job.payload.resource);
         const resourceCategory = normalizeString(job.payload.resourceCategory);
         const sourceProviderSlug = normalizeProviderSlug(job.payload.sourceProviderSlug);
+        if (!calendarRefreshDay
+            && sourceProviderSlug
+            && !isJunctionSourceAdmittedForImport(context.account.sources ?? [], sourceProviderSlug)
+            && (resource === null
+                || !isJunctionExtendedTimeseriesBackfillJob(job, resource)
+                || isJunctionSourceProjectionFenced(context.account.sources ?? [], sourceProviderSlug))) {
+            return {};
+        }
         let listedSourceProviders = null;
         let projectedSourceProviders = null;
         const loadSourceProviders = async () => {
@@ -1065,10 +1375,73 @@ export function createJunctionDeviceSyncProvider(config) {
             projectedSourceProviders = sourceProviders;
             return sourceProviders;
         };
+        if (calendarRefreshDay) {
+            if (!resource
+                || !JUNCTION_SPARSE_CALENDAR_AGGREGATE_RESOURCE_SET.has(resource)
+                || !isConfiguredJunctionResource("timeseries", resource)) {
+                throw deviceSyncError({
+                    code: JUNCTION_CALENDAR_REFRESH_JOB_INVALID_CODE,
+                    message: "Junction calendar refresh job did not name an admitted sparse resource.",
+                    retryable: false,
+                });
+            }
+            const queuedCalendarSourceIdentity = readJunctionSparseCalendarSourceIdentity(job);
+            const currentSources = context.listConnectionSources
+                ? await context.listConnectionSources()
+                : context.account.sources ?? [];
+            const accountSourceIdentity = resolveJunctionAccountSourceIdentity(currentSources, queuedCalendarSourceIdentity.sourceProviderSlug, context.connectionSourceAdmissionMode !== "listed_only");
+            if (!accountSourceIdentity
+                || !isJunctionSourceAdmittedForImport(currentSources, sourceProviderSlug, context.connectionSourceAdmissionMode !== "listed_only", "connected")) {
+                throw deviceSyncError({
+                    code: "JUNCTION_CALENDAR_REFRESH_SOURCE_AUTHORITY_UNAVAILABLE",
+                    message: "Junction calendar source authority is temporarily unavailable.",
+                    retryable: true,
+                });
+            }
+            const sourceProviders = await loadAndProjectSourceProviders();
+            const calendarSourceIdentity = {
+                ...queuedCalendarSourceIdentity,
+                sourceProviderSlug: accountSourceIdentity.sourceProviderSlug,
+                ...(accountSourceIdentity.sourceInstanceId
+                    ? { sourceInstanceId: accountSourceIdentity.sourceInstanceId }
+                    : {}),
+            };
+            const calendarFetchSourceProviderSlug = resolveJunctionProviderRouteSlug(queuedCalendarSourceIdentity.sourceProviderSlug);
+            const windowStart = `${calendarRefreshDay}T00:00:00.000Z`;
+            const dailyImport = await importTimeseriesDailyAggregateSnapshots(context, sourceProviders, windowStart, addMilliseconds(windowStart, TIMESERIES_CHUNK_MS), skippedOptionalResources, [resource], calendarFetchSourceProviderSlug, calendarSourceIdentity);
+            const expectedDailyAggregateResourceId = buildJunctionDailyTimeseriesAggregateResourceId({
+                dayKey: calendarRefreshDay,
+                resource,
+                ...calendarSourceIdentity,
+            });
+            if (!dailyImport.yieldedAt
+                && !dailyImport.appliedDailyAggregateResourceIds?.includes(expectedDailyAggregateResourceId)) {
+                throw deviceSyncError({
+                    code: "JUNCTION_CALENDAR_REFRESH_DAILY_STATE_NOT_APPLIED",
+                    message: "Junction calendar refresh did not apply its owned daily state.",
+                    retryable: true,
+                });
+            }
+            const followUp = dailyImport.yieldedAt
+                ? buildJunctionSparseCalendarRefreshJob({
+                    dayKey: calendarRefreshDay,
+                    priority: job.priority,
+                    resource,
+                    ...calendarSourceIdentity,
+                })
+                : null;
+            return withJunctionSkippedResourceMetadata(context, {
+                ...(followUp ? { scheduledJobs: [followUp] } : {}),
+                nextReconcileAt: clampWebhookJobNextReconcileAt(context),
+            }, skippedOptionalResources);
+        }
         const summaries = {};
         if (resource) {
             const directInput = readJunctionDirectResourceJobInput(job, window);
             if (directInput) {
+                if (!isJunctionSourceAdmittedForImport(context.account.sources ?? [], directInput.sourceProviderSlug)) {
+                    return {};
+                }
                 // This lookup uses the stable provider-config authority, not the
                 // replaceable per-connection credential epoch. It resolves source
                 // provenance only; the accepted inline payload remains the data
@@ -1132,19 +1505,307 @@ export function createJunctionDeviceSyncProvider(config) {
                 inferredCategory = fallback.category;
             }
             if (inferredCategory === "timeseries") {
-                const sourceProviders = await loadAndProjectSourceProviders();
-                const timeseriesImport = await importTimeseriesPreciseSnapshots(context, sourceProviders, window.windowStart, window.windowEnd, skippedOptionalResources, [effectiveResource], sourceProviderSlug);
+                const extendedHistoricalBackfill = isJunctionExtendedTimeseriesBackfillJob(job, effectiveResource);
+                const extendedHistoricalPolicy = extendedHistoricalBackfill
+                    ? resolveJunctionExtendedTimeseriesBackfillPolicy(effectiveResource)
+                    : null;
+                if (extendedHistoricalPolicy
+                    && !canCurrentRuntimeMutateJunctionExtendedTimeseriesHistoryBackfillCoverage(context.account.metadata, effectiveResource, extendedHistoricalPolicy.version)) {
+                    return {};
+                }
+                if (extendedHistoricalPolicy
+                    && sourceProviderSlug
+                    && !canRepresentJunctionExtendedTimeseriesHistoryBackfillCoverage(context.account.metadata, sourceProviderSlug, effectiveResource, extendedHistoricalPolicy.version)) {
+                    throw deviceSyncError({
+                        code: "JUNCTION_EXTENDED_HISTORY_COVERAGE_UNREPRESENTABLE",
+                        message: "Junction extended-history completion could not be retained exactly.",
+                        retryable: false,
+                    });
+                }
+                const historicalWindowStart = toIsoTimestampIfValid(normalizeString(job.payload.historicalWindowStart))
+                    ?? window.windowStart;
+                const dailyAggregateRetryAttempts = readHistoricalBackfillJobEmptyAttempts(job);
+                let sourceProviders;
+                let sourceIdentityAuthority;
+                let currentSourceAdmission = "admitted";
+                try {
+                    sourceProviders = await loadAndProjectSourceProviders();
+                    if (extendedHistoricalBackfill && sourceProviderSlug) {
+                        sourceIdentityAuthority = context.listConnectionSources
+                            ? await context.listConnectionSources()
+                            : context.account.sources ?? [];
+                        currentSourceAdmission = resolveJunctionCurrentSourceAdmissionFromSources(sourceIdentityAuthority, sourceProviderSlug, context.connectionSourceAdmissionMode !== "listed_only");
+                    }
+                }
+                catch (error) {
+                    if (extendedHistoricalBackfill
+                        && (job.payload.historicalProviderRecordsSeen === true
+                            || job.payload.historicalRecordsSeen === true)
+                        && isRetryableDeviceSyncFailure(error)) {
+                        return withJunctionExtendedTimeseriesBackfillFollowUp({
+                            context,
+                            importResult: {
+                                acceptedProviderRecordCount: 0,
+                                canonicalProviderRecordIdentities: [],
+                                canonicalEventCount: 0,
+                                canonicalEventDayKeys: [],
+                                canonicalSparseCalendarTargets: [],
+                                fetchComplete: false,
+                                providerRecordsExamined: false,
+                                providerRecordCount: 0,
+                                unresolvedProviderRecordIdentities: [],
+                                unresolvedProviderRecordCount: 0,
+                                unresolvedProviderRecordsWithoutStableIdentity: false,
+                                yieldedAt: null,
+                            },
+                            job,
+                            resource: effectiveResource,
+                            result: {
+                                nextReconcileAt: clampWebhookJobNextReconcileAt(context),
+                            },
+                            window,
+                        });
+                    }
+                    throw error;
+                }
+                if (currentSourceAdmission === "fenced") {
+                    return {};
+                }
+                if (extendedHistoricalBackfill
+                    && (currentSourceAdmission !== "admitted"
+                        || !isJunctionSourceResourceCurrentlyAvailable({
+                            connectionId: context.account.id,
+                            providers: sourceProviders,
+                            resource: effectiveResource,
+                            sourceProviderSlug,
+                        }))) {
+                    const result = {
+                        nextReconcileAt: clampWebhookJobNextReconcileAt(context),
+                    };
+                    if (job.payload.historicalProviderRecordsSeen !== true
+                        && job.payload.historicalRecordsSeen !== true) {
+                        return result;
+                    }
+                    return withJunctionExtendedTimeseriesBackfillFollowUp({
+                        context,
+                        importResult: {
+                            acceptedProviderRecordCount: 0,
+                            canonicalProviderRecordIdentities: [],
+                            canonicalEventCount: 0,
+                            canonicalEventDayKeys: [],
+                            canonicalSparseCalendarTargets: [],
+                            fetchComplete: false,
+                            providerRecordsExamined: false,
+                            providerRecordCount: 0,
+                            unresolvedProviderRecordIdentities: [],
+                            unresolvedProviderRecordCount: 0,
+                            unresolvedProviderRecordsWithoutStableIdentity: false,
+                            yieldedAt: null,
+                        },
+                        job,
+                        resource: effectiveResource,
+                        result,
+                        window,
+                    });
+                }
+                if (extendedHistoricalPolicy?.completion === "daily_aggregate"
+                    && window.windowStart === historicalWindowStart) {
+                    const historicalPullReadiness = resolveJunctionHistoricalPullReadiness({
+                        resource: effectiveResource,
+                        snapshot: await loadJunctionHistoricalPullSnapshot(context),
+                        sourceProviderSlug,
+                    });
+                    if (historicalPullReadiness === "no_obligation") {
+                        return withJunctionExtendedTimeseriesBackfillFollowUp({
+                            context,
+                            historicalPullReadiness,
+                            importResult: {
+                                acceptedProviderRecordCount: 0,
+                                canonicalProviderRecordIdentities: [],
+                                canonicalEventCount: 0,
+                                canonicalEventDayKeys: [],
+                                canonicalSparseCalendarTargets: [],
+                                fetchComplete: true,
+                                providerRecordsExamined: false,
+                                providerRecordCount: 0,
+                                unresolvedProviderRecordIdentities: [],
+                                unresolvedProviderRecordCount: 0,
+                                unresolvedProviderRecordsWithoutStableIdentity: false,
+                                yieldedAt: null,
+                            },
+                            job,
+                            resource: effectiveResource,
+                            result: { nextReconcileAt: clampWebhookJobNextReconcileAt(context) },
+                            window,
+                        });
+                    }
+                    if (historicalPullReadiness === "pending") {
+                        const retryDelayMs = EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS.at(-1) ?? 0;
+                        return {
+                            nextReconcileAt: clampWebhookJobNextReconcileAt(context),
+                            scheduledJobs: [buildExtendedTimeseriesBackfillJob({
+                                    availableAt: addMilliseconds(context.now, retryDelayMs),
+                                    dedupeKey: job.dedupeKey,
+                                    historicalWindowStart,
+                                    resource: effectiveResource,
+                                    sourceProviderSlug,
+                                    windowEnd: window.windowEnd,
+                                    windowStart: window.windowStart,
+                                })],
+                        };
+                    }
+                    if (historicalPullReadiness === "terminal_failure") {
+                        return { nextReconcileAt: clampWebhookJobNextReconcileAt(context) };
+                    }
+                }
+                const timeseriesPolicy = resolveJunctionTimeseriesResourcePolicy(effectiveResource);
+                if (JUNCTION_DENSE_FIDELITY_RESOURCE_SET.has(effectiveResource)) {
+                    const dailyImport = await importTimeseriesDailyAggregateSnapshots(context, sourceProviders, window.windowStart, window.windowEnd, skippedOptionalResources, [effectiveResource], sourceProviderSlug);
+                    if (dailyImport.yieldedAt) {
+                        return withJunctionSkippedResourceMetadata(context, buildYieldedJunctionJobResult({
+                            context,
+                            job,
+                            windowEnd: window.windowEnd,
+                            windowStart: dailyImport.yieldedAt,
+                        }), skippedOptionalResources);
+                    }
+                    return withJunctionHistoricalCoverageVerification(context, job, window, withJunctionSkippedResourceMetadata(context, { nextReconcileAt: clampWebhookJobNextReconcileAt(context) }, skippedOptionalResources));
+                }
+                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 result = withJunctionSkippedResourceMetadata(context, dailyImport.yieldedAt
+                        ? buildYieldedJunctionJobResult({
+                            context,
+                            job,
+                            windowEnd: window.windowEnd,
+                            windowStart: dailyImport.yieldedAt,
+                            workoutStreamCursor: effectiveResource === "workout_stream"
+                                ? dailyImport.workoutStreamCursor
+                                : undefined,
+                        })
+                        : { nextReconcileAt: clampWebhookJobNextReconcileAt(context) }, skippedOptionalResources);
+                    return result;
+                }
+                const timeseriesImport = await importTimeseriesPreciseSnapshots(context, sourceProviders, window.windowStart, window.windowEnd, skippedOptionalResources, [effectiveResource], sourceProviderSlug, {
+                    dateQueryFormat: extendedHistoricalPolicy?.completion === "daily_aggregate"
+                        ? "date"
+                        : "datetime",
+                    historicalProviderRecordsSeen: job.payload.historicalProviderRecordsSeen === true,
+                    preservePartialRetryableFailure: extendedHistoricalBackfill,
+                    ...(sourceIdentityAuthority ? { sourceIdentityAuthority } : {}),
+                    sourceStatusRequirement: extendedHistoricalBackfill
+                        ? "connected"
+                        : undefined,
+                });
+                const calendarRefreshJobs = JUNCTION_SPARSE_CALENDAR_AGGREGATE_RESOURCE_SET.has(effectiveResource)
+                    ? buildJunctionSparseCalendarRefreshJobs({
+                        asOf: context.now,
+                        priority: job.priority,
+                        resource: effectiveResource,
+                        targets: timeseriesImport.canonicalSparseCalendarTargets,
+                    })
+                    : [];
+                const finalizePreciseImportResult = (result) => calendarRefreshJobs.length === 0
+                    ? result
+                    : {
+                        ...result,
+                        scheduledJobs: [
+                            ...(result.scheduledJobs ?? []),
+                            ...calendarRefreshJobs,
+                        ],
+                    };
+                if (extendedHistoricalBackfill
+                    && timeseriesImport.postFetchSourceAdmission === "fenced") {
+                    return finalizePreciseImportResult({});
+                }
+                if (extendedHistoricalBackfill
+                    && timeseriesImport.postFetchSourceAdmission === "pending"
+                    && job.payload.historicalProviderRecordsSeen !== true
+                    && job.payload.historicalRecordsSeen !== true
+                    && timeseriesImport.providerRecordCount === 0) {
+                    return finalizePreciseImportResult(withJunctionSkippedResourceMetadata(context, {
+                        nextReconcileAt: clampWebhookJobNextReconcileAt(context),
+                    }, skippedOptionalResources));
+                }
+                const historicalRecordsSeen = extendedHistoricalBackfill
+                    ? job.payload.historicalRecordsSeen === true
+                        || timeseriesImport.canonicalEventCount > 0
+                        || (effectiveResource === "weight"
+                            && timeseriesImport.providerRecordsExamined)
+                    : undefined;
+                const dailyAggregateNeedsRetry = extendedHistoricalPolicy?.completion === "daily_aggregate"
+                    && timeseriesImport.providerRecordCount > 0
+                    && timeseriesImport.acceptedProviderRecordCount < timeseriesImport.providerRecordCount
+                    && dailyAggregateRetryAttempts < EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS.length;
+                if (dailyAggregateNeedsRetry) {
+                    const retryAttempts = dailyAggregateRetryAttempts + 1;
+                    const retryDelayMs = EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS[retryAttempts - 1] ?? 0;
+                    return finalizePreciseImportResult(withJunctionSkippedResourceMetadata(context, {
+                        nextReconcileAt: clampWebhookJobNextReconcileAt(context),
+                        scheduledJobs: [buildExtendedTimeseriesBackfillJob({
+                                availableAt: addMilliseconds(context.now, retryDelayMs),
+                                dedupeKey: job.dedupeKey,
+                                emptyBackfillAttempts: retryAttempts,
+                                historicalRecordsSeen,
+                                historicalWindowStart,
+                                resource: effectiveResource,
+                                sourceProviderSlug,
+                                windowEnd: window.windowEnd,
+                                windowStart: window.windowStart,
+                            })],
+                    }, skippedOptionalResources));
+                }
+                const historicalUnresolvedProviderRecords = extendedHistoricalBackfill
+                    && extendedHistoricalPolicy?.completion !== "daily_aggregate"
+                    ? resolveJunctionHistoricalUnresolvedProviderRecords(job, timeseriesImport)
+                    : undefined;
+                const historicalUnresolvedProviderRecordCount = historicalUnresolvedProviderRecords === undefined
+                    ? undefined
+                    : countJunctionHistoricalUnresolvedProviderRecords(historicalUnresolvedProviderRecords);
+                const historicalUnresolvedProviderRecordIdentitiesJson = historicalUnresolvedProviderRecords === undefined
+                    ? undefined
+                    : encodeJunctionHistoricalUnresolvedProviderRecords(historicalUnresolvedProviderRecords);
+                const historicalProviderRecordsSeen = historicalUnresolvedProviderRecordCount === undefined
+                    ? undefined
+                    : historicalUnresolvedProviderRecordCount > 0;
                 if (timeseriesImport.yieldedAt) {
-                    return withJunctionSkippedResourceMetadata(context, buildYieldedJunctionJobResult({
+                    const yieldedResult = buildYieldedJunctionJobResult({
                         context,
+                        emptyBackfillAttempts: extendedHistoricalPolicy?.completion === "daily_aggregate"
+                            ? 0
+                            : undefined,
+                        historicalProviderRecordsSeen,
+                        historicalRecordsSeen,
+                        historicalUnresolvedProviderRecordIdentitiesJson,
+                        historicalUnresolvedProviderRecordCount,
                         job,
                         windowEnd: window.windowEnd,
                         windowStart: timeseriesImport.yieldedAt,
-                    }), skippedOptionalResources);
+                    });
+                    return finalizePreciseImportResult(withJunctionSkippedResourceMetadata(context, yieldedResult, skippedOptionalResources));
                 }
-                return withJunctionHistoricalCoverageVerification(context, job, window, withJunctionSkippedResourceMetadata(context, {
+                const result = withJunctionSkippedResourceMetadata(context, {
                     nextReconcileAt: clampWebhookJobNextReconcileAt(context),
-                }, skippedOptionalResources));
+                }, skippedOptionalResources);
+                const historicalPullReadiness = extendedHistoricalPolicy?.completion === "daily_aggregate"
+                    && timeseriesImport.fetchComplete
+                    ? resolveJunctionHistoricalPullReadiness({
+                        resource: effectiveResource,
+                        snapshot: await loadJunctionHistoricalPullSnapshot(context),
+                        sourceProviderSlug,
+                    })
+                    : undefined;
+                return finalizePreciseImportResult(withJunctionHistoricalCoverageVerification(context, job, window, withJunctionExtendedTimeseriesBackfillFollowUp({
+                    context,
+                    historicalPullReadiness,
+                    importResult: timeseriesImport,
+                    job,
+                    resource: effectiveResource,
+                    result,
+                    window,
+                })));
             }
             const dateQueryFormat = isFullUtcDayWindow(window) ? "date" : "datetime";
             summaries[effectiveResource] = await fetchOptionalJunctionResourceRecords(context, "summary", effectiveResource, skippedOptionalResources, () => client.listSummary({
@@ -1158,6 +1819,7 @@ 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),
@@ -1165,8 +1827,8 @@ export function createJunctionDeviceSyncProvider(config) {
             importedAt: context.now,
             windowStart: window.windowStart,
             windowEnd: window.windowEnd,
-            connections: sanitizeJunctionImportConnections(sourceProviders),
-            summaries: sanitizeJunctionImportSnapshots(summaries, sourceProviders),
+            connections: preparedImport.connections,
+            summaries: preparedImport.snapshots,
             timeseries: {},
         });
         return withJunctionHistoricalCoverageVerification(context, job, window, withJunctionSkippedResourceMetadata(context, {
@@ -1211,6 +1873,167 @@ export function createJunctionDeviceSyncProvider(config) {
             ? scheduledAt
             : latestAt;
     }
+    function withJunctionExtendedTimeseriesBackfillFollowUp(input) {
+        if (!isJunctionExtendedTimeseriesBackfillJob(input.job, input.resource)) {
+            return input.result;
+        }
+        const policy = resolveJunctionExtendedTimeseriesBackfillPolicy(input.resource);
+        if (!policy) {
+            return input.result;
+        }
+        const sourceProviderSlug = normalizeProviderSlug(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"
+                && input.importResult.providerRecordsExamined);
+        const unresolvedProviderRecords = input.resource === "weight"
+            && input.importResult.fetchComplete
+            && input.importResult.unresolvedProviderRecordCount === 0
+            ? { identities: [], withoutStableIdentity: false }
+            : resolveJunctionHistoricalUnresolvedProviderRecords(input.job, input.importResult);
+        const unresolvedProviderRecordCount = countJunctionHistoricalUnresolvedProviderRecords(unresolvedProviderRecords);
+        const unresolvedProviderRecordIdentitiesJson = encodeJunctionHistoricalUnresolvedProviderRecords(unresolvedProviderRecords);
+        const unresolvedProviderRecordsSeen = unresolvedProviderRecordCount > 0;
+        if (policy.completion === "daily_aggregate" && input.importResult.fetchComplete) {
+            const historicalPullReadiness = input.historicalPullReadiness ?? "unavailable";
+            const currentReconcileWindowStart = floorUtcDayTimestamp(subtractDays(floorUtcDayTimestamp(input.context.now), reconcileDays));
+            if (historicalPullReadiness === "pending"
+                || (historicalPullReadiness === "unavailable" && !recordsSeen)) {
+                const retryDelayMs = EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS.at(-1) ?? 0;
+                return {
+                    ...input.result,
+                    scheduledJobs: [
+                        ...(input.result.scheduledJobs ?? []),
+                        buildExtendedTimeseriesBackfillJob({
+                            availableAt: addMilliseconds(input.context.now, retryDelayMs),
+                            dedupeKey: input.job.dedupeKey,
+                            historicalWindowStart,
+                            resource: input.resource,
+                            sourceProviderSlug,
+                            windowEnd: maxIsoTimestamp(input.window.windowEnd, currentReconcileWindowStart),
+                            windowStart: historicalWindowStart,
+                        }),
+                    ],
+                };
+            }
+            if (Date.parse(input.window.windowEnd) < Date.parse(currentReconcileWindowStart)) {
+                return {
+                    ...input.result,
+                    scheduledJobs: [
+                        ...(input.result.scheduledJobs ?? []),
+                        buildExtendedTimeseriesBackfillJob({
+                            availableAt: input.context.now,
+                            dedupeKey: input.job.dedupeKey,
+                            historicalRecordsSeen: recordsSeen,
+                            historicalWindowStart,
+                            resource: input.resource,
+                            sourceProviderSlug,
+                            windowEnd: currentReconcileWindowStart,
+                            windowStart: input.window.windowEnd,
+                        }),
+                    ],
+                };
+            }
+            if (historicalPullReadiness === "terminal_failure") {
+                return input.result;
+            }
+            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
+        // cleared tag state, do not create a separate backfill repair obligation.
+        if (input.resource === "note" && input.importResult.fetchComplete) {
+            return withJunctionMetadataPatch(input.result, buildJunctionExtendedTimeseriesBackfillCompletionMetadataPatch(input.context, input.job, input.resource, sourceProviderSlug));
+        }
+        const completionProven = input.importResult.fetchComplete && (policy.completion === "fetch_complete"
+            || (policy.completion === "exact_records"
+                && recordsSeen
+                && unresolvedProviderRecordCount === 0));
+        if (completionProven) {
+            return withJunctionMetadataPatch(input.result, buildJunctionExtendedTimeseriesBackfillCompletionMetadataPatch(input.context, input.job, input.resource, sourceProviderSlug));
+        }
+        let emptyBackfillAttempts = readHistoricalBackfillJobEmptyAttempts(input.job) + 1;
+        let retryDelayMs = EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS[emptyBackfillAttempts - 1]
+            ?? null;
+        if (retryDelayMs === null
+            && (!input.importResult.fetchComplete || unresolvedProviderRecordsSeen)) {
+            emptyBackfillAttempts = EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS.length;
+            retryDelayMs =
+                EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS[emptyBackfillAttempts - 1]
+                    ?? null;
+        }
+        if (retryDelayMs === null) {
+            return withJunctionMetadataPatch(input.result, buildJunctionExtendedTimeseriesBackfillCompletionMetadataPatch(input.context, input.job, input.resource, sourceProviderSlug));
+        }
+        return {
+            ...input.result,
+            scheduledJobs: [
+                ...(input.result.scheduledJobs ?? []),
+                buildExtendedTimeseriesBackfillJob({
+                    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,
+                    windowEnd: input.window.windowEnd,
+                    windowStart: input.importResult.fetchComplete
+                        ? historicalWindowStart
+                        : input.window.windowStart,
+                }),
+            ],
+        };
+    }
+    function buildJunctionExtendedTimeseriesBackfillCompletionMetadataPatch(context, job, resource, sourceProviderSlug) {
+        if (!sourceProviderSlug) {
+            return {};
+        }
+        const policy = resolveJunctionExtendedTimeseriesBackfillPolicy(resource);
+        if (!policy) {
+            return {};
+        }
+        if (!canCurrentRuntimeMutateJunctionExtendedTimeseriesHistoryBackfillCoverage(context.account.metadata, resource, policy.version)) {
+            return {};
+        }
+        const admittedVersion = resource === "note"
+            ? readJunctionNoteHistoryBackfillVersion(job.payload)
+            : policy.version;
+        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.
+            return {};
+        }
+        const coverage = addJunctionExtendedTimeseriesHistoryBackfillCoverage({
+            metadata: context.account.metadata,
+            providerSlug: sourceProviderSlug,
+            resource,
+            version: admittedVersion,
+        });
+        if (!coverage) {
+            throw deviceSyncError({
+                code: "JUNCTION_EXTENDED_HISTORY_COVERAGE_UNREPRESENTABLE",
+                message: "Junction extended-history completion could not be retained exactly.",
+                retryable: false,
+            });
+        }
+        return { [coverage.metadataKey]: coverage.value };
+    }
+    function isJunctionExtendedTimeseriesBackfillJob(job, resource) {
+        return job.kind === "resource"
+            && job.payload.historicalBackfill === true
+            && resolveJunctionExtendedTimeseriesBackfillPolicy(resource) !== null;
+    }
     function withJunctionHistoricalCoverageVerification(context, job, resourceWindow, result) {
         const historicalState = readHistoricalBackfillStatus(context.account.metadata);
         const eventType = normalizeString(job.payload.eventType);
@@ -1303,7 +2126,8 @@ export function createJunctionDeviceSyncProvider(config) {
         const resource = inferJunctionWebhookResource(eventType, data);
         const sourceProviderSlug = extractJunctionWebhookSourceProviderSlug(data);
         const objectId = extractJunctionWebhookObjectId(data);
-        const occurredAt = extractJunctionWebhookOccurredAt(data) ?? context.now;
+        const eventOccurredAt = extractJunctionWebhookOccurredAt(data);
+        const occurredAt = eventOccurredAt ?? context.now;
         const window = buildJunctionWebhookWindow(data, occurredAt, context.now, resource);
         const webhookDataJsons = buildJunctionWebhookDataJobJsons({
             data,
@@ -1329,8 +2153,10 @@ export function createJunctionDeviceSyncProvider(config) {
             externalAccountDiagnostic: buildJunctionWebhookExternalAccountDiagnostic(externalAccountSelection),
             eventType,
             traceId: verified.messageId,
-            occurredAt,
+            ...(eventOccurredAt ? { occurredAt: eventOccurredAt } : {}),
+            providerSentAt: verified.providerSentAt,
             resourceCategory: resource?.category ?? null,
+            sourceProviderSlug,
             // 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.
@@ -1350,23 +2176,109 @@ export function createJunctionDeviceSyncProvider(config) {
             if (isJunctionProfileSummaryResource(resource)) {
                 continue;
             }
-            snapshots[resource] = await fetchOptionalJunctionResourceRecords(context, "summary", resource, skippedOptionalResources, () => client.listSummary({
+            const request = {
                 resource,
                 signal: context.signal ?? null,
                 userId: context.account.externalAccountId,
                 windowStart,
                 windowEnd,
-                ...(options.dateQueryFormat ? { dateQueryFormat: options.dateQueryFormat } : {}),
-            }));
+            };
+            if (options.dateQueryFormat) {
+                request.dateQueryFormat = options.dateQueryFormat;
+            }
+            snapshots[resource] = await fetchOptionalJunctionResourceRecords(context, "summary", resource, skippedOptionalResources, () => client.listSummary(request));
         }
         return snapshots;
     }
-    async function fetchProfileSummaryOnce(context, skippedOptionalResources) {
+    async function executeBoundedSummaryReconcile(input) {
+        const profileAlreadyChecked = hasCheckedJunctionProfileSummary(input.context.account.metadata);
+        const eligibleResources = summaryResources.filter((resource) => !isJunctionProfileSummaryResource(resource) || !profileAlreadyChecked);
+        const eligibleUnits = eligibleResources.reduce((units, resource) => {
+            if (resource === "sleep_cycle" && eligibleResources.includes("sleep")) {
+                return units;
+            }
+            units.push(resource === "sleep" && eligibleResources.includes("sleep_cycle")
+                ? ["sleep", "sleep_cycle"]
+                : [resource]);
+            return units;
+        }, []);
+        const requestedCursor = normalizeString(input.job.payload.summaryResourceCursor);
+        const cursorIndex = requestedCursor
+            ? eligibleUnits.findIndex((unit) => unit.includes(requestedCursor))
+            : 0;
+        const resources = eligibleUnits[cursorIndex >= 0 ? cursorIndex : 0] ?? null;
+        if (!resources) {
+            return null;
+        }
+        const summaries = {};
+        let profileMetadataPatch = {};
+        const profileResource = resources.find(isJunctionProfileSummaryResource);
+        if (profileResource) {
+            const profileSummaryResult = await fetchProfileSummaryOnce(input.context, input.skippedOptionalResources, { collectionWorkLimit: JUNCTION_FULL_JOB_SUMMARY_COLLECTION_WORK_LIMIT });
+            if (profileSummaryResult.checked) {
+                profileMetadataPatch = buildJunctionProfileSummaryCheckedMetadataPatch(input.context);
+            }
+            if (profileSummaryResult.records.length > 0) {
+                summaries[profileResource] = profileSummaryResult.records;
+            }
+        }
+        else {
+            const collectionWorkLimit = resources.length > 1
+                ? JUNCTION_FULL_JOB_COUPLED_SUMMARY_COLLECTION_WORK_LIMIT
+                : JUNCTION_FULL_JOB_SUMMARY_COLLECTION_WORK_LIMIT;
+            for (const resource of resources) {
+                summaries[resource] = await fetchOptionalJunctionResourceRecords(input.context, "summary", resource, input.skippedOptionalResources, () => client.listSummary({
+                    collectionWorkLimit,
+                    dateQueryFormat: input.dateQueryFormat,
+                    resource,
+                    signal: input.context.signal ?? null,
+                    userId: input.context.account.externalAccountId,
+                    windowEnd: input.summaryWindow.windowEnd,
+                    windowStart: input.summaryWindow.windowStart,
+                }));
+            }
+        }
+        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,
+            importedAt: input.summaryWindow.windowEnd,
+            windowStart: input.summaryWindow.windowStart,
+            windowEnd: input.summaryWindow.windowEnd,
+            connections: preparedSummaryImport.connections,
+            summaries: preparedSummaryImport.snapshots,
+            timeseries: {},
+        });
+        const nextResource = eligibleUnits[cursorIndex >= 0 ? cursorIndex + 1 : 1]?.[0] ?? null;
+        const sourceProviderSlug = normalizeProviderSlug(input.job.payload.sourceProviderSlug);
+        const continuation = buildExactWindowJob({
+            availableAt: input.context.now,
+            kind: "reconcile",
+            payload: {
+                ...(sourceProviderSlug ? { sourceProviderSlug } : {}),
+                ...(nextResource
+                    ? { summaryResourceCursor: nextResource }
+                    : { summaryPhaseComplete: true }),
+            },
+            priority: input.job.priority,
+            windowEnd: input.window.windowEnd,
+            windowStart: input.window.windowStart,
+        });
+        return withJunctionSkippedResourceMetadata(input.context, withJunctionMetadataPatch({
+            nextReconcileAt: resolveJunctionNextReconcileAt(input.context.account, input.context.now, addMilliseconds(input.context.now, reconcileIntervalMs)),
+            scheduledJobs: [continuation],
+        }, profileMetadataPatch), input.skippedOptionalResources);
+    }
+    async function fetchProfileSummaryOnce(context, skippedOptionalResources, options = {}) {
         if (!summaryResources.some(isJunctionProfileSummaryResource)
             || hasCheckedJunctionProfileSummary(context.account.metadata)) {
             return { checked: false, records: [] };
         }
         const records = await fetchOptionalJunctionResourceRecords(context, "summary", JUNCTION_PROFILE_SUMMARY_RESOURCE, skippedOptionalResources, () => client.listProfileSummary({
+            ...(options.collectionWorkLimit
+                ? { collectionWorkLimit: options.collectionWorkLimit }
+                : {}),
             signal: context.signal ?? null,
             userId: context.account.externalAccountId,
         }));
@@ -1384,21 +2296,29 @@ export function createJunctionDeviceSyncProvider(config) {
         let chunkStart = Date.parse(windowStart);
         const end = Date.parse(windowEnd);
         let optionalFailureLogged = false;
+        const fetchChunkMs = resolveJunctionTimeseriesFetchChunkMs(resource);
         while (chunkStart < end) {
-            const chunkEnd = Math.min(chunkStart + TIMESERIES_CHUNK_MS, end);
+            const chunkEnd = Math.min(chunkStart + fetchChunkMs, end);
             const chunkWindowStart = new Date(chunkStart).toISOString();
             const chunkWindowEnd = new Date(chunkEnd).toISOString();
             try {
-                const chunkRecords = await client.listTimeseries({
+                const request = {
+                    collectionWorkLimit: options.collectionWorkLimit,
                     resource,
                     signal: context.signal ?? null,
                     sourceProviderSlug,
                     userId: context.account.externalAccountId,
                     windowStart: chunkWindowStart,
                     windowEnd: chunkWindowEnd,
-                    ...(options.dateQueryFormat ? { dateQueryFormat: options.dateQueryFormat } : {}),
-                });
-                records.push(...filterJunctionTimeseriesRecordsToWindow(chunkRecords, chunkWindowStart, chunkWindowEnd));
+                };
+                if (options.dateQueryFormat) {
+                    request.dateQueryFormat = options.dateQueryFormat;
+                }
+                if (options.requireStructurallyCompleteCollection) {
+                    request.requireStructurallyCompleteCollection = true;
+                }
+                const chunkRecords = await fetchJunctionTimeseriesWindow(client, request);
+                records.push(...filterJunctionTimeseriesRecordsToWindow(resource, chunkRecords, chunkWindowStart, chunkWindowEnd, options.dateQueryFormat));
             }
             catch (error) {
                 const failure = classifyOptionalJunctionResourceFailure(error, "timeseries", resource, context.account.externalAccountId);
@@ -1418,21 +2338,55 @@ export function createJunctionDeviceSyncProvider(config) {
             }
             chunkStart = chunkEnd;
         }
+        if (resource === "electrocardiogram_voltage" || resource === "workout_stream") {
+            return resolveJunctionBoundedFeatureRecords(resource, records);
+        }
         return dedupeJunctionTimeseriesRecords(resource, records);
     }
-    async function importTimeseriesPreciseSnapshots(context, sourceProviders, windowStart, windowEnd, skippedOptionalResources, resources, sourceProviderSlug) {
+    async function importTimeseriesPreciseSnapshots(context, sourceProviders, windowStart, windowEnd, skippedOptionalResources, resources, sourceProviderSlug, options = {}) {
         const accumulatedTimeseries = {};
+        let acceptedProviderRecordCount = 0;
         let executionWindowEnd = null;
         let executionWindowStart = null;
+        let fetchComplete = true;
         let yieldedAt = null;
-        for (const window of buildPreciseTimeseriesWindows(windowStart, windowEnd)) {
+        let canonicalEventDayKeys = [];
+        let canonicalSparseCalendarTargets = [];
+        let canonicalProviderRecordIdentities = [];
+        let canonicalEventCount = 0;
+        let providerRecordsExamined = false;
+        let postFetchSourceAdmission;
+        if (resources.length !== 1) {
+            throw new TypeError("Precise Junction timeseries imports require exactly one resource.");
+        }
+        const resource = resources[0];
+        const preciseWindows = buildPreciseTimeseriesWindows(windowStart, windowEnd, resolveJunctionTimeseriesImportChunkMs(resources));
+        for (const [index, window] of preciseWindows.entries()) {
             if (context.shouldYield?.()) {
+                fetchComplete = false;
                 yieldedAt = window.windowStart;
                 break;
             }
             const skippedResourceCountBeforeFetch = skippedOptionalResources.length;
-            const timeseries = await fetchTimeseriesSnapshots(context, window.windowStart, window.windowEnd, skippedOptionalResources, resources, sourceProviderSlug, { dateQueryFormat: "datetime" });
+            let timeseries;
+            try {
+                timeseries = {
+                    [resource]: await fetchTimeseriesResourceInChunks(context, resource, window.windowStart, window.windowEnd, skippedOptionalResources, sourceProviderSlug, { dateQueryFormat: options.dateQueryFormat ?? "datetime" }),
+                };
+            }
+            catch (error) {
+                if (options.preservePartialRetryableFailure === true
+                    && (options.historicalProviderRecordsSeen === true
+                        || hasJunctionSnapshotRecords(accumulatedTimeseries))
+                    && (isRetryableDeviceSyncFailure(error)
+                        || isJunctionJobSignalAbort(error, context.signal))) {
+                    fetchComplete = false;
+                    break;
+                }
+                throw error;
+            }
             if (skippedOptionalResources.length > skippedResourceCountBeforeFetch) {
+                fetchComplete = false;
                 break;
             }
             executionWindowStart ??= window.windowStart;
@@ -1443,58 +2397,654 @@ export function createJunctionDeviceSyncProvider(config) {
                     ...records,
                 ];
             }
+            if (options.preservePartialRetryableFailure === true
+                && index < preciseWindows.length - 1) {
+                fetchComplete = false;
+                yieldedAt = window.windowEnd;
+                break;
+            }
         }
         const dedupedTimeseries = dedupeJunctionTimeseriesSnapshotRecords(accumulatedTimeseries);
-        if (executionWindowStart && executionWindowEnd && hasJunctionSnapshotRecords(dedupedTimeseries)) {
-            await context.importSnapshot({
-                provider: "junction",
-                accountId: buildJunctionImportAccountId(context.account.externalAccountId),
-                connectionId: context.account.id,
-                importedAt: executionWindowEnd,
-                windowStart: executionWindowStart,
-                windowEnd: executionWindowEnd,
-                connections: sanitizeJunctionImportConnections(sourceProviders),
-                summaries: {},
-                timeseries: sanitizeJunctionImportSnapshots(dedupedTimeseries, sourceProviders),
-            });
+        const providerRecordCount = countJunctionSnapshotRecords(dedupedTimeseries);
+        let unresolvedProviderRecordIdentities = [];
+        let unresolvedProviderRecordCount = providerRecordCount;
+        let unresolvedProviderRecordsWithoutStableIdentity = providerRecordCount > 0;
+        const requiresBloodPressureRecordResolution = resources.includes("blood_pressure");
+        const successfulImportTerminatesWeightRows = resources.length === 1 && resources[0] === "weight";
+        if (executionWindowStart && executionWindowEnd) {
+            const identifyFetchedProviderRecords = (sourceIdentities) => requiresBloodPressureRecordResolution && providerRecordCount > 0
+                ? identifyJunctionBloodPressureProviderRecords({
+                    connections: sanitizeJunctionImportConnections(sourceProviders, sourceIdentities),
+                    importedAt: executionWindowEnd,
+                    timeseries: sanitizeJunctionImportSnapshots(dedupedTimeseries, sourceProviders, { sourceIdentities }),
+                    windowStart: executionWindowStart,
+                    windowEnd: executionWindowEnd,
+                })
+                : null;
+            const applyFetchedProviderRecordEvidence = (evidence) => {
+                if (!evidence) {
+                    return;
+                }
+                unresolvedProviderRecordIdentities = uniqueJunctionProviderRecordIdentities(evidence.repairStableExternalRefResourceIds);
+                unresolvedProviderRecordsWithoutStableIdentity =
+                    evidence.providerRecordCount !== providerRecordCount
+                        || evidence.repairStableExternalRefResourceIds.some((identity) => identity === null);
+                unresolvedProviderRecordCount =
+                    unresolvedProviderRecordIdentities.length
+                        + (unresolvedProviderRecordsWithoutStableIdentity ? 1 : 0);
+            };
+            let fetchedProviderRecordIdentityEvidence = identifyFetchedProviderRecords(resolveJunctionAccountSourceIdentities(options.sourceIdentityAuthority ?? []));
+            applyFetchedProviderRecordEvidence(fetchedProviderRecordIdentityEvidence);
+            try {
+                const currentSources = context.listConnectionSources
+                    ? await context.listConnectionSources()
+                    : context.account.sources ?? [];
+                const importSourceIdentities = resolveJunctionAccountSourceIdentities(currentSources);
+                if (sourceProviderSlug
+                    && options.sourceStatusRequirement === "connected") {
+                    postFetchSourceAdmission = resolveJunctionCurrentSourceAdmissionFromSources(currentSources, sourceProviderSlug, context.connectionSourceAdmissionMode !== "listed_only");
+                    if (postFetchSourceAdmission !== "admitted") {
+                        return {
+                            acceptedProviderRecordCount: 0,
+                            canonicalProviderRecordIdentities: [],
+                            canonicalEventCount: 0,
+                            canonicalEventDayKeys: [],
+                            canonicalSparseCalendarTargets: [],
+                            fetchComplete: false,
+                            postFetchSourceAdmission,
+                            providerRecordsExamined: false,
+                            providerRecordCount,
+                            unresolvedProviderRecordIdentities,
+                            unresolvedProviderRecordCount,
+                            unresolvedProviderRecordsWithoutStableIdentity,
+                            yieldedAt: null,
+                        };
+                    }
+                }
+                fetchedProviderRecordIdentityEvidence = identifyFetchedProviderRecords(importSourceIdentities);
+                applyFetchedProviderRecordEvidence(fetchedProviderRecordIdentityEvidence);
+                const preparedImport = prepareJunctionImportSnapshotForSources(dedupedTimeseries, sourceProviders, currentSources, {
+                    sourceIdentities: importSourceIdentities,
+                }, {
+                    allowUnlistedSources: context.connectionSourceAdmissionMode !== "listed_only",
+                    sourceStatusRequirement: options.sourceStatusRequirement,
+                });
+                acceptedProviderRecordCount = countAcceptedJunctionDailyTimeseriesProviderRecords({
+                    connections: preparedImport.connections,
+                    importedAt: executionWindowEnd,
+                    timeseries: preparedImport.snapshots,
+                    windowEnd: executionWindowEnd,
+                    windowStart: executionWindowStart,
+                });
+                if (hasJunctionSnapshotRecords(preparedImport.snapshots)) {
+                    const receipt = await context.importSnapshot({
+                        provider: "junction",
+                        accountId: buildJunctionImportAccountId(context.account.externalAccountId),
+                        connectionId: context.account.id,
+                        importedAt: executionWindowEnd,
+                        windowStart: executionWindowStart,
+                        windowEnd: executionWindowEnd,
+                        timeseriesWindowKind: "precise",
+                        connections: preparedImport.connections,
+                        summaries: {},
+                        timeseries: preparedImport.snapshots,
+                    });
+                    providerRecordsExamined = true;
+                    canonicalEventCount = readProviderSnapshotCanonicalEventCount(receipt);
+                    canonicalEventDayKeys = readProviderSnapshotCanonicalEventDayKeys(receipt);
+                    canonicalSparseCalendarTargets = readProviderSnapshotCanonicalSparseCalendarTargets(receipt);
+                    if (fetchedProviderRecordIdentityEvidence) {
+                        const resolutionEvidence = resolveJunctionBloodPressureProviderRecordResolutionEvidence({
+                            canonicalEventCount,
+                            canonicalEventExternalRefResourceIds: readProviderSnapshotCanonicalEventExternalRefResourceIds(receipt),
+                            providerRecordCount,
+                            providerRecordIdentityEvidence: fetchedProviderRecordIdentityEvidence,
+                        });
+                        canonicalProviderRecordIdentities =
+                            resolutionEvidence.canonicalProviderRecordIdentities;
+                        unresolvedProviderRecordIdentities =
+                            resolutionEvidence.unresolvedProviderRecordIdentities;
+                        unresolvedProviderRecordsWithoutStableIdentity =
+                            resolutionEvidence.unresolvedProviderRecordsWithoutStableIdentity;
+                        unresolvedProviderRecordCount =
+                            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.
+                        unresolvedProviderRecordCount = 0;
+                        unresolvedProviderRecordsWithoutStableIdentity = false;
+                    }
+                    else {
+                        unresolvedProviderRecordCount =
+                            canonicalEventCount >= providerRecordCount ? 0 : providerRecordCount;
+                        unresolvedProviderRecordsWithoutStableIdentity = unresolvedProviderRecordCount > 0;
+                    }
+                }
+            }
+            catch (error) {
+                if (options.preservePartialRetryableFailure === true
+                    && (options.historicalProviderRecordsSeen === true
+                        || providerRecordCount > 0)
+                    && (isRetryableDeviceSyncFailure(error)
+                        || isJunctionJobSignalAbort(error, context.signal))) {
+                    return {
+                        acceptedProviderRecordCount: 0,
+                        canonicalProviderRecordIdentities: [],
+                        canonicalEventCount: 0,
+                        canonicalEventDayKeys: [],
+                        canonicalSparseCalendarTargets: [],
+                        fetchComplete: false,
+                        providerRecordsExamined: false,
+                        providerRecordCount,
+                        unresolvedProviderRecordIdentities,
+                        unresolvedProviderRecordCount,
+                        unresolvedProviderRecordsWithoutStableIdentity,
+                        yieldedAt: null,
+                    };
+                }
+                throw error;
+            }
         }
         return {
+            acceptedProviderRecordCount,
+            canonicalEventDayKeys,
+            canonicalSparseCalendarTargets,
+            canonicalProviderRecordIdentities,
+            canonicalEventCount,
+            fetchComplete,
+            ...(postFetchSourceAdmission === undefined
+                ? {}
+                : { postFetchSourceAdmission }),
+            providerRecordsExamined,
+            providerRecordCount,
+            unresolvedProviderRecordIdentities,
+            unresolvedProviderRecordCount,
+            unresolvedProviderRecordsWithoutStableIdentity,
             yieldedAt,
         };
     }
-    async function importTimeseriesDailySnapshots(context, sourceProviders, windowStart, windowEnd, skippedOptionalResources, resources, sourceProviderSlug) {
+    async function importTimeseriesDailyAggregateSnapshots(context, sourceProviders, windowStart, windowEnd, skippedOptionalResources, resources, sourceProviderSlug, emptySparseCalendarSource) {
+        const requestedResources = resources ?? timeseriesResources;
+        const globallyClosedEndMs = resolveGloballyClosedProviderDayEnd(windowEnd, context.now);
+        const appliedDailyAggregateResourceIds = new Set();
         for (const window of buildClosedDailyWindows(windowStart, windowEnd)) {
             if (context.shouldYield?.()) {
                 return {
+                    appliedDailyAggregateResourceIds: [...appliedDailyAggregateResourceIds],
                     yieldedAt: window.windowStart,
                 };
             }
-            const timeseries = await fetchTimeseriesSnapshots(context, window.windowStart, window.windowEnd, skippedOptionalResources, resources, sourceProviderSlug, { dateQueryFormat: "date" });
-            if (!hasJunctionSnapshotRecords(timeseries)) {
+            const windowResources = Date.parse(window.windowEnd) <= globallyClosedEndMs
+                ? requestedResources
+                : requestedResources.filter((resource) => !JUNCTION_CALENDAR_DAY_AGGREGATE_RESOURCE_SET.has(resource));
+            if (windowResources.length === 0) {
                 continue;
             }
-            await context.importSnapshot({
-                provider: "junction",
-                accountId: buildJunctionImportAccountId(context.account.externalAccountId),
-                connectionId: context.account.id,
-                importedAt: window.windowEnd,
-                windowStart: window.windowStart,
+            const skippedResourceCountBeforeFetch = skippedOptionalResources.length;
+            const timeseries = await fetchTimeseriesSnapshots(context, window.windowStart, window.windowEnd, skippedOptionalResources, windowResources, sourceProviderSlug, {
+                dateQueryFormat: "date",
+                requireStructurallyCompleteCollection: Boolean(emptySparseCalendarSource),
+            });
+            if (emptySparseCalendarSource
+                && skippedOptionalResources.length > skippedResourceCountBeforeFetch) {
+                throw deviceSyncError({
+                    code: "JUNCTION_CALENDAR_REFRESH_UNAVAILABLE",
+                    message: "Junction calendar refresh is temporarily unavailable.",
+                    retryable: true,
+                });
+            }
+            if (emptySparseCalendarSource) {
+                for (const resource of windowResources) {
+                    timeseries[resource] = filterJunctionSparseCalendarRecordsToSource(timeseries[resource] ?? [], {
+                        sourceProviderSlug: emptySparseCalendarSource.sourceProviderSlug,
+                        ...(emptySparseCalendarSource.sourceType
+                            ? { sourceType: emptySparseCalendarSource.sourceType }
+                            : {}),
+                    });
+                }
+            }
+            if (!hasJunctionSnapshotRecords(timeseries) && emptySparseCalendarSource) {
+                const [resource] = windowResources;
+                if (!resource || !JUNCTION_SPARSE_CALENDAR_AGGREGATE_RESOURCE_SET.has(resource)) {
+                    throw deviceSyncError({
+                        code: JUNCTION_CALENDAR_REFRESH_EMPTY_IDENTITY_INVALID_CODE,
+                        message: "Junction empty calendar refresh lacked an admitted sparse identity.",
+                        retryable: false,
+                    });
+                }
+                timeseries[resource] = [buildJunctionEmptySparseCalendarAggregate({
+                        dayKey: window.windowStart.slice(0, 10),
+                        resource,
+                        ...emptySparseCalendarSource,
+                    })];
+            }
+            else if (!hasJunctionSnapshotRecords(timeseries)) {
+                continue;
+            }
+            const preparedImport = await prepareJunctionImportSnapshot(context, timeseries, sourceProviders, {
+                projectAccountSourceIdentities: true,
+                sourceIdentities: emptySparseCalendarSource
+                    ? [{
+                            ...(emptySparseCalendarSource.sourceInstanceId
+                                ? { sourceInstanceId: emptySparseCalendarSource.sourceInstanceId }
+                                : {}),
+                            sourceProviderSlug: emptySparseCalendarSource.sourceProviderSlug,
+                        }]
+                    : [],
+            });
+            if (hasJunctionSnapshotRecords(preparedImport.snapshots)) {
+                const receipt = await context.importSnapshot({
+                    provider: "junction",
+                    accountId: buildJunctionImportAccountId(context.account.externalAccountId),
+                    connectionId: context.account.id,
+                    importedAt: window.windowEnd,
+                    windowStart: window.windowStart,
+                    windowEnd: window.windowEnd,
+                    timeseriesWindowKind: "calendar_day",
+                    ...(emptySparseCalendarSource
+                        ? {
+                            strictSparseCalendarRepair: {
+                                dayKey: window.windowStart.slice(0, 10),
+                                resource: windowResources[0],
+                                ...emptySparseCalendarSource,
+                                sourceProviderSlug: normalizeJunctionSourceProviderSlug(emptySparseCalendarSource.sourceProviderSlug) ?? emptySparseCalendarSource.sourceProviderSlug,
+                            },
+                        }
+                        : {}),
+                    connections: preparedImport.connections,
+                    summaries: {},
+                    timeseries: preparedImport.snapshots,
+                });
+                for (const resourceId of readProviderSnapshotCanonicalEventExternalRefResourceIds(receipt) ?? []) {
+                    appliedDailyAggregateResourceIds.add(resourceId);
+                }
+            }
+        }
+        return {
+            appliedDailyAggregateResourceIds: [...appliedDailyAggregateResourceIds],
+            yieldedAt: null,
+        };
+    }
+    async function importTimeseriesDailySnapshots(context, sourceProviders, windowStart, windowEnd, skippedOptionalResources, resource, sourceProviderSlug, completedWorkoutStreamIdentities = new Set()) {
+        let resumeWorkoutStreamIdentities = new Set(completedWorkoutStreamIdentities);
+        let madeProgress = false;
+        for (const window of buildClosedDailyWindows(windowStart, windowEnd)) {
+            let workoutStreamCursor = resource === "workout_stream"
+                ? encodeJunctionWorkoutStreamCompletedIdentities(resumeWorkoutStreamIdentities)
+                : null;
+            if (context.shouldYield?.()) {
+                if (madeProgress) {
+                    return {
+                        workoutStreamCursor,
+                        yieldedAt: window.windowStart,
+                    };
+                }
+                context.throwIfAborted?.();
+            }
+            if (resource === "workout_stream") {
+                const workoutImport = await importJunctionWorkoutStreamWindow({
+                    allowImmediateYield: madeProgress,
+                    completedIdentities: resumeWorkoutStreamIdentities,
+                    context,
+                    skippedOptionalResources,
+                    sourceProviderSlug,
+                    sourceProviders,
+                    windowEnd: window.windowEnd,
+                    windowStart: window.windowStart,
+                });
+                workoutStreamCursor = workoutImport.workoutStreamCursor;
+                madeProgress ||= workoutImport.madeProgress;
+                if (workoutImport.yieldedAt) {
+                    return {
+                        workoutStreamCursor,
+                        yieldedAt: workoutImport.yieldedAt,
+                    };
+                }
+                madeProgress = true;
+            }
+            else {
+                try {
+                    await importJunctionTimeseriesResourceSnapshot({
+                        context,
+                        dateQueryFormat: "date",
+                        resource,
+                        skippedOptionalResources,
+                        sourceProviderSlug,
+                        sourceProviders,
+                        windowEnd: window.windowEnd,
+                        windowStart: window.windowStart,
+                    });
+                }
+                catch (error) {
+                    if (isJunctionJobSignalAbort(error, context.signal)) {
+                        if (madeProgress) {
+                            return {
+                                workoutStreamCursor,
+                                yieldedAt: window.windowStart,
+                            };
+                        }
+                        throw error;
+                    }
+                    if (isRetryableDeviceSyncFailure(error)) {
+                        throw new JunctionTimeseriesProgressError(error, window.windowStart, workoutStreamCursor);
+                    }
+                    throw error;
+                }
+                madeProgress = true;
+            }
+            resumeWorkoutStreamIdentities = new Set();
+            madeProgress = true;
+        }
+        return {
+            workoutStreamCursor: null,
+            yieldedAt: null,
+        };
+    }
+    async function executeFullJobTimeseriesContinuation(context, job, skippedOptionalResources, completedWorkoutStreamIdentities) {
+        const window = resolveJobWindow(job, context.now, job.kind === "backfill" ? summaryBackfillDays : reconcileDays);
+        const baseTimeseriesWindowStart = job.kind === "backfill"
+            ? maxIsoTimestamp(window.windowStart, subtractDays(window.windowEnd, timeseriesBackfillDays))
+            : window.windowStart;
+        const resourceCursor = readFullJobTimeseriesResourceCursor(job, timeseriesResources);
+        const persistedTimeseriesCursor = readFullJobTimeseriesCursor(job, {
+            windowEnd: window.windowEnd,
+            windowStart: baseTimeseriesWindowStart,
+        });
+        const persistedTimeseriesWindowHours = readFullJobTimeseriesWindowHours(job);
+        if (!resourceCursor || !persistedTimeseriesCursor) {
+            throw invalidJunctionTimeseriesResourceProgress();
+        }
+        const timeseriesCursor = resourceCursor.restartFromWindowStart
+            ? baseTimeseriesWindowStart
+            : persistedTimeseriesCursor;
+        const timeseriesWindowHours = resourceCursor.restartFromWindowStart
+            ? 24
+            : persistedTimeseriesWindowHours;
+        const resource = resourceCursor.resource;
+        const policy = resolveJunctionTimeseriesResourcePolicy(resource);
+        if ((timeseriesWindowHours === 1
+            && policy?.normalizationMode !== "hourly_or_session_feature")
+            || (!resourceCursor.restartFromWindowStart
+                && resource !== "workout_stream"
+                && job.payload.workoutStreamCursor !== undefined)) {
+            throw invalidJunctionTimeseriesResourceProgress();
+        }
+        const executionWindowEnd = new Date(Math.min(Date.parse(timeseriesCursor) + timeseriesWindowHours * TIMESERIES_HOUR_MS, Date.parse(window.windowEnd))).toISOString();
+        let workoutStreamCursor = null;
+        if (resource === "workout_stream") {
+            try {
+                const workoutImport = await importJunctionWorkoutStreamWindow({
+                    allowImmediateYield: false,
+                    collectionWorkLimit: JUNCTION_FULL_JOB_TIMESERIES_COLLECTION_WORK_LIMIT,
+                    completedIdentities: completedWorkoutStreamIdentities,
+                    context,
+                    skippedOptionalResources,
+                    sourceProviders: [],
+                    windowEnd: executionWindowEnd,
+                    windowStart: timeseriesCursor,
+                });
+                workoutStreamCursor = workoutImport.workoutStreamCursor;
+                if (workoutImport.yieldedAt) {
+                    return buildFullJobTimeseriesContinuationResult({
+                        context,
+                        job,
+                        skippedOptionalResources,
+                        continuation: {
+                            timeseriesCursor,
+                            timeseriesResourceCursor: resource,
+                            timeseriesWindowHours,
+                            workoutStreamCursor,
+                        },
+                        window,
+                    });
+                }
+            }
+            catch (error) {
+                if (error instanceof JunctionTimeseriesProgressError) {
+                    if (!error.workoutStreamCursor
+                        || error.workoutStreamCursor === job.payload.workoutStreamCursor) {
+                        throw error.failure;
+                    }
+                    return buildFullJobTimeseriesContinuationResult({
+                        context,
+                        job,
+                        skippedOptionalResources,
+                        continuation: {
+                            timeseriesCursor,
+                            timeseriesResourceCursor: resource,
+                            timeseriesWindowHours,
+                            workoutStreamCursor: error.workoutStreamCursor,
+                        },
+                        window,
+                    });
+                }
+                throw error;
+            }
+        }
+        else {
+            try {
+                const calendarDayAggregate = JUNCTION_CALENDAR_DAY_AGGREGATE_RESOURCE_SET.has(resource);
+                const importWindow = calendarDayAggregate
+                    ? {
+                        windowEnd: floorUtcDayTimestamp(executionWindowEnd),
+                        windowStart: floorUtcDayTimestamp(timeseriesCursor),
+                    }
+                    : {
+                        windowEnd: executionWindowEnd,
+                        windowStart: timeseriesCursor,
+                    };
+                if (Date.parse(importWindow.windowStart) < Date.parse(importWindow.windowEnd)) {
+                    await importJunctionTimeseriesResourceSnapshot({
+                        collectionWorkLimit: JUNCTION_FULL_JOB_TIMESERIES_COLLECTION_WORK_LIMIT,
+                        context,
+                        dateQueryFormat: timeseriesWindowHours === 1 ? "datetime" : "date",
+                        resource,
+                        skippedOptionalResources,
+                        sourceProviders: [],
+                        windowEnd: importWindow.windowEnd,
+                        windowStart: importWindow.windowStart,
+                    });
+                }
+            }
+            catch (error) {
+                if (isJunctionTimeseriesWindowTooLarge(error)
+                    && timeseriesWindowHours === 24
+                    && policy?.normalizationMode === "hourly_or_session_feature") {
+                    return buildFullJobTimeseriesContinuationResult({
+                        context,
+                        job,
+                        skippedOptionalResources,
+                        continuation: {
+                            timeseriesCursor,
+                            timeseriesResourceCursor: resource,
+                            timeseriesWindowHours: 1,
+                            workoutStreamCursor: null,
+                        },
+                        window,
+                    });
+                }
+                throw error;
+            }
+        }
+        return buildFullJobTimeseriesContinuationResult({
+            context,
+            job,
+            skippedOptionalResources,
+            continuation: resolveNextFullJobTimeseriesContinuation({
+                baseTimeseriesWindowStart,
+                executionWindowEnd,
+                resource,
+                resources: timeseriesResources,
+                timeseriesWindowHours,
                 windowEnd: window.windowEnd,
-                connections: sanitizeJunctionImportConnections(sourceProviders),
-                summaries: {},
-                timeseries: sanitizeJunctionImportSnapshots(timeseries, sourceProviders),
+            }),
+            window,
+        });
+    }
+    async function importJunctionTimeseriesResourceSnapshot(input) {
+        const calendarDayAggregate = JUNCTION_CALENDAR_DAY_AGGREGATE_RESOURCE_SET.has(input.resource);
+        if (calendarDayAggregate) {
+            const windowEndMs = Date.parse(input.windowEnd);
+            const globallyClosedProviderDayEnd = resolveGloballyClosedProviderDayEnd(input.windowEnd, input.context.now);
+            if (!Number.isFinite(windowEndMs)
+                || !Number.isFinite(globallyClosedProviderDayEnd)
+                || windowEndMs > globallyClosedProviderDayEnd) {
+                return;
+            }
+        }
+        const records = await fetchTimeseriesResourceInChunks(input.context, input.resource, input.windowStart, input.windowEnd, input.skippedOptionalResources, input.sourceProviderSlug, {
+            collectionWorkLimit: input.collectionWorkLimit,
+            dateQueryFormat: input.dateQueryFormat,
+        });
+        if (records.length === 0) {
+            return;
+        }
+        const preparedImport = await prepareJunctionImportSnapshot(input.context, { [input.resource]: records }, input.sourceProviders, { projectAccountSourceIdentities: calendarDayAggregate });
+        if (!hasJunctionSnapshotRecords(preparedImport.snapshots)) {
+            return;
+        }
+        await input.context.importSnapshot({
+            provider: "junction",
+            accountId: buildJunctionImportAccountId(input.context.account.externalAccountId),
+            connectionId: input.context.account.id,
+            importedAt: input.windowEnd,
+            windowStart: input.windowStart,
+            windowEnd: input.windowEnd,
+            ...(calendarDayAggregate ? { timeseriesWindowKind: "calendar_day" } : {}),
+            connections: preparedImport.connections,
+            summaries: {},
+            timeseries: preparedImport.snapshots,
+        });
+    }
+    async function importJunctionWorkoutStreamWindow(input) {
+        const policy = resolveJunctionTimeseriesResourcePolicy("workout_stream");
+        const maxWorkouts = policy?.maxRecordsPerWindow;
+        const maxSamples = policy?.maxSamplesPerRecord;
+        if (!maxWorkouts || !maxSamples) {
+            throw new TypeError("Junction workout_stream policy did not define bounded limits.");
+        }
+        let completedIdentities = new Set(input.completedIdentities);
+        let madeProgress = false;
+        const carryTerminalProgressOrThrow = (error) => {
+            if (isJunctionJobSignalAbort(error, input.context.signal)) {
+                if (input.allowImmediateYield || madeProgress) {
+                    return {
+                        madeProgress,
+                        workoutStreamCursor: encodeJunctionWorkoutStreamCompletedIdentities(completedIdentities),
+                        yieldedAt: input.windowStart,
+                    };
+                }
+                throw error;
+            }
+            if (isRetryableDeviceSyncFailure(error)) {
+                throw new JunctionTimeseriesProgressError(error, input.windowStart, encodeJunctionWorkoutStreamCompletedIdentities(completedIdentities));
+            }
+            throw error;
+        };
+        let candidates;
+        try {
+            candidates = await listJunctionWorkoutStreamCandidates(client, {
+                collectionWorkLimit: input.collectionWorkLimit,
+                resource: "workout_stream",
+                signal: input.context.signal ?? null,
+                sourceProviderSlug: input.sourceProviderSlug,
+                userId: input.context.account.externalAccountId,
+                windowEnd: input.windowEnd,
+                windowStart: input.windowStart,
             });
         }
+        catch (error) {
+            return carryTerminalProgressOrThrow(error);
+        }
+        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()) {
+            if (completedIdentities.has(candidate.identity)) {
+                continue;
+            }
+            if (input.context.shouldYield?.()) {
+                if (input.allowImmediateYield || madeProgress) {
+                    return {
+                        madeProgress,
+                        workoutStreamCursor: encodeJunctionWorkoutStreamCompletedIdentities(completedIdentities),
+                        yieldedAt: input.windowStart,
+                    };
+                }
+                input.context.throwIfAborted?.();
+            }
+            let feature;
+            try {
+                feature = await fetchJunctionWorkoutStreamFeature(client, candidate, maxSamples, input.context.signal ?? null, input.collectionWorkLimit);
+            }
+            catch (error) {
+                const failure = classifyOptionalJunctionResourceFailure(error, "timeseries", "workout_stream", input.context.account.externalAccountId);
+                if (!failure) {
+                    return carryTerminalProgressOrThrow(addJunctionWorkoutStreamCandidateFailureContext(error, {
+                        aliasSource: candidate.workoutIdAliasSource,
+                        candidateCount: candidates.length,
+                        candidateOrdinal: candidateIndex + 1,
+                    }));
+                }
+                logSkippedOptionalJunctionResource(input.context, "timeseries", "workout_stream", failure);
+                input.skippedOptionalResources.push({
+                    ...failure,
+                    resource: "workout_stream",
+                    resourceCategory: "timeseries",
+                });
+                completedIdentities.add(candidate.identity);
+                madeProgress = true;
+                continue;
+            }
+            if (feature === undefined) {
+                input.context.logger.warn?.("Skipping Junction workout with unaligned metric cardinality.", {
+                    errorCode: "JUNCTION_WORKOUT_STREAM_CARDINALITY_MISMATCH",
+                    provider: "junction",
+                    resource: "workout_stream",
+                    resourceCategory: "timeseries",
+                });
+                completedIdentities.add(candidate.identity);
+                madeProgress = true;
+                continue;
+            }
+            try {
+                const preparedImport = await prepareJunctionImportSnapshot(input.context, { workout_stream: [feature] }, input.sourceProviders);
+                if (hasJunctionSnapshotRecords(preparedImport.snapshots)) {
+                    await input.context.importSnapshot({
+                        provider: "junction",
+                        accountId: buildJunctionImportAccountId(input.context.account.externalAccountId),
+                        connectionId: input.context.account.id,
+                        importedAt: input.windowEnd,
+                        windowStart: input.windowStart,
+                        windowEnd: input.windowEnd,
+                        connections: preparedImport.connections,
+                        summaries: {},
+                        timeseries: preparedImport.snapshots,
+                    });
+                }
+            }
+            catch (error) {
+                return carryTerminalProgressOrThrow(error);
+            }
+            completedIdentities.add(candidate.identity);
+            madeProgress = true;
+        }
         return {
+            madeProgress,
+            workoutStreamCursor: encodeJunctionWorkoutStreamCompletedIdentities(completedIdentities),
             yieldedAt: null,
         };
     }
     async function importJunctionDirectResourceSnapshot(context, sourceProviders, windowStart, windowEnd, resource, records, historicalEvidenceWindow) {
         const snapshots = { [resource]: [...records] };
-        const connections = sanitizeJunctionImportConnections(sourceProviders);
-        const summaries = sanitizeJunctionImportSnapshots(snapshots, sourceProviders, {
+        const preparedImport = await prepareJunctionImportSnapshot(context, snapshots, sourceProviders, {
             blockedStringValues: [context.account.externalAccountId],
         });
+        const connections = preparedImport.connections;
+        const summaries = preparedImport.snapshots;
         const normalizationEvidence = classifyJunctionSummaryNormalizationEvidence({
             connections,
             importedAt: context.now,
@@ -1502,6 +3052,12 @@ export function createJunctionDeviceSyncProvider(config) {
             windowEnd,
             windowStart,
         }, historicalEvidenceWindow);
+        if (!hasJunctionSnapshotRecords(summaries)) {
+            return {
+                durableDeliveryAccepted: false,
+                normalizationEvidence,
+            };
+        }
         const receipt = await context.importSnapshot({
             provider: "junction",
             accountId: buildJunctionImportAccountId(context.account.externalAccountId),
@@ -1574,98 +3130,218 @@ export function createJunctionDeviceSyncProvider(config) {
     function buildYieldedJunctionJobResult(input) {
         const followUp = buildYieldedJunctionFollowUpJob(input);
         return {
-            ...(followUp ? { scheduledJobs: [followUp] } : {}),
+            ...(followUp
+                ? {
+                    scheduledJobs: [{
+                            ...followUp,
+                            ...(input.job.kind === "resource"
+                                ? {}
+                                : { availableAt: input.context.now }),
+                            ...(input.workoutStreamCursor !== undefined
+                                ? {
+                                    maxAttempts: input.job.maxAttempts - Math.max(input.job.attempts - 1, 0),
+                                }
+                                : {}),
+                        }],
+                }
+                : {}),
             nextReconcileAt: input.job.kind === "resource"
                 ? clampWebhookJobNextReconcileAt(input.context)
                 : addMilliseconds(input.context.now, reconcileIntervalMs),
         };
     }
-    function buildYieldedJunctionFollowUpJob(input) {
-        if (Date.parse(input.windowStart) >= Date.parse(input.windowEnd)) {
+    function buildDeferredNonConnectHistoricalBackfillRetry(input) {
+        const emptyBackfillAttempts = readHistoricalBackfillJobEmptyAttempts(input.job);
+        if (input.job.kind !== "backfill"
+            || emptyBackfillAttempts === 0
+            || isConnectHistoricalBackfillWindow(input.account, input.window)) {
             return null;
         }
-        if (input.job.kind === "backfill") {
-            const cursor = toIsoTimestampIfValid(input.timeseriesCursor);
-            if (!cursor || !isTimestampInHalfOpenWindow(cursor, input)) {
-                return null;
-            }
-            const emptyBackfillAttempts = readHistoricalBackfillJobEmptyAttempts(input.job);
-            const followUp = buildExactWindowJob({
-                kind: "backfill",
-                priority: input.job.priority,
-                windowEnd: input.windowEnd,
-                windowStart: input.windowStart,
-            });
-            return {
-                ...followUp,
-                payload: {
-                    ...followUp.payload,
-                    ...(emptyBackfillAttempts > 0 ? { emptyBackfillAttempts } : {}),
-                    timeseriesCursor: cursor,
-                },
-            };
+        const retryDelayMs = EMPTY_HISTORICAL_BACKFILL_RETRY_DELAYS_MS[emptyBackfillAttempts - 1] ?? null;
+        if (retryDelayMs === null) {
+            return null;
         }
-        if (input.job.kind === "reconcile") {
-            return buildExactWindowJob({
-                kind: input.job.kind,
-                priority: input.job.priority,
-                windowEnd: input.windowEnd,
-                windowStart: input.windowStart,
+        const retryJob = buildExactWindowJob({
+            kind: "backfill",
+            priority: Math.max(input.job.priority, JUNCTION_HISTORICAL_BACKFILL_RETRY_PRIORITY),
+            windowEnd: input.window.windowEnd,
+            windowStart: input.window.windowStart,
+        });
+        return {
+            ...retryJob,
+            availableAt: addMilliseconds(input.now, retryDelayMs),
+            payload: {
+                ...(retryJob.payload ?? {}),
+                emptyBackfillAttempts,
+            },
+        };
+    }
+    function buildFullJobTimeseriesContinuationResult(input) {
+        const continuationJob = input.continuation
+            ? buildFullJobTimeseriesContinuationJob({
+                deferredEmptyBackfillAttempts: readHistoricalBackfillJobEmptyAttempts(input.job),
+                job: input.job,
+                ...input.continuation,
+                window: input.window,
+            })
+            : null;
+        const scheduledJob = continuationJob
+            ? { ...continuationJob, availableAt: input.context.now }
+            : buildDeferredNonConnectHistoricalBackfillRetry({
+                account: input.context.account,
+                job: input.job,
+                now: input.context.now,
+                window: input.window,
             });
+        return withJunctionSkippedResourceMetadata(input.context, {
+            ...(scheduledJob ? { scheduledJobs: [scheduledJob] } : {}),
+            nextReconcileAt: resolveJunctionNextReconcileAt(input.context.account, input.context.now, addMilliseconds(input.context.now, reconcileIntervalMs)),
+        }, input.skippedOptionalResources);
+    }
+    function buildFullJobTimeseriesContinuationJob(input) {
+        if (input.job.kind !== "backfill" && input.job.kind !== "reconcile") {
+            return null;
+        }
+        const timeseriesResourceCursor = normalizeFullJobTimeseriesResourceCursor(input.timeseriesResourceCursor, timeseriesResources);
+        if (!timeseriesResourceCursor
+            || !isTimestampInHalfOpenWindow(input.timeseriesCursor, {
+                windowEnd: input.window.windowEnd,
+                windowStart: input.job.kind === "backfill"
+                    ? maxIsoTimestamp(input.window.windowStart, subtractDays(input.window.windowEnd, timeseriesBackfillDays))
+                    : input.window.windowStart,
+            })) {
+            return null;
+        }
+        const sourceProviderSlug = normalizeProviderSlug(input.job.payload.sourceProviderSlug);
+        return buildExactWindowJob({
+            kind: input.job.kind,
+            payload: {
+                ...(input.deferredEmptyBackfillAttempts > 0
+                    ? { emptyBackfillAttempts: input.deferredEmptyBackfillAttempts }
+                    : {}),
+                ...(sourceProviderSlug ? { sourceProviderSlug } : {}),
+                timeseriesCursor: input.timeseriesCursor,
+                timeseriesResourceCursor,
+                ...(input.timeseriesWindowHours === 1 ? { timeseriesWindowHours: 1 } : {}),
+                ...(input.workoutStreamCursor
+                    ? { workoutStreamCursor: input.workoutStreamCursor }
+                    : {}),
+            },
+            priority: input.job.priority,
+            windowEnd: input.window.windowEnd,
+            windowStart: input.window.windowStart,
+        });
+    }
+    function buildYieldedJunctionFollowUpJob(input) {
+        if (Date.parse(input.windowStart) >= Date.parse(input.windowEnd)) {
+            return null;
         }
+        const sourceProviderSlug = normalizeProviderSlug(input.job.payload.sourceProviderSlug);
         if (input.job.kind !== "resource") {
             return null;
         }
-        const payload = {
+        const payload = stripUndefined({
             ...input.job.payload,
+            emptyBackfillAttempts: input.emptyBackfillAttempts === undefined
+                ? input.job.payload.emptyBackfillAttempts
+                : input.emptyBackfillAttempts > 0
+                    ? input.emptyBackfillAttempts
+                    : undefined,
+            ...(input.historicalProviderRecordsSeen === undefined
+                ? {}
+                : { historicalProviderRecordsSeen: input.historicalProviderRecordsSeen }),
+            ...(input.historicalRecordsSeen === undefined
+                ? {}
+                : { historicalRecordsSeen: input.historicalRecordsSeen }),
+            historicalUnresolvedProviderRecordIdentitiesJson: input.historicalUnresolvedProviderRecordIdentitiesJson === undefined
+                ? input.job.payload.historicalUnresolvedProviderRecordIdentitiesJson
+                : input.historicalUnresolvedProviderRecordIdentitiesJson,
+            historicalUnresolvedProviderRecordCount: input.historicalUnresolvedProviderRecordCount === undefined
+                ? input.job.payload.historicalUnresolvedProviderRecordCount
+                : input.historicalUnresolvedProviderRecordCount > 0
+                    ? input.historicalUnresolvedProviderRecordCount
+                    : undefined,
             windowEnd: input.windowEnd,
             windowStart: input.windowStart,
-        };
+            workoutStreamCursor: input.workoutStreamCursor || undefined,
+        });
         return {
             kind: "resource",
             payload,
             priority: input.job.priority,
-            dedupeKey: sha256Text(JSON.stringify([
-                "junction",
-                "yield-follow-up",
-                input.windowStart,
-                input.windowEnd,
-                normalizeString(payload.eventType),
-                normalizeString(payload.objectId),
-                normalizeString(payload.occurredAt),
-                normalizeString(payload.resource),
-                normalizeString(payload.resourceCategory),
-                normalizeString(payload.sourceProviderSlug),
-            ])),
+            dedupeKey: input.job.dedupeKey
+                ?? buildJunctionExtendedTimeseriesBackfillDedupeKey(payload)
+                ?? sha256Text(JSON.stringify([
+                    "junction",
+                    "yield-follow-up",
+                    input.windowStart,
+                    input.windowEnd,
+                    normalizeString(payload.eventType),
+                    normalizeString(payload.objectId),
+                    normalizeString(payload.occurredAt),
+                    normalizeString(payload.resource),
+                    normalizeString(payload.resourceCategory),
+                    normalizeString(payload.sourceProviderSlug),
+                ])),
+        };
+    }
+    function buildExtendedTimeseriesBackfillWindow(input) {
+        const windowEnd = floorUtcDayTimestamp(input.anchorAt);
+        return {
+            windowEnd,
+            windowStart: floorUtcDayTimestamp(subtractDays(windowEnd, input.days)),
         };
     }
-    function buildInitialJobs(now) {
+    function hasTerminalJunctionHistoricalBackfill(account) {
+        const status = readJunctionHistoricalBackfillStatus(account.metadata[JUNCTION_HISTORICAL_BACKFILL_METADATA_KEYS.status]);
+        const connectWindow = buildConnectHistoricalBackfillWindow(account, summaryBackfillDays);
+        return status?.coverageVersion === JUNCTION_HISTORICAL_BACKFILL_COVERAGE_VERSION
+            && (status.status === "complete" || status.status === "exhausted")
+            && 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 }
+            : undefined;
         return [
             buildWindowJob({
                 kind: "backfill",
                 now,
+                payload,
                 windowStart: subtractDays(now, summaryBackfillDays),
-                priority: 30,
+                priority: JUNCTION_HISTORICAL_BACKFILL_PRIORITY,
             }),
             buildWindowJob({
                 kind: "reconcile",
                 now,
+                payload,
                 windowStart: subtractDays(now, reconcileDays),
-                priority: 40,
+                priority: JUNCTION_SCHEDULED_RECONCILE_PRIORITY,
             }),
         ];
     }
+    function buildSourceConnectionWork(input) {
+        return {
+            initialJobs: buildInitialJobs(input.now, input.sourceProviderSlug),
+            nextReconcileAt: addMilliseconds(input.now, reconcileIntervalMs),
+        };
+    }
     return {
         provider: "junction",
-        descriptor: JUNCTION_DEVICE_PROVIDER_DESCRIPTOR,
+        descriptor: buildJunctionDeviceSyncRuntimeDescriptor(config),
         credentialPolicy: {
             kind: "provider_config",
             providerConfigKey: JUNCTION_PROVIDER_CONFIG_KEY,
         },
         connectionHandler: {
             beginConnection,
+            buildSourceConnectionWork,
             completeConnection,
+            isSourceAccessActive,
             revokeAccess,
+            revokeSourceAccess,
         },
         sdkConnectionHandler: {
             ensureConnection: ensureSdkConnection,
@@ -1684,6 +3360,80 @@ export function createJunctionDeviceSyncProvider(config) {
         },
     };
 }
+async function fetchJunctionTimeseriesWindow(junctionClient, input) {
+    const policy = resolveJunctionTimeseriesResourcePolicy(input.resource);
+    if (!policy) {
+        throw new TypeError(`Unknown Junction timeseries resource: ${input.resource}.`);
+    }
+    if (policy.fetchMode === "workout_stream") {
+        const maxSamples = policy.maxSamplesPerRecord;
+        if (!maxSamples) {
+            throw new TypeError("Junction workout_stream policy did not define bounded limits.");
+        }
+        const candidates = await listJunctionWorkoutStreamCandidates(junctionClient, input);
+        const features = [];
+        for (const candidate of candidates) {
+            const feature = await fetchJunctionWorkoutStreamFeature(junctionClient, candidate, maxSamples, input.signal ?? null);
+            if (feature !== undefined) {
+                features.push(feature);
+            }
+        }
+        return features;
+    }
+    const records = await junctionClient.listTimeseries({
+        ...input,
+        maxRecords: input.maxRecords ?? policy.maxSamplesPerWindow,
+    });
+    if (policy.normalizationMode !== "ecg_recording_feature") {
+        return records;
+    }
+    if (!policy.maxRecordsPerWindow || !policy.maxSamplesPerWindow) {
+        throw new TypeError("Junction ECG voltage policy did not define bounded limits.");
+    }
+    return reduceJunctionElectrocardiogramVoltageRecords(records, {
+        maxRecordings: policy.maxRecordsPerWindow,
+        maxSamples: policy.maxSamplesPerWindow,
+    });
+}
+async function listJunctionWorkoutStreamCandidates(junctionClient, input) {
+    const maxWorkouts = resolveJunctionTimeseriesResourcePolicy("workout_stream")
+        ?.maxRecordsPerWindow;
+    if (!maxWorkouts) {
+        throw new TypeError("Junction workout_stream policy did not define a workout limit.");
+    }
+    const indexRecords = await junctionClient.listSummary({
+        collectionWorkLimit: input.collectionWorkLimit,
+        resource: "workouts",
+        signal: input.signal ?? null,
+        sourceProviderSlug: input.sourceProviderSlug,
+        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);
+}
+async function fetchJunctionWorkoutStreamFeature(junctionClient, candidate, maxSamples, signal, collectionWorkLimit) {
+    const stream = await junctionClient.getWorkoutStream({
+        collectionWorkLimit,
+        signal,
+        workoutId: candidate.workoutId,
+    });
+    return reduceJunctionWorkoutStreamPayload({
+        maxSamples,
+        stream,
+        summary: candidate.summary,
+    });
+}
+function withJunctionSourceProviderFallback(value, sourceProviderSlug) {
+    const record = readPlainObject(value);
+    const normalizedSource = normalizeProviderSlug(sourceProviderSlug);
+    if (!record || !normalizedSource || resolveJunctionOrigin(record).sourceProviderSlug) {
+        return value;
+    }
+    return { ...record, sourceProviderSlug: normalizedSource };
+}
 function withJunctionSkippedResourceMetadata(context, result, skippedOptionalResources) {
     if (skippedOptionalResources.length === 0) {
         return result;
@@ -1711,6 +3461,7 @@ function withJunctionMetadataPatch(result, metadataPatch) {
 function buildJunctionProfileSummaryCheckedMetadataPatch(context) {
     return {
         [JUNCTION_PROFILE_SUMMARY_CHECKED_AT_METADATA_KEY]: context.now,
+        [JUNCTION_PROFILE_SUMMARY_NORMALIZATION_REVISION_METADATA_KEY]: JUNCTION_PROFILE_SUMMARY_NORMALIZATION_REVISION,
     };
 }
 function buildJunctionSkippedResourceMetadataPatch(context, skippedOptionalResources) {
@@ -1740,7 +3491,29 @@ function isJunctionProfileSummaryResource(resource) {
 }
 function hasCheckedJunctionProfileSummary(metadata) {
     const checkedAt = normalizeString(metadata[JUNCTION_PROFILE_SUMMARY_CHECKED_AT_METADATA_KEY]);
-    return checkedAt !== undefined && Number.isFinite(Date.parse(checkedAt));
+    return checkedAt !== undefined
+        && Number.isFinite(Date.parse(checkedAt))
+        && metadata[JUNCTION_PROFILE_SUMMARY_NORMALIZATION_REVISION_METADATA_KEY]
+            === JUNCTION_PROFILE_SUMMARY_NORMALIZATION_REVISION;
+}
+function addJunctionWorkoutStreamCandidateFailureContext(error, input) {
+    if (!isDeviceSyncError(error) || error.code !== "JUNCTION_API_REQUEST_FAILED") {
+        return error;
+    }
+    return deviceSyncError({
+        accountStatus: error.accountStatus,
+        cause: error.cause,
+        code: error.code,
+        details: {
+            ...error.details,
+            requestCandidateAliasSource: input.aliasSource,
+            requestCandidateCount: input.candidateCount,
+            requestCandidateOrdinal: input.candidateOrdinal,
+        },
+        httpStatus: error.httpStatus,
+        message: error.message,
+        retryable: error.retryable,
+    });
 }
 function classifyOptionalJunctionResourceFailure(error, resourceCategory, resource, accountExternalId) {
     if (!isDeviceSyncError(error) || error.code !== "JUNCTION_API_REQUEST_FAILED") {
@@ -1785,6 +3558,22 @@ function classifyOptionalJunctionResourceFailure(error, resourceCategory, resour
         ...(responseDetail ? { responseDetail } : {}),
     };
 }
+function isRetryableDeviceSyncFailure(error) {
+    return isDeviceSyncError(error) && error.retryable;
+}
+function isJunctionJobSignalAbort(error, signal, depth = 0) {
+    if (!signal?.aborted) {
+        return false;
+    }
+    if (error === signal.reason) {
+        return true;
+    }
+    if (depth >= 4 || typeof error !== "object" || error === null) {
+        return false;
+    }
+    const cause = "cause" in error ? error.cause : undefined;
+    return cause !== undefined && isJunctionJobSignalAbort(cause, signal, depth + 1);
+}
 function buildJunctionOptionalResourceResponseDetail(input) {
     // The generic redactor does not know the current Junction user id; strip it
     // explicitly before the shared sanitizer so provider prose that embeds the
@@ -2201,7 +3990,7 @@ function resolveJunctionDiagnosticMatrixResources(input) {
 }
 async function runJunctionDiagnosticMatrixRead(input) {
     const response = await runJunctionDiagnosticCall(() => input.category === "timeseries"
-        ? input.client.listTimeseries({
+        ? fetchJunctionTimeseriesWindow(input.client, {
             resource: input.resource,
             sourceProviderSlug: input.sourceProviderSlug,
             userId: input.account.externalAccountId,
@@ -2219,9 +4008,7 @@ async function runJunctionDiagnosticMatrixRead(input) {
         request: {
             configuredResource: input.configuredResource,
             endpoint: input.category,
-            endpointKind: input.category === "timeseries"
-                ? "junction_timeseries_collection"
-                : "junction_summary_collection",
+            endpointKind: resolveJunctionDiagnosticEndpointKind(input.category, input.resource),
             queryParameterNames: resolveJunctionDiagnosticResourceQueryParameterNames(input.category, input.resource, input.sourceProviderSlug),
             resource: input.resource,
             resourceCategory: input.category,
@@ -2231,6 +4018,14 @@ async function runJunctionDiagnosticMatrixRead(input) {
         response: describeJunctionDiagnosticRecords(response),
     };
 }
+function resolveJunctionDiagnosticEndpointKind(category, resource) {
+    if (category === "summary") {
+        return "junction_summary_collection";
+    }
+    return resolveJunctionTimeseriesResourcePolicy(resource)?.fetchMode === "workout_stream"
+        ? "junction_workout_stream"
+        : "junction_timeseries_collection";
+}
 function resolveJunctionDiagnosticResourceQueryParameterNames(category, resource, sourceProviderSlug) {
     if (category === "summary" && isJunctionProfileSummaryResource(resource)) {
         return sourceProviderSlug ? ["provider"] : [];
@@ -2645,10 +4440,12 @@ function normalizeDiagnosticTimeseriesProbeDays(value) {
     }
     return Math.min(value, JUNCTION_MAX_DIAGNOSTIC_TIMESERIES_PROBE_DAYS);
 }
-export function buildJunctionClientUserId(secret, ownerId) {
+export function buildJunctionClientUserId(secret, ownerId, namespace) {
     const normalizedSecret = assertValidJunctionClientUserIdSecret(secret);
+    const normalizedNamespace = normalizeJunctionClientUserIdNamespace(namespace);
     const digest = createHmac("sha256", normalizedSecret).update(ownerId).digest();
-    return `murph_${base32UrlEncode(digest)}`.slice(0, 32);
+    const prefix = normalizedNamespace ? `murph_${normalizedNamespace}_` : "murph_";
+    return `${prefix}${base32UrlEncode(digest)}`.slice(0, 32);
 }
 function resolveJunctionLinkDirectProvider(providerFilter, sourceProviderSlug) {
     const requested = normalizeString(sourceProviderSlug);
@@ -2671,6 +4468,7 @@ function toClientConfig(config) {
         apiKey: config.apiKey,
         environment: config.environment,
         region: config.region,
+        apiBaseUrl: config.apiBaseUrl,
         allowedLinkHosts: config.allowedLinkHosts,
         requestTimeoutMs: config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
         fetchImpl: config.fetchImpl,
@@ -2680,14 +4478,153 @@ function normalizeProviderSlug(value) {
     const normalized = normalizeString(value)?.toLowerCase().replace(/[^a-z0-9_]+/gu, "_").replace(/^_+|_+$/gu, "");
     return normalized || null;
 }
+function resolveJunctionProviderRouteSlug(value) {
+    const normalized = normalizeProviderSlug(value);
+    if (!normalized) {
+        return null;
+    }
+    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) {
+        const identity = resolveJunctionAccountSourceIdentity(sources, source.sourceProviderSlug);
+        if (identity
+            && !identities.some((candidate) => candidate.sourceProviderSlug === identity.sourceProviderSlug)) {
+            identities.push(identity);
+        }
+    }
+    return identities;
+}
+function resolveJunctionAccountSourceStates(sources) {
+    const states = [];
+    for (const source of sources) {
+        if (states.some((state) => areJunctionProviderSlugsRouteEquivalent(state.identitySource.sourceProviderSlug, source.sourceProviderSlug))) {
+            continue;
+        }
+        const state = resolveJunctionAccountSourceState(sources, source.sourceProviderSlug);
+        if (state) {
+            states.push(state);
+        }
+    }
+    return states;
+}
+function mergeJunctionAccountSourceIdentities(accountSourceIdentities, requestedSourceIdentities) {
+    return [
+        ...accountSourceIdentities,
+        ...requestedSourceIdentities.filter((requestedIdentity) => !accountSourceIdentities.some((accountIdentity) => areJunctionProviderSlugsRouteEquivalent(requestedIdentity.sourceProviderSlug, accountIdentity.sourceProviderSlug))),
+    ];
+}
+function resolveJunctionAccountSourceIdentity(sources, sourceProviderSlug, allowUnlistedSource = false) {
+    const normalizedSourceProviderSlug = normalizeProviderSlug(sourceProviderSlug);
+    if (!normalizedSourceProviderSlug) {
+        return null;
+    }
+    const matchingSource = findJunctionAccountSource(sources, normalizedSourceProviderSlug);
+    if (!matchingSource) {
+        return allowUnlistedSource
+            ? { sourceProviderSlug: normalizedSourceProviderSlug }
+            : null;
+    }
+    const establishedSourceProviderSlug = normalizeProviderSlug(matchingSource.sourceProviderSlug);
+    if (!establishedSourceProviderSlug) {
+        return null;
+    }
+    const sourceInstanceId = matchingSource.sourceInstanceKey
+        ? resolveJunctionOrigin({
+            sourceInstanceId: matchingSource.sourceInstanceKey,
+            sourceProviderSlug: establishedSourceProviderSlug,
+        }).sourceInstanceId
+        : undefined;
+    return {
+        ...(matchingSource.sourceInstanceKey
+            ? {
+                ...(sourceInstanceId ? { sourceInstanceId } : {}),
+                sourceInstanceKey: matchingSource.sourceInstanceKey,
+            }
+            : {}),
+        sourceProviderSlug: establishedSourceProviderSlug,
+    };
+}
+function findJunctionAccountSource(sources, sourceProviderSlug) {
+    return resolveJunctionAccountSourceState(sources, sourceProviderSlug)
+        ?.identitySource;
+}
+function findJunctionAccountSources(sources, sourceProviderSlug) {
+    return sources.filter((source) => areJunctionProviderSlugsRouteEquivalent(source.sourceProviderSlug, sourceProviderSlug));
+}
+function resolveJunctionAccountSourceState(sources, sourceProviderSlug) {
+    const [first, ...rest] = findJunctionAccountSources(sources, sourceProviderSlug);
+    if (!first) {
+        return null;
+    }
+    return resolveDeviceSyncSourceState([first, ...rest], junctionSourceStateUnavailableError);
+}
 function stripUndefined(value) {
     return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
 }
-function sanitizeJunctionImportConnections(providers) {
-    return providers.map((provider) => stripUndefined({
-        sourceProviderSlug: provider.origin.sourceProviderSlug ?? provider.slug,
-        sourceInstanceId: provider.origin.sourceInstanceId,
-    }));
+function sanitizeJunctionImportConnections(providers, sourceIdentities = []) {
+    return providers.map((provider) => {
+        const sourceProviderSlug = provider.origin.sourceProviderSlug ?? provider.slug;
+        const projectedSourceIdentity = sourceIdentities.find((identity) => areJunctionProviderSlugsRouteEquivalent(sourceProviderSlug, identity.sourceProviderSlug));
+        return stripUndefined({
+            sourceProviderSlug: projectedSourceIdentity?.sourceProviderSlug ?? sourceProviderSlug,
+            sourceInstanceId: projectedSourceIdentity?.sourceInstanceId ?? provider.origin.sourceInstanceId,
+        });
+    });
+}
+async function prepareJunctionImportSnapshot(context, snapshots, providers, options = {}, sourceStatusRequirement = "not_disconnected") {
+    const currentSources = context.listConnectionSources
+        ? await context.listConnectionSources()
+        : context.account.sources ?? [];
+    const sourceIdentities = options.projectAccountSourceIdentities
+        ? mergeJunctionAccountSourceIdentities(resolveJunctionAccountSourceIdentities(currentSources), options.sourceIdentities ?? [])
+        : options.sourceIdentities;
+    return prepareJunctionImportSnapshotForSources(snapshots, providers, currentSources, { ...options, sourceIdentities }, {
+        allowUnlistedSources: context.connectionSourceAdmissionMode !== "listed_only",
+        sourceStatusRequirement,
+    });
+}
+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 {
+        connections: sanitizeJunctionImportConnections(sourceProviders, options.sourceIdentities),
+        sourceProviders,
+        snapshots: sanitizeJunctionImportSnapshots(filterJunctionImportSnapshots(snapshots, providers, currentSources, allowUnlistedSources, sourceStatusRequirement), providers, options),
+    };
+}
+function filterJunctionImportSnapshots(snapshots, providers, sources, allowUnlistedSources = true, sourceStatusRequirement = "not_disconnected") {
+    const sourceReferences = buildJunctionSourceReferenceMap(providers);
+    const hasPendingSourceAdmission = resolveJunctionAccountSourceStates(sources).some(({ lifecycleSource }) => sourceStatusRequirement === "connected"
+        ? !isDeviceSyncSourceAdmitted([lifecycleSource], lifecycleSource.sourceProviderSlug)
+        : lifecycleSource.status === "disconnected"
+            || isDeviceSyncSourceDisconnectFenced(lifecycleSource));
+    return Object.fromEntries(Object.entries(snapshots).map(([resource, records]) => [
+        resource,
+        records.filter((record) => isJunctionImportRecordAdmitted(record, sourceReferences, sources, hasPendingSourceAdmission, allowUnlistedSources, sourceStatusRequirement)),
+    ]));
+}
+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);
+    if (sourceProviderSlug) {
+        return isJunctionSourceAdmittedForImport(sources, sourceProviderSlug, allowUnlistedSources, sourceStatusRequirement);
+    }
+    return !hasPendingSourceAdmission || !hasJunctionSourceReferenceIdentity(record);
 }
 function sanitizeJunctionImportSnapshots(snapshots, providers, options = {}) {
     const sourceReferences = buildJunctionSourceReferenceMap(providers);
@@ -2723,6 +4660,9 @@ function sanitizeJunctionImportSnapshotValue(value, sourceReferences, options =
     if (typeof value === "string") {
         return redactJunctionBlockedStringValue(value, options.blockedStringValues ?? []);
     }
+    if (value instanceof Date) {
+        return Number.isFinite(value.getTime()) ? value.toISOString() : null;
+    }
     const record = readPlainObject(value);
     if (!record) {
         return value;
@@ -2736,11 +4676,18 @@ function sanitizeJunctionImportSnapshotValue(value, sourceReferences, options =
         hasJunctionSourceReferenceIdentity(record);
     const sourceInstanceId = fallbackSourceInstanceId ??
         (unresolvedPreservedSourceReference ? undefined : origin.sourceInstanceId);
+    const sourceProviderSlug = normalizeProviderSlug(origin.sourceProviderSlug);
+    const projectedSourceIdentity = options.sourceIdentities
+        ?.find((identity) => areJunctionProviderSlugsRouteEquivalent(sourceProviderSlug, identity.sourceProviderSlug));
     return stripUndefined({
         ...sanitized,
-        sourceProviderSlug: normalizeProviderSlug(origin.sourceProviderSlug) ?? sanitized.sourceProviderSlug,
+        sourceProviderSlug: projectedSourceIdentity?.sourceProviderSlug
+            ?? sourceProviderSlug
+            ?? sanitized.sourceProviderSlug,
         sourceType: origin.sourceType ?? sanitized.sourceType,
-        sourceInstanceId: sourceInstanceId ?? sanitized.sourceInstanceId,
+        sourceInstanceId: projectedSourceIdentity?.sourceInstanceId
+            ?? sourceInstanceId
+            ?? sanitized.sourceInstanceId,
     });
 }
 function readJunctionSourceReference(record, sourceReferences) {
@@ -2838,17 +4785,39 @@ function isBlockedJunctionImportSourceIdentityContainerKey(key) {
         || normalized === "owner";
 }
 function dedupeJunctionTimeseriesRecords(resource, records) {
+    const candidates = records.map((record) => ({
+        contentKey: buildJunctionTimeseriesRecordContentKey(resource, record),
+        key: buildJunctionTimeseriesRecordKey(resource, record),
+        providerRowKey: buildJunctionTimeseriesProviderRowKey(resource, record),
+        record,
+    }));
+    const contentKeysByProviderRow = new Map();
+    for (const candidate of candidates) {
+        if (!candidate.providerRowKey || !candidate.contentKey) {
+            continue;
+        }
+        const contentKeys = contentKeysByProviderRow.get(candidate.providerRowKey)
+            ?? new Set();
+        contentKeys.add(candidate.contentKey);
+        contentKeysByProviderRow.set(candidate.providerRowKey, contentKeys);
+    }
+    const conflictingProviderRows = new Set([...contentKeysByProviderRow.entries()]
+        .filter(([, contentKeys]) => contentKeys.size > 1)
+        .map(([providerRowKey]) => providerRowKey));
     const seen = new Set();
     const deduped = [];
-    for (const record of records) {
-        const key = buildJunctionTimeseriesRecordKey(resource, record);
-        if (key && seen.has(key)) {
+    for (const candidate of candidates) {
+        if (candidate.providerRowKey
+            && conflictingProviderRows.has(candidate.providerRowKey)) {
+            continue;
+        }
+        if (candidate.key && seen.has(candidate.key)) {
             continue;
         }
-        if (key) {
-            seen.add(key);
+        if (candidate.key) {
+            seen.add(candidate.key);
         }
-        deduped.push(record);
+        deduped.push(candidate.record);
     }
     return deduped;
 }
@@ -2859,21 +4828,38 @@ function dedupeJunctionTimeseriesSnapshotRecords(snapshot) {
     }
     return deduped;
 }
-function filterJunctionTimeseriesRecordsToWindow(records, windowStart, windowEnd) {
+function filterJunctionTimeseriesRecordsToWindow(resource, records, windowStart, windowEnd, dateQueryFormat) {
     const startMs = Date.parse(windowStart);
     const endMs = Date.parse(windowEnd);
     if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || startMs >= endMs) {
         return [...records];
     }
+    const policy = resolveJunctionTimeseriesResourcePolicy(resource);
+    const preferIntervalStart = usesJunctionTimeseriesIntervalStartOwnership(policy);
     return records.filter((record) => {
         const entry = readPlainObject(record);
         if (!entry) {
             return true;
         }
-        const timestamp = resolveJunctionTimeseriesRecordTimestamp(entry);
-        if (!timestamp) {
+        const rawTimestamp = resolveJunctionTimeseriesRecordRawTimestamp(entry, preferIntervalStart);
+        if (!rawTimestamp) {
             return true;
         }
+        if (dateQueryFormat === "date"
+            && policy?.normalizationMode === "daily_aggregate") {
+            if (JUNCTION_CALENDAR_DAY_AGGREGATE_RESOURCE_SET.has(resource)
+                || resolveJunctionExtendedTimeseriesBackfillPolicy(resource)?.completion
+                    === "daily_aggregate") {
+                // Junction's date-mode response owns the provider calendar day. Keep
+                // every interval together even when an explicit offset crosses UTC
+                // midnight; the importer owns provider-local day resolution.
+                return true;
+            }
+            if (isJunctionFloatingCalendarTimestamp(rawTimestamp)) {
+                return rawTimestamp.slice(0, 10) === windowStart.slice(0, 10);
+            }
+        }
+        const timestamp = toIsoTimestampIfValid(rawTimestamp) ?? rawTimestamp;
         const recordedMs = Date.parse(timestamp);
         if (!Number.isFinite(recordedMs)) {
             return true;
@@ -2882,10 +4868,22 @@ function filterJunctionTimeseriesRecordsToWindow(records, windowStart, windowEnd
     });
 }
 function buildJunctionTimeseriesRecordKey(resource, record) {
+    const providerRowKey = buildJunctionTimeseriesProviderRowKey(resource, record);
+    if (providerRowKey) {
+        return providerRowKey;
+    }
     const entry = readPlainObject(record);
     if (!entry) {
         return null;
     }
+    if ((resource === "electrocardiogram_voltage" && entry.schema === JUNCTION_ECG_VOLTAGE_FEATURE_SCHEMA)
+        || (resource === "workout_stream" && entry.schema === JUNCTION_WORKOUT_STREAM_FEATURE_SCHEMA)) {
+        return JSON.stringify([
+            "junction-bounded-timeseries-feature",
+            resource,
+            buildJunctionBoundedFeatureIdentity(resource, entry),
+        ]);
+    }
     const origin = resolveJunctionOrigin(entry);
     const sourceProviderSlug = normalizeProviderSlug(origin.sourceProviderSlug);
     const timestamp = resolveJunctionTimeseriesRecordTimestamp(entry);
@@ -2902,26 +4900,237 @@ function buildJunctionTimeseriesRecordKey(resource, record) {
         ...junctionTimeseriesRecordValueIdentity(resource, entry),
     ]);
 }
-// Blood-pressure readings carry their paired values as part of identity
-// (the importer keeps distinct same-second readings as distinct events), so
-// the pre-import dedupe key must not collapse same-timestamp rows whose
-// values differ. A stable provider row id wins when present.
-function junctionTimeseriesRecordValueIdentity(resource, entry) {
-    if (resource !== "blood_pressure") {
-        return [];
+function buildJunctionTimeseriesProviderRowKey(resource, record) {
+    // The bounded fidelity importer owns same-row revision arbitration for these
+    // resources. Keep each distinct semantic body in transport so it can select
+    // an explicit newer revision or reject an ambiguous provider conflict.
+    if (JUNCTION_CALENDAR_DAY_AGGREGATE_RESOURCE_SET.has(resource)) {
+        return null;
+    }
+    const entry = readPlainObject(record);
+    if (!entry) {
+        return null;
+    }
+    const providerRowId = readJunctionTimeseriesProviderRowId(resource, entry);
+    if (!providerRowId) {
+        return null;
+    }
+    const origin = resolveJunctionOrigin(entry);
+    const sourceProviderSlug = normalizeProviderSlug(origin.sourceProviderSlug);
+    if (!sourceProviderSlug) {
+        return null;
+    }
+    return JSON.stringify([
+        "junction-timeseries-provider-row",
+        resource,
+        sourceProviderSlug,
+        normalizeString(origin.sourceType) ?? "",
+        normalizeString(origin.sourceInstanceId) ?? "",
+        providerRowId,
+    ]);
+}
+function buildJunctionTimeseriesRecordContentKey(resource, record) {
+    const entry = readPlainObject(record);
+    if (!entry) {
+        return null;
+    }
+    return JSON.stringify([
+        "junction-timeseries-content",
+        resolveJunctionTimeseriesRecordTimestamp(entry) ?? "",
+        normalizeString(entry.recordedAt ?? entry.recorded_at ?? entry.updatedAt ?? entry.updated_at)
+            ?? "",
+        String(entry.timeZoneOffsetMinutes
+            ?? entry.time_zone_offset_minutes
+            ?? entry.timezoneOffsetMinutes
+            ?? entry.timezone_offset_minutes
+            ?? entry.timezone_offset
+            ?? entry.timezoneOffset
+            ?? ""),
+        normalizeString(entry.timestampSemantics ?? entry.timestamp_semantics) ?? "",
+        normalizeString(entry.originConfidence ?? entry.origin_confidence) ?? "",
+        ...junctionTimeseriesRecordValueIdentity(resource, entry, false),
+    ]);
+}
+function junctionTimeseriesRecordNeedsSemanticIdentity(resource) {
+    const policy = resolveJunctionTimeseriesResourcePolicy(resource);
+    return resource === "blood_pressure"
+        || resource === "note"
+        || JUNCTION_CALENDAR_DAY_AGGREGATE_RESOURCE_SET.has(resource)
+        || policy?.normalizationMode === "sparse_alert"
+        || policy?.normalizationMode === "sparse_intervention"
+        || policy?.normalizationMode === "sparse_observation"
+        || policy?.normalizationMode === "sparse_reading";
+}
+function readJunctionTimeseriesProviderRowId(resource, entry) {
+    if (!junctionTimeseriesRecordNeedsSemanticIdentity(resource)) {
+        return null;
     }
-    // Same stable-id alias list as the importer's reading identity: rows
-    // distinguished only by a provider id must survive fetch-side dedupe.
-    for (const key of ["id", "resourceId", "resource_id", "externalId", "external_id"]) {
+    const providerRowIdKeys = [
+        "id",
+        "resourceId",
+        "resource_id",
+        "externalId",
+        "external_id",
+        "providerId",
+        "provider_id",
+        ...(JUNCTION_CALENDAR_DAY_AGGREGATE_RESOURCE_SET.has(resource)
+            ? ["recordId", "record_id", "sampleId", "sample_id"]
+            : []),
+    ];
+    for (const key of providerRowIdKeys) {
         const rowId = normalizeString(entry[key]);
         if (rowId) {
-            return [rowId];
+            return rowId;
+        }
+    }
+    return null;
+}
+// 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 (!junctionTimeseriesRecordNeedsSemanticIdentity(resource)) {
+        return [];
+    }
+    const providerRowId = readJunctionTimeseriesProviderRowId(resource, entry) ?? "";
+    if (resource === "weight") {
+        if (includeProviderRowId && providerRowId) {
+            return [providerRowId];
+        }
+        const { weightKilograms } = resolveJunctionWeightProviderRecordIdentity(entry);
+        return weightKilograms === undefined ? [] : [`kg:${weightKilograms}`];
+    }
+    if (resource === "note") {
+        if (includeProviderRowId && providerRowId) {
+            return [providerRowId];
         }
+        return [
+            ...(Array.isArray(entry.tags) ? entry.tags : [])
+                .flatMap((tag) => {
+                const normalized = normalizeString(tag);
+                return normalized ? [normalized] : [];
+            })
+                .sort(),
+        ];
+    }
+    const fidelityPointResource = resource === "glucose"
+        || resource === "blood_oxygen"
+        || resource === "stress_level";
+    const fidelityIntervalResource = resource === "caffeine"
+        || resource === "water"
+        || resource === "mindfulness_minutes";
+    const rowId = includeProviderRowId ? providerRowId : "";
+    const fidelitySourceRevision = String(entry.recordedAt
+        ?? entry.recorded_at
+        ?? entry.updatedAt
+        ?? entry.updated_at
+        ?? "");
+    const timeZoneIdentity = [
+        String(entry.timeZone ?? entry.timezone ?? entry.time_zone ?? ""),
+        String(entry.timeZoneOffsetMinutes
+            ?? entry.time_zone_offset_minutes
+            ?? entry.timezoneOffsetMinutes
+            ?? entry.timezone_offset_minutes
+            ?? entry.utcOffsetMinutes
+            ?? entry.utc_offset_minutes
+            ?? ""),
+        String(entry.timezone_offset
+            ?? entry.timezoneOffset
+            ?? entry.timeZoneOffset
+            ?? entry.time_zone_offset
+            ?? entry.timezoneOffsetSeconds
+            ?? entry.timezone_offset_seconds
+            ?? entry.timeZoneOffsetSeconds
+            ?? entry.time_zone_offset_seconds
+            ?? entry.utcOffsetSeconds
+            ?? entry.utc_offset_seconds
+            ?? ""),
+    ];
+    const providerDayIdentity = [
+        String(entry.calendarDate
+            ?? entry.calendar_date
+            ?? entry.localDate
+            ?? entry.local_date
+            ?? ""),
+        String(entry.timestampSemantics ?? entry.timestamp_semantics ?? ""),
+    ];
+    if (fidelityIntervalResource) {
+        const intervalValue = resource === "mindfulness_minutes"
+            ? entry.value ?? entry.mindfulnessMinutes ?? entry.mindfulness_minutes
+            : resource === "caffeine"
+                ? entry.value ?? entry.caffeine
+                : entry.value ?? entry.water;
+        return [
+            rowId,
+            String(entry.start ?? entry.startAt ?? entry.start_at ?? entry.timeStart ?? entry.time_start ?? ""),
+            String(entry.end ?? entry.endAt ?? entry.end_at ?? entry.timeEnd ?? entry.time_end ?? ""),
+            String(entry.unit ?? entry.valueUnit ?? entry.value_unit ?? ""),
+            String(intervalValue ?? ""),
+            ...providerDayIdentity,
+            ...timeZoneIdentity,
+            fidelitySourceRevision,
+        ];
+    }
+    if (fidelityPointResource) {
+        return [
+            rowId,
+            String(entry.observedAt
+                ?? entry.observed_at
+                ?? entry.observed_at_utc
+                ?? entry.timestamp
+                ?? entry.time
+                ?? entry.date
+                ?? entry.day
+                ?? ""),
+            String(entry.value ?? (resource === "glucose"
+                ? entry.glucose ?? entry.bloodGlucose ?? entry.blood_glucose
+                : resource === "blood_oxygen"
+                    ? entry.spo2
+                        ?? entry.spO2
+                        ?? entry.bloodOxygen
+                        ?? entry.blood_oxygen
+                        ?? entry.oxygenSaturation
+                        ?? entry.oxygen_saturation
+                    : entry.stressLevel
+                        ?? entry.stress_level
+                        ?? entry.averageStressLevel
+                        ?? entry.average_stress_level
+                        ?? readPlainObject(entry.stress)?.average
+                        ?? entry.stressLevelValue
+                        ?? entry.stress_level_value
+                        ?? entry.score) ?? ""),
+            String(entry.unit ?? entry.valueUnit ?? entry.value_unit ?? ""),
+            ...providerDayIdentity,
+            ...timeZoneIdentity,
+            fidelitySourceRevision,
+        ];
     }
-    // Field names mirror the importer's blood-pressure value paths.
-    return [String(entry.systolic ?? ""), String(entry.diastolic ?? "")];
+    if (resource === "blood_pressure") {
+        return includeProviderRowId && providerRowId
+            ? [providerRowId]
+            : [String(entry.systolic ?? ""), String(entry.diastolic ?? "")];
+    }
+    return [
+        ...(includeProviderRowId ? [providerRowId] : []),
+        String(entry.start ?? ""),
+        String(entry.end ?? ""),
+        String(entry.value ?? ""),
+        String(entry.unit ?? ""),
+        String(entry.type ?? ""),
+        String(entry.bolus_purpose ?? entry.bolusPurpose ?? ""),
+        String(entry.delivery_form ?? entry.deliveryForm ?? ""),
+        String(entry.delivery_mode ?? entry.deliveryMode ?? ""),
+    ];
+}
+function resolveJunctionTimeseriesRecordTimestamp(record, preferIntervalStart = false) {
+    const rawTimestamp = resolveJunctionTimeseriesRecordRawTimestamp(record, preferIntervalStart);
+    return rawTimestamp
+        ? toIsoTimestampIfValid(rawTimestamp) ?? rawTimestamp
+        : null;
 }
-function 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"]
+        : ["sessionEnd", "session_end", "timeEnd", "time_end", "end", "endAt", "end_at", "sessionStart", "session_start", "timeStart", "time_start", "start", "startAt", "start_at"];
     for (const key of [
         "observedAt",
         "observed_at",
@@ -2930,21 +5139,26 @@ function resolveJunctionTimeseriesRecordTimestamp(record) {
         "time",
         "date",
         "day",
-        "end",
-        "endAt",
-        "end_at",
-        "start",
-        "startAt",
-        "start_at",
+        ...intervalKeys,
     ]) {
-        const normalized = normalizeString(record[key]);
+        const value = record[key];
+        const normalized = value instanceof Date
+            ? Number.isFinite(value.getTime()) ? value.toISOString() : null
+            : normalizeString(value);
         if (!normalized) {
             continue;
         }
-        return toIsoTimestampIfValid(normalized) ?? normalized;
+        return normalized;
     }
     return null;
 }
+function isJunctionFloatingCalendarTimestamp(value) {
+    const normalized = value.trim();
+    if (/z$/iu.test(normalized) || /[+-]\d{2}:?\d{2}$/u.test(normalized)) {
+        return false;
+    }
+    return /^\d{4}-\d{2}-\d{2}(?:$|[ t]\d{2}:\d{2})/iu.test(normalized);
+}
 function buildJunctionRedirectUrl(callbackUrl, state) {
     const url = new URL(callbackUrl);
     url.searchParams.set("murph_state", state);
@@ -3016,6 +5230,115 @@ function resolveJobWindow(job, now, fallbackDays) {
         windowEnd,
     };
 }
+function readFullJobTimeseriesCursor(job, ownerWindow) {
+    const cursor = toIsoTimestampIfValid(job.payload.timeseriesCursor);
+    return cursor && isTimestampInHalfOpenWindow(cursor, ownerWindow)
+        ? cursor
+        : null;
+}
+function readFullJobTimeseriesWindowHours(job) {
+    if (job.payload.timeseriesWindowHours === undefined) {
+        return 24;
+    }
+    if (job.payload.timeseriesWindowHours !== 1) {
+        throw invalidJunctionTimeseriesResourceProgress();
+    }
+    return 1;
+}
+function readFullJobTimeseriesResourceCursor(job, resources) {
+    const configuredResource = normalizeFullJobTimeseriesResourceCursor(job.payload.timeseriesResourceCursor, resources);
+    if (configuredResource) {
+        return {
+            resource: configuredResource,
+            restartFromWindowStart: false,
+        };
+    }
+    const previouslyConfiguredResource = normalizeFullJobTimeseriesResourceCursor(job.payload.timeseriesResourceCursor, JUNCTION_ALLOWED_TIMESERIES_RESOURCES);
+    const firstConfiguredResource = resources[0];
+    return previouslyConfiguredResource && firstConfiguredResource
+        ? {
+            resource: firstConfiguredResource,
+            restartFromWindowStart: true,
+        }
+        : null;
+}
+function normalizeFullJobTimeseriesResourceCursor(value, resources) {
+    const cursor = normalizeJunctionResourceName(value);
+    if (cursor && resources.includes(cursor)) {
+        return cursor;
+    }
+    if (typeof value !== "string") {
+        return null;
+    }
+    let parsedValue;
+    try {
+        parsedValue = JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+    const parsed = readPlainObject(parsedValue);
+    const activeResource = normalizeJunctionResourceName(parsed?.a);
+    const completedResources = parsed?.i;
+    if (!parsed
+        || parsed.v !== JUNCTION_DEPLOYED_FULL_JOB_PROGRESS_VERSION
+        || Object.keys(parsed).some((key) => key !== "a" && key !== "i" && key !== "v")
+        || !activeResource
+        || !resources.includes(activeResource)
+        || !Array.isArray(completedResources)
+        || completedResources.length > JUNCTION_ALLOWED_TIMESERIES_RESOURCES.length
+        || !completedResources.every((resource) => normalizeJunctionResourceName(resource) === resource
+            && JUNCTION_ALLOWED_TIMESERIES_RESOURCE_SET.has(resource))) {
+        return null;
+    }
+    const sortedCompletedResources = [...completedResources].sort();
+    if (new Set(sortedCompletedResources).size !== sortedCompletedResources.length
+        || sortedCompletedResources.includes(activeResource)
+        || JSON.stringify({
+            v: JUNCTION_DEPLOYED_FULL_JOB_PROGRESS_VERSION,
+            a: activeResource,
+            i: sortedCompletedResources,
+        }) !== value) {
+        return null;
+    }
+    return activeResource;
+}
+function isFullJobTimeseriesContinuation(job) {
+    return (job.kind === "backfill" || job.kind === "reconcile")
+        && Object.prototype.hasOwnProperty.call(job.payload, "timeseriesResourceCursor");
+}
+function isJunctionTimeseriesWindowTooLarge(error) {
+    return isDeviceSyncError(error)
+        && error.code === "JUNCTION_API_WINDOW_TOO_LARGE";
+}
+function resolveNextFullJobTimeseriesContinuation(input) {
+    if (Date.parse(input.executionWindowEnd) < Date.parse(input.windowEnd)) {
+        return {
+            timeseriesCursor: input.executionWindowEnd,
+            timeseriesResourceCursor: input.resource,
+            timeseriesWindowHours: input.timeseriesWindowHours,
+            workoutStreamCursor: null,
+        };
+    }
+    const nextResource = input.resources[input.resources.indexOf(input.resource) + 1] ?? null;
+    return nextResource
+        ? {
+            timeseriesCursor: input.baseTimeseriesWindowStart,
+            timeseriesResourceCursor: nextResource,
+            timeseriesWindowHours: 24,
+            workoutStreamCursor: null,
+        }
+        : null;
+}
+function readDeferredEmptyBackfillAttempts(followUp) {
+    for (const job of followUp.scheduledJobs ?? []) {
+        const attempts = job.payload?.emptyBackfillAttempts;
+        if (typeof attempts === "number" && Number.isSafeInteger(attempts) && attempts > 0) {
+            return attempts;
+        }
+    }
+    return 0;
+}
 function readBackfillTimeseriesCursor(job, ownerWindow) {
     const cursor = toIsoTimestampIfValid(job.payload.timeseriesCursor);
     return cursor && isTimestampInHalfOpenWindow(cursor, ownerWindow)
@@ -3059,6 +5382,19 @@ function shouldImportClosedTimeseriesForReconcile(lastSyncCompletedAt, windowEnd
         || !Number.isFinite(windowEndMs)
         || lastCompletedClosedDayMs < windowEndMs;
 }
+function resolveLatestGloballyClosedProviderDayWindow(windowStart, windowEnd, asOf) {
+    const flooredWindowStartMs = Date.parse(floorUtcDayTimestamp(windowStart));
+    const globallyClosedEndMs = resolveGloballyClosedProviderDayEnd(windowEnd, asOf);
+    if (!Number.isFinite(flooredWindowStartMs)
+        || !Number.isFinite(globallyClosedEndMs)
+        || flooredWindowStartMs >= globallyClosedEndMs) {
+        return null;
+    }
+    return {
+        windowStart: new Date(globallyClosedEndMs - TIMESERIES_CHUNK_MS).toISOString(),
+        windowEnd: new Date(globallyClosedEndMs).toISOString(),
+    };
+}
 function buildClosedDailyWindows(windowStart, windowEnd) {
     const startMs = Date.parse(windowStart);
     const endMs = Date.parse(windowEnd);
@@ -3086,7 +5422,16 @@ function buildClosedDailyWindows(windowStart, windowEnd) {
     }
     return windows;
 }
-function buildPreciseTimeseriesWindows(windowStart, windowEnd) {
+function resolveGloballyClosedProviderDayEnd(windowEnd, asOf) {
+    const requestedClosedEndMs = Date.parse(floorUtcDayTimestamp(windowEnd));
+    const asOfMs = Date.parse(asOf);
+    if (!Number.isFinite(requestedClosedEndMs) || !Number.isFinite(asOfMs)) {
+        return Number.NaN;
+    }
+    const globallyClosedEndMs = Date.parse(floorUtcDayTimestamp(new Date(asOfMs - JUNCTION_PROVIDER_CALENDAR_DAY_CLOSE_LAG_MS).toISOString()));
+    return Math.min(requestedClosedEndMs, globallyClosedEndMs);
+}
+function buildPreciseTimeseriesWindows(windowStart, windowEnd, chunkMs = TIMESERIES_CHUNK_MS) {
     const startMs = Date.parse(windowStart);
     const endMs = Date.parse(windowEnd);
     if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || startMs >= endMs) {
@@ -3095,7 +5440,7 @@ function buildPreciseTimeseriesWindows(windowStart, windowEnd) {
     const windows = [];
     let chunkStartMs = startMs;
     while (chunkStartMs < endMs) {
-        const chunkEndMs = Math.min(chunkStartMs + TIMESERIES_CHUNK_MS, endMs);
+        const chunkEndMs = Math.min(chunkStartMs + chunkMs, endMs);
         if (chunkEndMs <= chunkStartMs) {
             break;
         }
@@ -3107,6 +5452,16 @@ function buildPreciseTimeseriesWindows(windowStart, windowEnd) {
     }
     return windows;
 }
+function resolveJunctionTimeseriesFetchChunkMs(resource) {
+    const fetchChunkDays = resolveJunctionTimeseriesResourcePolicy(resource)?.fetchChunkDays ?? 1;
+    return Math.max(1, fetchChunkDays) * TIMESERIES_CHUNK_MS;
+}
+function resolveJunctionTimeseriesImportChunkMs(resources) {
+    if (resources.length === 0) {
+        return TIMESERIES_CHUNK_MS;
+    }
+    return resources.reduce((smallest, resource) => Math.min(smallest, resolveJunctionTimeseriesFetchChunkMs(resource)), Number.POSITIVE_INFINITY);
+}
 function floorUtcDayTimestamp(timestamp) {
     const parsed = Date.parse(timestamp);
     if (!Number.isFinite(parsed)) {
@@ -3118,9 +5473,39 @@ function floorUtcDayTimestamp(timestamp) {
 function hasJunctionSnapshotRecords(snapshot) {
     return Object.values(snapshot).some((records) => records.length > 0);
 }
+function countJunctionSnapshotRecords(snapshot) {
+    return Object.values(snapshot).reduce((recordCount, records) => recordCount + records.length, 0);
+}
 function hasJunctionHistoricalBackfillSummaryRecords(evidence) {
     return evidence.some(({ resource }) => isJunctionHistoricalBackfillCompletionSummaryResource(resource));
 }
+function resolveJunctionHistoricalPullReadiness(input) {
+    const sourceProviderSlug = canonicalizeJunctionHistoricalProviderSlug(input.sourceProviderSlug)
+        ?? normalizeProviderSlug(input.sourceProviderSlug);
+    if (!sourceProviderSlug || !input.snapshot?.matchedUser) {
+        return "unavailable";
+    }
+    const source = input.snapshot.sources.find((entry) => (canonicalizeJunctionHistoricalProviderSlug(entry.sourceProviderSlug)
+        ?? normalizeProviderSlug(entry.sourceProviderSlug)) === sourceProviderSlug);
+    if (!source) {
+        return "unavailable";
+    }
+    const pulled = source.pulledResources.find((entry) => normalizeJunctionResourceName(entry.resource) === input.resource);
+    if (pulled) {
+        if (pulled.status === "success") {
+            return "ready";
+        }
+        if (pulled.status === "failure") {
+            return "terminal_failure";
+        }
+        return ["in_progress", "retrying", "scheduled"].includes(pulled.status)
+            ? "pending"
+            : "unavailable";
+    }
+    return source.notPulledResources.some((resource) => normalizeJunctionResourceName(resource) === input.resource)
+        ? "no_obligation"
+        : "unavailable";
+}
 function evaluateJunctionHistoricalBackfillCoverage(summaryEvidence, sourceProviders, configuredSummaryResources, providerFilter, historicalPullSnapshot, historicalPushEvidence, window) {
     const configuredResources = new Set(configuredSummaryResources.filter((resource) => JUNCTION_HISTORICAL_BACKFILL_REQUIRED_SUMMARY_RESOURCE_SET.has(resource)));
     const advertisedResourcesByProvider = new Map();
@@ -3273,6 +5658,22 @@ function isJunctionResourceAdvertisedAvailable(value) {
     return record.available === true
         || normalizeString(record.status)?.toLowerCase() === "available";
 }
+function isJunctionResourceAvailableInSummary(availabilitySummary, resource) {
+    const normalizedResource = normalizeJunctionResourceName(resource);
+    if (!normalizedResource || !availabilitySummary) {
+        return false;
+    }
+    return Object.entries(availabilitySummary).some(([candidate, availability]) => normalizeJunctionResourceName(candidate) === normalizedResource
+        && isJunctionResourceAdvertisedAvailable(availability));
+}
+function isJunctionSourceResourceCurrentlyAvailable(input) {
+    if (!input.sourceProviderSlug) {
+        return false;
+    }
+    return projectJunctionSourcesByProviderSlug(input.connectionId, input.providers).some((source) => source.sourceProviderSlug === input.sourceProviderSlug
+        && source.status === "connected"
+        && isJunctionResourceAvailableInSummary(source.resourceAvailabilitySummary, input.resource));
+}
 function isJunctionHistoricalBackfillCompletionSummaryResource(resource) {
     return JUNCTION_HISTORICAL_BACKFILL_COMPLETION_SUMMARY_RESOURCE_SET.has(resource);
 }
@@ -3416,6 +5817,155 @@ function readHistoricalBackfillJobEmptyAttempts(job) {
     const rawAttempts = job.payload.emptyBackfillAttempts;
     return typeof rawAttempts === "number" && Number.isInteger(rawAttempts) && rawAttempts > 0 ? rawAttempts : 0;
 }
+function readJunctionWorkoutStreamCompletedIdentities(job) {
+    const encoded = job.payload.workoutStreamCursor;
+    if (encoded === undefined) {
+        return new Set();
+    }
+    const maxWorkouts = resolveJunctionTimeseriesResourcePolicy("workout_stream")
+        ?.maxRecordsPerWindow;
+    if (!maxWorkouts || typeof encoded !== "string" || encoded.length === 0) {
+        throw invalidJunctionWorkoutStreamProgress();
+    }
+    let parsedValue;
+    try {
+        parsedValue = JSON.parse(encoded);
+    }
+    catch {
+        throw invalidJunctionWorkoutStreamProgress();
+    }
+    const parsed = readPlainObject(parsedValue);
+    const identities = parsed?.i;
+    if (!parsed
+        || parsed.v !== JUNCTION_WORKOUT_STREAM_PROGRESS_VERSION
+        || Object.keys(parsed).some((key) => key !== "i" && key !== "v")
+        || !Array.isArray(identities)
+        || identities.length === 0
+        || identities.length > maxWorkouts
+        || !identities.every(isCanonicalJunctionWorkoutStreamCandidateIdentity)) {
+        throw invalidJunctionWorkoutStreamProgress();
+    }
+    const sortedIdentities = [...identities].sort();
+    if (new Set(sortedIdentities).size !== sortedIdentities.length
+        || JSON.stringify({ v: JUNCTION_WORKOUT_STREAM_PROGRESS_VERSION, i: sortedIdentities })
+            !== encoded) {
+        throw invalidJunctionWorkoutStreamProgress();
+    }
+    return new Set(sortedIdentities);
+}
+function encodeJunctionWorkoutStreamCompletedIdentities(identities) {
+    if (identities.size === 0) {
+        return null;
+    }
+    const maxWorkouts = resolveJunctionTimeseriesResourcePolicy("workout_stream")
+        ?.maxRecordsPerWindow;
+    const sortedIdentities = [...identities].sort();
+    if (!maxWorkouts
+        || sortedIdentities.length > maxWorkouts
+        || !sortedIdentities.every(isCanonicalJunctionWorkoutStreamCandidateIdentity)) {
+        throw new TypeError("Junction workout stream progress exceeded its identity contract.");
+    }
+    return JSON.stringify({
+        v: JUNCTION_WORKOUT_STREAM_PROGRESS_VERSION,
+        i: sortedIdentities,
+    });
+}
+function isCanonicalJunctionWorkoutStreamCandidateIdentity(value) {
+    if (typeof value !== "string" || value.length === 0) {
+        return false;
+    }
+    let identity;
+    try {
+        identity = JSON.parse(value);
+    }
+    catch {
+        return false;
+    }
+    if (!Array.isArray(identity) || identity.length !== 4) {
+        return false;
+    }
+    const [sourceProviderSlug, sourceType, sourceInstanceId, stableId] = identity;
+    return isNonEmptyCanonicalIdentityPart(sourceProviderSlug)
+        && (sourceType === null || isNonEmptyCanonicalIdentityPart(sourceType))
+        && (sourceInstanceId === null || isNonEmptyCanonicalIdentityPart(sourceInstanceId))
+        && isNonEmptyCanonicalIdentityPart(stableId)
+        && JSON.stringify(identity) === value;
+}
+function isNonEmptyCanonicalIdentityPart(value) {
+    return typeof value === "string" && value.length > 0 && value.trim() === value;
+}
+function invalidJunctionTimeseriesResourceProgress() {
+    return deviceSyncError({
+        code: "DEVICE_SYNC_JOB_PAYLOAD_INVALID",
+        message: "Junction timeseries resource continuation metadata was invalid.",
+        retryable: false,
+    });
+}
+function invalidJunctionWorkoutStreamProgress() {
+    return deviceSyncError({
+        code: "DEVICE_SYNC_JOB_PAYLOAD_INVALID",
+        message: "Junction workout stream continuation metadata was invalid.",
+        retryable: false,
+    });
+}
+function readJunctionHistoricalUnresolvedProviderRecords(job) {
+    const encoded = job.payload.historicalUnresolvedProviderRecordIdentitiesJson;
+    if (typeof encoded === "string") {
+        try {
+            const parsed = readPlainObject(JSON.parse(encoded));
+            const rawIdentities = parsed?.i;
+            const version = parsed?.v;
+            if (version !== JUNCTION_HISTORICAL_UNRESOLVED_PROVIDER_RECORD_IDENTITIES_VERSION
+                || !Array.isArray(rawIdentities)) {
+                return { identities: [], withoutStableIdentity: true };
+            }
+            const validIdentities = rawIdentities.filter((identity) => typeof identity === "string"
+                && JUNCTION_BLOOD_PRESSURE_PROVIDER_RECORD_IDENTITY_PATTERN.test(identity));
+            const identities = [...new Set(validIdentities)].sort();
+            return {
+                identities,
+                withoutStableIdentity: parsed?.u === true
+                    || validIdentities.length !== rawIdentities.length,
+            };
+        }
+        catch {
+            return { identities: [], withoutStableIdentity: true };
+        }
+    }
+    const legacyUnresolvedEvidence = job.payload.historicalProviderRecordsSeen === true
+        || (typeof job.payload.historicalUnresolvedProviderRecordCount === "number"
+            && Number.isSafeInteger(job.payload.historicalUnresolvedProviderRecordCount)
+            && job.payload.historicalUnresolvedProviderRecordCount > 0);
+    return {
+        identities: [],
+        withoutStableIdentity: legacyUnresolvedEvidence,
+    };
+}
+function resolveJunctionHistoricalUnresolvedProviderRecords(job, importResult) {
+    const carried = readJunctionHistoricalUnresolvedProviderRecords(job);
+    const identities = new Set(carried.identities);
+    for (const identity of importResult.canonicalProviderRecordIdentities) {
+        identities.delete(identity);
+    }
+    for (const identity of importResult.unresolvedProviderRecordIdentities) {
+        identities.add(identity);
+    }
+    return {
+        identities: [...identities].sort(),
+        withoutStableIdentity: carried.withoutStableIdentity
+            || importResult.unresolvedProviderRecordsWithoutStableIdentity,
+    };
+}
+function countJunctionHistoricalUnresolvedProviderRecords(unresolved) {
+    return unresolved.identities.length + (unresolved.withoutStableIdentity ? 1 : 0);
+}
+function encodeJunctionHistoricalUnresolvedProviderRecords(unresolved) {
+    return JSON.stringify({
+        v: JUNCTION_HISTORICAL_UNRESOLVED_PROVIDER_RECORD_IDENTITIES_VERSION,
+        i: unresolved.identities,
+        ...(unresolved.withoutStableIdentity ? { u: true } : {}),
+    });
+}
 function buildConnectHistoricalBackfillWindow(account, summaryBackfillDays) {
     return {
         windowStart: floorUtcDayTimestamp(subtractDays(account.connectedAt, summaryBackfillDays)),
@@ -3427,6 +5977,7 @@ function buildWindowJob(input) {
     const windowStart = floorUtcDayTimestamp(input.windowStart);
     return buildExactWindowJob({
         kind: input.kind,
+        payload: input.payload,
         windowStart,
         windowEnd,
         availableAt: input.now,
@@ -3434,6 +5985,15 @@ function buildWindowJob(input) {
     });
 }
 function buildExactWindowJob(input) {
+    const windowPayload = input.payload;
+    const sourceProviderSlug = normalizeString(windowPayload?.sourceProviderSlug);
+    const dedupeIdentity = [
+        "junction",
+        input.kind,
+        input.windowStart,
+        input.windowEnd,
+        ...(sourceProviderSlug ? [sourceProviderSlug] : []),
+    ];
     return {
         kind: input.kind,
         payload: {
@@ -3443,9 +6003,261 @@ function buildExactWindowJob(input) {
         },
         priority: input.priority,
         ...(input.availableAt ? { availableAt: input.availableAt } : {}),
-        dedupeKey: sha256Text(JSON.stringify(["junction", input.kind, input.windowStart, input.windowEnd])),
+        dedupeKey: sha256Text(JSON.stringify(dedupeIdentity)),
+    };
+}
+function buildJunctionSparseCalendarRefreshJobs(input) {
+    const targets = [...new Map(input.targets.map((target) => [
+            JSON.stringify([
+                target.dayKey,
+                target.sourceProviderSlug,
+                target.sourceType ?? null,
+                target.sourceInstanceId ?? null,
+            ]),
+            target,
+        ])).values()];
+    const dayKeys = [...new Set(targets.map((target) => target.dayKey))].sort();
+    if (dayKeys.length > JUNCTION_MAX_SPARSE_CALENDAR_REFRESH_DAYS
+        || targets.length > JUNCTION_MAX_SPARSE_CALENDAR_REFRESH_DAYS) {
+        throw deviceSyncError({
+            code: "JUNCTION_CALENDAR_REFRESH_DAY_LIMIT_EXCEEDED",
+            message: "Junction sparse import exceeded the calendar refresh day limit.",
+            retryable: false,
+            details: {
+                affectedDayCount: dayKeys.length,
+                affectedTargetCount: targets.length,
+                maxAllowed: JUNCTION_MAX_SPARSE_CALENDAR_REFRESH_DAYS,
+            },
+        });
+    }
+    return targets
+        .filter((target) => isGloballyClosedJunctionProviderDay(target.dayKey, input.asOf))
+        .map((target) => buildJunctionSparseCalendarRefreshJob({
+        dayKey: target.dayKey,
+        priority: input.priority,
+        resource: input.resource,
+        sourceInstanceId: target.sourceInstanceId,
+        sourceProviderSlug: target.sourceProviderSlug,
+        sourceType: target.sourceType,
+    }));
+}
+function buildJunctionSparseCalendarRefreshJob(input) {
+    const windowStart = `${input.dayKey}T00:00:00.000Z`;
+    const windowEnd = addMilliseconds(windowStart, TIMESERIES_CHUNK_MS);
+    const sourceProviderSlug = normalizeProviderSlug(input.sourceProviderSlug);
+    const sourceInstanceId = normalizeString(input.sourceInstanceId);
+    const sourceType = normalizeString(input.sourceType);
+    return {
+        kind: "resource",
+        payload: {
+            calendarRefreshDay: input.dayKey,
+            resource: input.resource,
+            resourceCategory: "timeseries",
+            ...(sourceInstanceId ? { sourceInstanceId } : {}),
+            ...(sourceProviderSlug ? { sourceProviderSlug } : {}),
+            ...(sourceType ? { sourceType } : {}),
+            windowEnd,
+            windowStart,
+        },
+        priority: input.priority,
+        dedupeKey: sha256Text(JSON.stringify([
+            "junction",
+            "sparse-calendar-refresh",
+            sourceProviderSlug,
+            sourceType,
+            sourceInstanceId,
+            input.resource,
+            input.dayKey,
+        ])),
+    };
+}
+function readJunctionSparseCalendarRefreshDay(job) {
+    if (!("calendarRefreshDay" in job.payload)) {
+        return null;
+    }
+    const dayKey = job.payload.calendarRefreshDay;
+    if (!isCanonicalEventDayKey(dayKey)) {
+        throw deviceSyncError({
+            code: JUNCTION_CALENDAR_REFRESH_JOB_INVALID_CODE,
+            message: "Junction calendar refresh job had an invalid provider day.",
+            retryable: false,
+        });
+    }
+    return dayKey;
+}
+function readJunctionSparseCalendarSourceIdentity(job) {
+    const sourceProviderSlug = normalizeProviderSlug(job.payload.sourceProviderSlug);
+    if (!sourceProviderSlug) {
+        throw deviceSyncError({
+            code: JUNCTION_CALENDAR_REFRESH_JOB_INVALID_CODE,
+            message: "Junction calendar refresh job lacked its source provider identity.",
+            retryable: false,
+        });
+    }
+    const sourceInstanceId = normalizeString(job.payload.sourceInstanceId);
+    const sourceType = normalizeString(job.payload.sourceType);
+    return {
+        ...(sourceInstanceId ? { sourceInstanceId } : {}),
+        sourceProviderSlug,
+        ...(sourceType ? { sourceType } : {}),
+    };
+}
+function filterJunctionSparseCalendarRecordsToSource(records, source) {
+    const sourceProviderSlug = normalizeProviderSlug(source.sourceProviderSlug);
+    const sourceInstanceId = normalizeString(source.sourceInstanceId);
+    const sourceType = normalizeString(source.sourceType);
+    return records.flatMap((record) => {
+        const entry = readPlainObject(record);
+        if (!entry) {
+            throw incompleteJunctionSparseCalendarCollectionError();
+        }
+        const origin = resolveJunctionOrigin(entry);
+        const recordSourceProviderSlug = normalizeProviderSlug(origin.sourceProviderSlug);
+        if (!recordSourceProviderSlug) {
+            throw incompleteJunctionSparseCalendarCollectionError();
+        }
+        if (!areJunctionProviderSlugsRouteEquivalent(recordSourceProviderSlug, sourceProviderSlug)) {
+            return [];
+        }
+        const recordSourceType = normalizeString(origin.sourceType);
+        if (sourceType && !recordSourceType) {
+            throw incompleteJunctionSparseCalendarCollectionError();
+        }
+        if (sourceType && recordSourceType !== sourceType) {
+            return [];
+        }
+        const recordSourceInstanceId = normalizeString(origin.sourceInstanceId);
+        if (sourceInstanceId && !recordSourceInstanceId) {
+            throw incompleteJunctionSparseCalendarCollectionError();
+        }
+        if (sourceInstanceId && recordSourceInstanceId !== sourceInstanceId) {
+            return [];
+        }
+        return [{
+                ...entry,
+                sourceProviderSlug,
+                ...(sourceType ? { sourceType } : {}),
+                ...(sourceInstanceId ? { sourceInstanceId } : {}),
+            }];
+    });
+}
+function incompleteJunctionSparseCalendarCollectionError() {
+    return deviceSyncError({
+        code: "JUNCTION_CALENDAR_REFRESH_INCOMPLETE_NORMALIZATION",
+        message: "Junction calendar refresh response was not structurally complete.",
+        retryable: true,
+        httpStatus: 502,
+    });
+}
+function buildJunctionEmptySparseCalendarAggregate(input) {
+    return stripUndefined({
+        authoritativeEmptyCalendarSet: true,
+        calendarDate: input.dayKey,
+        date: input.dayKey,
+        sourceInstanceId: input.sourceInstanceId,
+        sourceProviderSlug: input.sourceProviderSlug,
+        sourceType: input.sourceType,
+        value: 0,
+    });
+}
+function isGloballyClosedJunctionProviderDay(dayKey, asOf) {
+    if (!isCanonicalEventDayKey(dayKey)) {
+        return false;
+    }
+    const windowEnd = addMilliseconds(`${dayKey}T00:00:00.000Z`, TIMESERIES_CHUNK_MS);
+    return Date.parse(windowEnd) <= resolveGloballyClosedProviderDayEnd(windowEnd, asOf);
+}
+function buildJunctionExtendedTimeseriesBackfillDedupeKey(payload) {
+    if (payload.historicalBackfill !== true) {
+        return null;
+    }
+    const historicalWindowStart = toIsoTimestampIfValid(normalizeString(payload.historicalWindowStart));
+    const resource = normalizeJunctionResourceName(payload.resource);
+    const windowEnd = toIsoTimestampIfValid(normalizeString(payload.windowEnd));
+    const policy = resource
+        ? resolveJunctionExtendedTimeseriesBackfillPolicy(resource)
+        : null;
+    if (!historicalWindowStart
+        || !resource
+        || !windowEnd
+        || !policy) {
+        return null;
+    }
+    if (!["blood_pressure", "weight"].includes(resource)) {
+        const coverageVersion = resource === "note"
+            ? readJunctionNoteHistoryBackfillVersion(payload)
+            : policy.version;
+        return sha256Text(JSON.stringify([
+            "junction",
+            "extended-timeseries-backfill",
+            normalizeProviderSlug(payload.sourceProviderSlug),
+            resource,
+            coverageVersion,
+        ]));
+    }
+    return sha256Text(JSON.stringify([
+        "junction",
+        "extended-timeseries-backfill",
+        normalizeProviderSlug(payload.sourceProviderSlug),
+        resource,
+        historicalWindowStart,
+        windowEnd,
+    ]));
+}
+function buildExtendedTimeseriesBackfillJob(input) {
+    const payload = {
+        ...(input.emptyBackfillAttempts && input.emptyBackfillAttempts > 0
+            ? { emptyBackfillAttempts: input.emptyBackfillAttempts }
+            : {}),
+        historicalBackfill: true,
+        ...(input.historicalBackfillVersion === undefined
+            ? {}
+            : { historicalBackfillVersion: input.historicalBackfillVersion }),
+        ...(input.historicalProviderRecordsSeen
+            ? { historicalProviderRecordsSeen: true }
+            : {}),
+        ...(input.historicalRecordsSeen
+            ? { historicalRecordsSeen: true }
+            : {}),
+        ...(input.historicalUnresolvedProviderRecordIdentitiesJson
+            ? {
+                historicalUnresolvedProviderRecordIdentitiesJson: input.historicalUnresolvedProviderRecordIdentitiesJson,
+            }
+            : {}),
+        ...(input.historicalUnresolvedProviderRecordCount
+            && input.historicalUnresolvedProviderRecordCount > 0
+            ? {
+                historicalUnresolvedProviderRecordCount: input.historicalUnresolvedProviderRecordCount,
+            }
+            : {}),
+        historicalWindowStart: input.historicalWindowStart,
+        resource: input.resource,
+        resourceCategory: "timeseries",
+        ...(input.sourceProviderSlug
+            ? { sourceProviderSlug: input.sourceProviderSlug }
+            : {}),
+        windowEnd: input.windowEnd,
+        windowStart: input.windowStart,
+    };
+    const dedupeKey = input.dedupeKey
+        ?? buildJunctionExtendedTimeseriesBackfillDedupeKey(payload);
+    if (!dedupeKey) {
+        throw new TypeError("Junction extended timeseries backfill identity was invalid.");
+    }
+    return {
+        kind: "resource",
+        payload,
+        availableAt: input.availableAt,
+        priority: JUNCTION_HISTORICAL_BACKFILL_PRIORITY,
+        dedupeKey,
     };
 }
+function readJunctionNoteHistoryBackfillVersion(payload) {
+    const version = payload.historicalBackfillVersion;
+    return typeof version === "number" && Number.isSafeInteger(version) && version >= 1
+        ? version
+        : 1;
+}
 function buildJunctionWebhookJobs(input) {
     if (isJunctionProviderConnectionEvent(input.eventType)) {
         const backfillWindowStart = subtractDays(input.window.windowEnd, input.summaryBackfillDays);
@@ -3538,8 +6350,7 @@ function isJunctionHistoricalDataEvent(eventType) {
     return eventType.startsWith("historical.data.");
 }
 function isJunctionHistoricalPullCompletedWebhookData(data, externalAccountId) {
-    const completed = parseJunctionHistoricalPullCompletedWebhookData(data, externalAccountId);
-    if (completed && normalizeJunctionWebhookSourceProviderCandidate(completed.provider)) {
+    if (isJunctionSdkHistoricalPullCompletedWebhookData(data, externalAccountId)) {
         return true;
     }
     if (hasJunctionHistoricalInlineRecordCarrierFields(data)) {
@@ -3547,14 +6358,19 @@ function isJunctionHistoricalPullCompletedWebhookData(data, externalAccountId) {
     }
     return isDocumentedJunctionHistoricalPullCompletedWebhookData(data, externalAccountId);
 }
-function parseJunctionHistoricalPullCompletedWebhookData(data, externalAccountId) {
-    const parsed = JunctionHistoricalPullCompletedSchema.parse({
-        ...data,
-        [JUNCTION_WEBHOOK_ROOT_FIELDS.userId]: normalizeString(data[JUNCTION_WEBHOOK_ROOT_FIELDS.userId]) ?? externalAccountId,
-    }, {
-        unrecognizedObjectKeys: "passthrough",
-    });
-    return parsed.ok ? parsed.value : null;
+function isJunctionSdkHistoricalPullCompletedWebhookData(data, externalAccountId) {
+    const userId = normalizeString(data[JUNCTION_WEBHOOK_ROOT_FIELDS.userId])
+        ?? externalAccountId;
+    const startDate = data.start_date;
+    const endDate = data.end_date;
+    return typeof userId === "string"
+        && typeof startDate === "string"
+        && JUNCTION_SDK_ISO_8601_DATE_PATTERN.test(startDate)
+        && typeof endDate === "string"
+        && JUNCTION_SDK_ISO_8601_DATE_PATTERN.test(endDate)
+        && data.is_final === true
+        && typeof data.provider === "string"
+        && normalizeJunctionWebhookSourceProviderCandidate(data.provider) !== null;
 }
 const JUNCTION_HISTORICAL_INLINE_RECORD_CARRIER_FIELDS = new Set([
     "activities",
@@ -3975,6 +6791,7 @@ function verifyAndParseJunctionWebhookEnvelope(input) {
     return {
         messageId,
         payload,
+        providerSentAt: new Date(timestampMs).toISOString(),
     };
 }
 function requireJunctionWebhookHeader(headers, name) {
@@ -4248,12 +7065,30 @@ async function projectJunctionSources(context, providers, options = {}) {
     const preserveHistoricalReconnectProviderSlugs = options.preserveHistoricalReconnectProviderSlugs === undefined
         ? null
         : new Set(options.preserveHistoricalReconnectProviderSlugs);
+    const projectedSources = projectJunctionSourcesByProviderSlug(context.account.id, providers);
+    if (projectedSources.length > JUNCTION_MAX_USER_PROVIDERS) {
+        throw deviceSyncError({
+            code: "JUNCTION_USER_PROVIDER_LIMIT",
+            message: "Junction projected sources exceeded the supported provider bound.",
+            retryable: true,
+            httpStatus: 502,
+        });
+    }
     const existingSources = context.listConnectionSources
-        ? await context.listConnectionSources()
+        ? [...await context.listConnectionSources()]
         : [];
-    const existingByInstanceKey = new Map(existingSources.map((source) => [source.sourceInstanceKey, source]));
-    for (const source of projectJunctionSourcesByProviderSlug(context.account.id, providers)) {
-        const existing = existingByInstanceKey.get(source.sourceInstanceKey) ?? existingSources.find((candidate) => normalizeProviderSlug(candidate.sourceProviderSlug) === source.sourceProviderSlug);
+    const admissionSources = context.listConnectionSources
+        ? existingSources
+        : context.account.sources ?? [];
+    for (const source of projectedSources) {
+        const listedOnly = context.connectionSourceAdmissionMode === "listed_only";
+        if ((listedOnly
+            && !hasJunctionSourceListing(admissionSources, source.sourceProviderSlug))
+            || isJunctionSourceProjectionFenced(admissionSources, source.sourceProviderSlug)) {
+            continue;
+        }
+        const accountSourceIdentity = resolveJunctionAccountSourceIdentity(existingSources, source.sourceProviderSlug, true);
+        const existing = findJunctionAccountSource(existingSources, source.sourceProviderSlug);
         const keepHistoricalReconnect = preserveHistoricalReconnect
             && (preserveHistoricalReconnectProviderSlugs === null
                 || preserveHistoricalReconnectProviderSlugs.has(source.sourceProviderSlug))
@@ -4264,11 +7099,14 @@ async function projectJunctionSources(context, providers, options = {}) {
                     && existing.lastErrorCode === DEVICE_SYNC_HISTORICAL_DATA_RECONNECT_REQUIRED_ERROR_CODE
                 : requiresHistoricalResetDeviceSyncSource(existing));
         const historicalReconnectError = keepHistoricalReconnect ? existing : null;
-        await context.upsertConnectionSource({
-            sourceInstanceKey: existing?.sourceInstanceKey ?? source.sourceInstanceKey,
-            sourceProviderSlug: source.sourceProviderSlug,
+        const persistedSource = await context.upsertConnectionSource({
+            sourceInstanceKey: accountSourceIdentity?.sourceInstanceKey ?? source.sourceInstanceKey,
+            sourceProviderSlug: accountSourceIdentity?.sourceProviderSlug ?? source.sourceProviderSlug,
             displayName: existing?.displayName ?? null,
-            status: keepHistoricalReconnect ? "error" : source.status,
+            ...(existing?.firstSeenAt ? { firstSeenAt: existing.firstSeenAt } : {}),
+            status: keepHistoricalReconnect
+                ? "error"
+                : source.status,
             resourceAvailabilitySummary: source.resourceAvailabilitySummary,
             // Only assert error fields when this projection saw an errored entry;
             // omitting the keys lets the store preserve existing detail while the
@@ -4283,7 +7121,118 @@ async function projectJunctionSources(context, providers, options = {}) {
                     : {}),
             lastSeenAt: context.now,
         });
+        const persistedIndex = existingSources.findIndex((candidate) => candidate.sourceInstanceKey === persistedSource.sourceInstanceKey);
+        if (persistedIndex >= 0) {
+            existingSources[persistedIndex] = persistedSource;
+        }
+        else {
+            existingSources.push(persistedSource);
+        }
+    }
+}
+function isJunctionSourceAdmittedForImport(sources, sourceProviderSlug, allowUnlistedSources = true, sourceStatusRequirement = "not_disconnected") {
+    const normalizedSourceProviderSlug = normalizeProviderSlug(sourceProviderSlug);
+    if (!normalizedSourceProviderSlug) {
+        return true;
+    }
+    const accountSourceIdentity = resolveJunctionAccountSourceIdentity(sources, normalizedSourceProviderSlug, allowUnlistedSources);
+    if (!accountSourceIdentity) {
+        return false;
+    }
+    const sourceState = resolveJunctionAccountSourceState(sources, accountSourceIdentity.sourceProviderSlug);
+    if (!sourceState) {
+        return allowUnlistedSources;
+    }
+    const lifecycleSource = sourceState.lifecycleSource;
+    return sourceStatusRequirement === "connected"
+        ? isDeviceSyncSourceAdmitted([lifecycleSource], lifecycleSource.sourceProviderSlug)
+        : lifecycleSource.status !== "disconnected"
+            && !isDeviceSyncSourceDisconnectFenced(lifecycleSource);
+}
+function isJunctionSourceProjectionFenced(sources, sourceProviderSlug) {
+    const normalizedSourceProviderSlug = normalizeProviderSlug(sourceProviderSlug);
+    if (!normalizedSourceProviderSlug) {
+        return false;
+    }
+    const accountSourceIdentity = resolveJunctionAccountSourceIdentity(sources, normalizedSourceProviderSlug);
+    if (!accountSourceIdentity) {
+        return false;
+    }
+    const sourceState = resolveJunctionAccountSourceState(sources, accountSourceIdentity.sourceProviderSlug);
+    return sourceState !== null
+        && isDeviceSyncSourceDisconnectFenced(sourceState.lifecycleSource);
+}
+function hasJunctionSourceListing(sources, sourceProviderSlug) {
+    const normalizedSourceProviderSlug = normalizeProviderSlug(sourceProviderSlug);
+    if (!normalizedSourceProviderSlug) {
+        return true;
+    }
+    return sources.some((source) => areJunctionProviderSlugsRouteEquivalent(source.sourceProviderSlug, normalizedSourceProviderSlug));
+}
+async function resolveJunctionCurrentSourceAdmission(context, sourceProviderSlug) {
+    const sources = context.listConnectionSources
+        ? await context.listConnectionSources()
+        : context.account.sources ?? [];
+    return resolveJunctionCurrentSourceAdmissionFromSources(sources, sourceProviderSlug, context.connectionSourceAdmissionMode !== "listed_only");
+}
+function resolveJunctionCurrentSourceAdmissionFromSources(sources, sourceProviderSlug, allowUnlistedSources) {
+    if (isJunctionSourceProjectionFenced(sources, sourceProviderSlug)) {
+        return "fenced";
+    }
+    return isJunctionSourceAdmittedForImport(sources, sourceProviderSlug, allowUnlistedSources, "connected")
+        ? "admitted"
+        : "pending";
+}
+async function isJunctionCompanionSourceCurrentlyAdmitted(context, sourceProviderSlug) {
+    const normalizedSourceProviderSlug = normalizeProviderSlug(sourceProviderSlug);
+    if (!context.listConnectionSources) {
+        throw junctionCompanionSourceStateUnavailableError();
+    }
+    if (!normalizedSourceProviderSlug) {
+        throw junctionCompanionSourceStateUnavailableError();
+    }
+    let sources;
+    try {
+        sources = await context.listConnectionSources({
+            sourceProviderSlug: normalizedSourceProviderSlug,
+        });
+    }
+    catch (error) {
+        if (isDeviceSyncError(error) && error.retryable) {
+            throw error;
+        }
+        throw junctionCompanionSourceStateUnavailableError(error);
+    }
+    if (isDeviceSyncSourceAdmitted(sources, normalizedSourceProviderSlug)) {
+        return true;
+    }
+    if (sources.some((source) => source.lastErrorCode === DEVICE_SYNC_SOURCE_USER_DISCONNECTED_ERROR_CODE)) {
+        return false;
     }
+    throw deviceSyncError({
+        code: "JUNCTION_COMPANION_SOURCE_NOT_READY",
+        message: "Current companion source authorization is not ready. Retry shortly.",
+        retryable: true,
+        httpStatus: 503,
+    });
+}
+function junctionSourceStateUnavailableError(cause) {
+    return deviceSyncError({
+        code: "JUNCTION_SOURCE_STATE_UNAVAILABLE",
+        message: "Current Junction source state is unavailable. Retry shortly.",
+        retryable: true,
+        httpStatus: 503,
+        ...(cause === undefined ? {} : { cause }),
+    });
+}
+function junctionCompanionSourceStateUnavailableError(cause) {
+    return deviceSyncError({
+        code: "JUNCTION_COMPANION_SOURCE_STATE_UNAVAILABLE",
+        message: "Current companion source authorization is unavailable. Retry shortly.",
+        retryable: true,
+        httpStatus: 503,
+        ...(cause === undefined ? {} : { cause }),
+    });
 }
 function projectJunctionSourcesByProviderSlug(connectionId, providers) {
     const projected = new Map();
@@ -4489,6 +7438,102 @@ function readPlainObject(value) {
 function readProviderSnapshotDurableDeliveryAccepted(value) {
     return readPlainObject(value)?.durableDeliveryAccepted === true;
 }
+function readProviderSnapshotCanonicalEventCount(value) {
+    const canonicalEventCount = readPlainObject(value)?.canonicalEventCount;
+    return typeof canonicalEventCount === "number"
+        && Number.isSafeInteger(canonicalEventCount)
+        && canonicalEventCount >= 0
+        ? canonicalEventCount
+        : 0;
+}
+function readProviderSnapshotCanonicalEventDayKeys(value) {
+    const dayKeys = readPlainObject(value)?.canonicalEventDayKeys;
+    if (!Array.isArray(dayKeys)) {
+        return [];
+    }
+    return [...new Set(dayKeys.filter((dayKey) => isCanonicalEventDayKey(dayKey)))].sort();
+}
+function readProviderSnapshotCanonicalSparseCalendarTargets(value) {
+    const rawTargets = readPlainObject(value)?.canonicalSparseCalendarTargets;
+    if (!Array.isArray(rawTargets)) {
+        return [];
+    }
+    return rawTargets.flatMap((rawTarget) => {
+        const target = readPlainObject(rawTarget);
+        if (!target) {
+            return [];
+        }
+        const sourceProviderSlug = normalizeProviderSlug(target.sourceProviderSlug);
+        if (!isCanonicalEventDayKey(target.dayKey) || !sourceProviderSlug) {
+            return [];
+        }
+        const sourceType = normalizeString(target.sourceType);
+        return [{
+                dayKey: target.dayKey,
+                ...(typeof target.sourceInstanceId === "string" || target.sourceInstanceId === null
+                    ? { sourceInstanceId: target.sourceInstanceId }
+                    : {}),
+                sourceProviderSlug,
+                ...(sourceType ? { sourceType } : {}),
+            }];
+    });
+}
+function isCanonicalEventDayKey(value) {
+    if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}$/u.test(value)) {
+        return false;
+    }
+    const parsed = new Date(`${value}T00:00:00.000Z`);
+    return Number.isFinite(parsed.getTime()) && parsed.toISOString().slice(0, 10) === value;
+}
+function readProviderSnapshotCanonicalEventExternalRefResourceIds(value) {
+    const record = readPlainObject(value);
+    if (!record || !("canonicalEventExternalRefResourceIds" in record)) {
+        return null;
+    }
+    const resourceIds = record.canonicalEventExternalRefResourceIds;
+    return Array.isArray(resourceIds)
+        && resourceIds.every((resourceId) => typeof resourceId === "string")
+        ? resourceIds
+        : null;
+}
+function uniqueJunctionProviderRecordIdentities(identities) {
+    return [...new Set(identities.filter((identity) => identity !== null && JUNCTION_BLOOD_PRESSURE_PROVIDER_RECORD_IDENTITY_PATTERN.test(identity)))].sort();
+}
+function resolveJunctionBloodPressureProviderRecordResolutionEvidence(input) {
+    const rawIdentities = input.providerRecordIdentityEvidence.repairStableExternalRefResourceIds;
+    const stableIdentities = uniqueJunctionProviderRecordIdentities(rawIdentities);
+    const identityEvidenceIncomplete = input.providerRecordIdentityEvidence.providerRecordCount !== input.providerRecordCount
+        || rawIdentities.some((identity) => identity !== null
+            && !JUNCTION_BLOOD_PRESSURE_PROVIDER_RECORD_IDENTITY_PATTERN.test(identity));
+    // Older unit seams may only expose the aggregate count. They can prove an
+    // all-canonical current scan, but never clear an exact carried obligation.
+    if (input.canonicalEventExternalRefResourceIds === null) {
+        const allCurrentRecordsCanonical = !identityEvidenceIncomplete
+            && input.canonicalEventCount >= input.providerRecordCount;
+        return {
+            canonicalProviderRecordIdentities: [],
+            unresolvedProviderRecordIdentities: allCurrentRecordsCanonical
+                ? []
+                : stableIdentities,
+            unresolvedProviderRecordsWithoutStableIdentity: !allCurrentRecordsCanonical
+                && (identityEvidenceIncomplete
+                    || rawIdentities.some((identity) => identity === null)),
+        };
+    }
+    const canonicalResourceIds = new Set(input.canonicalEventExternalRefResourceIds.filter((resourceId) => JUNCTION_BLOOD_PRESSURE_PROVIDER_RECORD_IDENTITY_PATTERN.test(resourceId)));
+    const stableIdentitySet = new Set(stableIdentities);
+    const canonicalProviderRecordIdentities = stableIdentities.filter((identity) => canonicalResourceIds.has(identity));
+    const unresolvedProviderRecordIdentities = stableIdentities.filter((identity) => !canonicalResourceIds.has(identity));
+    const providerRecordsWithoutStableIdentity = rawIdentities.filter((identity) => identity === null).length;
+    const canonicalRecordsWithoutStableIdentity = input.canonicalEventExternalRefResourceIds.filter((resourceId) => !stableIdentitySet.has(resourceId)).length;
+    return {
+        canonicalProviderRecordIdentities,
+        unresolvedProviderRecordIdentities,
+        unresolvedProviderRecordsWithoutStableIdentity: identityEvidenceIncomplete
+            || input.canonicalEventExternalRefResourceIds.length !== input.canonicalEventCount
+            || canonicalRecordsWithoutStableIdentity < providerRecordsWithoutStableIdentity,
+    };
+}
 function base32UrlEncode(input) {
     const alphabet = "abcdefghijklmnopqrstuvwxyz234567";
     let bits = 0;