auvrynt 1.0.2 → 1.0.5

package/dist/auth/room-registry.js

@@ -0,0 +1,131 @@
+import { eq } from "drizzle-orm";
+import { rooms } from "../db/schema.js";
+function rowToRecord(row) {
+    return {
+        roomId: row.id,
+        ownerClientId: row.ownerClientId,
+        workspaceId: row.workspaceId,
+        state: row.state,
+        createdAt: new Date(row.createdAt).getTime(),
+        closedAt: row.closedAt ? new Date(row.closedAt).getTime() : undefined,
+    };
+}
+function nowISO() {
+    return new Date().toISOString();
+}
+export class RoomRegistry {
+    database;
+    rooms = new Map();
+    constructor(database) {
+        this.database = database;
+        if (database) {
+            this.loadActiveRooms();
+        }
+    }
+    loadActiveRooms() {
+        const activeRows = this.database.db
+            .select()
+            .from(rooms)
+            .where(eq(rooms.state, "active"))
+            .all();
+        for (const row of activeRows) {
+            this.rooms.set(row.id, rowToRecord(row));
+        }
+    }
+    create(ownerClientId, workspaceId) {
+        const roomId = `room_${workspaceId}`;
+        const existing = this.get(roomId);
+        if (existing && existing.state !== "closed") {
+            if (existing.ownerClientId !== ownerClientId) {
+                throw new Error(`Forbidden: workspace ${workspaceId} belongs to a different OAuth client`);
+            }
+            return existing;
+        }
+        const record = {
+            roomId,
+            ownerClientId,
+            workspaceId,
+            state: "active",
+            createdAt: Date.now(),
+        };
+        this.rooms.set(roomId, record);
+        if (this.database) {
+            this.database.db
+                .insert(rooms)
+                .values({
+                id: roomId,
+                ownerClientId,
+                workspaceId,
+                state: "active",
+                createdAt: nowISO(),
+                lastActivityAt: nowISO(),
+            })
+                .run();
+        }
+        return record;
+    }
+    get(roomId) {
+        const cached = this.rooms.get(roomId);
+        if (cached)
+            return cached;
+        if (this.database) {
+            const row = this.database.db
+                .select()
+                .from(rooms)
+                .where(eq(rooms.id, roomId))
+                .get();
+            if (row) {
+                const record = rowToRecord(row);
+                if (record.state !== "closed")
+                    this.rooms.set(roomId, record);
+                return record;
+            }
+        }
+        return undefined;
+    }
+    getByWorkspace(workspaceId) {
+        const roomId = `room_${workspaceId}`;
+        const record = this.get(roomId);
+        return record?.state === "closed" ? undefined : record;
+    }
+    requireWorkspaceAccess(ownerClientId, workspaceId) {
+        const record = this.getByWorkspace(workspaceId);
+        if (!record || record.state !== "active") {
+            throw new Error(`Unknown or closed workspace room: ${workspaceId}`);
+        }
+        if (record.ownerClientId !== ownerClientId) {
+            throw new Error(`Forbidden: workspace ${workspaceId} belongs to a different OAuth client`);
+        }
+        return record;
+    }
+    closeOwned(ownerClientId, workspaceId) {
+        const record = this.requireWorkspaceAccess(ownerClientId, workspaceId);
+        this.close(record.roomId);
+    }
+    close(roomId) {
+        const record = this.rooms.get(roomId);
+        if (record) {
+            record.state = "closed";
+            record.closedAt = Date.now();
+            this.rooms.delete(roomId);
+        }
+        if (this.database) {
+            this.database.db
+                .update(rooms)
+                .set({ state: "closed", closedAt: nowISO() })
+                .where(eq(rooms.id, roomId))
+                .run();
+        }
+    }
+    findByOwner(ownerClientId) {
+        const result = [];
+        for (const record of this.rooms.values()) {
+            if (record.ownerClientId === ownerClientId)
+                result.push(record);
+        }
+        return result;
+    }
+    allRooms() {
+        return Array.from(this.rooms.values());
+    }
+}

package/dist/auth/session-registry.js

@@ -0,0 +1,531 @@
+import { randomUUID } from "node:crypto";
+import { logEvent, sessionIdPrefix } from "../logger.js";
+import { DEFAULT_SESSION_IDLE_TIMEOUT_MS, MAX_MCP_SESSIONS, MAX_SESSION_IDLE_TIMEOUT_MS, MIN_SESSION_IDLE_TIMEOUT_MS, } from "../config.js";
+export { DEFAULT_SESSION_IDLE_TIMEOUT_MS } from "../config.js";
+export const DEFAULT_DISCONNECT_GRACE_MS = 0;
+export const DEFAULT_SESSION_RESERVATION_TIMEOUT_MS = 60 * 1000;
+export const DEFAULT_SESSION_CLOSE_TIMEOUT_MS = 5 * 1000;
+export const DEFAULT_SESSION_CLEANUP_INTERVAL_MS = 60 * 1000;
+export const HARD_MAX_SESSIONS = MAX_MCP_SESSIONS;
+export const DEFAULT_MAX_SESSIONS = HARD_MAX_SESSIONS;
+export const DEFAULT_MAX_SESSIONS_PER_OWNER = HARD_MAX_SESSIONS;
+export class SessionRegistry {
+    config;
+    sessions = new Map();
+    reservations = new Map();
+    closingPromises = new Map();
+    cleanupTimer;
+    now;
+    sessionIdleTimeoutMs;
+    disconnectGraceMs;
+    reservationTimeoutMs;
+    closeTimeoutMs;
+    cleanupIntervalMs;
+    maxSessions;
+    maxSessionsPerOwner;
+    cleanupInFlight = false;
+    nextSessionOrdinal = 1;
+    constructor(config, options = {}) {
+        this.config = config;
+        this.now = options.now ?? Date.now;
+        this.sessionIdleTimeoutMs = boundedPositiveMs(options.sessionIdleTimeoutMs, positiveEnvMs("AUVRYNT_SESSION_IDLE_MS", DEFAULT_SESSION_IDLE_TIMEOUT_MS), MIN_SESSION_IDLE_TIMEOUT_MS, MAX_SESSION_IDLE_TIMEOUT_MS);
+        this.disconnectGraceMs = nonNegativeMs(options.disconnectGraceMs, nonNegativeEnvMs("AUVRYNT_DISCONNECT_GRACE_MS", DEFAULT_DISCONNECT_GRACE_MS));
+        this.reservationTimeoutMs = positiveMs(options.reservationTimeoutMs, DEFAULT_SESSION_RESERVATION_TIMEOUT_MS);
+        this.closeTimeoutMs = positiveMs(options.closeTimeoutMs, DEFAULT_SESSION_CLOSE_TIMEOUT_MS);
+        this.cleanupIntervalMs = positiveMs(options.cleanupIntervalMs, DEFAULT_SESSION_CLEANUP_INTERVAL_MS);
+        this.maxSessions = Math.min(HARD_MAX_SESSIONS, positiveInteger(options.maxSessions, positiveEnvInteger("AUVRYNT_MAX_SESSIONS", DEFAULT_MAX_SESSIONS)));
+        this.maxSessionsPerOwner = Math.min(HARD_MAX_SESSIONS, this.maxSessions, positiveInteger(options.maxSessionsPerOwner, positiveEnvInteger("AUVRYNT_MAX_SESSIONS_PER_CLIENT", DEFAULT_MAX_SESSIONS_PER_OWNER)));
+        if (options.startCleanupTimer !== false) {
+            this.cleanupTimer = setInterval(() => void this.cleanupSafely(), this.cleanupIntervalMs);
+            this.cleanupTimer.unref();
+        }
+    }
+    reserve(ownerClientId) {
+        this.reclaimCapacity(ownerClientId);
+        if (!this.hasCapacity(ownerClientId))
+            return undefined;
+        const reservation = {
+            reservationId: `reservation_${randomUUID()}`,
+            ownerClientId,
+            createdAt: this.now(),
+        };
+        this.reservations.set(reservation.reservationId, reservation);
+        return reservation;
+    }
+    create(reservation, transport, mcpServer, roomId, workspaceId) {
+        const storedReservation = this.reservations.get(reservation.reservationId);
+        if (!storedReservation || storedReservation.ownerClientId !== reservation.ownerClientId) {
+            throw new Error("Unknown or released session reservation");
+        }
+        const sessionId = transport.sessionId;
+        if (!sessionId)
+            throw new Error("Transport has no sessionId");
+        if (this.sessions.has(sessionId))
+            throw new Error(`Duplicate session: ${sessionId}`);
+        this.reservations.delete(reservation.reservationId);
+        const now = this.now();
+        const record = {
+            sessionId,
+            ownerClientId: storedReservation.ownerClientId,
+            state: "creating",
+            transport,
+            mcpServer,
+            roomId,
+            workspaceId,
+            createdAt: now,
+            ordinal: this.nextSessionOrdinal++,
+            lastActivityAt: now,
+            inFlightRequests: 0,
+            inFlightToolCalls: 0,
+        };
+        this.sessions.set(sessionId, record);
+        return record;
+    }
+    release(reservation) {
+        if (!reservation)
+            return false;
+        const stored = this.reservations.get(reservation.reservationId);
+        if (!stored || stored.ownerClientId !== reservation.ownerClientId)
+            return false;
+        return this.reservations.delete(reservation.reservationId);
+    }
+    canCreate(ownerClientId) {
+        return this.hasCapacity(ownerClientId);
+    }
+    isAtCapacity() {
+        return this.occupiedCount() >= this.maxSessions;
+    }
+    updateLimits(maxSessions, maxSessionsPerOwner = maxSessions) {
+        this.maxSessions = Math.min(HARD_MAX_SESSIONS, positiveInteger(maxSessions, DEFAULT_MAX_SESSIONS));
+        this.maxSessionsPerOwner = Math.min(this.maxSessions, HARD_MAX_SESSIONS, positiveInteger(maxSessionsPerOwner, this.maxSessions));
+    }
+    updateSessionIdleTimeout(timeoutMs) {
+        this.sessionIdleTimeoutMs = boundedPositiveMs(timeoutMs, DEFAULT_SESSION_IDLE_TIMEOUT_MS, MIN_SESSION_IDLE_TIMEOUT_MS, MAX_SESSION_IDLE_TIMEOUT_MS);
+    }
+    occupiedCount() {
+        return this.occupyingSessionCount() + this.reservations.size;
+    }
+    get(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    require(sessionId) {
+        const record = this.sessions.get(sessionId);
+        if (!record)
+            throw new Error(`Unknown session: ${sessionId}`);
+        return record;
+    }
+    transition(sessionId, newState) {
+        const record = this.sessions.get(sessionId);
+        if (!record)
+            return;
+        const oldState = record.state;
+        const now = this.now();
+        record.state = newState;
+        record.lastActivityAt = now;
+        record.disconnectedAt = newState === "disconnected" ? now : undefined;
+        if (newState !== "closing")
+            record.closingReason = undefined;
+        logEvent(this.config.logging, "debug", "session_state", {
+            sessionIdPrefix: sessionIdPrefix(sessionId),
+            oldState,
+            newState,
+        });
+    }
+    touch(sessionId) {
+        const record = this.sessions.get(sessionId);
+        if (!record || record.state === "closing" || record.state === "expired")
+            return false;
+        record.lastActivityAt = this.now();
+        if (record.state === "disconnected") {
+            record.state = "active";
+            record.disconnectedAt = undefined;
+        }
+        return true;
+    }
+    canTerminate(sessionId) {
+        const record = this.sessions.get(sessionId);
+        if (!record)
+            return false;
+        return record.state !== "closing" && record.inFlightToolCalls === 0;
+    }
+    beginRequest(sessionId, isToolCall = false) {
+        const record = this.sessions.get(sessionId);
+        if (!record || record.state === "closing" || record.state === "expired")
+            return false;
+        record.inFlightRequests += 1;
+        if (isToolCall)
+            record.inFlightToolCalls += 1;
+        this.touch(sessionId);
+        return true;
+    }
+    endRequest(sessionId, isToolCall = false) {
+        const record = this.sessions.get(sessionId);
+        if (!record)
+            return;
+        record.inFlightRequests = Math.max(0, record.inFlightRequests - 1);
+        if (isToolCall)
+            record.inFlightToolCalls = Math.max(0, record.inFlightToolCalls - 1);
+        record.lastActivityAt = this.now();
+        if (record.supersededBySessionId && record.inFlightRequests === 0) {
+            void this.closeSession(record.sessionId, "superseded_by_logical_session");
+        }
+    }
+    bindLogicalSession(sessionId, logicalSessionId) {
+        const normalized = logicalSessionId.trim();
+        if (!normalized || normalized.length > 256)
+            return false;
+        const record = this.sessions.get(sessionId);
+        if (!record || record.state === "closing" || record.state === "expired")
+            return false;
+        if (record.logicalSessionId && record.logicalSessionId !== normalized) {
+            logEvent(this.config.logging, "warn", "logical_session_rebind_rejected", {
+                sessionIdPrefix: sessionIdPrefix(sessionId),
+            });
+            return false;
+        }
+        record.logicalSessionId = normalized;
+        record.lastActivityAt = this.now();
+        const matching = [...this.sessions.values()].filter((candidate) => candidate.ownerClientId === record.ownerClientId
+            && candidate.logicalSessionId === normalized
+            && candidate.state !== "closing"
+            && candidate.state !== "expired");
+        if (matching.length < 2)
+            return true;
+        const newest = matching.reduce((current, candidate) => candidate.ordinal > current.ordinal ? candidate : current);
+        for (const candidate of matching) {
+            if (candidate.sessionId === newest.sessionId)
+                continue;
+            if (candidate.supersededBySessionId === newest.sessionId)
+                continue;
+            candidate.supersededBySessionId = newest.sessionId;
+            logEvent(this.config.logging, "info", "mcp_session_superseded", {
+                sessionIdPrefix: sessionIdPrefix(candidate.sessionId),
+                replacementSessionIdPrefix: sessionIdPrefix(newest.sessionId),
+                reason: "same_logical_chat",
+                inFlightRequests: candidate.inFlightRequests,
+                inFlightToolCalls: candidate.inFlightToolCalls,
+            });
+            if (candidate.inFlightRequests === 0) {
+                void this.closeSession(candidate.sessionId, "superseded_by_logical_session");
+            }
+        }
+        return true;
+    }
+    bindWorkspace(sessionId, roomId, workspaceId) {
+        const record = this.require(sessionId);
+        if (record.state === "closing" || record.state === "expired") {
+            throw new Error(`Session ${sessionId} is closing`);
+        }
+        record.roomId = roomId;
+        record.workspaceId = workspaceId;
+        record.lastActivityAt = this.now();
+    }
+    markClosing(sessionId, reason) {
+        const record = this.sessions.get(sessionId);
+        if (!record)
+            return false;
+        if (record.state !== "closing") {
+            const oldState = record.state;
+            record.state = "closing";
+            record.closingReason = reason;
+            record.lastActivityAt = this.now();
+            logEvent(this.config.logging, "debug", "session_state", {
+                sessionIdPrefix: sessionIdPrefix(sessionId),
+                oldState,
+                newState: "closing",
+                reason,
+            });
+        }
+        else if (!record.closingReason) {
+            record.closingReason = reason;
+        }
+        return true;
+    }
+    handleTransportClosed(sessionId, fallbackReason = "transport_closed") {
+        const record = this.sessions.get(sessionId);
+        if (!record)
+            return false;
+        this.sessions.delete(sessionId);
+        record.state = "expired";
+        const reason = record.closingReason ?? fallbackReason;
+        logEvent(this.config.logging, "info", "mcp_session_closed", {
+            sessionIdPrefix: sessionIdPrefix(sessionId),
+            reason,
+            inFlightRequests: record.inFlightRequests,
+            inFlightToolCalls: record.inFlightToolCalls,
+        });
+        return true;
+    }
+    async closeSession(sessionId, reason) {
+        const record = this.sessions.get(sessionId);
+        if (!record)
+            return false;
+        this.markClosing(sessionId, reason);
+        await this.closeRecord(record);
+        return true;
+    }
+    async closeAll(reason = "server_shutdown") {
+        this.reservations.clear();
+        const records = [...this.sessions.values()];
+        await Promise.allSettled(records.map((record) => this.closeSession(record.sessionId, reason)));
+    }
+    remove(sessionId) {
+        const record = this.sessions.get(sessionId);
+        if (record)
+            this.sessions.delete(sessionId);
+        return record;
+    }
+    findByOwner(ownerClientId) {
+        return [...this.sessions.values()].filter((record) => record.ownerClientId === ownerClientId);
+    }
+    findByRoom(roomId) {
+        return [...this.sessions.values()].filter((record) => record.roomId === roomId);
+    }
+    activeCount() {
+        let count = 0;
+        for (const record of this.sessions.values()) {
+            if (record.state === "active" || record.state === "disconnected")
+                count++;
+        }
+        return count;
+    }
+    connectedCount() {
+        let count = 0;
+        for (const record of this.sessions.values()) {
+            if (record.state === "active")
+                count++;
+        }
+        return count;
+    }
+    countByState() {
+        const counts = {};
+        for (const record of this.sessions.values()) {
+            counts[record.state] = (counts[record.state] || 0) + 1;
+        }
+        if (this.reservations.size > 0)
+            counts.reserved = this.reservations.size;
+        return counts;
+    }
+    allRecords() {
+        return [...this.sessions.values()];
+    }
+    close() {
+        if (this.cleanupTimer)
+            clearInterval(this.cleanupTimer);
+        this.reservations.clear();
+    }
+    async cleanupNow(now = this.now()) {
+        let cleaned = 0;
+        for (const [reservationId, reservation] of this.reservations) {
+            if (now - reservation.createdAt < this.reservationTimeoutMs)
+                continue;
+            this.reservations.delete(reservationId);
+            cleaned++;
+            logEvent(this.config.logging, "warn", "session_reservation_expired", {
+                reservationIdPrefix: reservationId.slice(0, 20),
+            });
+        }
+        const closePromises = [];
+        for (const record of this.sessions.values()) {
+            if (record.state === "expired") {
+                closePromises.push(this.closeSession(record.sessionId, record.closingReason ?? "transport_closed"));
+                cleaned++;
+                continue;
+            }
+            if (record.state === "disconnected" && record.disconnectedAt !== undefined) {
+                if (now - record.disconnectedAt >= this.disconnectGraceMs && record.inFlightRequests === 0) {
+                    closePromises.push(this.closeSession(record.sessionId, "disconnect_grace_expired"));
+                    cleaned++;
+                }
+                continue;
+            }
+            if (record.state === "active"
+                && record.inFlightRequests === 0
+                && now - record.lastActivityAt >= this.sessionIdleTimeoutMs) {
+                if (this.disconnectGraceMs === 0) {
+                    closePromises.push(this.closeSession(record.sessionId, "idle_timeout"));
+                    cleaned++;
+                    continue;
+                }
+                const oldState = record.state;
+                record.state = "disconnected";
+                record.disconnectedAt = now;
+                record.lastActivityAt = now;
+                logEvent(this.config.logging, "info", "session_disconnected", {
+                    sessionIdPrefix: sessionIdPrefix(record.sessionId),
+                    oldState,
+                    reason: "idle_timeout",
+                });
+                continue;
+            }
+            if (record.state === "creating" && now - record.lastActivityAt >= this.reservationTimeoutMs) {
+                closePromises.push(this.closeSession(record.sessionId, "never_initialized"));
+                cleaned++;
+                continue;
+            }
+            if (record.state === "closing" && now - record.lastActivityAt >= this.cleanupIntervalMs) {
+                record.closingReason ??= "closing_stuck";
+                closePromises.push(this.closeRecord(record));
+            }
+        }
+        await Promise.allSettled(closePromises);
+        return cleaned;
+    }
+    async cleanupSafely() {
+        if (this.cleanupInFlight)
+            return;
+        this.cleanupInFlight = true;
+        try {
+            await this.cleanupNow();
+        }
+        finally {
+            this.cleanupInFlight = false;
+        }
+    }
+    hasCapacity(ownerClientId) {
+        if (this.occupiedCount() >= this.maxSessions)
+            return false;
+        if (!ownerClientId)
+            return true;
+        return this.ownerOccupancy(ownerClientId) < this.maxSessionsPerOwner;
+    }
+    reclaimCapacity(ownerClientId) {
+        const ownerOverage = this.ownerOccupancy(ownerClientId) - this.maxSessionsPerOwner + 1;
+        if (ownerOverage > 0)
+            this.reclaimSessions(ownerOverage, ownerClientId);
+        const globalOverage = this.occupiedCount() - this.maxSessions + 1;
+        if (globalOverage > 0)
+            this.reclaimSessions(globalOverage);
+    }
+    reclaimSessions(count, ownerClientId) {
+        if (count <= 0)
+            return;
+        const now = this.now();
+        const candidates = [...this.sessions.values()]
+            .filter((record) => {
+            if (ownerClientId && record.ownerClientId !== ownerClientId)
+                return false;
+            if (record.inFlightRequests > 0 || record.state === "closing")
+                return false;
+            return record.state === "expired" || record.state === "disconnected";
+        })
+            .sort((left, right) => {
+            const stateDifference = recoveryPriority(left.state) - recoveryPriority(right.state);
+            return stateDifference || evictionTimestamp(left) - evictionTimestamp(right);
+        })
+            .slice(0, count);
+        for (const record of candidates) {
+            const previousState = record.state;
+            const idleMs = Math.max(0, now - record.lastActivityAt);
+            this.markClosing(record.sessionId, "capacity_recovery");
+            logEvent(this.config.logging, "info", "session_reclaimed", {
+                sessionIdPrefix: sessionIdPrefix(record.sessionId),
+                reason: "capacity_recovery",
+                previousState,
+                idleMs,
+            });
+            void this.closeRecord(record);
+        }
+    }
+    ownerOccupancy(ownerClientId) {
+        let count = 0;
+        for (const record of this.sessions.values()) {
+            if (record.ownerClientId === ownerClientId && occupiesCapacity(record))
+                count++;
+        }
+        for (const reservation of this.reservations.values()) {
+            if (reservation.ownerClientId === ownerClientId)
+                count++;
+        }
+        return count;
+    }
+    occupyingSessionCount() {
+        let count = 0;
+        for (const record of this.sessions.values()) {
+            if (occupiesCapacity(record))
+                count++;
+        }
+        return count;
+    }
+    closeRecord(record) {
+        const existing = this.closingPromises.get(record.sessionId);
+        if (existing)
+            return existing;
+        const promise = (async () => {
+            try {
+                await withTimeout(record.mcpServer.close(), this.closeTimeoutMs, `Timed out closing MCP session ${sessionIdPrefix(record.sessionId)}`);
+            }
+            catch (error) {
+                logEvent(this.config.logging, "warn", "session_close_failed", {
+                    sessionIdPrefix: sessionIdPrefix(record.sessionId),
+                    reason: record.closingReason,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                await record.transport.close().catch(() => undefined);
+            }
+            finally {
+                this.handleTransportClosed(record.sessionId, record.closingReason ?? "transport_closed");
+            }
+        })();
+        this.closingPromises.set(record.sessionId, promise);
+        void promise.finally(() => {
+            if (this.closingPromises.get(record.sessionId) === promise) {
+                this.closingPromises.delete(record.sessionId);
+            }
+        });
+        return promise;
+    }
+}
+function occupiesCapacity(record) {
+    return record.state !== "closing" && record.state !== "expired";
+}
+function evictionTimestamp(record) {
+    return record.disconnectedAt ?? record.lastActivityAt;
+}
+function recoveryPriority(state) {
+    if (state === "expired")
+        return 0;
+    if (state === "disconnected")
+        return 1;
+    if (state === "creating")
+        return 2;
+    if (state === "active")
+        return 3;
+    return 4;
+}
+function withTimeout(promise, timeoutMs, message) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error(message)), timeoutMs);
+        promise.then((value) => {
+            clearTimeout(timeout);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+    });
+}
+function positiveEnvMs(name, fallback) {
+    const value = Number(process.env[name]);
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function nonNegativeEnvMs(name, fallback) {
+    const value = Number(process.env[name]);
+    return Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function positiveEnvInteger(name, fallback) {
+    return positiveInteger(Number(process.env[name]), fallback);
+}
+function positiveMs(value, fallback) {
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function boundedPositiveMs(value, fallback, minimum, maximum) {
+    const resolved = positiveMs(value, fallback);
+    return Math.min(maximum, Math.max(minimum, resolved));
+}
+function nonNegativeMs(value, fallback) {
+    return Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function positiveInteger(value, fallback) {
+    return Number.isInteger(value) && value > 0 ? value : fallback;
+}

package/dist/background-lifecycle.js

@@ -0,0 +1 @@
+export * from "./process/background-lifecycle.js";