@murphai/murph 1.2.0 → 1.2.4

package/node_modules/@murphai/device-syncd/dist/config/provider-manifests.js

@@ -1,93 +1,37 @@
-import { junctionProviderAdapter, ouraProviderAdapter, stravaProviderAdapter, whoopProviderAdapter, } from "@murphai/importers";
-import { JUNCTION_DEVICE_PROVIDER_DESCRIPTOR, OURA_DEVICE_PROVIDER_DESCRIPTOR, STRAVA_DEVICE_PROVIDER_DESCRIPTOR, WHOOP_DEVICE_PROVIDER_DESCRIPTOR, normalizeDeviceProviderKey, resolveDeviceProviderConnectionDescriptor, } from "@murphai/importers/device-providers/provider-descriptors";
-import { createJunctionDeviceSyncProvider, JUNCTION_PROVIDER_CONFIG_KEY, } from "../providers/junction.js";
-import { assertValidJunctionClientConfig } from "../providers/junction-client.js";
-import { createOuraDeviceSyncProvider } from "../providers/oura.js";
-import { createStravaDeviceSyncProvider } from "../providers/strava.js";
-import { createWhoopDeviceSyncProvider } from "../providers/whoop.js";
-import { optionalEnv, parseCsvEnv, parseIntegerEnv, readOptionalCredentialPair, } from "./provider-config-helpers.js";
+import { JUNCTION_ALLOWED_SUMMARY_RESOURCES, JUNCTION_ALLOWED_TIMESERIES_RESOURCES, JUNCTION_DEFAULT_SUMMARY_RESOURCES, JUNCTION_DEFAULT_TIMESERIES_RESOURCES, JUNCTION_KNOWN_TIMESERIES_RESOURCES, normalizeJunctionResourceName, } from "@murphai/importers/device-providers/junction-resources";
+import { JUNCTION_DEVICE_PROVIDER_DESCRIPTOR, OURA_DEVICE_PROVIDER_DESCRIPTOR, STRAVA_DEVICE_PROVIDER_DESCRIPTOR, WHOOP_DEVICE_PROVIDER_DESCRIPTOR, normalizeDeviceProviderKey, requireDeviceProviderOAuthDescriptor, requireDeviceProviderSyncDescriptor, resolveDeviceProviderConnectionDescriptor, } from "@murphai/importers/device-providers/provider-descriptors";
+import { readConfiguredJunctionDeviceSyncProviderConfig, readConfiguredOuraDeviceSyncProviderConfig, readConfiguredStravaDeviceSyncProviderConfig, readConfiguredWhoopDeviceSyncProviderConfig, } from "./provider-configs.js";
 import { configuredDeviceSyncProviderKeys, listConfiguredDeviceSyncProviderNames, } from "./provider-keys.js";
-import { JUNCTION_API_KEY_ENV_KEYS, JUNCTION_CLIENT_USER_ID_SECRET_ENV_KEYS, JUNCTION_DEVICE_SYNC_PROVIDER_ENV_SPEC, JUNCTION_ENV_ENV_KEYS, JUNCTION_PROVIDER_FILTER_ENV_KEYS, JUNCTION_RECONCILE_DAYS_ENV_KEYS, JUNCTION_RECONCILE_INTERVAL_MS_ENV_KEYS, JUNCTION_REGION_ENV_KEYS, JUNCTION_REQUEST_TIMEOUT_MS_ENV_KEYS, JUNCTION_SUMMARY_BACKFILL_DAYS_ENV_KEYS, JUNCTION_SUMMARY_RESOURCES_ENV_KEYS, JUNCTION_TIMESERIES_BACKFILL_DAYS_ENV_KEYS, JUNCTION_TIMESERIES_RESOURCES_ENV_KEYS, JUNCTION_WEBHOOK_SECRET_ENV_KEYS, JUNCTION_WEBHOOK_TIMESTAMP_TOLERANCE_MS_ENV_KEYS, OURA_API_BASE_URL_ENV_KEYS, OURA_AUTH_BASE_URL_ENV_KEYS, OURA_BACKFILL_DAYS_ENV_KEYS, OURA_CLIENT_ID_ENV_KEYS, OURA_CLIENT_SECRET_ENV_KEYS, OURA_DEVICE_SYNC_PROVIDER_ENV_SPEC, OURA_RECONCILE_DAYS_ENV_KEYS, OURA_RECONCILE_INTERVAL_MS_ENV_KEYS, OURA_REQUEST_TIMEOUT_MS_ENV_KEYS, OURA_SCOPES_ENV_KEYS, OURA_WEBHOOK_TIMESTAMP_TOLERANCE_MS_ENV_KEYS, OURA_WEBHOOK_VERIFICATION_TOKEN_ENV_KEYS, STRAVA_API_BASE_URL_ENV_KEYS, STRAVA_AUTH_BASE_URL_ENV_KEYS, STRAVA_BACKFILL_DAYS_ENV_KEYS, STRAVA_CLIENT_ID_ENV_KEYS, STRAVA_CLIENT_SECRET_ENV_KEYS, STRAVA_DEVICE_SYNC_PROVIDER_ENV_SPEC, STRAVA_RECONCILE_DAYS_ENV_KEYS, STRAVA_RECONCILE_INTERVAL_MS_ENV_KEYS, STRAVA_REQUEST_TIMEOUT_MS_ENV_KEYS, STRAVA_SCOPES_ENV_KEYS, STRAVA_WEBHOOK_SIGNING_SECRET_ENV_KEYS, STRAVA_WEBHOOK_TIMESTAMP_TOLERANCE_MS_ENV_KEYS, STRAVA_WEBHOOK_VERIFY_TOKEN_ENV_KEYS, WHOOP_BACKFILL_DAYS_ENV_KEYS, WHOOP_BASE_URL_ENV_KEYS, WHOOP_CLIENT_ID_ENV_KEYS, WHOOP_CLIENT_SECRET_ENV_KEYS, WHOOP_DEVICE_SYNC_PROVIDER_ENV_SPEC, WHOOP_RECONCILE_DAYS_ENV_KEYS, WHOOP_RECONCILE_INTERVAL_MS_ENV_KEYS, WHOOP_REQUEST_TIMEOUT_MS_ENV_KEYS, WHOOP_SCOPES_ENV_KEYS, WHOOP_WEBHOOK_TIMESTAMP_TOLERANCE_MS_ENV_KEYS, } from "./provider-env.js";
-import { deviceSyncError } from "../errors.js";
-const DEFAULT_DISALLOWED_SERIALIZABLE_FIELDS = Object.freeze({
-    fetchImpl: "is not supported in serialized runtime config.",
-});
-function booleanJobField(options = {}) {
-    return {
-        kind: "boolean",
-        ...options,
-    };
-}
-function stringJobField(options = {}) {
-    return {
-        kind: "string",
-        ...options,
-    };
-}
+import { JUNCTION_DEVICE_SYNC_PROVIDER_ENV_SPEC, OURA_DEVICE_SYNC_PROVIDER_ENV_SPEC, STRAVA_DEVICE_SYNC_PROVIDER_ENV_SPEC, WHOOP_DEVICE_SYNC_PROVIDER_ENV_SPEC, } from "./provider-env.js";
+import { JUNCTION_SERIALIZABLE_PROVIDER_CONFIG_SCHEMA, OURA_SERIALIZABLE_PROVIDER_CONFIG_SCHEMA, STRAVA_SERIALIZABLE_PROVIDER_CONFIG_SCHEMA, WHOOP_SERIALIZABLE_PROVIDER_CONFIG_SCHEMA, } from "./serializable-provider-configs.js";
+import { normalizeJunctionProviderFilter } from "./junction-connect-sources.js";
+import { normalizeString } from "../shared.js";
+const OURA_OAUTH = requireDeviceProviderOAuthDescriptor(OURA_DEVICE_PROVIDER_DESCRIPTOR);
+const OURA_SYNC = requireDeviceProviderSyncDescriptor(OURA_DEVICE_PROVIDER_DESCRIPTOR);
+const OURA_DEFAULT_SCOPES = Object.freeze([...OURA_OAUTH.defaultScopes]);
+const STRAVA_OAUTH = requireDeviceProviderOAuthDescriptor(STRAVA_DEVICE_PROVIDER_DESCRIPTOR);
+const STRAVA_SYNC = requireDeviceProviderSyncDescriptor(STRAVA_DEVICE_PROVIDER_DESCRIPTOR);
+const STRAVA_DEFAULT_SCOPES = Object.freeze([...STRAVA_OAUTH.defaultScopes]);
+const WHOOP_OAUTH = requireDeviceProviderOAuthDescriptor(WHOOP_DEVICE_PROVIDER_DESCRIPTOR);
+const WHOOP_SYNC = requireDeviceProviderSyncDescriptor(WHOOP_DEVICE_PROVIDER_DESCRIPTOR);
+const WHOOP_DEFAULT_SCOPES = Object.freeze([...WHOOP_OAUTH.defaultScopes]);
+const WHOOP_REQUIRED_SCOPES = Object.freeze(["offline", "read:profile"]);
 const JUNCTION_DEVICE_SYNC_PROVIDER_MANIFEST = defineConfiguredDeviceSyncProviderManifest({
     provider: "junction",
     credentialPolicy: {
         kind: "provider_config",
-        providerConfigKey: JUNCTION_PROVIDER_CONFIG_KEY,
+        providerConfigKey: "junction",
     },
     descriptor: JUNCTION_DEVICE_PROVIDER_DESCRIPTOR,
-    importer: junctionProviderAdapter,
     env: JUNCTION_DEVICE_SYNC_PROVIDER_ENV_SPEC,
-    readConfig(env) {
-        const apiKey = optionalEnv(env, JUNCTION_API_KEY_ENV_KEYS);
-        const clientUserIdSecret = optionalEnv(env, JUNCTION_CLIENT_USER_ID_SECRET_ENV_KEYS);
-        const environment = optionalEnv(env, JUNCTION_ENV_ENV_KEYS);
-        const region = optionalEnv(env, JUNCTION_REGION_ENV_KEYS);
-        const webhookSecret = optionalEnv(env, JUNCTION_WEBHOOK_SECRET_ENV_KEYS);
-        if (!apiKey && !clientUserIdSecret && !environment && !region && !webhookSecret) {
-            return null;
-        }
-        if (!apiKey || !clientUserIdSecret || !environment || !region) {
-            throw new TypeError("Junction configuration is incomplete. Set JUNCTION_API_KEY, JUNCTION_CLIENT_USER_ID_SECRET, JUNCTION_ENV, and JUNCTION_REGION together.");
-        }
-        const config = {
-            apiKey,
-            clientUserIdSecret,
-            environment: parseJunctionEnvironment(environment),
-            region: parseJunctionRegion(region),
-            providerFilter: parseCsvEnv(env, JUNCTION_PROVIDER_FILTER_ENV_KEYS),
-            summaryResources: parseCsvEnv(env, JUNCTION_SUMMARY_RESOURCES_ENV_KEYS),
-            timeseriesResources: parseCsvEnv(env, JUNCTION_TIMESERIES_RESOURCES_ENV_KEYS),
-            summaryBackfillDays: parseIntegerEnv(env, JUNCTION_SUMMARY_BACKFILL_DAYS_ENV_KEYS),
-            timeseriesBackfillDays: parseIntegerEnv(env, JUNCTION_TIMESERIES_BACKFILL_DAYS_ENV_KEYS),
-            reconcileDays: parseIntegerEnv(env, JUNCTION_RECONCILE_DAYS_ENV_KEYS),
-            reconcileIntervalMs: parseIntegerEnv(env, JUNCTION_RECONCILE_INTERVAL_MS_ENV_KEYS),
-            requestTimeoutMs: parseIntegerEnv(env, JUNCTION_REQUEST_TIMEOUT_MS_ENV_KEYS),
-            webhookSecret,
-            webhookTimestampToleranceMs: parseIntegerEnv(env, JUNCTION_WEBHOOK_TIMESTAMP_TOLERANCE_MS_ENV_KEYS),
-        };
-        assertValidJunctionClientConfig(config);
-        return config;
-    },
-    createProvider: createJunctionDeviceSyncProvider,
-    serializableFields: {
-        allowedLinkHosts: "string[]",
-        environment: "string",
-        providerFilter: "string[]",
-        reconcileDays: "number",
-        reconcileIntervalMs: "number",
-        region: "string",
-        requestTimeoutMs: "number",
-        summaryBackfillDays: "number",
-        summaryResources: "string[]",
-        timeseriesBackfillDays: "number",
-        timeseriesResources: "string[]",
-        webhookTimestampToleranceMs: "number",
-    },
-    disallowedSerializableFields: {
-        ...DEFAULT_DISALLOWED_SERIALIZABLE_FIELDS,
-        apiKey: "is a provider-owned API secret and is not supported in serialized runtime config.",
-        clientUserIdSecret: "is a provider-owned HMAC secret and is not supported in serialized runtime config.",
-        webhookSecret: "is a provider-owned webhook secret and is not supported in serialized runtime config.",
-    },
-    jobs: {
+    readConfig: readConfiguredJunctionDeviceSyncProviderConfig,
+    serializableFields: JUNCTION_SERIALIZABLE_PROVIDER_CONFIG_SCHEMA.serializableFields,
+    disallowedSerializableFields: JUNCTION_SERIALIZABLE_PROVIDER_CONFIG_SCHEMA.disallowedSerializableFields,
+    jobs: freezeConfiguredDeviceSyncProviderJobDefinitions({
         backfill: {
             payload: {
+                emptyBackfillAttempts: numberJobField({ includeInHostedHint: true }),
+                timeseriesCursor: stringJobField({ includeInHostedHint: true }),
                 windowEnd: stringJobField({ includeInHostedHint: true }),
                 windowStart: stringJobField({ includeInHostedHint: true }),
             },
@@ -100,6 +44,8 @@ const JUNCTION_DEVICE_SYNC_PROVIDER_MANIFEST = defineConfiguredDeviceSyncProvide
         },
         resource: {
             payload: {
+                companionAdmissionId: stringJobField({ includeInHostedHint: true }),
+                companionObservationJson: stringJobField({ includeInHostedHint: true }),
                 eventType: stringJobField({ includeInHostedHint: true }),
                 objectId: stringJobField({ includeInHostedHint: true }),
                 occurredAt: stringJobField({ includeInHostedHint: true }),
@@ -111,7 +57,7 @@ const JUNCTION_DEVICE_SYNC_PROVIDER_MANIFEST = defineConfiguredDeviceSyncProvide
                 windowStart: stringJobField({ includeInHostedHint: true }),
             },
         },
-    },
+    }),
 });
 const OURA_DEVICE_SYNC_PROVIDER_MANIFEST = defineConfiguredDeviceSyncProviderManifest({
     provider: "oura",
@@ -119,45 +65,11 @@ const OURA_DEVICE_SYNC_PROVIDER_MANIFEST = defineConfiguredDeviceSyncProviderMan
         kind: "oauth_tokens",
     },
     descriptor: OURA_DEVICE_PROVIDER_DESCRIPTOR,
-    importer: ouraProviderAdapter,
     env: OURA_DEVICE_SYNC_PROVIDER_ENV_SPEC,
-    readConfig(env) {
-        const credentials = readOptionalCredentialPair(env, OURA_CLIENT_ID_ENV_KEYS, OURA_CLIENT_SECRET_ENV_KEYS, "Oura");
-        if (!credentials) {
-            return null;
-        }
-        return {
-            clientId: credentials.clientId,
-            clientSecret: credentials.clientSecret,
-            authBaseUrl: optionalEnv(env, OURA_AUTH_BASE_URL_ENV_KEYS),
-            apiBaseUrl: optionalEnv(env, OURA_API_BASE_URL_ENV_KEYS),
-            scopes: parseCsvEnv(env, OURA_SCOPES_ENV_KEYS),
-            backfillDays: parseIntegerEnv(env, OURA_BACKFILL_DAYS_ENV_KEYS),
-            reconcileDays: parseIntegerEnv(env, OURA_RECONCILE_DAYS_ENV_KEYS),
-            reconcileIntervalMs: parseIntegerEnv(env, OURA_RECONCILE_INTERVAL_MS_ENV_KEYS),
-            webhookTimestampToleranceMs: parseIntegerEnv(env, OURA_WEBHOOK_TIMESTAMP_TOLERANCE_MS_ENV_KEYS),
-            requestTimeoutMs: parseIntegerEnv(env, OURA_REQUEST_TIMEOUT_MS_ENV_KEYS),
-            webhookVerificationToken: optionalEnv(env, OURA_WEBHOOK_VERIFICATION_TOKEN_ENV_KEYS),
-        };
-    },
-    createProvider: createOuraDeviceSyncProvider,
-    serializableFields: {
-        apiBaseUrl: "string",
-        authBaseUrl: "string",
-        backfillDays: "number",
-        clientId: "string",
-        clientSecret: "string",
-        reconcileDays: "number",
-        reconcileIntervalMs: "number",
-        requestTimeoutMs: "number",
-        scopes: "string[]",
-        webhookTimestampToleranceMs: "number",
-    },
-    disallowedSerializableFields: {
-        ...DEFAULT_DISALLOWED_SERIALIZABLE_FIELDS,
-        webhookVerificationToken: "is a provider-owned admin secret and is not supported in serialized runtime config.",
-    },
-    jobs: {
+    readConfig: readConfiguredOuraDeviceSyncProviderConfig,
+    serializableFields: OURA_SERIALIZABLE_PROVIDER_CONFIG_SCHEMA.serializableFields,
+    disallowedSerializableFields: OURA_SERIALIZABLE_PROVIDER_CONFIG_SCHEMA.disallowedSerializableFields,
+    jobs: freezeConfiguredDeviceSyncProviderJobDefinitions({
         backfill: {
             payload: {
                 includePersonalInfo: booleanJobField({ includeInHostedHint: true }),
@@ -190,7 +102,7 @@ const OURA_DEVICE_SYNC_PROVIDER_MANIFEST = defineConfiguredDeviceSyncProviderMan
                 sourceEventType: stringJobField({ includeInHostedHint: true }),
             },
         },
-    },
+    }),
 });
 const WHOOP_DEVICE_SYNC_PROVIDER_MANIFEST = defineConfiguredDeviceSyncProviderManifest({
     provider: "whoop",
@@ -198,39 +110,11 @@ const WHOOP_DEVICE_SYNC_PROVIDER_MANIFEST = defineConfiguredDeviceSyncProviderMa
         kind: "oauth_tokens",
     },
     descriptor: WHOOP_DEVICE_PROVIDER_DESCRIPTOR,
-    importer: whoopProviderAdapter,
     env: WHOOP_DEVICE_SYNC_PROVIDER_ENV_SPEC,
-    readConfig(env) {
-        const credentials = readOptionalCredentialPair(env, WHOOP_CLIENT_ID_ENV_KEYS, WHOOP_CLIENT_SECRET_ENV_KEYS, "WHOOP");
-        if (!credentials) {
-            return null;
-        }
-        return {
-            clientId: credentials.clientId,
-            clientSecret: credentials.clientSecret,
-            baseUrl: optionalEnv(env, WHOOP_BASE_URL_ENV_KEYS),
-            scopes: parseCsvEnv(env, WHOOP_SCOPES_ENV_KEYS),
-            backfillDays: parseIntegerEnv(env, WHOOP_BACKFILL_DAYS_ENV_KEYS),
-            reconcileDays: parseIntegerEnv(env, WHOOP_RECONCILE_DAYS_ENV_KEYS),
-            reconcileIntervalMs: parseIntegerEnv(env, WHOOP_RECONCILE_INTERVAL_MS_ENV_KEYS),
-            webhookTimestampToleranceMs: parseIntegerEnv(env, WHOOP_WEBHOOK_TIMESTAMP_TOLERANCE_MS_ENV_KEYS),
-            requestTimeoutMs: parseIntegerEnv(env, WHOOP_REQUEST_TIMEOUT_MS_ENV_KEYS),
-        };
-    },
-    createProvider: createWhoopDeviceSyncProvider,
-    serializableFields: {
-        backfillDays: "number",
-        baseUrl: "string",
-        clientId: "string",
-        clientSecret: "string",
-        reconcileDays: "number",
-        reconcileIntervalMs: "number",
-        requestTimeoutMs: "number",
-        scopes: "string[]",
-        webhookTimestampToleranceMs: "number",
-    },
-    disallowedSerializableFields: DEFAULT_DISALLOWED_SERIALIZABLE_FIELDS,
-    jobs: {
+    readConfig: readConfiguredWhoopDeviceSyncProviderConfig,
+    serializableFields: WHOOP_SERIALIZABLE_PROVIDER_CONFIG_SCHEMA.serializableFields,
+    disallowedSerializableFields: WHOOP_SERIALIZABLE_PROVIDER_CONFIG_SCHEMA.disallowedSerializableFields,
+    jobs: freezeConfiguredDeviceSyncProviderJobDefinitions({
         backfill: {
             payload: {
                 windowEnd: stringJobField({ includeInHostedHint: true }),
@@ -259,7 +143,7 @@ const WHOOP_DEVICE_SYNC_PROVIDER_MANIFEST = defineConfiguredDeviceSyncProviderMa
                 resourceType: stringJobField({ includeInHostedHint: true, required: true }),
             },
         },
-    },
+    }),
 });
 const STRAVA_DEVICE_SYNC_PROVIDER_MANIFEST = defineConfiguredDeviceSyncProviderManifest({
     provider: "strava",
@@ -267,47 +151,11 @@ const STRAVA_DEVICE_SYNC_PROVIDER_MANIFEST = defineConfiguredDeviceSyncProviderM
         kind: "oauth_tokens",
     },
     descriptor: STRAVA_DEVICE_PROVIDER_DESCRIPTOR,
-    importer: stravaProviderAdapter,
     env: STRAVA_DEVICE_SYNC_PROVIDER_ENV_SPEC,
-    readConfig(env) {
-        const credentials = readOptionalCredentialPair(env, STRAVA_CLIENT_ID_ENV_KEYS, STRAVA_CLIENT_SECRET_ENV_KEYS, "Strava");
-        if (!credentials) {
-            return null;
-        }
-        return {
-            clientId: credentials.clientId,
-            clientSecret: credentials.clientSecret,
-            authBaseUrl: optionalEnv(env, STRAVA_AUTH_BASE_URL_ENV_KEYS),
-            apiBaseUrl: optionalEnv(env, STRAVA_API_BASE_URL_ENV_KEYS),
-            scopes: parseCsvEnv(env, STRAVA_SCOPES_ENV_KEYS),
-            backfillDays: parseIntegerEnv(env, STRAVA_BACKFILL_DAYS_ENV_KEYS),
-            reconcileDays: parseIntegerEnv(env, STRAVA_RECONCILE_DAYS_ENV_KEYS),
-            reconcileIntervalMs: parseIntegerEnv(env, STRAVA_RECONCILE_INTERVAL_MS_ENV_KEYS),
-            requestTimeoutMs: parseIntegerEnv(env, STRAVA_REQUEST_TIMEOUT_MS_ENV_KEYS),
-            webhookSigningSecret: optionalEnv(env, STRAVA_WEBHOOK_SIGNING_SECRET_ENV_KEYS),
-            webhookTimestampToleranceMs: parseIntegerEnv(env, STRAVA_WEBHOOK_TIMESTAMP_TOLERANCE_MS_ENV_KEYS),
-            webhookVerifyToken: optionalEnv(env, STRAVA_WEBHOOK_VERIFY_TOKEN_ENV_KEYS),
-        };
-    },
-    createProvider: createStravaDeviceSyncProvider,
-    serializableFields: {
-        apiBaseUrl: "string",
-        authBaseUrl: "string",
-        backfillDays: "number",
-        clientId: "string",
-        clientSecret: "string",
-        reconcileDays: "number",
-        reconcileIntervalMs: "number",
-        requestTimeoutMs: "number",
-        scopes: "string[]",
-        webhookTimestampToleranceMs: "number",
-    },
-    disallowedSerializableFields: {
-        ...DEFAULT_DISALLOWED_SERIALIZABLE_FIELDS,
-        webhookSigningSecret: "is a provider-owned webhook signing secret and is not supported in serialized runtime config.",
-        webhookVerifyToken: "is a provider-owned admin secret and is not supported in serialized runtime config.",
-    },
-    jobs: {
+    readConfig: readConfiguredStravaDeviceSyncProviderConfig,
+    serializableFields: STRAVA_SERIALIZABLE_PROVIDER_CONFIG_SCHEMA.serializableFields,
+    disallowedSerializableFields: STRAVA_SERIALIZABLE_PROVIDER_CONFIG_SCHEMA.disallowedSerializableFields,
+    jobs: freezeConfiguredDeviceSyncProviderJobDefinitions({
         backfill: {
             payload: {
                 includeAthlete: booleanJobField(),
@@ -348,7 +196,7 @@ const STRAVA_DEVICE_SYNC_PROVIDER_MANIFEST = defineConfiguredDeviceSyncProviderM
                 resourceType: stringJobField({ includeInHostedHint: true, required: true }),
             },
         },
-    },
+    }),
 });
 export const deviceSyncProviderManifestByKey = Object.freeze({
     junction: JUNCTION_DEVICE_SYNC_PROVIDER_MANIFEST,
@@ -370,18 +218,6 @@ export function resolveConfiguredDeviceSyncProviderManifest(provider) {
     }
     return deviceSyncProviderManifestByKey[key];
 }
-export function resolveDeviceSyncProviderCredentialPolicy(provider) {
-    const manifest = resolveConfiguredDeviceSyncProviderManifest(provider.provider);
-    if (manifest) {
-        return manifest.credentialPolicy;
-    }
-    if (provider.credentialPolicy) {
-        return provider.credentialPolicy;
-    }
-    return provider.descriptor.oauth
-        ? { kind: "oauth_tokens" }
-        : { kind: "none" };
-}
 export function requireConfiguredDeviceSyncProviderManifest(provider) {
     const manifest = resolveConfiguredDeviceSyncProviderManifest(provider);
     if (!manifest) {
@@ -406,28 +242,207 @@ export function listDeviceSyncProviderCatalog() {
         };
     });
 }
-export function getConfiguredDeviceSyncProviderJobDefinition(provider, kind) {
-    const manifest = resolveConfiguredDeviceSyncProviderManifest(provider);
-    return manifest?.jobs[kind];
+export function getConfiguredDeviceSyncProviderDescriptor(provider) {
+    return deviceSyncProviderManifestByKey[provider].descriptor;
 }
-export function normalizeConfiguredDeviceSyncJobInput(provider, job, context) {
+export function resolveConfiguredDeviceSyncProviderDescriptor(provider) {
+    return resolveConfiguredDeviceSyncProviderManifest(provider)?.descriptor;
+}
+export function buildConfiguredDeviceSyncProviderRuntimeDescriptor(provider, config) {
+    switch (provider) {
+        case "junction":
+            normalizeJunctionDeviceSyncRuntimeConfig(config);
+            return getConfiguredDeviceSyncProviderDescriptor("junction");
+        case "oura":
+            return buildOuraDeviceSyncRuntimeDescriptor(config);
+        case "whoop":
+            return buildWhoopDeviceSyncRuntimeDescriptor(config);
+        case "strava":
+            return buildStravaDeviceSyncRuntimeDescriptor(config);
+    }
+}
+export function normalizeJunctionDeviceSyncRuntimeConfig(config) {
+    const clientUserIdSecret = assertValidJunctionClientUserIdSecret(config.clientUserIdSecret);
+    const summaryResources = normalizeRequiredJunctionResourceList(config.summaryResources, JUNCTION_DEFAULT_SUMMARY_RESOURCES, JUNCTION_ALLOWED_SUMMARY_RESOURCES, "summary");
+    const timeseriesResources = normalizeOptionalJunctionResourceList(config.timeseriesResources, JUNCTION_DEFAULT_TIMESERIES_RESOURCES, JUNCTION_ALLOWED_TIMESERIES_RESOURCES, JUNCTION_KNOWN_TIMESERIES_RESOURCES, "timeseries");
+    const providerFilter = normalizeJunctionProviderFilter(config.providerFilter);
+    if (providerFilter.length === 0) {
+        throw new TypeError("Junction provider filter must include at least one hosted Link provider.");
+    }
     return {
-        ...job,
-        payload: normalizeConfiguredDeviceSyncJobPayload(provider, job.kind, job.payload, context),
+        clientUserIdSecret,
+        providerFilter,
+        summaryResources,
+        timeseriesResources,
     };
 }
-export function normalizeConfiguredDeviceSyncJobRecord(provider, job, context) {
+export function assertValidJunctionClientUserIdSecret(secret) {
+    const normalizedSecret = normalizeString(secret);
+    if (!normalizedSecret || normalizedSecret.length < 16) {
+        throw new TypeError("JUNCTION_CLIENT_USER_ID_SECRET must be at least 16 characters.");
+    }
+    return normalizedSecret;
+}
+export function buildOuraDeviceSyncScopes(input) {
+    const requested = [...OURA_DEFAULT_SCOPES, ...(input ?? [])];
+    return [...new Set(requested
+            .map((scope) => scope.trim())
+            .filter((scope) => scope && !isDeprecatedOuraScope(scope)))];
+}
+export function buildOuraDeviceSyncRuntimeDescriptor(config) {
+    const backfillDays = Math.max(1, config.backfillDays ?? OURA_SYNC.windows.backfillDays);
+    const reconcileDays = Math.max(1, config.reconcileDays ?? OURA_SYNC.windows.reconcileDays);
+    const reconcileIntervalMs = Math.max(60_000, config.reconcileIntervalMs ?? OURA_SYNC.windows.reconcileIntervalMs);
     return {
-        ...job,
-        payload: normalizeConfiguredDeviceSyncJobPayload(provider, job.kind, job.payload, context),
+        ...getConfiguredDeviceSyncProviderDescriptor("oura"),
+        oauth: {
+            ...OURA_OAUTH,
+            defaultScopes: buildOuraDeviceSyncScopes(config.scopes),
+        },
+        sync: {
+            ...OURA_SYNC,
+            windows: {
+                backfillDays,
+                reconcileDays,
+                reconcileIntervalMs,
+            },
+        },
     };
 }
-export function shapeConfiguredDeviceSyncHostedHintPayload(provider, job) {
-    const definition = getConfiguredDeviceSyncProviderJobDefinition(provider, job.kind);
-    if (!definition) {
-        return {};
+export function normalizeStravaDeviceSyncScopes(value) {
+    if (!Array.isArray(value) && typeof value !== "string") {
+        return [];
+    }
+    const rawScopes = Array.isArray(value) ? value : [value];
+    const deduped = new Set();
+    for (const entry of rawScopes) {
+        if (typeof entry !== "string") {
+            continue;
+        }
+        for (const scope of entry.split(/[\s,]+/u)) {
+            const normalized = scope.trim();
+            if (normalized) {
+                deduped.add(normalized);
+            }
+        }
     }
-    return pickConfiguredDeviceSyncHostedHintPayload(normalizeJobPayloadRecord(job.payload, `${provider} ${job.kind} hosted hint payload`), definition);
+    return [...deduped];
+}
+export function buildStravaDeviceSyncScopes(input) {
+    const scopes = normalizeStravaDeviceSyncScopes(input);
+    return scopes.length > 0 ? scopes : [...STRAVA_DEFAULT_SCOPES];
+}
+export function buildStravaDeviceSyncRuntimeDescriptor(config) {
+    const backfillDays = Math.max(1, config.backfillDays ?? STRAVA_SYNC.windows.backfillDays);
+    const reconcileDays = Math.max(1, config.reconcileDays ?? STRAVA_SYNC.windows.reconcileDays);
+    const reconcileIntervalMs = Math.max(60_000, config.reconcileIntervalMs ?? STRAVA_SYNC.windows.reconcileIntervalMs);
+    return {
+        ...getConfiguredDeviceSyncProviderDescriptor("strava"),
+        oauth: {
+            ...STRAVA_OAUTH,
+            defaultScopes: buildStravaDeviceSyncScopes(config.scopes),
+        },
+        sync: {
+            ...STRAVA_SYNC,
+            windows: {
+                backfillDays,
+                reconcileDays,
+                reconcileIntervalMs,
+            },
+        },
+    };
+}
+export function buildWhoopDeviceSyncScopes(input) {
+    const requested = input === undefined ? [...WHOOP_DEFAULT_SCOPES] : input;
+    return [...new Set([...WHOOP_REQUIRED_SCOPES, ...requested]
+            .map((scope) => scope.trim())
+            .filter(Boolean))];
+}
+export function buildWhoopDeviceSyncRuntimeDescriptor(config) {
+    const backfillDays = Math.max(1, config.backfillDays ?? WHOOP_SYNC.windows.backfillDays);
+    const reconcileDays = Math.max(1, config.reconcileDays ?? WHOOP_SYNC.windows.reconcileDays);
+    const reconcileIntervalMs = Math.max(60_000, config.reconcileIntervalMs ?? WHOOP_SYNC.windows.reconcileIntervalMs);
+    return {
+        ...getConfiguredDeviceSyncProviderDescriptor("whoop"),
+        oauth: {
+            ...WHOOP_OAUTH,
+            defaultScopes: buildWhoopDeviceSyncScopes(config.scopes),
+        },
+        sync: {
+            ...WHOOP_SYNC,
+            windows: {
+                backfillDays,
+                reconcileDays,
+                reconcileIntervalMs,
+            },
+        },
+    };
+}
+function isDeprecatedOuraScope(scope) {
+    return scope.replace(/^extapi:/u, "") === "heartrate";
+}
+function normalizeRequiredJunctionResourceList(value, defaults, allowedResources, label) {
+    const normalized = (value && value.length > 0 ? value : defaults)
+        .map(normalizeJunctionResourceName)
+        .filter((entry) => entry !== null);
+    const allowedResourceSet = new Set(allowedResources);
+    const unsupportedResources = normalized.filter((entry) => !allowedResourceSet.has(entry));
+    if (unsupportedResources.length > 0) {
+        throw new TypeError(`Junction ${label} resources include unsupported resource(s): ${[...new Set(unsupportedResources)].join(", ")}.`);
+    }
+    if (normalized.length === 0) {
+        throw new TypeError(`Junction ${label} resources must include at least one supported resource.`);
+    }
+    return [...new Set(normalized)];
+}
+function normalizeOptionalJunctionResourceList(value, defaults, allowedResources, knownResources, label) {
+    const normalized = (value === undefined ? defaults : value)
+        .map(normalizeJunctionResourceName)
+        .filter((entry) => entry !== null);
+    const allowedResourceSet = new Set(allowedResources);
+    const knownResourceSet = new Set([...allowedResources, ...knownResources]);
+    const unsupportedResources = normalized.filter((entry) => !knownResourceSet.has(entry));
+    if (unsupportedResources.length > 0) {
+        throw new TypeError(`Junction ${label} resources include unsupported resource(s): ${[...new Set(unsupportedResources)].join(", ")}.`);
+    }
+    const enabledResources = normalized.filter((entry) => allowedResourceSet.has(entry));
+    if (value !== undefined && value.length > 0 && enabledResources.length === 0) {
+        return [...new Set(defaults)];
+    }
+    return [...new Set(enabledResources)];
+}
+function booleanJobField(options = {}) {
+    return {
+        kind: "boolean",
+        ...options,
+    };
+}
+function numberJobField(options = {}) {
+    return {
+        kind: "number",
+        ...options,
+    };
+}
+function stringJobField(options = {}) {
+    return {
+        kind: "string",
+        ...options,
+    };
+}
+function freezeConfiguredDeviceSyncProviderJobDefinitions(definitions) {
+    return Object.freeze(Object.fromEntries(Object.entries(definitions).flatMap(([kind, definition]) => definition
+        ? [
+            [
+                kind,
+                Object.freeze({
+                    payload: Object.freeze(Object.fromEntries(Object.entries(definition.payload).map(([field, spec]) => [
+                        field,
+                        Object.freeze({ ...spec }),
+                    ]))),
+                }),
+            ],
+        ]
+        : [])));
 }
 function defineConfiguredDeviceSyncProviderManifest(input) {
     return Object.freeze({
@@ -437,7 +452,7 @@ function defineConfiguredDeviceSyncProviderManifest(input) {
             ? Object.freeze({ ...input.disallowedSerializableFields })
             : undefined,
         env: freezeDeviceSyncProviderEnvSpec(input.env),
-        jobs: freezeConfiguredDeviceSyncProviderJobDefinitions(input.jobs),
+        jobs: input.jobs,
         serializableFields: Object.freeze({ ...input.serializableFields }),
     });
 }
@@ -453,18 +468,6 @@ function deriveConfiguredDeviceSyncProviderCapabilities(descriptor) {
 function isConfiguredDeviceSyncProviderKey(value) {
     return Object.prototype.hasOwnProperty.call(deviceSyncProviderManifestByKey, value);
 }
-function parseJunctionEnvironment(value) {
-    if (value === "sandbox" || value === "production") {
-        return value;
-    }
-    throw new TypeError("JUNCTION_ENV must be sandbox or production.");
-}
-function parseJunctionRegion(value) {
-    if (value === "us" || value === "eu") {
-        return value;
-    }
-    throw new TypeError("JUNCTION_REGION must be us or eu.");
-}
 function freezeDeviceSyncProviderEnvSpec(env) {
     return Object.freeze({
         configKeys: Object.freeze([...env.configKeys]),
@@ -472,112 +475,6 @@ function freezeDeviceSyncProviderEnvSpec(env) {
         variableKeys: Object.freeze([...env.variableKeys]),
     });
 }
-function freezeConfiguredDeviceSyncProviderJobDefinitions(definitions) {
-    return Object.freeze(Object.fromEntries(Object.entries(definitions).flatMap(([kind, definition]) => definition
-        ? [
-            [
-                kind,
-                Object.freeze({
-                    payload: Object.freeze(Object.fromEntries(Object.entries(definition.payload).map(([field, spec]) => [
-                        field,
-                        Object.freeze({ ...spec }),
-                    ]))),
-                }),
-            ],
-        ]
-        : [])));
-}
-function normalizeConfiguredDeviceSyncJobPayload(provider, kind, payload, context) {
-    const normalizedPayload = normalizeJobPayloadRecord(payload, `${provider} ${kind} ${context} payload`);
-    const manifest = resolveConfiguredDeviceSyncProviderManifest(provider);
-    if (!manifest) {
-        return normalizedPayload;
-    }
-    const definition = manifest.jobs[kind];
-    if (!definition) {
-        throw deviceSyncError({
-            code: "DEVICE_SYNC_JOB_PAYLOAD_INVALID",
-            message: `Device sync provider ${provider} job kind ${kind} is not declared in the provider manifest.`,
-            retryable: false,
-        });
-    }
-    const output = {};
-    for (const key of Object.keys(normalizedPayload)) {
-        if (!Object.prototype.hasOwnProperty.call(definition.payload, key)) {
-            throw deviceSyncError({
-                code: "DEVICE_SYNC_JOB_PAYLOAD_INVALID",
-                message: `Device sync provider ${provider} job ${kind} ${context} payload field ${key} is not declared in the provider manifest.`,
-                retryable: false,
-            });
-        }
-    }
-    for (const [field, spec] of Object.entries(definition.payload)) {
-        const value = normalizedPayload[field];
-        if (value === undefined) {
-            if (spec.required) {
-                throw deviceSyncError({
-                    code: "DEVICE_SYNC_JOB_PAYLOAD_INVALID",
-                    message: `Device sync provider ${provider} job ${kind} ${context} payload field ${field} is required.`,
-                    retryable: false,
-                });
-            }
-            continue;
-        }
-        if (!matchesConfiguredDeviceSyncJobFieldKind(value, spec.kind)) {
-            throw deviceSyncError({
-                code: "DEVICE_SYNC_JOB_PAYLOAD_INVALID",
-                message: `Device sync provider ${provider} job ${kind} ${context} payload field ${field} must be ${describeConfiguredDeviceSyncJobFieldKind(spec.kind)}.`,
-                retryable: false,
-            });
-        }
-        output[field] = spec.kind === "string[]" && Array.isArray(value) ? [...value] : value;
-    }
-    return output;
-}
-function normalizeJobPayloadRecord(payload, context) {
-    if (payload === undefined) {
-        return {};
-    }
-    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-        throw deviceSyncError({
-            code: "DEVICE_SYNC_JOB_PAYLOAD_INVALID",
-            message: `Device sync ${context} must be an object payload.`,
-            retryable: false,
-        });
-    }
-    return { ...payload };
-}
-function matchesConfiguredDeviceSyncJobFieldKind(value, kind) {
-    switch (kind) {
-        case "boolean":
-            return value === true || value === false;
-        case "number":
-            return typeof value === "number" && Number.isFinite(value);
-        case "string":
-            return typeof value === "string";
-        case "string[]":
-            return Array.isArray(value) && value.every((entry) => typeof entry === "string");
-    }
-}
-function describeConfiguredDeviceSyncJobFieldKind(kind) {
-    return kind === "string[]" ? "an array of strings" : `a ${kind}`;
-}
-function pickConfiguredDeviceSyncHostedHintPayload(payload, definition) {
-    const shaped = {};
-    for (const [field, spec] of Object.entries(definition.payload)) {
-        if (!spec.includeInHostedHint || spec.kind === "string[]") {
-            continue;
-        }
-        const value = payload[field];
-        if (spec.kind === "string" && value === "") {
-            continue;
-        }
-        if (matchesConfiguredDeviceSyncJobFieldKind(value, spec.kind)) {
-            shaped[field] = value;
-        }
-    }
-    return shaped;
-}
 function uniqueDeviceSyncProviderEnvKeys(keys) {
     return [...new Set(keys)];
 }