@helyx/bot 1.5.2 → 1.5.3

package/dist/managed-resource-query.js

@@ -0,0 +1,15 @@
+import { BotControlValidationError } from "./control-errors.js";
+export function validateManagedResourceQuery(module, resourceType, input) {
+    const query = module.manifest.dashboard?.resources?.find(({ id }) => id === resourceType)?.query;
+    if (input.search !== undefined && !query?.search)
+        throw new BotControlValidationError("Managed resource search is not declared by this module");
+    for (const [key, value] of Object.entries(input.filters ?? {})) {
+        const filter = query?.filters?.find((candidate) => candidate.key === key);
+        if (!filter)
+            throw new BotControlValidationError("Managed resource filter is not declared by this module");
+        if (filter.type === "select" &&
+            !filter.options.some((option) => option.value === value))
+            throw new BotControlValidationError("Managed resource filter value is not declared by this module");
+    }
+}
+//# sourceMappingURL=managed-resource-query.js.map

package/dist/member-role-ids.d.ts

@@ -0,0 +1,17 @@
+import { Client, Guild, GuildMember } from "discord.js";
+/** Private actor-construction failure; never turn an unknown member into no roles. */
+export declare class MemberRoleSnapshotError extends Error {
+    constructor();
+}
+/**
+ * Pinned Discord.js compatibility: member.roles.cache omits assigned IDs whose
+ * Role objects are unavailable. Authorization must retain those IDs for denies.
+ */
+export declare function snapshotMemberRoleIds({ member, client, guild, guildId, actorUserId, }: {
+    member: GuildMember;
+    client: Client;
+    guild: Guild | null;
+    guildId: string | null;
+    actorUserId: string;
+}): readonly string[];
+//# sourceMappingURL=member-role-ids.d.ts.map

package/dist/member-role-ids.js

@@ -0,0 +1,66 @@
+import { Client, Guild, GuildMember } from "discord.js";
+const maximumAssignedRoles = 250;
+const snowflake = /^\d{17,20}$/u;
+/** Private actor-construction failure; never turn an unknown member into no roles. */
+export class MemberRoleSnapshotError extends Error {
+    constructor() {
+        super("Discord member roles could not be verified.");
+        this.name = "MemberRoleSnapshotError";
+    }
+}
+/**
+ * Pinned Discord.js compatibility: member.roles.cache omits assigned IDs whose
+ * Role objects are unavailable. Authorization must retain those IDs for denies.
+ */
+export function snapshotMemberRoleIds({ member, client, guild, guildId, actorUserId, }) {
+    try {
+        if (!(client instanceof Client) ||
+            !(guild instanceof Guild) ||
+            !(member instanceof GuildMember) ||
+            typeof guildId !== "string" ||
+            !snowflake.test(guildId) ||
+            !snowflake.test(actorUserId))
+            throw new MemberRoleSnapshotError();
+        const user = member.user;
+        const currentIdentity = () => guild.id === guildId &&
+            guild.client === client &&
+            member.guild === guild &&
+            member.client === client &&
+            member.id === actorUserId &&
+            member.user === user &&
+            user.id === actorUserId &&
+            user.client === client &&
+            member.partial === false;
+        if (!currentIdentity())
+            throw new MemberRoleSnapshotError();
+        const assigned = Reflect.get(member, "_roles");
+        if (!Array.isArray(assigned) || assigned.length > maximumAssignedRoles)
+            throw new MemberRoleSnapshotError();
+        const length = assigned.length;
+        const snapshot = [];
+        const seen = new Set();
+        for (let index = 0; index < length; index++) {
+            const id = assigned[index];
+            if (typeof id !== "string" ||
+                !snowflake.test(id) ||
+                id === guildId ||
+                seen.has(id))
+                throw new MemberRoleSnapshotError();
+            seen.add(id);
+            snapshot.push(id);
+        }
+        if (!currentIdentity() ||
+            Reflect.get(member, "_roles") !== assigned ||
+            assigned.length !== length ||
+            snapshot.some((id, index) => assigned[index] !== id) ||
+            !currentIdentity() ||
+            Reflect.get(member, "_roles") !== assigned ||
+            assigned.length !== length)
+            throw new MemberRoleSnapshotError();
+        return Object.freeze([guildId, ...snapshot].sort());
+    }
+    catch {
+        throw new MemberRoleSnapshotError();
+    }
+}
+//# sourceMappingURL=member-role-ids.js.map

package/dist/message-protection-admission.d.ts

@@ -0,0 +1,60 @@
+import type { MessageProtectionEligibility } from "./guild-message-protection-delivery.js";
+export type ProtectionAdmissionOwner = Readonly<{
+    applicationId: string;
+    instanceId: string;
+} & ({
+    mode: "standalone";
+} | {
+    mode: "sharded";
+    scope: "local" | "coordinated";
+    generation: string;
+    deploymentOrder: string;
+    supervisorId: string;
+    shardId: number;
+    shardCount: number;
+    fencingToken: string;
+})>;
+export interface ProtectionAdmissionScope {
+    readonly guildId: string;
+    readonly moduleId: string;
+}
+export interface ProtectionReloadTicket {
+    readonly owner: ProtectionAdmissionOwner;
+    readonly scope: ProtectionAdmissionScope;
+    readonly ownerEpoch: string;
+    readonly scopeEpoch: string;
+    readonly sequence: string;
+    readonly capturedAt: number;
+}
+/** Trusted cold-loader digest, not a claimed existing persistence revision. */
+export interface ProtectionAdmissionSnapshot {
+    readonly state: "enabled" | "disabled";
+    readonly revisionFingerprint: string;
+    /** Lease measured from ticket capture, never from delayed completion. */
+    readonly validForMs: number;
+}
+/**
+ * Private, pure runtime publisher. No loader, service registry, timer or I/O.
+ * Production composition intentionally does not instantiate or expose it yet.
+ */
+export declare class MessageProtectionAdmissionPublisher {
+    #private;
+    readonly owner: ProtectionAdmissionOwner;
+    readonly eligibility: MessageProtectionEligibility;
+    constructor(options: {
+        owner: ProtectionAdmissionOwner;
+        capacity: number;
+        maxAgeMs: number;
+        now?: () => number;
+    });
+    get scopeCount(): number;
+    /** One latest reference-bound ticket per scope; replacement rejects old I/O. */
+    captureReload(scope: ProtectionAdmissionScope): ProtectionReloadTicket | null;
+    publish(ticket: ProtectionReloadTicket, snapshot: ProtectionAdmissionSnapshot): boolean;
+    invalidateScope(scope: ProtectionAdmissionScope): void;
+    invalidateGuild(guildId: string): void;
+    invalidateModule(moduleId: string): void;
+    invalidateAll(): void;
+    stop(): void;
+}
+//# sourceMappingURL=message-protection-admission.d.ts.map

package/dist/message-protection-admission.js

@@ -0,0 +1,279 @@
+import { randomUUID } from "node:crypto";
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
+const SNOWFLAKE = /^\d{17,20}$/u;
+const MODULE_ID = /^[a-z][a-z0-9-]{0,62}\.[a-z][a-z0-9-]{0,62}$/u;
+const unavailable = Object.freeze({ state: "unavailable" });
+const disabled = Object.freeze({ state: "disabled" });
+/**
+ * Private, pure runtime publisher. No loader, service registry, timer or I/O.
+ * Production composition intentionally does not instantiate or expose it yet.
+ */
+export class MessageProtectionAdmissionPublisher {
+    owner;
+    eligibility;
+    #entries = new Map();
+    #tokens = new Map();
+    #clock;
+    #capacity;
+    #maxAgeMs;
+    #ownerEpoch = 0n;
+    #sequence = 0n;
+    #scopeEpoch = 0n;
+    #lastNow = -Infinity;
+    #stopped = false;
+    constructor(options) {
+        assertOwner(options.owner);
+        if (!Number.isSafeInteger(options.capacity) ||
+            options.capacity < 1 ||
+            options.capacity > 100_000)
+            throw new TypeError("Protection admission capacity must be 1..100000");
+        if (!Number.isSafeInteger(options.maxAgeMs) ||
+            options.maxAgeMs < 1 ||
+            options.maxAgeMs > 600_000)
+            throw new TypeError("Protection admission maximum age must be 1..600000ms");
+        this.owner = Object.freeze({ ...options.owner });
+        this.#capacity = options.capacity;
+        this.#maxAgeMs = options.maxAgeMs;
+        this.#clock = options.now ?? (() => performance.now());
+        this.eligibility = Object.freeze({
+            read: (guildId, moduleId) => this.#read(guildId, moduleId),
+            isCurrent: (token) => this.#isCurrent(token),
+        });
+    }
+    get scopeCount() {
+        return this.#entries.size;
+    }
+    /** One latest reference-bound ticket per scope; replacement rejects old I/O. */
+    captureReload(scope) {
+        assertScope(scope);
+        const now = this.#now();
+        if (now === null)
+            return null;
+        const key = scopeKey(scope);
+        let entry = this.#entries.get(key);
+        if (!entry) {
+            this.#prune(now);
+            if (this.#entries.size >= this.#capacity)
+                return null;
+            entry = {
+                scope: Object.freeze({
+                    guildId: scope.guildId,
+                    moduleId: scope.moduleId,
+                }),
+                epoch: String(++this.#scopeEpoch),
+            };
+            this.#entries.set(key, entry);
+        }
+        const ticket = Object.freeze({
+            owner: this.owner,
+            scope: entry.scope,
+            ownerEpoch: String(this.#ownerEpoch),
+            scopeEpoch: entry.epoch,
+            sequence: String(++this.#sequence),
+            capturedAt: now,
+        });
+        entry.ticket = ticket;
+        return ticket;
+    }
+    publish(ticket, snapshot) {
+        const now = this.#now();
+        if (now === null || !ticket || !validScope(ticket.scope))
+            return false;
+        const key = scopeKey(ticket.scope), entry = this.#entries.get(key);
+        if (!entry ||
+            entry.ticket !== ticket ||
+            ticket.owner !== this.owner ||
+            ticket.ownerEpoch !== String(this.#ownerEpoch) ||
+            ticket.scopeEpoch !== entry.epoch)
+            return false;
+        delete entry.ticket; // A receipt cannot be replayed to extend freshness.
+        const normalized = normalizeSnapshot(snapshot, this.#maxAgeMs);
+        if (!normalized || ticket.capturedAt + normalized.validForMs <= now) {
+            this.#remove(key, entry);
+            return false;
+        }
+        const same = entry.snapshot?.state === normalized.state &&
+            entry.snapshot.revisionFingerprint === normalized.revisionFingerprint &&
+            entry.expiresAt !== undefined &&
+            now < entry.expiresAt;
+        if (!same || normalized.state !== "enabled")
+            this.#revoke(entry);
+        entry.snapshot = normalized;
+        entry.expiresAt = ticket.capturedAt + normalized.validForMs;
+        if (normalized.state === "enabled" && !entry.token) {
+            entry.token = randomUUID();
+            this.#tokens.set(entry.token, entry);
+        }
+        return true;
+    }
+    invalidateScope(scope) {
+        assertScope(scope);
+        const key = scopeKey(scope), entry = this.#entries.get(key);
+        if (entry)
+            this.#remove(key, entry);
+    }
+    invalidateGuild(guildId) {
+        if (!SNOWFLAKE.test(guildId))
+            throw new TypeError("Invalid protection guild scope");
+        for (const [key, entry] of this.#entries)
+            if (entry.scope.guildId === guildId)
+                this.#remove(key, entry);
+    }
+    invalidateModule(moduleId) {
+        if (!MODULE_ID.test(moduleId))
+            throw new TypeError("Invalid protection module scope");
+        for (const [key, entry] of this.#entries)
+            if (entry.scope.moduleId === moduleId)
+                this.#remove(key, entry);
+    }
+    invalidateAll() {
+        ++this.#ownerEpoch;
+        this.#entries.clear();
+        this.#tokens.clear();
+    }
+    stop() {
+        this.#stopped = true;
+        this.invalidateAll();
+    }
+    #read(guildId, moduleId) {
+        const now = this.#now();
+        if (now === null || !validScope({ guildId, moduleId }))
+            return unavailable;
+        const entry = this.#entries.get(scopeKey({ guildId, moduleId }));
+        if (!entry || !this.#live(entry, now))
+            return unavailable;
+        if (entry.snapshot?.state === "disabled")
+            return disabled;
+        return entry.token
+            ? Object.freeze({ state: "enabled", generation: entry.token })
+            : unavailable;
+    }
+    #isCurrent(token) {
+        const now = this.#now();
+        if (now === null || typeof token !== "string")
+            return false;
+        const entry = this.#tokens.get(token);
+        return Boolean(entry &&
+            this.#live(entry, now) &&
+            entry.token === token &&
+            entry.snapshot?.state === "enabled");
+    }
+    #live(entry, now) {
+        if (entry.expiresAt === undefined || now >= entry.expiresAt) {
+            this.#revoke(entry);
+            return false;
+        }
+        return true;
+    }
+    #revoke(entry) {
+        if (entry.token)
+            this.#tokens.delete(entry.token);
+        delete entry.token;
+    }
+    #remove(key, entry) {
+        this.#revoke(entry);
+        this.#entries.delete(key);
+    }
+    #prune(now) {
+        for (const [key, entry] of this.#entries) {
+            const pending = entry.ticket && now < entry.ticket.capturedAt + this.#maxAgeMs;
+            if (!this.#live(entry, now) && !pending)
+                this.#remove(key, entry);
+        }
+    }
+    #now() {
+        if (this.#stopped)
+            return null;
+        let now;
+        try {
+            now = this.#clock();
+        }
+        catch {
+            this.stop();
+            return null;
+        }
+        if (!Number.isFinite(now) ||
+            now < 0 ||
+            now < this.#lastNow ||
+            now > Number.MAX_SAFE_INTEGER - this.#maxAgeMs) {
+            this.stop();
+            return null;
+        }
+        this.#lastNow = now;
+        return now;
+    }
+}
+function validScope(scope) {
+    return Boolean(scope &&
+        typeof scope.guildId === "string" &&
+        SNOWFLAKE.test(scope.guildId) &&
+        typeof scope.moduleId === "string" &&
+        MODULE_ID.test(scope.moduleId));
+}
+function assertScope(scope) {
+    if (!validScope(scope))
+        throw new TypeError("Invalid protection admission scope");
+}
+function scopeKey(scope) {
+    return `${scope.guildId}:${scope.moduleId}`;
+}
+function normalizeSnapshot(snapshot, maxAgeMs) {
+    try {
+        if (!snapshot ||
+            !plain(snapshot) ||
+            Object.keys(snapshot).length !== 3 ||
+            Object.keys(snapshot).some((key) => !["state", "revisionFingerprint", "validForMs"].includes(key)))
+            return null;
+        const { state, revisionFingerprint, validForMs } = snapshot;
+        if ((state !== "enabled" && state !== "disabled") ||
+            typeof revisionFingerprint !== "string" ||
+            !/^[a-f0-9]{64}$/u.test(revisionFingerprint) ||
+            !Number.isSafeInteger(validForMs) ||
+            validForMs < 1 ||
+            validForMs > maxAgeMs)
+            return null;
+        return Object.freeze({ state, revisionFingerprint, validForMs });
+    }
+    catch {
+        return null;
+    }
+}
+function plain(value) {
+    return (!Array.isArray(value) &&
+        (Object.getPrototypeOf(value) === Object.prototype ||
+            Object.getPrototypeOf(value) === null));
+}
+function assertOwner(owner) {
+    if (!owner ||
+        !plain(owner) ||
+        typeof owner.applicationId !== "string" ||
+        !SNOWFLAKE.test(owner.applicationId) ||
+        typeof owner.instanceId !== "string" ||
+        !UUID.test(owner.instanceId))
+        throw new TypeError("Invalid protection admission owner");
+    if (owner.mode === "standalone" && Object.keys(owner).length === 3)
+        return;
+    if (owner.mode === "sharded" &&
+        Object.keys(owner).length === 10 &&
+        ["local", "coordinated"].includes(owner.scope) &&
+        typeof owner.generation === "string" &&
+        /^[a-zA-Z0-9._:-]{1,128}$/u.test(owner.generation) &&
+        positiveDecimal(owner.deploymentOrder) &&
+        typeof owner.supervisorId === "string" &&
+        UUID.test(owner.supervisorId) &&
+        Number.isSafeInteger(owner.shardCount) &&
+        owner.shardCount >= 1 &&
+        owner.shardCount <= 4096 &&
+        Number.isSafeInteger(owner.shardId) &&
+        owner.shardId >= 0 &&
+        owner.shardId < owner.shardCount &&
+        positiveDecimal(owner.fencingToken))
+        return;
+    throw new TypeError("Invalid protection admission owner");
+}
+function positiveDecimal(value) {
+    return (typeof value === "string" &&
+        /^[1-9]\d{0,18}$/u.test(value) &&
+        BigInt(value) <= 9223372036854775807n);
+}
+//# sourceMappingURL=message-protection-admission.js.map

package/dist/message-protection-cold-data.d.ts

@@ -0,0 +1,42 @@
+import { type MessageProtectionSnapshotData, type MessageProtectionSnapshotReader } from "@helyx/database-contracts";
+import type { ModuleDefinition } from "@helyx/sdk";
+export interface MessageProtectionColdScope {
+    readonly guildId: string;
+    readonly moduleId: string;
+}
+export type MessageProtectionColdResult = Readonly<{
+    kind: "unavailable";
+    reason: "read-failed" | "malformed" | "stale" | "unsupported-module";
+}> | Readonly<{
+    kind: "observed";
+    scope: Readonly<MessageProtectionColdScope>;
+    configuredApplicationId: string;
+    databaseObservedAt: string;
+    guild: MessageProtectionSnapshotData["guild"];
+    installation: MessageProtectionSnapshotData["installation"];
+    configuration: MessageProtectionSnapshotData["configuration"];
+    availability: MessageProtectionSnapshotData["availability"];
+    tierAccess: Readonly<{
+        required: boolean;
+        reviewed: boolean;
+        granted: boolean;
+        activeUntil: string | null;
+    }>;
+    revisionFingerprint: string;
+    freshness: Readonly<{
+        capturedAt: number;
+        completedAt: number;
+        expiresAt: number;
+    }>;
+}>;
+/** No owner grant, enabled state, publisher call, timer or production registration. */
+export declare function createMessageProtectionColdDataReader(options: {
+    applicationId: string;
+    modules: readonly ModuleDefinition[];
+    data: MessageProtectionSnapshotReader;
+    maximumAgeMs: number;
+    now?: () => number;
+}): {
+    read(scope: MessageProtectionColdScope): Promise<MessageProtectionColdResult>;
+};
+//# sourceMappingURL=message-protection-cold-data.d.ts.map

package/dist/message-protection-cold-data.js

@@ -0,0 +1,180 @@
+import { createHash } from "node:crypto";
+import { MessageProtectionSnapshotDataError, assertMessageProtectionSnapshotQuery, copyMessageProtectionSnapshotData, } from "@helyx/database-contracts";
+import { getModuleTier, HELYX_PREMIUM_ENTITLEMENT_CAPABILITY, isReviewedPremiumModuleId, } from "@helyx/module-manifest";
+/** No owner grant, enabled state, publisher call, timer or production registration. */
+export function createMessageProtectionColdDataReader(options) {
+    if (typeof options.applicationId !== "string" ||
+        !/^\d{17,20}$/u.test(options.applicationId) ||
+        !Number.isSafeInteger(options.maximumAgeMs) ||
+        options.maximumAgeMs < 1 ||
+        options.maximumAgeMs > 600_000)
+        throw new TypeError("Invalid protection cold-reader context");
+    const applicationId = options.applicationId;
+    const maximumAgeMs = options.maximumAgeMs;
+    const dataReader = options.data;
+    const clock = options.now ?? (() => performance.now());
+    let lastNow = -Infinity;
+    let clockFailed = false;
+    const readClock = () => {
+        if (clockFailed)
+            return NaN;
+        let value;
+        try {
+            value = clock();
+        }
+        catch {
+            clockFailed = true;
+            return NaN;
+        }
+        if (!validClock(value, maximumAgeMs) || value < lastNow) {
+            clockFailed = true;
+            return NaN;
+        }
+        lastNow = value;
+        return value;
+    };
+    if (new Set(options.modules.map(({ manifest }) => manifest.id)).size !==
+        options.modules.length)
+        throw new TypeError("Duplicate protection cold-reader module");
+    const policies = new Map(options.modules.flatMap((module) => {
+        const protection = (module.events?.guildMessageCreate ?? []).flatMap(({ protection: value }) => value
+            ? [
+                {
+                    version: value.version,
+                    otherBots: value.otherBots === true,
+                    webhooks: value.webhooks === true,
+                    summary: value.summary === true,
+                    deleteMessage: value.deleteMessage === true,
+                },
+            ]
+            : []);
+        const updateMetadata = (module.events?.guildMessageUpdateMetadata ?? []).map(({ metadata }) => ({
+            version: metadata.version,
+            otherBots: metadata.otherBots === true,
+            webhooks: metadata.webhooks === true,
+        }));
+        return protection.length || updateMetadata.length
+            ? [
+                [
+                    module.manifest.id,
+                    Object.freeze({
+                        moduleId: module.manifest.id,
+                        version: module.manifest.version,
+                        schemaVersion: module.configuration?.schemaVersion ?? 1,
+                        premium: getModuleTier(module.manifest) === "premium",
+                        reviewed: isReviewedPremiumModuleId(module.manifest.id),
+                        protection: Object.freeze(protection.map((item) => Object.freeze(item))),
+                        updateMetadata: Object.freeze(updateMetadata.map((item) => Object.freeze(item))),
+                    }),
+                ],
+            ]
+            : [];
+    }));
+    return Object.freeze({
+        async read(scope) {
+            const policy = policies.get(scope.moduleId);
+            if (!policy)
+                return unavailable("unsupported-module");
+            const query = {
+                guildId: scope.guildId,
+                moduleId: scope.moduleId,
+                capability: HELYX_PREMIUM_ENTITLEMENT_CAPABILITY,
+            };
+            try {
+                assertMessageProtectionSnapshotQuery(query);
+            }
+            catch {
+                return unavailable("malformed");
+            }
+            let capturedAt;
+            try {
+                capturedAt = readClock();
+            }
+            catch {
+                return unavailable("stale");
+            }
+            if (!validClock(capturedAt, maximumAgeMs))
+                return unavailable("stale");
+            let data;
+            try {
+                data = await dataReader.read(query);
+            }
+            catch (error) {
+                return unavailable(error instanceof MessageProtectionSnapshotDataError
+                    ? "malformed"
+                    : "read-failed");
+            }
+            try {
+                data = copyMessageProtectionSnapshotData(query, data);
+            }
+            catch {
+                return unavailable("malformed");
+            }
+            let completedAt;
+            try {
+                completedAt = readClock();
+            }
+            catch {
+                return unavailable("stale");
+            }
+            if (!validClock(completedAt, maximumAgeMs) || completedAt < capturedAt)
+                return unavailable("stale");
+            const granted = !policy.premium || (policy.reviewed && data.entitlement.granted);
+            const activeUntil = policy.premium && policy.reviewed && granted
+                ? data.entitlement.activeUntil
+                : null;
+            let budget = maximumAgeMs;
+            if (activeUntil !== null)
+                budget = Math.min(budget, Math.max(0, Math.floor(Date.parse(activeUntil) - Date.parse(data.observedAt)) -
+                    1));
+            const expiresAt = capturedAt + budget;
+            if (!Number.isFinite(expiresAt) || completedAt >= expiresAt)
+                return unavailable("stale");
+            const stableScope = Object.freeze({
+                guildId: query.guildId,
+                moduleId: query.moduleId,
+            });
+            const tierAccess = Object.freeze({
+                required: policy.premium,
+                reviewed: policy.reviewed,
+                granted,
+                activeUntil,
+            });
+            const vector = [
+                1,
+                applicationId,
+                policy,
+                stableScope,
+                data.guild,
+                data.installation,
+                data.configuration,
+                data.availability,
+                tierAccess,
+            ];
+            return Object.freeze({
+                kind: "observed",
+                scope: stableScope,
+                configuredApplicationId: applicationId,
+                databaseObservedAt: data.observedAt,
+                guild: data.guild,
+                installation: data.installation,
+                configuration: data.configuration,
+                availability: data.availability,
+                tierAccess,
+                revisionFingerprint: createHash("sha256")
+                    .update(JSON.stringify(vector))
+                    .digest("hex"),
+                freshness: Object.freeze({ capturedAt, completedAt, expiresAt }),
+            });
+        },
+    });
+}
+function validClock(value, maxAgeMs) {
+    return (Number.isFinite(value) &&
+        value >= 0 &&
+        value <= Number.MAX_SAFE_INTEGER - maxAgeMs);
+}
+function unavailable(reason) {
+    return Object.freeze({ kind: "unavailable", reason });
+}
+//# sourceMappingURL=message-protection-cold-data.js.map