@vallum/standards 0.0.0-prerelease

package/dist/a2aPush.js

@@ -0,0 +1,608 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { isIP } from "node:net";
+import { dirname } from "node:path";
+import { A2A_TASK_MEDIA_TYPE, A2A_TASK_PROTOCOL_VERSION, redactA2ATaskForLog, } from "./a2aTask.js";
+export class A2APushNotificationError extends Error {
+    code;
+    status;
+    constructor(code, message, status = 400) {
+        super(message);
+        this.name = "A2APushNotificationError";
+        this.code = code;
+        this.status = status;
+    }
+}
+export class LocalA2APushNotificationStore {
+    #configs = new Map();
+    put(config) {
+        const taskConfigs = this.#configs.get(config.taskId) ?? new Map();
+        taskConfigs.set(config.id, clone(config));
+        this.#configs.set(config.taskId, taskConfigs);
+        return clone(config);
+    }
+    get(taskId, id) {
+        const config = this.#configs.get(taskId)?.get(id);
+        return config ? clone(config) : undefined;
+    }
+    list(taskId, pageSize) {
+        const configs = [...(this.#configs.get(taskId)?.values() ?? [])]
+            .sort((left, right) => left.createdAt.localeCompare(right.createdAt))
+            .slice(0, pageSize ?? Number.POSITIVE_INFINITY)
+            .map((config) => clone(config));
+        return { configs };
+    }
+    delete(taskId, id) {
+        const taskConfigs = this.#configs.get(taskId);
+        if (!taskConfigs)
+            return false;
+        const deleted = taskConfigs.delete(id);
+        if (taskConfigs.size === 0)
+            this.#configs.delete(taskId);
+        return deleted;
+    }
+}
+export class LocalA2APushNotificationAttemptStore {
+    #attempts = [];
+    record(attempt) {
+        this.#attempts.push(clone(attempt));
+    }
+    list() {
+        return this.#attempts.map((attempt) => clone(attempt));
+    }
+}
+export class JsonlA2APushNotificationAttemptStore {
+    #filePath;
+    constructor(filePath) {
+        if (typeof filePath !== "string" || filePath.trim() === "") {
+            throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", "A2A push attempt store path is required.");
+        }
+        this.#filePath = filePath;
+        mkdirSync(dirname(filePath), { recursive: true });
+    }
+    record(attempt) {
+        appendFileSync(this.#filePath, `${JSON.stringify(sanitizePushAttempt(attempt))}\n`, "utf8");
+    }
+    list() {
+        if (!existsSync(this.#filePath))
+            return [];
+        const raw = readFileSync(this.#filePath, "utf8");
+        if (raw.trim() === "")
+            return [];
+        return raw.split(/\n/u)
+            .filter((line) => line.trim() !== "")
+            .map((line) => {
+            try {
+                return sanitizePushAttempt(JSON.parse(line));
+            }
+            catch {
+                throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", "A2A push attempt store JSONL is invalid.");
+            }
+        });
+    }
+}
+export class JsonFileA2APushNotificationDeliveryQueue {
+    #filePath;
+    constructor(filePath) {
+        if (typeof filePath !== "string" || filePath.trim() === "") {
+            throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", "A2A push delivery queue path is required.");
+        }
+        this.#filePath = filePath;
+        mkdirSync(dirname(filePath), { recursive: true });
+        if (!existsSync(filePath))
+            this.#write([]);
+    }
+    enqueue(request, options = {}) {
+        const entries = this.#read();
+        const entry = sanitizeQueueEntry({
+            id: options.id ?? `push_delivery_${crypto.randomUUID()}`,
+            enqueuedAt: (options.enqueuedAt ?? new Date()).toISOString(),
+            status: "queued",
+            request,
+        });
+        entries.push(entry);
+        this.#write(entries);
+        return clone(entry);
+    }
+    list() {
+        return this.#read().map((entry) => clone(entry));
+    }
+    claim(options = {}) {
+        const entries = this.#read();
+        const index = entries.findIndex((entry) => entry.status === "queued");
+        if (index < 0)
+            return undefined;
+        const claimed = sanitizeQueueEntry({
+            ...entries[index],
+            status: "claimed",
+            claimedAt: (options.now ?? new Date()).toISOString(),
+        });
+        entries[index] = claimed;
+        this.#write(entries);
+        return clone(claimed);
+    }
+    complete(id, options = {}) {
+        const entries = this.#read();
+        const index = entries.findIndex((entry) => entry.id === id && entry.status !== "completed");
+        if (index < 0)
+            return false;
+        entries[index] = sanitizeQueueEntry({
+            ...entries[index],
+            status: "completed",
+            completedAt: (options.now ?? new Date()).toISOString(),
+        });
+        this.#write(entries);
+        return true;
+    }
+    fail(id, options = {}) {
+        const entries = this.#read();
+        const index = entries.findIndex((entry) => entry.id === id && entry.status !== "completed" && entry.status !== "failed");
+        if (index < 0)
+            return false;
+        entries[index] = sanitizeQueueEntry({
+            ...entries[index],
+            status: "failed",
+            failedAt: (options.now ?? new Date()).toISOString(),
+        });
+        this.#write(entries);
+        return true;
+    }
+    #read() {
+        if (!existsSync(this.#filePath))
+            return [];
+        const raw = readFileSync(this.#filePath, "utf8");
+        if (raw.trim() === "")
+            return [];
+        try {
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed)) {
+                throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", "A2A push delivery queue JSON is invalid.");
+            }
+            return parsed.map((entry) => sanitizeQueueEntry(entry));
+        }
+        catch (error) {
+            if (error instanceof A2APushNotificationError)
+                throw error;
+            throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", "A2A push delivery queue JSON is invalid.");
+        }
+    }
+    #write(entries) {
+        const sanitized = entries.map((entry) => sanitizeQueueEntry(entry));
+        writeFileSync(this.#filePath, `${JSON.stringify(sanitized, null, 2)}\n`, "utf8");
+    }
+}
+export function createA2APushNotificationConfig(options) {
+    const config = parsePushNotificationConfig(options.taskId, options.value, {
+        allowedCallbackHosts: options.allowedCallbackHosts,
+    });
+    return options.store.put({
+        ...config,
+        id: config.id ?? `push_${crypto.randomUUID()}`,
+        taskId: options.taskId,
+        createdAt: (options.now ?? new Date()).toISOString(),
+    });
+}
+export function getA2APushNotificationConfig(options) {
+    const config = options.store.get(options.taskId, options.id);
+    if (!config) {
+        throw new A2APushNotificationError("A2A_PUSH_CONFIG_NOT_FOUND", "A2A push notification config was not found.", 404);
+    }
+    return config;
+}
+export function listA2APushNotificationConfigs(options) {
+    return options.store.list(options.taskId, options.pageSize);
+}
+export function deleteA2APushNotificationConfig(options) {
+    return {
+        taskId: options.taskId,
+        id: options.id,
+        deleted: options.store.delete(options.taskId, options.id),
+    };
+}
+export async function deliverA2APushNotifications(options) {
+    const configs = options.store.list(options.task.id).configs;
+    const attempts = [];
+    const maxAttempts = normalizeMaxAttempts(options.maxAttempts);
+    const retryDelayMs = normalizeRetryDelayMs(options.retryDelayMs);
+    const now = options.now ?? (() => new Date());
+    for (const config of configs) {
+        const request = buildA2APushNotificationDeliveryRequest(config, options.task);
+        if (!options.transport) {
+            const attempt = {
+                configId: config.id,
+                taskId: config.taskId,
+                url: config.url,
+                attemptNumber: 1,
+                observedAt: now().toISOString(),
+                status: "skipped",
+                errorCode: "A2A_PUSH_TRANSPORT_UNCONFIGURED",
+            };
+            recordPushAttempt(attempt, attempts, options.attemptStore);
+            continue;
+        }
+        for (let attemptNumber = 1; attemptNumber <= maxAttempts; attemptNumber += 1) {
+            try {
+                const response = await options.transport(request);
+                const delivered = response.status >= 200 && response.status <= 299;
+                const observedAt = now();
+                const attempt = {
+                    configId: config.id,
+                    taskId: config.taskId,
+                    url: config.url,
+                    attemptNumber,
+                    observedAt: observedAt.toISOString(),
+                    status: delivered ? "delivered" : "failed",
+                    httpStatus: response.status,
+                    ...(delivered ? {} : {
+                        errorCode: "A2A_PUSH_TRANSPORT_FAILED",
+                        ...(attemptNumber < maxAttempts ? { nextRetryAt: addMilliseconds(observedAt, retryDelayMs).toISOString() } : {}),
+                    }),
+                };
+                recordPushAttempt(attempt, attempts, options.attemptStore);
+                if (delivered)
+                    break;
+            }
+            catch {
+                const observedAt = now();
+                const attempt = {
+                    configId: config.id,
+                    taskId: config.taskId,
+                    url: config.url,
+                    attemptNumber,
+                    observedAt: observedAt.toISOString(),
+                    status: "failed",
+                    errorCode: "A2A_PUSH_TRANSPORT_FAILED",
+                    ...(attemptNumber < maxAttempts ? { nextRetryAt: addMilliseconds(observedAt, retryDelayMs).toISOString() } : {}),
+                };
+                recordPushAttempt(attempt, attempts, options.attemptStore);
+            }
+        }
+    }
+    return { attempts };
+}
+export function queueA2APushNotificationDeliveries(options) {
+    const configs = options.store.list(options.task.id).configs;
+    const entries = configs.map((config) => options.queue.enqueue(buildA2APushNotificationDeliveryRequest(config, options.task), { enqueuedAt: (options.now ?? (() => new Date()))() }));
+    return { entries };
+}
+export async function processNextA2APushNotificationDelivery(options) {
+    const observedAt = (options.now ?? (() => new Date()))();
+    const entry = options.queue.claim({ now: observedAt });
+    if (!entry)
+        return { status: "empty" };
+    try {
+        const response = await options.transport(entry.request);
+        const delivered = response.status >= 200 && response.status <= 299;
+        const attempt = {
+            configId: entry.request.config.id,
+            taskId: entry.request.config.taskId,
+            url: entry.request.url,
+            attemptNumber: 1,
+            observedAt: observedAt.toISOString(),
+            status: delivered ? "delivered" : "failed",
+            httpStatus: response.status,
+            ...(delivered ? {} : { errorCode: "A2A_PUSH_TRANSPORT_FAILED" }),
+        };
+        options.attemptStore?.record(attempt);
+        if (delivered) {
+            options.queue.complete(entry.id, { now: observedAt });
+            return { status: "delivered", entry: options.queue.list().find((candidate) => candidate.id === entry.id), attempt };
+        }
+        options.queue.fail(entry.id, { now: observedAt });
+        return { status: "failed", entry: options.queue.list().find((candidate) => candidate.id === entry.id), attempt };
+    }
+    catch {
+        const attempt = {
+            configId: entry.request.config.id,
+            taskId: entry.request.config.taskId,
+            url: entry.request.url,
+            attemptNumber: 1,
+            observedAt: observedAt.toISOString(),
+            status: "failed",
+            errorCode: "A2A_PUSH_TRANSPORT_FAILED",
+        };
+        options.attemptStore?.record(attempt);
+        options.queue.fail(entry.id, { now: observedAt });
+        return { status: "failed", entry: options.queue.list().find((candidate) => candidate.id === entry.id), attempt };
+    }
+}
+export function buildA2APushNotificationDeliveryRequest(config, task) {
+    const body = {
+        kind: "task",
+        task: redactA2ATaskForLog(task),
+    };
+    return {
+        method: "POST",
+        url: config.url,
+        headers: {
+            "content-type": `${A2A_TASK_MEDIA_TYPE}; charset=utf-8`,
+            "a2a-version": A2A_TASK_PROTOCOL_VERSION,
+        },
+        body,
+        json: `${JSON.stringify(body)}\n`,
+        config: clone(config),
+    };
+}
+export function createA2APushHttpTransport(options = {}) {
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (typeof fetchImpl !== "function") {
+        throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", "A2A push HTTP transport requires fetch support.");
+    }
+    const timeoutMs = normalizeTimeoutMs(options.timeoutMs);
+    return async (request) => {
+        const url = safeWebhookUrl(request.url, {
+            allowedCallbackHosts: options.allowedCallbackHosts,
+        });
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const response = await fetchImpl(url, {
+                method: request.method,
+                headers: publicDeliveryHeaders(request.headers),
+                body: request.json,
+                redirect: "manual",
+                signal: controller.signal,
+            });
+            return { status: response.status };
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    };
+}
+function parsePushNotificationConfig(taskId, value, options = {}) {
+    if (!isRecord(value)) {
+        throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", "A2A push notification config must be an object.");
+    }
+    const bodyTaskId = optionalString(value.taskId, "$.taskId");
+    if (bodyTaskId !== undefined && bodyTaskId !== taskId) {
+        throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", "A2A push notification task id must match the route.");
+    }
+    if (typeof value.token === "string" && value.token.trim() !== "") {
+        throw new A2APushNotificationError("A2A_PUSH_CREDENTIAL_STORAGE_UNSUPPORTED", "A2A local push notification config does not store webhook tokens.");
+    }
+    const authentication = parseAuthentication(value.authentication);
+    const id = optionalString(value.id, "$.id");
+    const tenant = optionalString(value.tenant, "$.tenant");
+    return {
+        ...(id ? { id } : {}),
+        url: safeWebhookUrl(value.url, {
+            allowedCallbackHosts: options.allowedCallbackHosts,
+        }),
+        ...(tenant ? { tenant } : {}),
+        ...(authentication ? { authentication } : {}),
+    };
+}
+function parseAuthentication(value) {
+    if (value === undefined)
+        return undefined;
+    if (!isRecord(value)) {
+        throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", "A2A push notification authentication must be an object.");
+    }
+    if (typeof value.credentials === "string" && value.credentials.trim() !== "") {
+        throw new A2APushNotificationError("A2A_PUSH_CREDENTIAL_STORAGE_UNSUPPORTED", "A2A local push notification config does not store webhook credentials.");
+    }
+    const schemes = Array.isArray(value.schemes)
+        ? value.schemes
+        : typeof value.scheme === "string"
+            ? [value.scheme]
+            : [];
+    if (schemes.length === 0) {
+        throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", "A2A push notification authentication schemes are required when authentication is present.");
+    }
+    const normalized = schemes.map((scheme, index) => {
+        if (typeof scheme !== "string" || scheme.trim() === "") {
+            throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", `A2A push notification authentication scheme ${index} is invalid.`);
+        }
+        return scheme.trim();
+    });
+    return { schemes: normalized };
+}
+function safeWebhookUrl(value, options = {}) {
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", "A2A push notification URL is required.");
+    }
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new A2APushNotificationError("A2A_PUSH_URL_UNSAFE", "A2A push notification URL must be a valid HTTPS URL.");
+    }
+    if (parsed.protocol !== "https:"
+        || parsed.username
+        || parsed.password
+        || parsed.search
+        || parsed.hash
+        || isUnsafeWebhookHost(parsed.hostname)) {
+        throw new A2APushNotificationError("A2A_PUSH_URL_UNSAFE", "A2A push notification URL must be public HTTPS without credentials, query strings, or fragments.");
+    }
+    if (!isAllowedCallbackHost(parsed.hostname, options.allowedCallbackHosts)) {
+        throw new A2APushNotificationError("A2A_PUSH_URL_UNSAFE", "A2A push notification URL host is not on the configured allowlist.");
+    }
+    return parsed.toString();
+}
+function optionalString(value, path) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", `${path} must be a non-empty string when present.`);
+    }
+    return value.trim();
+}
+function normalizeTimeoutMs(value) {
+    if (value === undefined)
+        return 5000;
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", "A2A push HTTP transport timeout must be positive.");
+    }
+    return Math.floor(value);
+}
+function normalizeMaxAttempts(value) {
+    if (value === undefined)
+        return 1;
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", "A2A push delivery max attempts must be positive.");
+    }
+    return Math.floor(value);
+}
+function normalizeRetryDelayMs(value) {
+    if (value === undefined)
+        return 1000;
+    if (!Number.isFinite(value) || value < 0) {
+        throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", "A2A push delivery retry delay must be zero or positive.");
+    }
+    return Math.floor(value);
+}
+function addMilliseconds(value, milliseconds) {
+    return new Date(value.getTime() + milliseconds);
+}
+function recordPushAttempt(attempt, attempts, store) {
+    attempts.push(attempt);
+    store?.record(attempt);
+}
+function publicDeliveryHeaders(headers) {
+    const result = {};
+    for (const [name, value] of Object.entries(headers)) {
+        const normalized = name.trim().toLowerCase();
+        if (normalized === "authorization"
+            || normalized === "proxy-authorization"
+            || normalized === "cookie"
+            || normalized === "set-cookie") {
+            continue;
+        }
+        result[normalized] = value;
+    }
+    return result;
+}
+function sanitizeQueueEntry(entry) {
+    return {
+        id: nonEmptyAttemptString(entry.id, "queue id"),
+        enqueuedAt: validAttemptIsoDate(entry.enqueuedAt, "queue enqueue time"),
+        ...(entry.claimedAt === undefined ? {} : { claimedAt: validAttemptIsoDate(entry.claimedAt, "queue claim time") }),
+        ...(entry.completedAt === undefined ? {} : { completedAt: validAttemptIsoDate(entry.completedAt, "queue completion time") }),
+        ...(entry.failedAt === undefined ? {} : { failedAt: validAttemptIsoDate(entry.failedAt, "queue failure time") }),
+        status: validQueueStatus(entry.status),
+        request: sanitizeDeliveryRequest(entry.request),
+    };
+}
+function sanitizeDeliveryRequest(request) {
+    const config = sanitizePushConfig(request.config);
+    const body = {
+        kind: "task",
+        task: redactA2ATaskForLog(request.body.task),
+    };
+    return {
+        method: "POST",
+        url: safeWebhookUrl(request.url),
+        headers: publicDeliveryHeaders({
+            ...request.headers,
+            "content-type": `${A2A_TASK_MEDIA_TYPE}; charset=utf-8`,
+            "a2a-version": A2A_TASK_PROTOCOL_VERSION,
+        }),
+        body,
+        json: `${JSON.stringify(body)}\n`,
+        config,
+    };
+}
+function sanitizePushConfig(config) {
+    return {
+        id: nonEmptyAttemptString(config.id, "config id"),
+        taskId: nonEmptyAttemptString(config.taskId, "task id"),
+        url: safeWebhookUrl(config.url),
+        createdAt: validAttemptIsoDate(config.createdAt, "config created time"),
+        ...(config.tenant ? { tenant: config.tenant } : {}),
+        ...(config.authentication ? { authentication: {
+                schemes: config.authentication.schemes.map((scheme) => nonEmptyAttemptString(scheme, "authentication scheme")),
+            } } : {}),
+    };
+}
+function sanitizePushAttempt(attempt) {
+    return {
+        configId: nonEmptyAttemptString(attempt.configId, "config id"),
+        taskId: nonEmptyAttemptString(attempt.taskId, "task id"),
+        url: safeWebhookUrl(attempt.url),
+        ...(attempt.attemptNumber === undefined ? {} : { attemptNumber: positiveAttemptInteger(attempt.attemptNumber, "attempt number") }),
+        ...(attempt.observedAt === undefined ? {} : { observedAt: validAttemptIsoDate(attempt.observedAt, "observed time") }),
+        ...(attempt.nextRetryAt === undefined ? {} : { nextRetryAt: validAttemptIsoDate(attempt.nextRetryAt, "retry time") }),
+        status: validAttemptStatus(attempt.status),
+        ...(attempt.httpStatus === undefined ? {} : { httpStatus: validHttpStatus(attempt.httpStatus) }),
+        ...(attempt.errorCode === undefined ? {} : { errorCode: validAttemptErrorCode(attempt.errorCode) }),
+    };
+}
+function nonEmptyAttemptString(value, label) {
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", `A2A push attempt ${label} is invalid.`);
+    }
+    return value.trim();
+}
+function positiveAttemptInteger(value, label) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", `A2A push attempt ${label} is invalid.`);
+    }
+    return value;
+}
+function validHttpStatus(value) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 100 || value > 599) {
+        throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", "A2A push attempt HTTP status is invalid.");
+    }
+    return value;
+}
+function validAttemptIsoDate(value, label) {
+    if (typeof value !== "string" || Number.isNaN(Date.parse(value))) {
+        throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", `A2A push attempt ${label} is invalid.`);
+    }
+    return new Date(value).toISOString();
+}
+function validAttemptStatus(value) {
+    if (value === "delivered" || value === "failed" || value === "skipped")
+        return value;
+    throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", "A2A push attempt status is invalid.");
+}
+function validQueueStatus(value) {
+    if (value === "queued" || value === "claimed" || value === "completed" || value === "failed")
+        return value;
+    throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", "A2A push delivery queue status is invalid.");
+}
+function validAttemptErrorCode(value) {
+    if (value === "A2A_PUSH_TRANSPORT_UNCONFIGURED" || value === "A2A_PUSH_TRANSPORT_FAILED")
+        return value;
+    throw new A2APushNotificationError("A2A_PUSH_CONFIG_INVALID", "A2A push attempt error code is invalid.");
+}
+function isUnsafeWebhookHost(hostname) {
+    const normalized = hostname.trim().toLowerCase();
+    if (normalized === "localhost" || normalized.endsWith(".localhost"))
+        return true;
+    const ipVersion = isIP(normalized);
+    if (ipVersion === 4) {
+        const [first = 0, second = 0] = normalized.split(".").map((octet) => Number.parseInt(octet, 10));
+        return first === 0
+            || first === 10
+            || first === 127
+            || (first === 100 && second >= 64 && second <= 127)
+            || (first === 169 && second === 254)
+            || (first === 172 && second >= 16 && second <= 31)
+            || (first === 192 && second === 168)
+            || (first === 198 && (second === 18 || second === 19))
+            || first >= 224;
+    }
+    if (ipVersion === 6) {
+        return normalized === "::"
+            || normalized === "::1"
+            || normalized.startsWith("fc")
+            || normalized.startsWith("fd")
+            || normalized.startsWith("fe80:");
+    }
+    return false;
+}
+function isAllowedCallbackHost(hostname, allowedCallbackHosts) {
+    if (!allowedCallbackHosts || allowedCallbackHosts.length === 0)
+        return true;
+    const normalized = hostname.trim().toLowerCase();
+    return allowedCallbackHosts.some((allowed) => allowed.trim().toLowerCase() === normalized);
+}
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}