updateday 0.0.0-stage → 0.2.0

package/dist/notify.js

@@ -0,0 +1,72 @@
+const WEBHOOK_PATTERN = /^https:\/\/(?:(?:canary|ptb)\.)?discord(?:app)?\.com\/api\/webhooks\/\d+\/[\w-]+$/;
+const BOT_NAME = "UpdateDay";
+const IMAGE_NAME = "icon.png";
+const COLORS = {
+    reminders: 0xf0b232,
+    failures: 0xf0555a,
+    live: 0x2fbf71,
+    finished: 0x4c8dff,
+    steps: 0x8b93a7,
+};
+export function isWebhookUrl(url) {
+    return WEBHOOK_PATTERN.test(url.trim());
+}
+function allowedMentions(mention) {
+    if (!mention) {
+        return { parse: [] };
+    }
+    return { parse: ["everyone", "roles", "users"] };
+}
+export async function postDiscord(webhook, message, mention) {
+    if (!isWebhookUrl(webhook)) {
+        throw new Error("That isn't a Discord webhook link (https://discord.com/api/webhooks/...)");
+    }
+    const embed = {
+        title: message.title,
+        description: message.text,
+        color: COLORS[message.event],
+        timestamp: new Date().toISOString(),
+    };
+    const payload = {
+        username: BOT_NAME,
+        content: mention ?? "",
+        embeds: [embed],
+        allowed_mentions: allowedMentions(mention),
+    };
+    let body;
+    if (message.image) {
+        embed.image = { url: `attachment://${IMAGE_NAME}` };
+        const form = new FormData();
+        form.set("payload_json", JSON.stringify(payload));
+        form.set("files[0]", new Blob([new Uint8Array(message.image)], { type: "image/png" }), IMAGE_NAME);
+        body = form;
+    }
+    else {
+        body = JSON.stringify(payload);
+    }
+    const response = await fetch(webhook.trim(), {
+        method: "POST",
+        headers: message.image ? undefined : { "content-type": "application/json" },
+        body,
+    });
+    if (!response.ok) {
+        throw new Error(`Discord refused the message (${response.status})`);
+    }
+}
+export function discordNotifier(config, webhook) {
+    const settings = config.notify;
+    if (!settings || !webhook) {
+        return undefined;
+    }
+    return async (message) => {
+        if (!settings.events.includes(message.event)) {
+            return;
+        }
+        try {
+            await postDiscord(webhook, { ...message, title: `${config.name}: ${message.title}` }, settings.mention);
+        }
+        catch (error) {
+            console.error(`Discord alert not sent: ${error instanceof Error ? error.message : error}`);
+        }
+    };
+}

package/dist/openCloud.js

@@ -0,0 +1,211 @@
+const BASE_URL = "https://apis.roblox.com";
+const MAX_RETRIES = 4;
+const RETRY_BASE_MS = 1000;
+const UPLOAD_POLLS = 20;
+const UPLOAD_POLL_MS = 1500;
+export class OpenCloudError extends Error {
+    status;
+    body;
+    constructor(status, body, label) {
+        super(`${label} failed (${status}): ${body.slice(0, 300)}`);
+        this.status = status;
+        this.body = body;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRetryable(status) {
+    return status === 429 || status >= 500;
+}
+function priceBasePath(universeId, target) {
+    if (target.kind === "gamePass") {
+        return `/game-passes/v1/universes/${universeId}/game-passes/${target.id}`;
+    }
+    return `/developer-products/v2/universes/${universeId}/developer-products/${target.id}`;
+}
+function listPath(universeId, kind) {
+    if (kind === "gamePass") {
+        return `/game-passes/v1/universes/${universeId}/game-passes/creator`;
+    }
+    return `/developer-products/v2/universes/${universeId}/developer-products/creator`;
+}
+function readPrice(json) {
+    const price = json.priceInformation?.defaultPriceInRobux ?? json.price ?? json.priceInRobux ?? null;
+    return {
+        price: typeof price === "number" ? price : null,
+        isForSale: Boolean(json.isForSale ?? json.priceInformation != null),
+        name: String(json.name ?? json.displayName ?? ""),
+    };
+}
+export class OpenCloud {
+    apiKey;
+    universeId;
+    constructor(apiKey, universeId) {
+        this.apiKey = apiKey;
+        this.universeId = universeId;
+    }
+    async request(method, path, label, body, contentType) {
+        const headers = { "x-api-key": this.apiKey };
+        if (contentType) {
+            headers["content-type"] = contentType;
+        }
+        for (let attempt = 0;; attempt++) {
+            const response = await fetch(BASE_URL + path, { method, headers, body });
+            const text = await response.text();
+            if (response.ok) {
+                return text ? JSON.parse(text) : null;
+            }
+            if (!isRetryable(response.status) || attempt >= MAX_RETRIES) {
+                throw new OpenCloudError(response.status, text, label);
+            }
+            await sleep(RETRY_BASE_MS * 2 ** attempt);
+        }
+    }
+    json(method, path, label, payload) {
+        return this.request(method, path, label, JSON.stringify(payload), "application/json");
+    }
+    async getPrice(target) {
+        const json = await this.request("GET", `${priceBasePath(this.universeId, target)}/creator`, `read ${target.kind} ${target.id}`);
+        return readPrice(json);
+    }
+    async setPrice(target, price) {
+        const form = new FormData();
+        form.set("price", String(price));
+        await this.request("PATCH", priceBasePath(this.universeId, target), `price ${target.kind} ${target.id}`, form);
+    }
+    async setName(target, name) {
+        const form = new FormData();
+        form.set("name", name);
+        await this.request("PATCH", priceBasePath(this.universeId, target), `rename ${target.kind} ${target.id}`, form);
+    }
+    async listItems(kind) {
+        const items = [];
+        let pageToken = "";
+        do {
+            const query = pageToken ? `?pageToken=${encodeURIComponent(pageToken)}` : "";
+            const json = await this.request("GET", listPath(this.universeId, kind) + query, `list ${kind}s`);
+            for (const item of json.gamePasses ?? json.developerProducts ?? []) {
+                const info = readPrice(item);
+                items.push({
+                    kind,
+                    id: Number(item.gamePassId ?? item.productId ?? item.id),
+                    name: info.name,
+                    price: info.price,
+                    isForSale: Boolean(item.isForSale),
+                    iconAssetId: Number(item.iconAssetId ?? item.iconImageAssetId) || null,
+                });
+            }
+            pageToken = json.nextPageToken ?? "";
+        } while (pageToken);
+        return items;
+    }
+    async listPriceTargets(kind) {
+        const targets = [];
+        let pageToken = "";
+        do {
+            const query = pageToken ? `?pageToken=${encodeURIComponent(pageToken)}` : "";
+            const json = await this.request("GET", listPath(this.universeId, kind) + query, `list ${kind}s`);
+            const items = json.gamePasses ?? json.developerProducts ?? json.data ?? [];
+            for (const item of items) {
+                const id = item.gamePassId ?? item.productId ?? item.id;
+                if (typeof id === "number") {
+                    targets.push({ kind, id });
+                }
+            }
+            pageToken = json.nextPageToken ?? "";
+        } while (pageToken);
+        return targets;
+    }
+    async setIcon(image, languageCode) {
+        const form = new FormData();
+        form.set("Files", image, "icon.png");
+        const path = `/legacy-game-internationalization/v1/game-icon/games/${this.universeId}/language-codes/${languageCode}`;
+        await this.request("POST", path, "set game icon", form);
+    }
+    async setSourceLanguage(languageCode) {
+        const path = `/legacy-game-internationalization/v1/source-language/games/${this.universeId}?languageCode=${encodeURIComponent(languageCode)}`;
+        await this.request("PATCH", path, `set source language ${languageCode}`);
+    }
+    listIcons() {
+        const path = `/legacy-game-internationalization/v1/game-icon/games/${this.universeId}`;
+        return this.request("GET", path, "list game icons");
+    }
+    async deleteIcon(languageCode) {
+        const path = `/legacy-game-internationalization/v1/game-icon/games/${this.universeId}/language-codes/${languageCode}`;
+        await this.request("DELETE", path, `delete ${languageCode} icon`);
+    }
+    async uploadImage(image, displayName) {
+        const universe = await this.getUniverse();
+        const owner = /^(users|groups)\/(\d+)$/.exec(String(universe?.user ?? universe?.group ?? ""));
+        if (!owner) {
+            throw new Error("Could not tell who owns this game");
+        }
+        const creator = owner[1] === "users" ? { userId: owner[2] } : { groupId: owner[2] };
+        const form = new FormData();
+        form.set("request", JSON.stringify({ assetType: "Image", displayName, description: "Uploaded by UpdateDay", creationContext: { creator } }));
+        form.set("fileContent", image, "image.png");
+        let operation = await this.request("POST", "/assets/v1/assets", "upload image", form);
+        for (let attempt = 0; !operation?.done && attempt < UPLOAD_POLLS; attempt++) {
+            await sleep(UPLOAD_POLL_MS);
+            const id = String(operation?.path ?? operation?.operationId ?? "").split("/").pop();
+            operation = await this.request("GET", `/assets/v1/operations/${id}`, "check upload");
+        }
+        const assetId = Number(operation?.response?.assetId);
+        if (!operation?.done || !assetId) {
+            throw new Error(`Image upload didn't finish: ${JSON.stringify(operation).slice(0, 200)}`);
+        }
+        return assetId;
+    }
+    getUniverse() {
+        return this.request("GET", `/cloud/v2/universes/${this.universeId}`, "read universe");
+    }
+    async rootPlaceId() {
+        const universe = await this.getUniverse();
+        const placeId = Number(String(universe?.rootPlace ?? "").split("/").pop());
+        if (!Number.isInteger(placeId) || placeId <= 0) {
+            throw new Error("Could not find the game's root place");
+        }
+        return placeId;
+    }
+    getPlace(placeId) {
+        return this.request("GET", `/cloud/v2/universes/${this.universeId}/places/${placeId}`, "read place");
+    }
+    async setNameDescription(name, description) {
+        const placeId = await this.rootPlaceId();
+        const fields = {};
+        if (name !== undefined) {
+            fields.displayName = name;
+        }
+        if (description !== undefined) {
+            fields.description = description;
+        }
+        const mask = Object.keys(fields).join(",");
+        const path = `/cloud/v2/universes/${this.universeId}/places/${placeId}?updateMask=${mask}`;
+        const updated = await this.json("PATCH", path, "set name/description", fields);
+        return { name: String(updated?.displayName ?? ""), description: String(updated?.description ?? "") };
+    }
+    createEvent(input) {
+        const path = `/virtual-events/v3/universes/${this.universeId}/game-events`;
+        return this.json("POST", path, "create event", input);
+    }
+    publishMessage(topic, message) {
+        const path = `/cloud/v2/universes/${this.universeId}:publishMessage`;
+        return this.json("POST", path, "publish message", { topic, message });
+    }
+    restartServers(bleedOffMinutes) {
+        const path = `/cloud/v2/universes/${this.universeId}:restartServers`;
+        const payload = bleedOffMinutes > 0
+            ? { closeAllVersions: false, bleedOffServers: true, bleedOffDurationMinutes: bleedOffMinutes }
+            : { closeAllVersions: false, bleedOffServers: false };
+        return this.json("POST", path, "restart servers", payload);
+    }
+    publishPlace(placeId, file) {
+        const path = `/universes/v1/${this.universeId}/places/${placeId}/versions?versionType=Published`;
+        return this.request("POST", path, "publish place", file, "application/octet-stream");
+    }
+    getEntry(dataStore, key, scope = "global") {
+        const path = `/cloud/v2/universes/${this.universeId}/data-stores/${encodeURIComponent(dataStore)}/scopes/${encodeURIComponent(scope)}/entries/${encodeURIComponent(key)}`;
+        return this.request("GET", path, `read entry ${dataStore}/${key}`);
+    }
+}

package/dist/playerData.js

@@ -0,0 +1,109 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { OpenCloudError } from "./openCloud.js";
+const USERNAMES_API = "https://users.roblox.com/v1/usernames/users";
+const USERS_API = "https://users.roblox.com/v1/users";
+const HEADSHOT_API = "https://thumbnails.roblox.com/v1/users/avatar-headshot";
+const BACKUP_DIR = "updateday-backups";
+const USER_ID_TOKEN = /\{userId\}/g;
+const SAFE_NAME = /[^\w.-]+/g;
+async function avatar(userId) {
+    const response = await fetch(`${HEADSHOT_API}?userIds=${userId}&size=150x150&format=Png`);
+    return response.ok ? (await response.json()).data?.[0]?.imageUrl ?? null : null;
+}
+export async function lookupPlayer(query) {
+    const text = query.trim().replace(/^@/, "");
+    let user = null;
+    if (/^\d+$/.test(text)) {
+        const response = await fetch(`${USERS_API}/${text}`);
+        user = response.ok ? await response.json() : null;
+    }
+    else {
+        const response = await fetch(USERNAMES_API, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ usernames: [text], excludeBannedUsers: false }),
+        });
+        user = response.ok ? (await response.json()).data?.[0] ?? null : null;
+    }
+    if (!user?.id) {
+        throw new Error(`No Roblox player called "${text}"`);
+    }
+    return { id: user.id, name: user.name, displayName: user.displayName ?? user.name, avatarUrl: await avatar(user.id) };
+}
+export function entryKey(keyFormat, userId) {
+    return keyFormat.replace(USER_ID_TOKEN, String(userId));
+}
+function entryPath(cloud, dataStore, key) {
+    return `/cloud/v2/universes/${cloud.universeId}/data-stores/${encodeURIComponent(dataStore)}/entries/${encodeURIComponent(key)}`;
+}
+export async function listDataStores(cloud) {
+    const names = [];
+    let pageToken = "";
+    do {
+        const query = pageToken ? `?pageToken=${encodeURIComponent(pageToken)}` : "";
+        const json = await cloud.request("GET", `/cloud/v2/universes/${cloud.universeId}/data-stores${query}`, "list data stores");
+        for (const store of json?.dataStores ?? []) {
+            names.push(String(store.id ?? String(store.path).split("/").pop()));
+        }
+        pageToken = json?.nextPageToken ?? "";
+    } while (pageToken);
+    return names;
+}
+export async function readEntry(cloud, dataStore, key) {
+    try {
+        const json = await cloud.request("GET", entryPath(cloud, dataStore, key), "read entry");
+        return { value: json.value, etag: json.etag ?? null, revisionId: json.revisionId ?? null, updateTime: json.revisionCreateTime ?? null };
+    }
+    catch (error) {
+        if (error instanceof OpenCloudError && error.status === 404) {
+            return null;
+        }
+        throw error;
+    }
+}
+function backupFolder(baseDir, universeId, dataStore, key) {
+    return join(baseDir, BACKUP_DIR, String(universeId), dataStore.replace(SAFE_NAME, "_"), key.replace(SAFE_NAME, "_"));
+}
+export function writeBackup(baseDir, universeId, dataStore, key, entry, reason) {
+    const folder = backupFolder(baseDir, universeId, dataStore, key);
+    mkdirSync(folder, { recursive: true });
+    const savedAt = new Date().toISOString();
+    const file = `${savedAt.replace(/[:.]/g, "-")}.json`;
+    writeFileSync(join(folder, file), JSON.stringify({ savedAt, reason, dataStore, key, existed: entry !== null, value: entry?.value ?? null }, null, "\t"));
+    return file;
+}
+export function listBackups(baseDir, universeId, dataStore, key) {
+    const folder = backupFolder(baseDir, universeId, dataStore, key);
+    if (!existsSync(folder)) {
+        return [];
+    }
+    return readdirSync(folder)
+        .filter((file) => file.endsWith(".json"))
+        .sort()
+        .reverse()
+        .map((file) => {
+        const data = JSON.parse(readFileSync(join(folder, file), "utf8"));
+        return { file, savedAt: data.savedAt, reason: data.reason };
+    });
+}
+export function readBackup(baseDir, universeId, dataStore, key, file) {
+    if (!/^[\w-]+\.json$/.test(file)) {
+        throw new Error("Bad backup name");
+    }
+    return JSON.parse(readFileSync(join(backupFolder(baseDir, universeId, dataStore, key), file), "utf8")).value;
+}
+export async function saveEntry(cloud, baseDir, dataStore, key, value, expectedEtag, reason) {
+    const current = await readEntry(cloud, dataStore, key);
+    if (expectedEtag && current?.etag && current.etag !== expectedEtag) {
+        throw new Error("This player's data changed since you loaded it (they may be in game). Reload and try again.");
+    }
+    writeBackup(baseDir, cloud.universeId, dataStore, key, current, reason);
+    const body = { value };
+    if (current?.etag) {
+        body.etag = current.etag;
+    }
+    const path = `${entryPath(cloud, dataStore, key)}?allowMissing=true`;
+    const json = await cloud.json("PATCH", path, "save entry", body);
+    return { value: json.value, etag: json.etag ?? null, revisionId: json.revisionId ?? null, updateTime: json.revisionCreateTime ?? null };
+}

package/dist/preflight.js

@@ -0,0 +1,202 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import sharp from "sharp";
+import { nextOccurrence } from "./config.js";
+import { checkKey } from "./doctor.js";
+import { fetchCurrentIcon, ICON_SIZE, renderIcon } from "./icons.js";
+import { iconMarks } from "./bundle.js";
+import { moderationStatus } from "./moderation.js";
+import { titleFor } from "./runner.js";
+import { buildSchedule } from "./schedule.js";
+const EVENT_LEAD_MS = 15 * 60 * 1000;
+function when(date) {
+    return date.toUTCString().replace(" GMT", " UTC");
+}
+function timingChecks({ config, now }) {
+    const checks = [];
+    const updateAt = new Date(config.updateAt);
+    if (updateAt <= now) {
+        checks.push({ level: "warn", title: "The update time has passed", detail: `It was ${when(updateAt)}. Steps that are still due run right away.` });
+    }
+    else {
+        checks.push({ level: "ok", title: `Update at ${when(updateAt)}` });
+    }
+    const steps = buildSchedule(config).filter((step) => step.at.getTime() > 0);
+    const missed = steps.filter((step) => step.at <= now && step.action.type === "icon");
+    if (missed.length > 1 && updateAt > now) {
+        checks.push({ level: "info", title: "The countdown starts part-way", detail: `${missed.length - 1} earlier stage${missed.length === 2 ? " is" : "s are"} already past and will be skipped.` });
+    }
+    const next = nextOccurrence(config);
+    if (config.repeat) {
+        checks.push({ level: "info", title: `Repeats every ${config.repeat.every === "2weeks" ? "2 weeks" : config.repeat.every}`, detail: next ? `After this one: ${when(next)}` : "This is the last one." });
+    }
+    return checks;
+}
+function fileChecks({ config }) {
+    const checks = [];
+    const files = [
+        [config.countdown?.newIcon, "The new game icon"],
+        [config.publish ? resolve(config.baseDir, config.publish.file) : undefined, "The place file to publish"],
+    ];
+    for (const [path, what] of files) {
+        if (path && !existsSync(path)) {
+            checks.push({ level: "bad", title: `${what} is missing`, detail: path });
+        }
+    }
+    const artDir = config.countdown?.overlayDir;
+    if (artDir && !existsSync(artDir)) {
+        checks.push({ level: "warn", title: "No hourglass art uploaded yet", detail: "The built-in hourglass is used until you add your own." });
+    }
+    return checks;
+}
+async function baseIcon(config) {
+    if (existsSync(config.snapshotPath)) {
+        return readFileSync(config.snapshotPath);
+    }
+    return sharp(await fetchCurrentIcon(config.universeId)).resize(ICON_SIZE, ICON_SIZE).png().toBuffer();
+}
+async function iconChecks({ config }) {
+    const countdown = config.countdown;
+    if (!countdown) {
+        return [];
+    }
+    let base;
+    try {
+        base = await baseIcon(config);
+    }
+    catch (error) {
+        return [{ level: "bad", title: "Couldn't read the game icon", detail: error instanceof Error ? error.message : String(error) }];
+    }
+    const marks = iconMarks(countdown);
+    const broken = [];
+    for (const mark of marks) {
+        try {
+            await renderIcon(base, mark, countdown);
+        }
+        catch (error) {
+            broken.push(`${mark}: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    if (broken.length) {
+        return [{ level: "bad", title: `${broken.length} countdown icon${broken.length === 1 ? "" : "s"} won't render`, detail: broken.join("; ") }];
+    }
+    const how = countdown.iconMethod === "languageSwap" ? "uploaded automatically" : "made for you to upload";
+    return [{ level: "ok", title: `${marks.length} countdown icons render`, detail: `They'll be ${how}.` }];
+}
+async function keyChecks({ config, cloud }) {
+    if (!cloud) {
+        return [{ level: "bad", title: "No API key", detail: `Paste one in UpdateDay or set ${config.apiKeyEnv}.` }];
+    }
+    const probes = await checkKey(cloud, config);
+    const blocking = probes.filter((probe) => probe.used && (probe.status === "missing" || probe.status === "error"));
+    if (blocking.length) {
+        return [{ level: "bad", title: `The API key is missing ${blocking.length} permission${blocking.length === 1 ? "" : "s"}`, detail: blocking.map((probe) => `${probe.feature} (${probe.permission})`).join(", ") }];
+    }
+    return [{ level: "ok", title: "The API key has every permission the plan needs" }];
+}
+async function saleChecks({ config, cloud, now }) {
+    const sale = config.sale;
+    if (!sale) {
+        return [];
+    }
+    const checks = [];
+    const endsAt = sale.endsAt ? Date.parse(sale.endsAt) : (sale.startsAt ? Date.parse(sale.startsAt) : Date.parse(config.updateAt)) + sale.durationHours * 36e5;
+    if (endsAt <= now.getTime()) {
+        checks.push({ level: "warn", title: "The sale's end time has already passed", detail: "It would start and end straight away." });
+    }
+    if (!cloud) {
+        return checks;
+    }
+    try {
+        const items = [...(await cloud.listItems("gamePass")), ...(await cloud.listItems("developerProduct"))];
+        const picked = (kind, setting) => {
+            const sellable = items.filter((item) => item.kind === kind && item.isForSale && item.price !== null);
+            if (setting === "all") {
+                return { count: sellable.length, missing: [] };
+            }
+            const ids = new Set(sellable.map((item) => item.id));
+            return { count: setting.filter((id) => ids.has(id)).length, missing: setting.filter((id) => !ids.has(id)) };
+        };
+        const passes = picked("gamePass", sale.gamePasses);
+        const products = picked("developerProduct", sale.developerProducts);
+        const total = passes.count + products.count;
+        const missing = [...passes.missing, ...products.missing];
+        if (total === 0) {
+            checks.push({ level: "warn", title: "Nothing would go on sale", detail: "No picked pass or product is for sale right now." });
+        }
+        else {
+            checks.push({ level: "ok", title: `${total} item${total === 1 ? "" : "s"} go on sale at ${sale.percentOff}% off` });
+        }
+        if (missing.length) {
+            checks.push({ level: "warn", title: `${missing.length} picked item${missing.length === 1 ? " isn't" : "s aren't"} for sale any more`, detail: `They'll be skipped: ${missing.join(", ")}` });
+        }
+    }
+    catch (error) {
+        checks.push({ level: "warn", title: "Couldn't list the passes and products", detail: error instanceof Error ? error.message : String(error) });
+    }
+    return checks;
+}
+function eventChecks({ config, now }) {
+    if (!config.event) {
+        return [];
+    }
+    if (Date.parse(config.updateAt) - now.getTime() < EVENT_LEAD_MS) {
+        return [{ level: "warn", title: "The event will start a little late", detail: "Roblox events need 15 minutes' notice, so it starts about 20 minutes from now." }];
+    }
+    return [{ level: "ok", title: `Event "${config.event.title}" will be created` }];
+}
+function titleChecks({ config }) {
+    if (!config.title) {
+        return [];
+    }
+    const example = titleFor(config.title.format, config.name, "6H");
+    return [{ level: "info", title: "Title countdown is on", detail: `For example "${example}", then "${titleFor(config.title.nowFormat, config.name, "LIVE")}". The real title is saved first and put back.` }];
+}
+async function moderationChecks({ config, cloud }) {
+    if (!config.countdown || !cloud) {
+        return [];
+    }
+    try {
+        const stages = await moderationStatus(config, cloud, await baseIcon(config));
+        const rejected = stages.filter((stage) => stage.state === "Rejected").map((stage) => stage.mark);
+        const reviewing = stages.filter((stage) => stage.state === "Reviewing").length;
+        const unchecked = stages.filter((stage) => stage.state === "unchecked").length;
+        if (rejected.length) {
+            return [{ level: "bad", title: `Roblox moderation rejected ${rejected.length} icon${rejected.length === 1 ? "" : "s"}`, detail: `Change the look of: ${rejected.join(", ")}` }];
+        }
+        if (unchecked === stages.length) {
+            return [{ level: "info", title: "Icons not checked with Roblox moderation yet", detail: "Optional: Countdown → Stages → Check with moderation." }];
+        }
+        if (reviewing || unchecked) {
+            return [{ level: "info", title: "Moderation check in progress", detail: `${reviewing} in review, ${unchecked} not checked since the last change.` }];
+        }
+        return [{ level: "ok", title: `Roblox moderation approved all ${stages.length} icons` }];
+    }
+    catch (error) {
+        return [{ level: "warn", title: "Couldn't read the moderation status", detail: error instanceof Error ? error.message : String(error) }];
+    }
+}
+function notifyChecks({ config, webhook }) {
+    if (!config.notify) {
+        return [];
+    }
+    if (!webhook) {
+        return [{ level: "warn", title: "Discord alerts are on, but there's no webhook", detail: `Paste one in UpdateDay or set ${config.notify.discordWebhookEnv}.` }];
+    }
+    return [{ level: "ok", title: "Discord alerts are ready" }];
+}
+export async function preflight(config, cloud, webhook, now = new Date()) {
+    const inputs = { config, cloud, webhook, now };
+    const checks = [
+        ...timingChecks(inputs),
+        ...(await keyChecks(inputs)),
+        ...fileChecks(inputs),
+        ...(await iconChecks(inputs)),
+        ...(await saleChecks(inputs)),
+        ...eventChecks(inputs),
+        ...titleChecks(inputs),
+        ...(await moderationChecks(inputs)),
+        ...notifyChecks(inputs),
+    ];
+    return { game: config.name, universeId: config.universeId, ready: !checks.some((check) => check.level === "bad"), checks };
+}