@hansjm10/volt-coding-agent 0.0.0-bootstrap.0 → 0.1.0

package/dist/core/remote/iroh/push.js

@@ -0,0 +1,662 @@
+import { createHash } from "node:crypto";
+export const DEFAULT_IROH_REMOTE_PUSH_RELAY_RETRY_ATTEMPTS = 3;
+export const DEFAULT_IROH_REMOTE_PUSH_RELAY_RETRY_DELAY_MS = 250;
+export const DEFAULT_IROH_REMOTE_PUSH_RELAY_TIMEOUT_MS = 10_000;
+export const DEFAULT_IROH_REMOTE_PUSH_RELAY_URL = "https://us-central1-volt-3fae7.cloudfunctions.net/pushRelay";
+// The deduper lives for the daemon's whole lifetime, so the per-client id set is
+// bounded. Re-marking an evicted id at most re-sends one very old notification.
+const MAX_SENT_EVENT_IDS_PER_CLIENT = 1000;
+export const MAX_IROH_REMOTE_PUSH_TARGET_REVOCATIONS_PER_CLIENT = 8;
+export const MAX_IROH_REMOTE_PUSH_TARGET_REVOCATION_CONCURRENCY = 4;
+const MAX_IROH_REMOTE_PUSH_RELAY_RESPONSE_BYTES = 1024;
+export class IrohRemoteInMemoryPushNotificationDeduper {
+    sentEventIdsByClient = new Map();
+    tryMark(clientNodeId, eventId) {
+        let sentEventIds = this.sentEventIdsByClient.get(clientNodeId);
+        if (!sentEventIds) {
+            sentEventIds = new Set();
+            this.sentEventIdsByClient.set(clientNodeId, sentEventIds);
+        }
+        if (sentEventIds.has(eventId)) {
+            return false;
+        }
+        sentEventIds.add(eventId);
+        // Evict oldest ids (Sets preserve insertion order) once over the cap.
+        while (sentEventIds.size > MAX_SENT_EVENT_IDS_PER_CLIENT) {
+            const oldest = sentEventIds.values().next().value;
+            if (oldest === undefined) {
+                break;
+            }
+            sentEventIds.delete(oldest);
+        }
+        return true;
+    }
+    unmark(clientNodeId, eventId) {
+        this.sentEventIdsByClient.get(clientNodeId)?.delete(eventId);
+    }
+}
+export class IrohRemotePushRelayHttpError extends Error {
+    status;
+    transient;
+    constructor(status, transient, detail) {
+        super(`Push relay request failed with HTTP ${status}${detail ? ` (${detail})` : ""}`);
+        this.name = "IrohRemotePushRelayHttpError";
+        this.status = status;
+        this.transient = transient;
+    }
+}
+const MAX_RELAY_ERROR_DETAIL_LENGTH = 200;
+/** Best-effort extraction of the relay's `{ error, code }` body for audit logs. */
+async function readRelayErrorDetail(response) {
+    try {
+        const body = await readBoundedRelayJson(response);
+        if (typeof body !== "object" || body === null) {
+            return undefined;
+        }
+        const record = body;
+        const parts = [record.error, record.code].filter((part) => typeof part === "string" && part.length > 0);
+        if (parts.length === 0) {
+            return undefined;
+        }
+        return parts.join(": ").slice(0, MAX_RELAY_ERROR_DETAIL_LENGTH);
+    }
+    catch {
+        return undefined;
+    }
+}
+export class IrohRemotePushRelayHttpClient {
+    authToken;
+    baseUrl;
+    fetcher;
+    timeoutMs;
+    constructor(options) {
+        this.authToken = options.authToken;
+        const baseUrl = options.baseUrl ?? DEFAULT_IROH_REMOTE_PUSH_RELAY_URL;
+        this.baseUrl = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+        this.fetcher = options.fetcher ?? ((input, init) => fetch(input, init));
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_IROH_REMOTE_PUSH_RELAY_TIMEOUT_MS;
+    }
+    async sendNotification(request) {
+        return this.sendRelayRequest("v1/notifications", createRelayNotificationBody(request));
+    }
+    async sendLiveActivityUpdate(request) {
+        return this.sendRelayRequest("v1/live-activities", createRelayLiveActivityBody(request));
+    }
+    async revokePushTarget(request) {
+        const response = await this.fetcher(new URL("v1/push-targets/revoke", this.baseUrl).toString(), {
+            body: JSON.stringify(createRelayRevocationBody(request)),
+            headers: this.createHeaders(),
+            method: "POST",
+            signal: AbortSignal.timeout(this.timeoutMs),
+        });
+        if (response.status === 404 || response.status === 410) {
+            return { status: "already_absent" };
+        }
+        if (!response.ok) {
+            throw new IrohRemotePushRelayHttpError(response.status, isTransientHttpStatus(response.status), await readRelayErrorDetail(response));
+        }
+        const body = await readBoundedRelayJson(response);
+        if (body.status === "revoked")
+            return { status: "revoked" };
+        if (body.status === "already_revoked")
+            return { status: "already_absent" };
+        throw new IrohRemotePushRelayHttpError(502, true, "invalid revoke response");
+    }
+    async sendRelayRequest(path, body) {
+        const response = await this.fetcher(new URL(path, this.baseUrl).toString(), {
+            body: JSON.stringify(body),
+            headers: this.createHeaders(),
+            method: "POST",
+            signal: AbortSignal.timeout(this.timeoutMs),
+        });
+        if (response.ok) {
+            return { status: "sent" };
+        }
+        // 404/410: target unknown or disabled. 422: the relay cannot deliver to
+        // this target at all (e.g. a development-environment Live Activity token,
+        // which FCM cannot reach) — treat as invalid so the caller prunes the
+        // registration instead of retrying a permanently undeliverable channel.
+        if (response.status === 404 || response.status === 410 || response.status === 422) {
+            return { status: "invalid_target" };
+        }
+        throw new IrohRemotePushRelayHttpError(response.status, isTransientHttpStatus(response.status), await readRelayErrorDetail(response));
+    }
+    createHeaders() {
+        return {
+            "content-type": "application/json",
+            ...(this.authToken ? { authorization: `Bearer ${this.authToken}` } : {}),
+        };
+    }
+}
+function createRelayNotificationBody(request) {
+    return {
+        pushTargetId: request.pushTargetId,
+        pushTargetAuthToken: request.pushTargetAuthToken,
+        eventId: request.eventId,
+        kind: request.kind,
+        title: request.title,
+        body: request.body,
+        ...(request.workspace === undefined ? {} : { workspace: request.workspace }),
+        data: request.data,
+    };
+}
+function createRelayLiveActivityBody(request) {
+    return {
+        pushTargetId: request.pushTargetId,
+        pushTargetAuthToken: request.pushTargetAuthToken,
+        activityId: request.activityId,
+        activityPushToken: request.activityPushToken,
+        ...(request.tokenEnvironment === undefined ? {} : { tokenEnvironment: request.tokenEnvironment }),
+        eventId: request.eventId,
+        kind: request.kind,
+        contentState: request.contentState,
+        ...(request.activityEvent === undefined ? {} : { activityEvent: request.activityEvent }),
+        ...(request.staleDateEpochSeconds === undefined ? {} : { staleDateEpochSeconds: request.staleDateEpochSeconds }),
+        ...(request.dismissalDateEpochSeconds === undefined
+            ? {}
+            : { dismissalDateEpochSeconds: request.dismissalDateEpochSeconds }),
+    };
+}
+function createRelayRevocationBody(request) {
+    return {
+        pushTargetId: request.pushTargetId,
+        pushTargetAuthToken: request.pushTargetAuthToken,
+    };
+}
+async function readBoundedRelayJson(response) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        return {};
+    const chunks = [];
+    let totalBytes = 0;
+    try {
+        while (true) {
+            const chunk = await reader.read();
+            if (chunk.done)
+                break;
+            totalBytes += chunk.value.byteLength;
+            if (totalBytes > MAX_IROH_REMOTE_PUSH_RELAY_RESPONSE_BYTES) {
+                await reader.cancel();
+                throw new IrohRemotePushRelayHttpError(502, true, "relay response too large");
+            }
+            chunks.push(chunk.value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(totalBytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    try {
+        const parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Best-effort cleanup after local client revocation. Local authority is already
+ * gone before this runs, so relay failures are summarized rather than thrown.
+ * The call count is capped to keep a corrupted or malicious state file from
+ * turning one control request into unbounded outbound work; relay TTL bounds any
+ * skipped or failed credential's remaining lifetime.
+ */
+export async function revokeIrohRemoteClientPushTargets(client, relayClient) {
+    const uniqueTargets = new Map();
+    for (const target of client?.pushTargets ?? []) {
+        if (target.id.length === 0 || target.pushTargetAuthToken.length === 0)
+            continue;
+        uniqueTargets.set(`${target.id}\0${target.pushTargetAuthToken}`, {
+            pushTargetId: target.id,
+            pushTargetAuthToken: target.pushTargetAuthToken,
+        });
+    }
+    const targets = Array.from(uniqueTargets.values());
+    const selectedTargets = targets.slice(0, MAX_IROH_REMOTE_PUSH_TARGET_REVOCATIONS_PER_CLIENT);
+    const summary = {
+        attempted: selectedTargets.length,
+        revoked: 0,
+        alreadyAbsent: 0,
+        failed: 0,
+        skipped: targets.length - selectedTargets.length,
+    };
+    const revokePushTarget = relayClient.revokePushTarget?.bind(relayClient);
+    if (!revokePushTarget) {
+        summary.failed = selectedTargets.length;
+        return summary;
+    }
+    for (let offset = 0; offset < selectedTargets.length; offset += MAX_IROH_REMOTE_PUSH_TARGET_REVOCATION_CONCURRENCY) {
+        const batch = selectedTargets.slice(offset, offset + MAX_IROH_REMOTE_PUSH_TARGET_REVOCATION_CONCURRENCY);
+        const results = await Promise.allSettled(batch.map((target) => revokePushTarget(target)));
+        for (const result of results) {
+            if (result.status === "rejected") {
+                summary.failed += 1;
+            }
+            else if (result.value.status === "revoked") {
+                summary.revoked += 1;
+            }
+            else {
+                summary.alreadyAbsent += 1;
+            }
+        }
+    }
+    return summary;
+}
+export class IrohRemotePushNotificationDispatcher {
+    auditLogger;
+    clientNodeId;
+    deduper;
+    now;
+    relayClient;
+    retryAttempts;
+    retryDelayMs;
+    stateManager;
+    workspace;
+    constructor(options) {
+        this.auditLogger = options.auditLogger;
+        this.clientNodeId = options.clientNodeId;
+        this.deduper = options.deduper ?? new IrohRemoteInMemoryPushNotificationDeduper();
+        this.now = options.now ?? Date.now;
+        this.relayClient = options.relayClient;
+        this.retryAttempts = Math.max(1, Math.trunc(options.retryAttempts ?? DEFAULT_IROH_REMOTE_PUSH_RELAY_RETRY_ATTEMPTS));
+        this.retryDelayMs = Math.max(0, Math.trunc(options.retryDelayMs ?? DEFAULT_IROH_REMOTE_PUSH_RELAY_RETRY_DELAY_MS));
+        this.stateManager = options.stateManager;
+        this.workspace = options.workspace;
+    }
+    async registerPushTarget(args) {
+        const registration = parseRegisterPushTargetArgs(args);
+        try {
+            const now = this.now();
+            const pushTarget = {
+                id: registration.pushTargetId,
+                provider: registration.provider,
+                platform: registration.platform,
+                pushTargetAuthToken: registration.pushTargetAuthToken,
+                ...(registration.relayUrl === undefined ? {} : { relayUrl: registration.relayUrl }),
+                ...(registration.tokenHash === undefined ? {} : { tokenHash: registration.tokenHash }),
+                ...(registration.liveActivity === undefined
+                    ? {}
+                    : {
+                        liveActivity: {
+                            activityId: registration.liveActivity.activityId,
+                            pushToken: registration.liveActivity.pushToken,
+                            ...(registration.liveActivity.tokenHash === undefined
+                                ? {}
+                                : { tokenHash: registration.liveActivity.tokenHash }),
+                            ...(registration.liveActivity.tokenEnvironment === undefined
+                                ? {}
+                                : { tokenEnvironment: registration.liveActivity.tokenEnvironment }),
+                            updatedAt: now,
+                        },
+                    }),
+                enabled: registration.enabled,
+                createdAt: now,
+                updatedAt: now,
+            };
+            const client = await this.stateManager.upsertClientPushTarget(this.clientNodeId, pushTarget);
+            if (!client) {
+                throw new Error("paired client not found");
+            }
+            await this.log({
+                type: "push_target_registered",
+                clientNodeId: this.clientNodeId,
+                workspace: this.workspace,
+                success: true,
+                details: getPushTargetAuditDetails(pushTarget),
+            });
+            return { status: "registered", pushTargetId: registration.pushTargetId };
+        }
+        catch (error) {
+            const errorMessage = toErrorMessage(error);
+            const redactedError = registration.pushTargetAuthToken.length === 0
+                ? errorMessage
+                : errorMessage.split(registration.pushTargetAuthToken).join("[redacted-push-target-auth-token]");
+            await this.log({
+                type: "push_target_registered",
+                clientNodeId: this.clientNodeId,
+                workspace: this.workspace,
+                success: false,
+                error: redactedError,
+                details: {
+                    pushTargetId: registration.pushTargetId,
+                    provider: registration.provider,
+                    platform: registration.platform,
+                    relayUrl: registration.relayUrl,
+                    tokenHash: registration.tokenHash,
+                    liveActivityTokenHash: registration.liveActivity?.tokenHash,
+                    liveActivityTokenEnvironment: registration.liveActivity?.tokenEnvironment,
+                    enabled: registration.enabled,
+                },
+            });
+            throw new Error(redactedError);
+        }
+    }
+    async deliverNotification(notification) {
+        if (!(await this.markDeliveryIntent(notification.eventId, notification.kind))) {
+            return "duplicate";
+        }
+        const client = await this.stateManager.getClient(this.clientNodeId);
+        const pushTarget = selectEnabledPushTarget(client?.pushTargets ?? []);
+        if (!pushTarget) {
+            await this.logPushFallback(notification.eventId, notification.kind, "no_push_target");
+            return "no_push_target";
+        }
+        const relayRequest = createRelayNotificationRequest(pushTarget, notification);
+        try {
+            const relayResult = await this.sendNotificationWithRetry(relayRequest);
+            if (relayResult.status === "invalid_target") {
+                await this.stateManager.disableClientPushTarget(this.clientNodeId, pushTarget.id, this.now());
+                await this.logPushDelivery(pushTarget, notification.eventId, notification.kind, false, "push target is invalid or unregistered");
+                return "invalid_target";
+            }
+            await this.logPushDelivery(pushTarget, notification.eventId, notification.kind, true);
+            return "sent";
+        }
+        catch (error) {
+            // Release the dedup claim so a transient relay failure can be retried on a
+            // later re-emission instead of being permanently suppressed as delivered.
+            this.deduper.unmark(this.clientNodeId, notification.eventId);
+            await this.logPushDelivery(pushTarget, notification.eventId, notification.kind, false, toErrorMessage(error));
+            return "failed";
+        }
+    }
+    async deliverLiveActivityUpdate(update) {
+        if (!(await this.markDeliveryIntent(update.eventId, update.kind))) {
+            return "duplicate";
+        }
+        const client = await this.stateManager.getClient(this.clientNodeId);
+        const registration = selectLiveActivityRegistration(client, update.contentState);
+        const pushTarget = registration ? findRegisteredLiveActivityPushTarget(client, registration) : undefined;
+        if (!registration || !pushTarget?.liveActivity) {
+            await this.logPushFallback(update.eventId, update.kind, "no_live_activity_target");
+            return "no_push_target";
+        }
+        const relayRequest = createRelayLiveActivityRequest(pushTarget, update, registration.activityId);
+        try {
+            const relayResult = await this.sendLiveActivityUpdateWithRetry(relayRequest);
+            if (relayResult.status === "invalid_target") {
+                await this.stateManager.pruneClientLiveActivityDeliveryChannel(this.clientNodeId, registration, this.now());
+                await this.logPushDelivery(pushTarget, update.eventId, update.kind, false, "live activity target is invalid or unregistered", registration.tokenHash);
+                return "invalid_target";
+            }
+            await this.logPushDelivery(pushTarget, update.eventId, update.kind, true, undefined, registration.tokenHash);
+            return "sent";
+        }
+        catch (error) {
+            // Release the dedup claim so a transient relay failure can be retried on a
+            // later re-emission instead of being permanently suppressed as delivered.
+            this.deduper.unmark(this.clientNodeId, update.eventId);
+            await this.logPushDelivery(pushTarget, update.eventId, update.kind, false, toErrorMessage(error), registration.tokenHash);
+            return "failed";
+        }
+    }
+    async markDeliveryIntent(eventId, kind) {
+        if (this.deduper.tryMark(this.clientNodeId, eventId)) {
+            return true;
+        }
+        await this.log({
+            type: "push_notification_deduplicated",
+            clientNodeId: this.clientNodeId,
+            workspace: this.workspace,
+            success: true,
+            details: { eventId, kind },
+        });
+        return false;
+    }
+    async logPushFallback(eventId, kind, reason) {
+        await this.log({
+            type: "push_notification_fallback",
+            clientNodeId: this.clientNodeId,
+            workspace: this.workspace,
+            success: true,
+            details: { eventId, kind, reason },
+        });
+    }
+    async sendNotificationWithRetry(request) {
+        return this.sendWithRetry(() => this.relayClient.sendNotification(request));
+    }
+    async sendLiveActivityUpdateWithRetry(request) {
+        const sendLiveActivityUpdate = this.relayClient.sendLiveActivityUpdate?.bind(this.relayClient);
+        if (!sendLiveActivityUpdate) {
+            throw new Error("push relay does not support live activity updates");
+        }
+        return this.sendWithRetry(() => sendLiveActivityUpdate(request));
+    }
+    async sendWithRetry(send) {
+        let lastError;
+        for (let attempt = 1; attempt <= this.retryAttempts; attempt += 1) {
+            try {
+                return await send();
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt >= this.retryAttempts || !isTransientPushRelayError(error)) {
+                    throw error;
+                }
+                await delay(this.retryDelayMs * attempt);
+            }
+        }
+        throw lastError;
+    }
+    async logPushDelivery(pushTarget, eventId, kind, success, error, deliveredTokenHash) {
+        await this.log({
+            type: "push_notification_delivered",
+            clientNodeId: this.clientNodeId,
+            workspace: this.workspace,
+            success,
+            error,
+            details: {
+                eventId,
+                kind,
+                pushTargetId: pushTarget.id,
+                provider: pushTarget.provider,
+                platform: pushTarget.platform,
+                tokenHash: deliveredTokenHash ?? pushTarget.tokenHash,
+            },
+        });
+    }
+    async log(event) {
+        if (!this.auditLogger) {
+            return;
+        }
+        try {
+            await this.auditLogger.log(event);
+        }
+        catch {
+            // Push relay side effects should not be reinterpreted as RPC failures if audit I/O fails.
+        }
+    }
+}
+export function hashIrohRemotePushToken(token) {
+    return `sha256:${createHash("sha256").update(token, "utf8").digest("base64url")}`;
+}
+export function parseRegisterPushTargetArgs(value) {
+    const args = expectRecord(value, "register_push_target args");
+    return {
+        provider: expectPushProvider(args.provider),
+        platform: expectPushPlatform(args.platform),
+        pushTargetId: expectString(args.pushTargetId, "push target id"),
+        pushTargetAuthToken: expectString(args.pushTargetAuthToken, "push target auth token"),
+        relayUrl: expectOptionalString(args.relayUrl, "push relay URL"),
+        tokenHash: expectOptionalString(args.tokenHash, "push token hash"),
+        liveActivity: parseOptionalLiveActivityRegistration(args.liveActivity, "push liveActivity"),
+        enabled: expectBoolean(args.enabled, "push enabled"),
+    };
+}
+function parseOptionalLiveActivityRegistration(value, label) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const liveActivity = expectRecord(value, label);
+    return {
+        activityId: expectString(liveActivity.activityId, `${label} activityId`),
+        pushToken: expectString(liveActivity.pushToken, `${label} pushToken`),
+        tokenHash: expectOptionalString(liveActivity.tokenHash, `${label} tokenHash`),
+        tokenEnvironment: expectOptionalPushTokenEnvironment(liveActivity.tokenEnvironment, `${label} tokenEnvironment`),
+    };
+}
+function selectEnabledPushTarget(pushTargets) {
+    return pushTargets
+        .filter((target) => target.enabled)
+        .sort((a, b) => b.updatedAt - a.updatedAt || b.createdAt - a.createdAt)[0];
+}
+function createRelayNotificationRequest(pushTarget, notification) {
+    const workspace = getSafeNotificationWorkspace(notification.workspace);
+    return {
+        pushTargetId: pushTarget.id,
+        pushTargetAuthToken: pushTarget.pushTargetAuthToken,
+        eventId: notification.eventId,
+        kind: notification.kind,
+        title: notification.title,
+        body: notification.body,
+        ...(workspace === undefined ? {} : { workspace }),
+        data: {
+            eventId: notification.eventId,
+            kind: notification.kind,
+            ...(notification.sessionId === undefined ? {} : { sessionId: notification.sessionId }),
+            ...(workspace === undefined ? {} : { workspace }),
+        },
+    };
+}
+function getSafeNotificationWorkspace(workspace) {
+    if (workspace === undefined) {
+        return undefined;
+    }
+    const trimmed = workspace.trim();
+    if (trimmed.length === 0 || trimmed.includes("/") || trimmed.includes("\\") || trimmed.includes("\0")) {
+        return undefined;
+    }
+    return trimmed;
+}
+function createRelayLiveActivityRequest(pushTarget, update, activityId = pushTarget.liveActivity?.activityId) {
+    if (!pushTarget.liveActivity) {
+        throw new Error("push target has no live activity token");
+    }
+    if (!activityId) {
+        throw new Error("live activity registration has no activity id");
+    }
+    return {
+        pushTargetId: pushTarget.id,
+        pushTargetAuthToken: pushTarget.pushTargetAuthToken,
+        activityId,
+        activityPushToken: pushTarget.liveActivity.pushToken,
+        ...(pushTarget.liveActivity.tokenEnvironment === undefined
+            ? {}
+            : { tokenEnvironment: pushTarget.liveActivity.tokenEnvironment }),
+        eventId: update.eventId,
+        kind: update.kind,
+        contentState: update.contentState,
+        ...(update.activityEvent === undefined ? {} : { activityEvent: update.activityEvent }),
+        ...(update.staleDateEpochSeconds === undefined ? {} : { staleDateEpochSeconds: update.staleDateEpochSeconds }),
+        ...(update.dismissalDateEpochSeconds === undefined
+            ? {}
+            : { dismissalDateEpochSeconds: update.dismissalDateEpochSeconds }),
+    };
+}
+function getPushTargetAuditDetails(pushTarget) {
+    return {
+        pushTargetId: pushTarget.id,
+        provider: pushTarget.provider,
+        platform: pushTarget.platform,
+        relayUrl: pushTarget.relayUrl,
+        tokenHash: pushTarget.tokenHash,
+        liveActivityTokenHash: pushTarget.liveActivity?.tokenHash,
+        liveActivityTokenEnvironment: pushTarget.liveActivity?.tokenEnvironment,
+        enabled: pushTarget.enabled,
+        createdAt: pushTarget.createdAt,
+        updatedAt: pushTarget.updatedAt,
+    };
+}
+function selectLiveActivityRegistration(client, contentState) {
+    const workspaceName = contentState.workspaceName;
+    const sessionId = contentState.sessionID;
+    if (!workspaceName || !sessionId) {
+        return undefined;
+    }
+    return (client?.liveActivities ?? [])
+        .filter((registration) => {
+        return registration.workspaceName === workspaceName && registration.sessionId === sessionId;
+    })
+        .sort((a, b) => b.updatedAt - a.updatedAt || b.createdAt - a.createdAt)[0];
+}
+function findRegisteredLiveActivityPushTarget(client, registration) {
+    return client?.pushTargets?.find((target) => {
+        return (target.id === registration.pushTargetId &&
+            target.platform === registration.platform &&
+            target.liveActivity?.tokenHash === registration.tokenHash &&
+            target.liveActivity.tokenEnvironment === registration.tokenEnvironment);
+    });
+}
+function isTransientPushRelayError(error) {
+    if (error instanceof IrohRemotePushRelayHttpError) {
+        return error.transient;
+    }
+    return true;
+}
+function isTransientHttpStatus(status) {
+    return status === 408 || status === 409 || status === 425 || status === 429 || status >= 500;
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function expectRecord(value, label) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(`${label} must be an object`);
+    }
+    return value;
+}
+function expectString(value, label) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`${label} must be a non-empty string`);
+    }
+    return value;
+}
+function expectOptionalString(value, label) {
+    if (value === undefined) {
+        return undefined;
+    }
+    return expectString(value, label);
+}
+function expectBoolean(value, label) {
+    if (typeof value !== "boolean") {
+        throw new Error(`${label} must be a boolean`);
+    }
+    return value;
+}
+function expectPushProvider(value) {
+    if (value === "fcm") {
+        return value;
+    }
+    throw new Error("push provider must be fcm");
+}
+function expectPushPlatform(value) {
+    if (value === "ios") {
+        return value;
+    }
+    throw new Error("push platform must be ios");
+}
+function expectOptionalPushTokenEnvironment(value, label) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "development" || value === "production") {
+        return value;
+    }
+    throw new Error(`${label} must be development or production`);
+}
+function delay(ms) {
+    if (ms === 0) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+//# sourceMappingURL=push.js.map