@murphai/murph 1.3.1 → 1.3.2

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

@@ -12,8 +12,8 @@ import { UserClient, } from "@junction-api/sdk/user";
 import { VitalsClient } from "@junction-api/sdk/vitals";
 import { WorkoutsClient } from "@junction-api/sdk/workouts";
 import { resolveJunctionTimeseriesResourcePolicy } from "@murphai/contracts";
-import { resolveJunctionOrigin } from "@murphai/importers/device-providers/junction-origin";
-import { normalizeJunctionProviderSlug, resolveJunctionDeviceConnectRouteByProviderSlug, } from "../config/connect-routes.js";
+import { normalizeJunctionSourceProviderSlug, resolveJunctionOrigin, } from "@murphai/importers/device-providers/junction-origin";
+import { canonicalizeJunctionProviderSlug, normalizeJunctionProviderSlug, resolveJunctionDeviceConnectRouteByProviderSlug, } from "../config/connect-routes.js";
 import { deviceSyncError, isDeviceSyncError } from "../errors.js";
 import { normalizeString } from "../shared.js";
 import { buildProviderApiError as buildProviderApiErrorBase } from "./shared-oauth.js";
@@ -43,6 +43,7 @@ const MAX_COLLECTION_PAGES = 100;
 const MAX_COLLECTION_RECORDS = 25_000;
 export const JUNCTION_MAX_USER_PROVIDERS = 64;
 const MAX_SDK_COMPAT_RESPONSE_BYTES = 32 * 1_024 * 1_024;
+export const JUNCTION_WORKOUT_STREAM_MAX_RESPONSE_BYTES = 8 * 1_024 * 1_024;
 // These summary endpoints declare `start_date`/`end_date` as YYYY-MM-DD dates
 // (not datetimes) in the Junction API reference.
 const JUNCTION_DATE_ONLY_SUMMARY_RESOURCES = new Set(["electrocardiogram", "menstrual_cycle", "sleep_cycle"]);
@@ -100,8 +101,20 @@ export class JunctionClient {
     }
     async createLinkToken(input) {
         const provider = normalizeJunctionProviderSlug(input.provider);
-        const sdkProvider = provider ? requireJunctionSdkProvider(provider) : undefined;
-        const providerFilter = input.providerFilter?.map((candidate) => requireJunctionSdkProvider(normalizeRequiredProviderSlug(candidate)));
+        const providerTransport = provider
+            ? requireJunctionSdkProviderTransport(provider)
+            : undefined;
+        const sdkProvider = providerTransport?.provider;
+        const providerFilterTransports = input.providerFilter?.map((candidate) => requireJunctionSdkProviderTransport(normalizeRequiredProviderSlug(candidate)));
+        const providerFilterRewrite = providerFilterTransports
+            ?.find((candidate) => candidate.providerSlugRewrite)
+            ?.providerSlugRewrite;
+        if (providerFilterRewrite
+            && providerFilterTransports?.some((candidate) => candidate.provider === providerFilterRewrite.from
+                && candidate.providerSlugRewrite === undefined)) {
+            throw new TypeError("Junction provider filters cannot combine a compatibility provider with its legacy transport placeholder.");
+        }
+        const providerFilter = providerFilterTransports?.map((candidate) => candidate.provider);
         const bodyFieldNames = ["user_id", "redirect_url"];
         if (sdkProvider) {
             bodyFieldNames.push("provider");
@@ -112,6 +125,7 @@ export class JunctionClient {
         const payload = await this.requestSdkResource("POST", {
             bodyFieldNames,
             endpointKind: "junction_link_token_create",
+            providerSlugRewrite: providerTransport?.providerSlugRewrite ?? providerFilterRewrite,
             signal: input.signal ?? null,
         }, (clientOptions, requestOptions) => {
             const request = {
@@ -186,8 +200,13 @@ export class JunctionClient {
         if (!userId) {
             throw new TypeError("Junction provider deregistration requires a Junction user id.");
         }
-        await this.requestSdkResource("DELETE", { endpointKind: "junction_user_provider_deregister", signal: input.signal ?? null }, (clientOptions, requestOptions) => new UserClient(clientOptions).deregisterProvider({
-            provider: requireJunctionSdkProvider(providerSlug),
+        const providerTransport = requireJunctionSdkProviderTransport(providerSlug);
+        await this.requestSdkResource("DELETE", {
+            endpointKind: "junction_user_provider_deregister",
+            providerSlugRewrite: providerTransport.providerSlugRewrite,
+            signal: input.signal ?? null,
+        }, (clientOptions, requestOptions) => new UserClient(clientOptions).deregisterProvider({
+            provider: providerTransport.provider,
             userId,
         }, requestOptions));
     }
@@ -203,9 +222,11 @@ export class JunctionClient {
         return this.fetchWindowedCollection({ ...input, dateQueryFormat: resolveJunctionSummaryDateQueryFormat(input) }, extractCollectionRecords, (cursor) => this.requestSummaryPage(input, cursor));
     }
     async listProfileSummary(input) {
-        const provider = optionalJunctionSdkProvider(input.sourceProviderSlug);
+        const providerTransport = optionalJunctionSdkProviderTransport(input.sourceProviderSlug);
+        const provider = providerTransport?.provider;
         const payload = await this.requestSdkResource("GET", {
             endpointKind: "junction_summary_collection",
+            providerSlugRewrite: providerTransport?.providerSlugRewrite,
             queryParameterNames: provider ? ["provider"] : [],
             signal: input.signal ?? null,
             ...(input.collectionWorkLimit
@@ -228,6 +249,9 @@ export class JunctionClient {
         if (policy?.fetchMode === "workout_stream") {
             throw new TypeError("Junction workout_stream uses the dedicated workout stream endpoint.");
         }
+        if (policy?.normalizationMode === "ecg_recording_feature") {
+            throw new TypeError("Junction electrocardiogram_voltage uses its dedicated identity-bound fetch path.");
+        }
         return this.fetchWindowedCollection({
             ...input,
             maxRecords: policy?.maxSamplesPerWindow === undefined
@@ -237,6 +261,29 @@ export class JunctionClient {
             ? (payload, resource) => extractStructurallyCompleteTimeseriesRecords(payload, resource, normalizeSourceSlug(input.sourceProviderSlug))
             : extractTimeseriesRecords, (cursor) => this.requestTimeseriesPage(input, cursor));
     }
+    async listElectrocardiogramVoltage(input) {
+        const recordingId = normalizeString(input.recordingId);
+        const sourceProviderSlug = normalizeJunctionSourceProviderSlug(canonicalizeJunctionProviderSlug(input.sourceProviderSlug));
+        if (!recordingId || !sourceProviderSlug) {
+            throw new TypeError("Junction ECG voltage requires summary recording and source identity.");
+        }
+        const requestInput = {
+            ...input,
+            dateQueryFormat: "datetime",
+            resource: "electrocardiogram_voltage",
+            sourceProviderSlug,
+        };
+        const records = await this.fetchWindowedCollection(requestInput, (payload) => extractBoundElectrocardiogramVoltageRecords(payload, {
+            recordingId,
+            sessionEnd: input.windowEnd,
+            sessionStart: input.windowStart,
+            sourceInstanceId: normalizeString(input.sourceInstanceId),
+            sourceProviderSlug,
+            sourceType: normalizeString(input.sourceType),
+        }), (cursor) => this.requestTimeseriesPage(requestInput, cursor));
+        assertSingleElectrocardiogramCollectionSource(records);
+        return records;
+    }
     async getWorkoutStream(input) {
         const workoutId = normalizeString(input.workoutId);
         if (!workoutId) {
@@ -244,6 +291,7 @@ export class JunctionClient {
         }
         return this.requestSdkResource("GET", {
             endpointKind: "junction_workout_stream",
+            maxResponseBytes: JUNCTION_WORKOUT_STREAM_MAX_RESPONSE_BYTES,
             signal: input.signal ?? null,
             ...(input.collectionWorkLimit
                 ? {
@@ -255,9 +303,11 @@ export class JunctionClient {
             .getByWorkoutId({ workoutId }, requestOptions));
     }
     async introspectResources(input) {
-        const provider = optionalJunctionSdkProvider(input.sourceProviderSlug);
+        const providerTransport = optionalJunctionSdkProviderTransport(input.sourceProviderSlug);
+        const provider = providerTransport?.provider;
         return this.requestSdkResource("GET", {
             endpointKind: "junction_introspect_resources",
+            providerSlugRewrite: providerTransport?.providerSlugRewrite,
             queryParameterNames: ["user_id", "user_limit", ...(provider ? ["provider"] : [])],
             signal: input.signal ?? null,
         }, (clientOptions, requestOptions) => {
@@ -272,9 +322,11 @@ export class JunctionClient {
         });
     }
     async introspectHistoricalPull(input) {
-        const provider = optionalJunctionSdkProvider(input.sourceProviderSlug);
+        const providerTransport = optionalJunctionSdkProviderTransport(input.sourceProviderSlug);
+        const provider = providerTransport?.provider;
         const payload = await this.requestSdkResource("GET", {
             endpointKind: "junction_introspect_historical_pull",
+            providerSlugRewrite: providerTransport?.providerSlugRewrite,
             queryParameterNames: ["user_id", "user_limit", ...(provider ? ["provider"] : [])],
             signal: input.signal ?? null,
         }, (clientOptions, requestOptions) => {
@@ -312,12 +364,14 @@ export class JunctionClient {
             throw new TypeError("Junction historical pull triggers require at least one user id.");
         }
         try {
+            const providerTransport = requireJunctionSdkOAuthProviderTransport(sourceProviderSlug);
             await this.requestSdkResource("POST", {
                 bodyFieldNames: ["provider", "user_ids"],
                 endpointKind: "junction_bulk_trigger_historical_pull",
+                providerSlugRewrite: providerTransport.providerSlugRewrite,
                 signal: input.signal ?? null,
             }, (clientOptions, requestOptions) => new LinkClient(clientOptions).bulkTriggerHistoricalPull({
-                provider: requireJunctionSdkOAuthProvider(sourceProviderSlug),
+                provider: providerTransport.provider,
                 userIds,
             }, requestOptions));
             return { accepted: true, endpointUnavailable: false };
@@ -382,7 +436,8 @@ export class JunctionClient {
     }
     requestSummaryPage(input, cursor) {
         const format = resolveJunctionSummaryDateQueryFormat(input);
-        const provider = optionalJunctionSdkProvider(input.sourceProviderSlug);
+        const providerTransport = optionalJunctionSdkProviderTransport(input.sourceProviderSlug);
+        const provider = providerTransport?.provider;
         const request = {
             userId: input.userId,
             startDate: toDateParameter(input.windowStart, format, "start"),
@@ -399,6 +454,7 @@ export class JunctionClient {
         ];
         return this.requestSdkResource("GET", {
             endpointKind: "junction_summary_collection",
+            providerSlugRewrite: providerTransport?.providerSlugRewrite,
             queryParameterNames,
             signal: input.signal ?? null,
             ...(input.collectionWorkLimit
@@ -425,7 +481,8 @@ export class JunctionClient {
         });
     }
     requestTimeseriesPage(input, cursor) {
-        const provider = optionalJunctionSdkProvider(input.sourceProviderSlug);
+        const providerTransport = optionalJunctionSdkProviderTransport(input.sourceProviderSlug);
+        const provider = providerTransport?.provider;
         const request = {
             userId: input.userId,
             startDate: toDateParameter(input.windowStart, input.dateQueryFormat ?? "datetime", "start"),
@@ -445,8 +502,15 @@ export class JunctionClient {
         ];
         return this.requestSdkResource("GET", {
             endpointKind: "junction_timeseries_collection",
+            providerSlugRewrite: providerTransport?.providerSlugRewrite,
             queryParameterNames,
             signal: input.signal ?? null,
+            ...(input.resource === "electrocardiogram_voltage" && input.collectionWorkLimit
+                ? {
+                    maxAttempts: input.collectionWorkLimit.maxAttemptsPerPage,
+                    timeoutMs: input.collectionWorkLimit.requestTimeoutMs,
+                }
+                : {}),
         }, (clientOptions, requestOptions) => {
             const client = new VitalsClient(clientOptions);
             switch (input.resource) {
@@ -527,8 +591,9 @@ export class JunctionClient {
             let capturedResponse = null;
             let observedOptionalNotFound = false;
             const sdkFetch = async (input, init) => {
-                const response = await this.fetchImpl(input, {
-                    ...init,
+                const rewrittenRequest = rewriteJunctionSdkProviderRequest(input, init, options.providerSlugRewrite);
+                const response = await this.fetchImpl(rewrittenRequest.input, {
+                    ...rewrittenRequest.init,
                     signal: requestAbort.signal,
                 });
                 if (options.optional404 && response.status === 404) {
@@ -543,13 +608,14 @@ export class JunctionClient {
                 if (!response.body) {
                     return response;
                 }
-                if (junctionSdkResponseExceedsDeclaredLimit(response)) {
+                const maxResponseBytes = options.maxResponseBytes ?? MAX_SDK_COMPAT_RESPONSE_BYTES;
+                if (junctionSdkResponseExceedsDeclaredLimit(response, maxResponseBytes)) {
                     await response.body.cancel().catch(() => undefined);
                     throw junctionSdkResponseTooLargeError();
                 }
                 const capture = createJunctionSdkResponseCapture(response);
                 capturedResponse = capture;
-                return new Response(createJunctionSdkBoundedBodyStream(response.body, capture), {
+                return new Response(createJunctionSdkBoundedBodyStream(response.body, capture, maxResponseBytes), {
                     headers: response.headers,
                     status: response.status,
                     statusText: response.statusText,
@@ -693,7 +759,7 @@ function createJunctionSdkResponseCapture(response) {
         totalBytes: 0,
     };
 }
-function createJunctionSdkBoundedBodyStream(body, capture) {
+function createJunctionSdkBoundedBodyStream(body, capture, maxResponseBytes) {
     const reader = body.getReader();
     return new ReadableStream({
         async pull(controller) {
@@ -706,7 +772,7 @@ function createJunctionSdkBoundedBodyStream(body, capture) {
             }
             const chunk = value;
             capture.totalBytes += chunk.byteLength;
-            if (capture.totalBytes > MAX_SDK_COMPAT_RESPONSE_BYTES) {
+            if (capture.totalBytes > maxResponseBytes) {
                 capture.exceededLimit = true;
                 capture.chunks = [];
                 const error = junctionSdkResponseTooLargeError();
@@ -724,13 +790,13 @@ function createJunctionSdkBoundedBodyStream(body, capture) {
         },
     });
 }
-function junctionSdkResponseExceedsDeclaredLimit(response) {
+function junctionSdkResponseExceedsDeclaredLimit(response, maxResponseBytes) {
     const contentLength = response.headers.get("content-length");
     if (contentLength === null || !/^\d+$/u.test(contentLength.trim())) {
         return false;
     }
     const parsedLength = Number(contentLength);
-    return Number.isSafeInteger(parsedLength) && parsedLength > MAX_SDK_COMPAT_RESPONSE_BYTES;
+    return Number.isSafeInteger(parsedLength) && parsedLength > maxResponseBytes;
 }
 function junctionSdkResponseTooLargeError() {
     return deviceSyncError({
@@ -894,6 +960,47 @@ function normalizeJunctionRefreshTimeoutSeconds(value) {
     }
     return Math.max(5, Math.min(60, Math.trunc(value)));
 }
+function rewriteJunctionSdkProviderRequest(input, init, rewrite) {
+    if (!rewrite) {
+        return { init, input };
+    }
+    const url = new URL(input instanceof Request ? input.url : input.toString());
+    if (url.searchParams.get("provider") === rewrite.from) {
+        url.searchParams.set("provider", rewrite.to);
+    }
+    url.pathname = url.pathname
+        .split("/")
+        .map((segment) => segment === rewrite.from ? rewrite.to : segment)
+        .join("/");
+    let body = init?.body;
+    if (typeof body === "string") {
+        try {
+            const parsed = readPlainObject(JSON.parse(body));
+            if (parsed) {
+                const filterOnProviders = Array.isArray(parsed.filter_on_providers)
+                    ? parsed.filter_on_providers.map((provider) => provider === rewrite.from ? rewrite.to : provider)
+                    : parsed.filter_on_providers;
+                if (parsed.provider === rewrite.from
+                    || filterOnProviders !== parsed.filter_on_providers) {
+                    body = JSON.stringify({
+                        ...parsed,
+                        ...(parsed.provider === rewrite.from
+                            ? { provider: rewrite.to }
+                            : {}),
+                        ...(filterOnProviders === undefined ? {} : { filter_on_providers: filterOnProviders }),
+                    });
+                }
+            }
+        }
+        catch {
+            // The generated SDK owns body validation; leave non-JSON bodies intact.
+        }
+    }
+    return {
+        init: body === init?.body ? init : { ...init, body },
+        input: input instanceof Request ? new Request(url, input) : url,
+    };
+}
 function normalizeRequiredProviderSlug(value) {
     const provider = normalizeJunctionProviderSlug(value);
     if (!provider) {
@@ -901,9 +1008,27 @@ function normalizeRequiredProviderSlug(value) {
     }
     return provider;
 }
-function optionalJunctionSdkProvider(value) {
+function optionalJunctionSdkProviderTransport(value) {
     const normalized = normalizeJunctionProviderSlug(value);
-    return normalized ? requireJunctionSdkProvider(normalized) : undefined;
+    return normalized ? requireJunctionSdkProviderTransport(normalized) : undefined;
+}
+function requireJunctionSdkProviderTransport(value) {
+    if (value === "google_health") {
+        return {
+            provider: "fitbit",
+            providerSlugRewrite: { from: "fitbit", to: value },
+        };
+    }
+    return { provider: requireJunctionSdkProvider(value) };
+}
+function requireJunctionSdkOAuthProviderTransport(value) {
+    if (value === "google_health") {
+        return {
+            provider: "fitbit",
+            providerSlugRewrite: { from: "fitbit", to: value },
+        };
+    }
+    return { provider: requireJunctionSdkOAuthProvider(value) };
 }
 function requireJunctionSdkProvider(value) {
     const route = resolveJunctionDeviceConnectRouteByProviderSlug(value);
@@ -1222,15 +1347,134 @@ function extractTimeseriesRecords(payload, resource) {
     const groupedRecords = flattenGroupedTimeseries(resource, payload);
     return groupedRecords ?? extractCollectionRecords(payload, resource);
 }
+function extractBoundElectrocardiogramVoltageRecords(payload, identity) {
+    const envelope = readPlainObject(payload);
+    const groups = readPlainObject(envelope?.groups);
+    if (!groups) {
+        throw junctionElectrocardiogramBindingError("group_envelope_invalid");
+    }
+    const sessionStartMs = Date.parse(identity.sessionStart);
+    const sessionEndMs = Date.parse(identity.sessionEnd);
+    if (!Number.isFinite(sessionStartMs)
+        || !Number.isFinite(sessionEndMs)
+        || sessionEndMs < sessionStartMs) {
+        throw new TypeError("Junction ECG summary window was invalid.");
+    }
+    const records = [];
+    let matchingGroupCount = 0;
+    for (const [sourceSlug, rawGroups] of Object.entries(groups)) {
+        if (!Array.isArray(rawGroups)) {
+            throw junctionElectrocardiogramBindingError("group_collection_invalid");
+        }
+        for (const rawGroup of rawGroups) {
+            const group = readPlainObject(rawGroup);
+            if (!group || !Array.isArray(group.data)) {
+                throw junctionElectrocardiogramBindingError("group_invalid");
+            }
+            const unresolvedOrigin = resolveJunctionOrigin(group, {
+                groupedSourceSlug: sourceSlug,
+            });
+            const canonicalSourceProviderSlug = canonicalizeJunctionProviderSlug(unresolvedOrigin.sourceProviderSlug);
+            const origin = resolveJunctionOrigin({
+                ...group,
+                sourceProviderSlug: canonicalSourceProviderSlug
+                    ?? unresolvedOrigin.sourceProviderSlug,
+            }, {
+                groupedSourceSlug: canonicalSourceProviderSlug ?? sourceSlug,
+            });
+            if (normalizeJunctionSourceProviderSlug(origin.sourceProviderSlug)
+                !== identity.sourceProviderSlug) {
+                continue;
+            }
+            if (identity.sourceInstanceId
+                && origin.sourceInstanceId !== identity.sourceInstanceId) {
+                continue;
+            }
+            if (identity.sourceType && origin.sourceType !== identity.sourceType) {
+                continue;
+            }
+            matchingGroupCount += 1;
+            if (matchingGroupCount > 1) {
+                throw junctionElectrocardiogramBindingError("group_ambiguous");
+            }
+            const groupId = firstDefinedString(group, [
+                "id",
+                "recordingId",
+                "recording_id",
+            ]);
+            if (groupId && groupId !== identity.recordingId) {
+                throw junctionElectrocardiogramBindingError("group_identity_conflict");
+            }
+            for (const rawSample of group.data) {
+                const sample = readPlainObject(rawSample);
+                if (!sample) {
+                    throw junctionElectrocardiogramBindingError("sample_invalid");
+                }
+                const sampleRecordingId = firstDefinedString(sample, [
+                    "recordingId",
+                    "recording_id",
+                ]);
+                if (sampleRecordingId && sampleRecordingId !== identity.recordingId) {
+                    throw junctionElectrocardiogramBindingError("sample_identity_conflict");
+                }
+                const sampleTimestamp = firstDefinedValue(sample, ["timestamp"]);
+                const sampleTimestampMs = sampleTimestamp instanceof Date
+                    ? sampleTimestamp.getTime()
+                    : typeof sampleTimestamp === "string"
+                        ? Date.parse(sampleTimestamp)
+                        : Number.NaN;
+                if (!Number.isFinite(sampleTimestampMs)
+                    || sampleTimestampMs < sessionStartMs
+                    || sampleTimestampMs > sessionEndMs) {
+                    throw junctionElectrocardiogramBindingError("sample_outside_summary_window");
+                }
+                records.push(stripUndefinedRecord({
+                    ...sample,
+                    // Junction documents the numeric sample `id` as deprecated. It is
+                    // not recording identity and must not escape this transient buffer.
+                    id: undefined,
+                    junctionGroupId: identity.recordingId,
+                    junctionResource: "electrocardiogram_voltage",
+                    sourceInstanceId: identity.sourceInstanceId ?? origin.sourceInstanceId,
+                    sourceProviderSlug: identity.sourceProviderSlug,
+                    sourceType: identity.sourceType ?? origin.sourceType,
+                    timestamp: new Date(sampleTimestampMs).toISOString(),
+                }));
+            }
+        }
+    }
+    return records;
+}
+function assertSingleElectrocardiogramCollectionSource(records) {
+    let collectionSource = null;
+    for (const rawRecord of records) {
+        const record = readPlainObject(rawRecord);
+        if (!record) {
+            throw junctionElectrocardiogramBindingError("sample_invalid");
+        }
+        const source = JSON.stringify([
+            normalizeString(record.sourceProviderSlug),
+            normalizeString(record.sourceType),
+            normalizeString(record.sourceInstanceId),
+        ]);
+        collectionSource ??= source;
+        if (source !== collectionSource) {
+            throw junctionElectrocardiogramBindingError("collection_source_ambiguous");
+        }
+    }
+}
 function extractStructurallyCompleteTimeseriesRecords(payload, resource, requestedSourceProviderSlug) {
     const groupedRecords = flattenGroupedTimeseries(resource, payload, {
         strict: true,
     });
-    const records = groupedRecords ?? extractCollectionRecords(payload, resource);
-    if (groupedRecords === null
-        && (!payload || typeof payload !== "object")) {
+    // A structurally complete collection requires grouped proof. Generic and
+    // legacy envelopes (arrays, data/results wrappers, resource-keyed bodies,
+    // raw SDK-parse fallbacks) stay parseable for ordinary ingestion but can
+    // never certify a complete source day.
+    if (groupedRecords === null) {
         throw incompleteJunctionCalendarCollectionError();
     }
+    const records = groupedRecords;
     for (const record of records) {
         const entry = readPlainObject(record);
         const sourceProviderSlug = entry
@@ -1260,27 +1504,25 @@ function flattenGroupedTimeseries(resource, payload, options = {}) {
         if (options.strict && (rawGroups === undefined || rawGroups === null)) {
             throw incompleteJunctionCalendarCollectionError();
         }
+        // A complete collection proof requires real arrays: a schema-drifted
+        // singleton object must fail retryably rather than certify the day.
+        if (options.strict && !Array.isArray(rawGroups)) {
+            throw incompleteJunctionCalendarCollectionError();
+        }
         for (const rawGroup of asArray(rawGroups)) {
             const group = readPlainObject(rawGroup);
             if (!group) {
                 if (options.strict) {
                     throw incompleteJunctionCalendarCollectionError();
                 }
-                if (resource === "electrocardiogram_voltage") {
-                    throw new TypeError("Junction ECG group must be an object.");
-                }
                 continue;
             }
             if (options.strict
                 && (!("data" in group) || group.data === undefined || group.data === null)) {
                 throw incompleteJunctionCalendarCollectionError();
             }
-            const groupId = firstDefinedString(group, ["id", "recordingId", "recording_id"]);
-            if (resource === "electrocardiogram_voltage" && !groupId) {
-                throw new TypeError("Junction ECG group lacked a stable recording id.");
-            }
-            if (resource === "electrocardiogram_voltage" && !Array.isArray(group.data)) {
-                throw new TypeError("Junction ECG group data must be an array.");
+            if (options.strict && !Array.isArray(group.data)) {
+                throw incompleteJunctionCalendarCollectionError();
             }
             for (const rawSample of asArray(group.data)) {
                 const sample = readPlainObject(rawSample);
@@ -1288,17 +1530,8 @@ function flattenGroupedTimeseries(resource, payload, options = {}) {
                     if (options.strict) {
                         throw incompleteJunctionCalendarCollectionError();
                     }
-                    if (resource === "electrocardiogram_voltage") {
-                        throw new TypeError("Junction ECG sample must be an object.");
-                    }
                     continue;
                 }
-                const sampleId = firstDefinedString(sample, ["recordingId", "recording_id"]);
-                if (resource === "electrocardiogram_voltage"
-                    && sampleId
-                    && sampleId !== groupId) {
-                    throw new TypeError("Junction ECG sample conflicted with its group recording id.");
-                }
                 const origin = resolveJunctionOrigin(sample, {
                     ...group,
                     groupedSourceSlug: normalizedGroupedSourceSlug ?? sourceSlug,
@@ -1310,9 +1543,6 @@ function flattenGroupedTimeseries(resource, payload, options = {}) {
                 records.push(stripUndefinedRecord({
                     ...sample,
                     sourceProviderSlug: sourceProviderSlug ?? undefined,
-                    junctionGroupId: resource === "electrocardiogram_voltage"
-                        ? groupId
-                        : undefined,
                     sourceType: origin.sourceType,
                     sourceInstanceId: origin.sourceInstanceId,
                     junctionResource: resource,
@@ -1330,6 +1560,15 @@ function incompleteJunctionCalendarCollectionError() {
         httpStatus: 502,
     });
 }
+function junctionElectrocardiogramBindingError(reason) {
+    return deviceSyncError({
+        code: "JUNCTION_ECG_RECORDING_BINDING_INCOMPLETE",
+        details: { reason },
+        message: "Junction ECG summary and voltage response were inconsistent.",
+        retryable: true,
+        httpStatus: 502,
+    });
+}
 function firstDefinedValue(record, keys) {
     for (const key of keys) {
         if (record[key] !== undefined && record[key] !== null) {