@murphai/murph 1.3.1 → 1.3.2

package/node_modules/@murphai/device-syncd/dist/service.js

@@ -1,5 +1,7 @@
 import { resolveJunctionTimeseriesResourcePolicy } from "@murphai/contracts";
-import { createImporters, JunctionSparseCalendarRepairNormalizationError, } from "@murphai/importers";
+import { createDeviceProviderSnapshotImportSession, createImporters, JunctionSparseCalendarRepairNormalizationError, normalizeKnownJunctionSourceProviderSlug, } from "@murphai/importers";
+import { JunctionWorkoutStreamTimestampCardinalityError } from "@murphai/importers/device-providers/junction";
+import { normalizeJunctionCanonicalCoverageBoundary } from "@murphai/importers/device-providers/junction-resources";
 import { normalizeConfiguredDeviceSyncJobInput, normalizeConfiguredDeviceSyncJobRecord, } from "./provider-job-definitions.js";
 import { buildDeviceSyncTokenCipherOptions, createSecretCodec } from "./local-secret-codec.js";
 import { deviceSyncError, isDeviceSyncError } from "./errors.js";
@@ -12,7 +14,7 @@ import { isDeviceSyncConnectionSetupPending, isDeviceSyncSourceDisconnectFenced,
 import { createDeviceSyncRegistry } from "./registry.js";
 import { addMilliseconds, computeRetryDelayMs, defaultStateDatabasePath, generatePrefixedId, normalizeString, normalizeOriginList, normalizePublicBaseUrl, sha256Text, stringifyJson, toIsoTimestamp, } from "./shared.js";
 import { SqliteDeviceSyncStore } from "./store.js";
-import { DEVICE_SYNC_WEBHOOK_TRACE_COMPLETED, } from "./types.js";
+import { DEVICE_SYNC_CANONICAL_IMPORT_RECEIPT_LIMIT, DEVICE_SYNC_WEBHOOK_TRACE_COMPLETED, } from "./types.js";
 export { SqliteDeviceSyncStore } from "./store.js";
 export function resolveDeviceSyncStoreNextJobWakeAt(input) {
     const store = new SqliteDeviceSyncStore(input.stateDatabasePath ?? defaultStateDatabasePath(input.vaultRoot));
@@ -38,12 +40,35 @@ const DEVICE_SYNC_JOB_YIELD_POLL_MS = 100;
 // Never retain fewer diagnostics than one hosted pass can produce, and never
 // regress below the established 100-attempt observability window.
 export const DEVICE_SYNC_JOB_FAILURE_DIAGNOSTIC_LIMIT = Math.max(100, HOSTED_EXECUTION_DEVICE_SYNC_PASS_JOB_LIMIT);
+export const DEVICE_SYNC_JOB_TIMING_DIAGNOSTIC_LIMIT = Math.max(100, HOSTED_EXECUTION_DEVICE_SYNC_PASS_JOB_LIMIT);
 const DEVICE_SYNC_CONNECTION_MUTATION_MAX_PENDING = 1;
 const DEVICE_SYNC_CONNECTION_MUTATION_WAIT_TIMEOUT_MS = 15_000;
 const DEFAULT_PROVIDER_JOB_BATCH_MAX_JOBS = 50;
 const DEFAULT_PROVIDER_JOB_BATCH_MAX_ESTIMATED_BYTES = 2 * 1024 * 1024;
 const DEFAULT_PROVIDER_JOB_BATCH_CANDIDATE_SCAN_LIMIT = 200;
 const JUNCTION_WORKOUT_STREAM_CANDIDATE_DIAGNOSTIC_LIMIT = resolveJunctionTimeseriesResourcePolicy("workout_stream")?.maxRecordsPerWindow ?? 0;
+const JUNCTION_ECG_DIAGNOSTIC_COUNT_LIMIT = (resolveJunctionTimeseriesResourcePolicy("electrocardiogram_voltage")?.maxSamplesPerWindow ?? 0) + 1;
+const JUNCTION_ECG_BINDING_REASONS = new Set([
+    "collection_source_ambiguous",
+    "feature_cardinality_mismatch",
+    "group_ambiguous",
+    "group_collection_invalid",
+    "group_envelope_invalid",
+    "group_identity_conflict",
+    "group_invalid",
+    "recording_limit_exceeded",
+    "sample_count_mismatch",
+    "sample_identity_conflict",
+    "sample_invalid",
+    "sample_limit_exceeded",
+    "sample_normalization_invalid",
+    "sample_outside_summary_window",
+    "summary_identity_conflict",
+    "summary_identity_incomplete",
+    "summary_source_inconsistent",
+    "summary_window_invalid",
+    "summary_windows_ambiguous",
+]);
 const DEVICE_SYNC_VALIDATION_SENSITIVE_FIELD_PATTERN = /(?:authorization|bearer|cookie|password|secret|token|api[-_]?key|client[-_]?secret|access[-_]?token|refresh[-_]?token|id[-_]?token|email|phone|address|user(?:name)?|owner|account(?:id)?|external(?:id)?)/iu;
 const DEVICE_SYNC_VALIDATION_METADATA_FIELDS = Object.freeze([
     "expected",
@@ -116,6 +141,7 @@ class DeviceSyncServiceController {
     workerTimer = null;
     schedulerTimer = null;
     jobFailureDiagnostics = [];
+    jobTimingDiagnostics = [];
     connectionMutationStates = new Map();
     constructor(input) {
         this.vaultRoot = input.config.vaultRoot;
@@ -210,7 +236,7 @@ class DeviceSyncServiceController {
                         }
                         : null;
                 },
-                upsertConnectionSource: (input) => this.store.upsertConnectionSource(input),
+                upsertConnectionSource: (input, options) => this.store.upsertConnectionSource(input, options),
                 listConnectionSources: (input) => this.store.listConnectionSources(input),
                 resolveConnectionSourceAdmissionCandidate: (input) => this.store.listConnectionSources(input)
                     .sort((left, right) => {
@@ -236,15 +262,16 @@ class DeviceSyncServiceController {
             },
             hooks: {
                 runConnectionMutation: ({ provider }, operation) => this.runProviderConnectionMutation(provider, operation),
-                onConnectionEstablished: async ({ account, connection, now, provider, sourceProviderSlug, }) => {
+                onConnectionEstablished: async ({ account, connection, connectionStartedAt, now, provider, sourceProviderSlug, }) => {
                     const sourceInstanceKey = provider.provider === "junction" && sourceProviderSlug
                         ? buildJunctionProviderSourceInstanceKey({
                             connectionId: account.id,
                             sourceProviderSlug,
                         })
                         : null;
-                    this.store.commitConnectionEstablished({
+                    const committed = this.store.commitConnectionEstablished({
                         accountId: account.id,
+                        expectedSourceLastSeenAt: connectionStartedAt,
                         jobs: this.normalizeJobsForEnqueue(account, connection.initialJobs ?? []),
                         provider: account.provider,
                         source: sourceInstanceKey && sourceProviderSlug
@@ -258,6 +285,14 @@ class DeviceSyncServiceController {
                             }
                             : null,
                     });
+                    if (sourceInstanceKey && committed === null) {
+                        throw deviceSyncError({
+                            code: "CONNECTION_SOURCE_START_STALE",
+                            message: "Device source state changed while its connection link was starting. Start again.",
+                            retryable: false,
+                            httpStatus: 409,
+                        });
+                    }
                     await this.ensureWebhookAdminUpkeepAfterConnectionEstablished(provider);
                     return {
                         sourceAdmissionCommitted: true,
@@ -347,6 +382,9 @@ class DeviceSyncServiceController {
             details: { ...entry.details },
         }));
     }
+    listJobTimingDiagnostics() {
+        return this.jobTimingDiagnostics.map((entry) => ({ ...entry }));
+    }
     start() {
         if (!this.workerTimer) {
             void this.runWorkerBatchOnce();
@@ -418,7 +456,13 @@ class DeviceSyncServiceController {
         }
         const provider = this.requireProvider(account.provider);
         const now = this.nowIso();
-        const scheduledJobs = resolveProviderJobExecutor(provider)?.createScheduledJobs?.(account, now).jobs ?? [];
+        const scheduledJobs = resolveProviderJobExecutor(provider)?.createScheduledJobs?.(account, now, {
+            findActiveDedupeKeys: (dedupeKeys) => this.store.findActiveJobDedupeKeys({
+                accountId: account.id,
+                dedupeKeys,
+                provider: account.provider,
+            }),
+        }).jobs ?? [];
         const jobs = scheduledJobs.length > 0 ? scheduledJobs : [{ kind: "reconcile", priority: 80 }];
         const queuedJobs = this.enqueueJobs(account, jobs.map((job) => ({
             ...job,
@@ -513,7 +557,13 @@ class DeviceSyncServiceController {
                     if (!jobExecutor?.createScheduledJobs) {
                         continue;
                     }
-                    const schedule = jobExecutor.createScheduledJobs(account, now);
+                    const schedule = jobExecutor.createScheduledJobs(account, now, {
+                        findActiveDedupeKeys: (dedupeKeys) => this.store.findActiveJobDedupeKeys({
+                            accountId: account.id,
+                            dedupeKeys,
+                            provider: account.provider,
+                        }),
+                    });
                     queuedJobs.push(...this.enqueueJobs(account, schedule.jobs));
                     this.store.patchAccount(account.id, {
                         nextReconcileAt: schedule.nextReconcileAt ?? null,
@@ -532,6 +582,7 @@ class DeviceSyncServiceController {
     async runWorkerOnce(accountId) {
         const result = await this.runWorkerPassOnce({
             accountId,
+            importSession: createDeviceProviderSnapshotImportSession(),
             maxJobRows: Number.POSITIVE_INFINITY,
         });
         return result?.job ?? null;
@@ -551,10 +602,67 @@ class DeviceSyncServiceController {
             return null;
         }
         let activeJobs = [job];
-        const finishPass = () => ({
-            job,
-            processedJobRows: Math.max(1, activeJobs.length),
-        });
+        let connectionSourceReadCount = 0;
+        let connectionSourceReadElapsedMs = 0;
+        let credentialRefreshCount = 0;
+        let credentialRefreshElapsedMs = 0;
+        let durableProgressCommitted = false;
+        let outcome = "cancelled";
+        let providerExecutionElapsedMs = null;
+        let providerInventoryRequestCount = 0;
+        let providerInventoryRequestElapsedMs = 0;
+        let providerResourceRequestCount = 0;
+        let providerResourceRequestElapsedMs = 0;
+        let snapshotImportCount = 0;
+        let snapshotImportElapsedMs = 0;
+        let snapshotCanonicalCoreElapsedMs = 0;
+        let snapshotCanonicalWriteElapsedMs = 0;
+        let snapshotEventIdentityIndexCacheHitCount = 0;
+        let snapshotEventIdentityIndexElapsedMs = 0;
+        let snapshotNormalizationElapsedMs = 0;
+        const finishPass = () => {
+            const finishedAt = currentNow();
+            const resource = readSafeDiagnosticToken(job.payload.resource);
+            this.recordJobTimingDiagnostic({
+                at: finishedAt,
+                attempts: job.attempts,
+                connectionSourceReadCount,
+                connectionSourceReadElapsedMs,
+                credentialRefreshCount,
+                credentialRefreshElapsedMs,
+                durableProgressCommitted,
+                elapsedMs: nonnegativeDeviceSyncDurationMs(now, finishedAt),
+                jobCount: Math.max(1, activeJobs.length),
+                jobKind: job.kind,
+                outcome,
+                provider: job.provider,
+                providerExecutionElapsedMs,
+                providerInventoryRequestCount,
+                providerInventoryRequestElapsedMs,
+                providerResourceRequestCount,
+                providerResourceRequestElapsedMs,
+                providerUnattributedElapsedMs: providerExecutionElapsedMs === null
+                    ? null
+                    : Math.max(0, providerExecutionElapsedMs
+                        - connectionSourceReadElapsedMs
+                        - credentialRefreshElapsedMs
+                        - providerInventoryRequestElapsedMs
+                        - providerResourceRequestElapsedMs
+                        - snapshotImportElapsedMs),
+                ...(resource ? { resource } : {}),
+                snapshotImportCount,
+                snapshotImportElapsedMs,
+                snapshotCanonicalCoreElapsedMs,
+                snapshotCanonicalWriteElapsedMs,
+                snapshotEventIdentityIndexCacheHitCount,
+                snapshotEventIdentityIndexElapsedMs,
+                snapshotNormalizationElapsedMs,
+            });
+            return {
+                job,
+                processedJobRows: Math.max(1, activeJobs.length),
+            };
+        };
         const failClaimedJob = (code, message, retryAt, retryable) => {
             const failedAt = currentNow();
             const failureTransition = this.store.failJobIfOwned(job.id, this.workerId, failedAt, code, message, retryAt, retryable);
@@ -566,6 +674,7 @@ class DeviceSyncServiceController {
                 });
                 return false;
             }
+            outcome = "failed";
             // No summary here: these repo-authored messages can embed the local
             // account id, and the failure code already names the cause.
             const failedJobResource = readSafeDiagnosticToken(job.payload.resource);
@@ -601,7 +710,8 @@ class DeviceSyncServiceController {
         const retainsAcceptedWork = preservesAcceptedCompanionHrv || retainsAcceptedCalendarRefresh;
         const delayRetainedJobUntilAuthorityReturns = (code, message) => {
             const delayedAt = currentNow();
-            this.store.failJobIfOwned(job.id, this.workerId, delayedAt, code, message, addMilliseconds(delayedAt, computeRetryDelayMs(job.attempts)), true, true);
+            const transition = this.store.failJobIfOwned(job.id, this.workerId, delayedAt, code, message, addMilliseconds(delayedAt, computeRetryDelayMs(job.attempts)), true, true);
+            outcome = transition ? "deferred" : "cancelled";
         };
         if (retainsAcceptedCalendarRefresh
             && !isJunctionSparseCalendarRefreshPayloadValid(job.payload)) {
@@ -633,6 +743,10 @@ class DeviceSyncServiceController {
                     jobId: job.id,
                 });
             }
+            else {
+                outcome = "completed";
+                durableProgressCommitted = true;
+            }
             return finishPass();
         }
         if (storedAccount.status === "reauthorization_required" && retainsAcceptedCalendarRefresh) {
@@ -744,9 +858,26 @@ class DeviceSyncServiceController {
             const normalizedJobs = activeJobs.map((activeJob) => activeJob.id === normalizedJob.id
                 ? normalizedJob
                 : normalizeConfiguredDeviceSyncJobRecord(provider.provider, activeJob, "execution"));
+            let vaultTimeZone;
+            if (provider.provider === "junction"
+                && this.importer.resolveDeviceProviderSnapshotDefaultTimeZone) {
+                try {
+                    vaultTimeZone = await this.importer.resolveDeviceProviderSnapshotDefaultTimeZone({
+                        vaultRoot: this.vaultRoot,
+                    });
+                }
+                catch {
+                    // Timezone-dependent authority fails closed; ordinary provider
+                    // ingestion remains available when vault metadata cannot be read.
+                    vaultTimeZone = undefined;
+                }
+            }
+            ensureExecutionActive();
+            const canonicalImportReceipts = new Map();
             const jobContext = {
                 account: currentAccount,
                 now,
+                ...(vaultTimeZone ? { vaultTimeZone } : {}),
                 signal: jobAbortController.signal,
                 connectionSourceAdmissionMode: this.listConnectionSourcesForJob
                     ? "listed_only"
@@ -755,45 +886,101 @@ class DeviceSyncServiceController {
                     ? { shouldYield: this.shouldYieldJobExecution }
                     : {}),
                 throwIfAborted: assertJobExecutionNotYielded,
-                importSnapshot: async (snapshot) => {
+                recordProviderRequestTiming: (category, elapsedMs) => {
+                    if (!Number.isFinite(elapsedMs) || elapsedMs < 0) {
+                        return;
+                    }
+                    if (category === "inventory") {
+                        providerInventoryRequestCount += 1;
+                        providerInventoryRequestElapsedMs += elapsedMs;
+                    }
+                    else {
+                        providerResourceRequestCount += 1;
+                        providerResourceRequestElapsedMs += elapsedMs;
+                    }
+                },
+                importSnapshot: async (snapshot, options) => {
                     ensureExecutionActive();
-                    const importResult = await this.importer.importDeviceProviderSnapshot({
-                        provider: provider.provider,
-                        snapshot,
-                        vaultRoot: this.vaultRoot,
-                    });
+                    const importStartedAt = currentNow();
+                    snapshotImportCount += 1;
+                    let importResult;
+                    try {
+                        importResult = await this.importer.importDeviceProviderSnapshot({
+                            provider: provider.provider,
+                            snapshot,
+                            vaultRoot: this.vaultRoot,
+                            ...options,
+                        }, { importSession: input.importSession });
+                    }
+                    finally {
+                        snapshotImportElapsedMs += nonnegativeDeviceSyncDurationMs(importStartedAt, currentNow());
+                    }
+                    const importTiming = readDeviceProviderSnapshotImportTiming(importResult);
+                    if (importTiming) {
+                        snapshotCanonicalCoreElapsedMs += importTiming.canonicalCoreElapsedMs;
+                        snapshotCanonicalWriteElapsedMs += importTiming.canonicalWriteElapsedMs;
+                        snapshotEventIdentityIndexCacheHitCount += importTiming.eventIdentityIndexCacheHit
+                            ? 1
+                            : 0;
+                        snapshotEventIdentityIndexElapsedMs += importTiming.eventIdentityIndexElapsedMs;
+                        snapshotNormalizationElapsedMs += importTiming.normalizationElapsedMs;
+                    }
+                    const canonicalEventCount = readCanonicalDeviceImportEventCount(importResult);
+                    const junctionCanonicalCoverage = readCanonicalDeviceImportJunctionCoverage(importResult);
+                    if (junctionCanonicalCoverage && junctionCanonicalCoverage.length > 0) {
+                        const importCompletedAt = currentNow();
+                        for (const evidence of junctionCanonicalCoverage) {
+                            const key = `${evidence.sourceProviderSlug}\u0000${evidence.resource}`;
+                            if (canonicalImportReceipts.has(key)
+                                || canonicalImportReceipts.size < DEVICE_SYNC_CANONICAL_IMPORT_RECEIPT_LIMIT) {
+                                canonicalImportReceipts.set(key, {
+                                    importCompletedAt,
+                                    resource: evidence.resource,
+                                    sourceProviderSlug: evidence.sourceProviderSlug,
+                                });
+                            }
+                        }
+                    }
                     const canonicalSparseCalendarTargets = readCanonicalDeviceImportSparseCalendarTargets(importResult);
                     const receipt = {
-                        canonicalEventCount: readCanonicalDeviceImportEventCount(importResult),
+                        canonicalEventCount,
                         canonicalEventDayKeys: readCanonicalDeviceImportEventDayKeys(importResult),
                         canonicalEventExternalRefResourceIds: readCanonicalDeviceImportEventExternalRefResourceIds(importResult),
                         ...(canonicalSparseCalendarTargets.length > 0
                             ? { canonicalSparseCalendarTargets }
                             : {}),
                         durableDeliveryAccepted: true,
+                        ...(junctionCanonicalCoverage === undefined
+                            ? {}
+                            : { junctionCanonicalCoverage }),
                     };
                     return receipt;
                 },
                 upsertConnectionSource: (input) => {
                     ensureExecutionActive();
-                    return this.store.upsertConnectionSource({
-                        ...input,
-                        connectionId: currentAccount.id,
-                    });
+                    return this.store.upsertConnectionSource({ ...input, connectionId: currentAccount.id }, { preserveDisconnected: provider.provider === "junction" });
                 },
                 listConnectionSources: async (input = {}) => {
                     ensureExecutionActive();
-                    const sources = this.listConnectionSourcesForJob
-                        ? await this.listConnectionSourcesForJob({
-                            accountId: currentAccount.id,
-                            provider: currentAccount.provider,
-                            signal: jobAbortController.signal,
-                            ...input,
-                        })
-                        : this.store.listConnectionSources({
-                            ...input,
-                            connectionId: currentAccount.id,
-                        });
+                    const sourceReadStartedAt = currentNow();
+                    connectionSourceReadCount += 1;
+                    let sources;
+                    try {
+                        sources = this.listConnectionSourcesForJob
+                            ? await this.listConnectionSourcesForJob({
+                                accountId: currentAccount.id,
+                                provider: currentAccount.provider,
+                                signal: jobAbortController.signal,
+                                ...input,
+                            })
+                            : this.store.listConnectionSources({
+                                ...input,
+                                connectionId: currentAccount.id,
+                            });
+                    }
+                    finally {
+                        connectionSourceReadElapsedMs += nonnegativeDeviceSyncDurationMs(sourceReadStartedAt, currentNow());
+                    }
                     ensureExecutionActive();
                     return sources;
                 },
@@ -816,7 +1003,15 @@ class DeviceSyncServiceController {
                             httpStatus: 409,
                         });
                     }
-                    const refreshed = await refreshTokens(currentAccount);
+                    const credentialRefreshStartedAt = currentNow();
+                    credentialRefreshCount += 1;
+                    let refreshed;
+                    try {
+                        refreshed = await refreshTokens(currentAccount);
+                    }
+                    finally {
+                        credentialRefreshElapsedMs += nonnegativeDeviceSyncDurationMs(credentialRefreshStartedAt, currentNow());
+                    }
                     ensureJobLeasesOwned();
                     ensureAccountActive();
                     const updated = this.store.updateAccountTokens(currentAccount.id, this.encryptTokens(currentAccount, refreshed), disconnectGeneration);
@@ -844,13 +1039,22 @@ class DeviceSyncServiceController {
                 },
                 logger: this.logger,
             };
-            const result = normalizedJobs.length > 1 && jobExecutor.batch
-                ? await jobExecutor.batch.execute(jobContext, normalizedJobs)
-                : await jobExecutor.executeJob(jobContext, normalizedJob);
+            const providerExecutionStartedAt = currentNow();
+            let result;
+            try {
+                result = normalizedJobs.length > 1 && jobExecutor.batch
+                    ? await jobExecutor.batch.execute(jobContext, normalizedJobs)
+                    : await jobExecutor.executeJob(jobContext, normalizedJob);
+            }
+            finally {
+                providerExecutionElapsedMs = nonnegativeDeviceSyncDurationMs(providerExecutionStartedAt, currentNow());
+            }
             ensureJobLeasesOwned();
             ensureAccountActive();
             if (preservesAcceptedCompanionHrv && !isOriginalActiveAccountExecutionCurrent()) {
-                this.store.completeJobsIfOwned(activeJobs.map((activeJob) => activeJob.id), this.workerId, currentNow());
+                const completed = this.store.completeJobsIfOwned(activeJobs.map((activeJob) => activeJob.id), this.workerId, currentNow());
+                outcome = completed ? "completed" : "cancelled";
+                durableProgressCommitted = completed;
                 return finishPass();
             }
             const successOptions = {
@@ -873,6 +1077,8 @@ class DeviceSyncServiceController {
             const scheduledJobs = this.normalizeJobsForEnqueue(storedAccount, result.scheduledJobs ?? []);
             const completed = this.store.completeJobsMarkSyncSucceededAndEnqueueJobs({
                 accountId: storedAccount.id,
+                canonicalImportReceipts: [...canonicalImportReceipts.values()].sort((left, right) => left.sourceProviderSlug.localeCompare(right.sourceProviderSlug)
+                    || left.resource.localeCompare(right.resource)),
                 completedAt: currentNow(),
                 disconnectGeneration,
                 jobIds: activeJobs.map((activeJob) => activeJob.id),
@@ -886,6 +1092,8 @@ class DeviceSyncServiceController {
                 releaseActiveJobsIfCurrentAccountActive(currentNow());
                 return finishPass();
             }
+            outcome = "completed";
+            durableProgressCommitted = true;
             return finishPass();
         }
         catch (error) {
@@ -898,6 +1106,7 @@ class DeviceSyncServiceController {
                     jobCount: activeJobs.length,
                     released,
                 });
+                outcome = "yielded";
                 return finishPass();
             }
             if (error instanceof DeviceSyncJobExecutionCancelledError) {
@@ -909,6 +1118,7 @@ class DeviceSyncServiceController {
                     jobId: job.id,
                     ...(released > 0 ? { released } : {}),
                 });
+                outcome = "cancelled";
                 return finishPass();
             }
             const timeseriesProgress = error instanceof JunctionTimeseriesProgressError
@@ -921,6 +1131,7 @@ class DeviceSyncServiceController {
                     payload: {
                         ...job.payload,
                         windowStart: timeseriesProgress.windowStart,
+                        workoutStreamEmptySeen: timeseriesProgress.workoutStreamEmptySeen || undefined,
                         workoutStreamCursor: timeseriesProgress.workoutStreamCursor ?? undefined,
                     },
                 }, "retry progress").payload
@@ -956,6 +1167,8 @@ class DeviceSyncServiceController {
             if (failureTransitions.length === 0) {
                 return finishPass();
             }
+            outcome = "failed";
+            durableProgressCommitted = timeseriesProgress !== null;
             const diagnosticTransition = failureTransitions.find(({ activeJob }) => activeJob.id === job.id)
                 ?? failureTransitions[0];
             if (!diagnosticTransition) {
@@ -1020,18 +1233,21 @@ class DeviceSyncServiceController {
             stopYieldPolling();
         }
     }
-    async drainWorker(limit = this.workerBatchSize, accountId) {
+    async drainWorker(limit = this.workerBatchSize, accountId, options = {}) {
         const maxJobRows = normalizeProviderJobBatchLimit(limit, this.workerBatchSize);
         let processedJobRows = 0;
+        const importSession = createDeviceProviderSnapshotImportSession();
         while (processedJobRows < maxJobRows) {
             const result = await this.runWorkerPassOnce({
                 accountId,
+                importSession,
                 maxJobRows: maxJobRows - processedJobRows,
             });
             if (!result) {
                 break;
             }
             processedJobRows += result.processedJobRows;
+            options.onProcessedJobRows?.(processedJobRows);
         }
         return processedJobRows;
     }
@@ -1144,6 +1360,12 @@ class DeviceSyncServiceController {
             this.jobFailureDiagnostics.splice(0, this.jobFailureDiagnostics.length - DEVICE_SYNC_JOB_FAILURE_DIAGNOSTIC_LIMIT);
         }
     }
+    recordJobTimingDiagnostic(entry) {
+        this.jobTimingDiagnostics.push({ ...entry });
+        if (this.jobTimingDiagnostics.length > DEVICE_SYNC_JOB_TIMING_DIAGNOSTIC_LIMIT) {
+            this.jobTimingDiagnostics.splice(0, this.jobTimingDiagnostics.length - DEVICE_SYNC_JOB_TIMING_DIAGNOSTIC_LIMIT);
+        }
+    }
     requireStoredAccount(accountId) {
         const account = this.store.getAccountById(accountId);
         if (!account) {
@@ -1296,8 +1518,11 @@ class DeviceSyncServiceController {
 export function createDefaultImporterPort() {
     const importers = createImporters();
     return {
-        importDeviceProviderSnapshot(input) {
-            return importers.importDeviceProviderSnapshot(input);
+        importDeviceProviderSnapshot(input, options) {
+            return importers.importDeviceProviderSnapshot(input, options);
+        },
+        resolveDeviceProviderSnapshotDefaultTimeZone(input) {
+            return importers.resolveDeviceProviderSnapshotDefaultTimeZone(input);
         },
     };
 }
@@ -1314,6 +1539,7 @@ export function createDeviceSyncService(input) {
         listAccounts: (input) => controller.listAccounts(input),
         getAccount: (accountId) => controller.getAccount(accountId),
         listJobFailureDiagnostics: () => controller.listJobFailureDiagnostics(),
+        listJobTimingDiagnostics: () => controller.listJobTimingDiagnostics(),
         start: () => controller.start(),
         stop: () => controller.stop(),
         close: () => controller.close(),
@@ -1327,10 +1553,18 @@ export function createDeviceSyncService(input) {
         getNextWakeAt: (now) => controller.getNextWakeAt(now),
         runSchedulerOnce: (accountId) => controller.runSchedulerOnce(accountId),
         runWorkerOnce: (accountId) => controller.runWorkerOnce(accountId),
-        drainWorker: (limit, accountId) => controller.drainWorker(limit, accountId),
+        drainWorker: (limit, accountId, options) => controller.drainWorker(limit, accountId, options),
     });
     return service;
 }
+function nonnegativeDeviceSyncDurationMs(startAt, endAt) {
+    const startMs = Date.parse(startAt);
+    const endMs = Date.parse(endAt);
+    if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs < startMs) {
+        return 0;
+    }
+    return endMs - startMs;
+}
 function earliestIsoTimestamp(...values) {
     return values
         .filter((value) => typeof value === "string" && value.length > 0)
@@ -1430,10 +1664,29 @@ function connectionChangedDuringDisconnectError() {
     });
 }
 function normalizeExecutionError(error) {
+    if (error instanceof JunctionWorkoutStreamTimestampCardinalityError) {
+        return {
+            code: "SYNC_JOB_FAILED",
+            details: compactFailureDiagnostics({
+                failureErrorName: readSafeDiagnosticToken(error.name),
+                junctionWorkoutStreamMaxTimestampCount: error.diagnostic.maxTimestampCount,
+                junctionWorkoutStreamTimestampCardinalityKind: readSafeDiagnosticToken(error.diagnostic.kind),
+                junctionWorkoutStreamTimestampCount: error.diagnostic.timestampCount,
+            }),
+            message: summarizeExecutionErrorMessage(error),
+            retryable: false,
+        };
+    }
     if (error instanceof JunctionSparseCalendarRepairNormalizationError) {
         return {
             code: error.code,
-            details: {},
+            details: compactFailureDiagnostics({
+                normalizationFailureReason: readSafeDiagnosticToken(error.diagnostic.reason),
+                normalizationRowOrdinal: error.diagnostic.rowOrdinal,
+                normalizationSourceProvider: readSafeDiagnosticToken(normalizeKnownJunctionSourceProviderSlug(error.diagnostic.sourceProvider)),
+                normalizationTimestampKind: readSafeDiagnosticToken(error.diagnostic.timestampKind),
+                normalizationTimestampSemantics: readSafeDiagnosticToken(error.diagnostic.timestampSemantics),
+            }),
             message: error.message,
             retryable: true,
         };
@@ -1475,6 +1728,7 @@ function buildDeviceSyncErrorFailureDiagnostics(error) {
     const cause = toPlainRecord(error.cause);
     const providerRequestEndpointKind = readSafeDiagnosticToken(error.details?.requestEndpointKind);
     const workoutCandidateContext = readSafeWorkoutCandidateFailureContext(error, providerRequestEndpointKind);
+    const junctionEcgContext = readSafeJunctionEcgFailureContext(error);
     return compactFailureDiagnostics({
         failureCauseCode: readSafeDiagnosticToken(cause?.code),
         failureCauseName: readSafeDiagnosticToken(cause?.name),
@@ -1486,6 +1740,7 @@ function buildDeviceSyncErrorFailureDiagnostics(error) {
         providerRequestBodyFieldCount: readSafeDiagnosticNumber(error.details?.requestBodyFieldCount),
         providerRequestBodyFieldNames: readSafeDiagnosticToken(error.details?.requestBodyFieldNames),
         providerRequestBodyKind: readSafeDiagnosticToken(error.details?.requestBodyKind),
+        ...junctionEcgContext,
         ...workoutCandidateContext,
         providerRequestContentType: readSafeDiagnosticToken(error.details?.requestContentType),
         providerRequestCredentialPresent: readSafeDiagnosticBoolean(error.details?.requestCredentialPresent),
@@ -1575,6 +1830,32 @@ function readSafeWorkoutCandidateFailureContext(error, providerRequestEndpointKi
         providerRequestCandidateOrdinal: candidateOrdinal,
     };
 }
+function readSafeJunctionEcgFailureContext(error) {
+    if (error.code !== "JUNCTION_ECG_RECORDING_BINDING_INCOMPLETE") {
+        return {};
+    }
+    const reason = readSafeDiagnosticToken(error.details?.reason);
+    if (!reason || !JUNCTION_ECG_BINDING_REASONS.has(reason)) {
+        return {};
+    }
+    return compactFailureDiagnostics({
+        junctionEcgActualRecordingCount: readSafeJunctionEcgDiagnosticCount(error.details?.actualRecordingCount),
+        junctionEcgActualSampleCount: readSafeJunctionEcgDiagnosticCount(error.details?.actualSampleCount),
+        junctionEcgBindingReason: reason,
+        junctionEcgExpectedRecordingCount: readSafeJunctionEcgDiagnosticCount(error.details?.expectedRecordingCount),
+        junctionEcgExpectedSampleCount: readSafeJunctionEcgDiagnosticCount(error.details?.expectedSampleCount),
+        junctionEcgMaxRecordingCount: readSafeJunctionEcgDiagnosticCount(error.details?.maxRecordingCount),
+        junctionEcgMaxSampleCount: readSafeJunctionEcgDiagnosticCount(error.details?.maxSampleCount),
+    });
+}
+function readSafeJunctionEcgDiagnosticCount(value) {
+    return typeof value === "number"
+        && Number.isSafeInteger(value)
+        && value >= 0
+        && value <= JUNCTION_ECG_DIAGNOSTIC_COUNT_LIMIT
+        ? value
+        : null;
+}
 function readSafeWorkoutCandidateAliasSource(value) {
     return value === "id"
         || value === "multiple_equal"
@@ -1694,6 +1975,35 @@ function toPlainRecord(value) {
     }
     return value;
 }
+function readDeviceProviderSnapshotImportTiming(value) {
+    const timing = toPlainRecord(toPlainRecord(value)?.deviceProviderSnapshotImportTiming);
+    if (!timing || typeof timing.eventIdentityIndexCacheHit !== "boolean") {
+        return null;
+    }
+    const readDuration = (field) => {
+        const duration = timing[field];
+        return typeof duration === "number" && Number.isFinite(duration) && duration >= 0
+            ? duration
+            : null;
+    };
+    const canonicalCoreElapsedMs = readDuration("canonicalCoreElapsedMs");
+    const canonicalWriteElapsedMs = readDuration("canonicalWriteElapsedMs");
+    const eventIdentityIndexElapsedMs = readDuration("eventIdentityIndexElapsedMs");
+    const normalizationElapsedMs = readDuration("normalizationElapsedMs");
+    if (canonicalCoreElapsedMs === null
+        || canonicalWriteElapsedMs === null
+        || eventIdentityIndexElapsedMs === null
+        || normalizationElapsedMs === null) {
+        return null;
+    }
+    return {
+        canonicalCoreElapsedMs,
+        canonicalWriteElapsedMs,
+        eventIdentityIndexCacheHit: timing.eventIdentityIndexCacheHit,
+        eventIdentityIndexElapsedMs,
+        normalizationElapsedMs,
+    };
+}
 function readCanonicalDeviceImportEventCount(value) {
     const record = toPlainRecord(value);
     return record && Array.isArray(record.events) ? record.events.length : 0;
@@ -1748,6 +2058,37 @@ function readCanonicalDeviceImportEventExternalRefResourceIds(value) {
             : [];
     });
 }
+function readCanonicalDeviceImportJunctionCoverage(value) {
+    const result = toPlainRecord(value);
+    if (!result || !Array.isArray(result.junctionCanonicalCoverage)) {
+        return undefined;
+    }
+    return result.junctionCanonicalCoverage.flatMap((entry) => {
+        const evidence = toPlainRecord(entry);
+        const resource = typeof evidence?.resource === "string" ? evidence.resource : "";
+        const coverageBoundary = normalizeJunctionCanonicalCoverageBoundary(resource, evidence?.coverageBoundary);
+        if (!evidence
+            || !coverageBoundary
+            || !resource
+            || typeof evidence.sourceProviderSlug !== "string") {
+            return [];
+        }
+        const coverageFinalizedAt = typeof evidence.coverageFinalizedAt === "string"
+            && Number.isFinite(Date.parse(evidence.coverageFinalizedAt))
+            && new Date(Date.parse(evidence.coverageFinalizedAt)).toISOString()
+                === evidence.coverageFinalizedAt
+            ? evidence.coverageFinalizedAt
+            : null;
+        return [{
+                coverageBoundary,
+                ...(coverageFinalizedAt
+                    ? { coverageFinalizedAt }
+                    : {}),
+                resource,
+                sourceProviderSlug: evidence.sourceProviderSlug,
+            }];
+    });
+}
 function readCanonicalDeviceImportSparseCalendarTargets(value) {
     const record = toPlainRecord(value);
     if (!record || !Array.isArray(record.affectedSparseCalendarTargets)) {