updateday 0.0.0-stage → 0.2.0

package/dist/experiments.js

@@ -0,0 +1,349 @@
+import { OpenCloud } from "./openCloud.js";
+const PUBLIC_I18N = "https://gameinternationalization.roblox.com";
+async function publicJson(path) {
+    const response = await fetch(PUBLIC_I18N + path);
+    return response.ok ? response.json() : { status: response.status, body: await response.text() };
+}
+async function snapshot(universeId) {
+    return {
+        source: await publicJson(`/v1/source-language/games/${universeId}`),
+        supported: await publicJson(`/v2/supported-languages/games/${universeId}`),
+        nameDescription: await publicJson(`/v1/name-description/games/${universeId}`),
+    };
+}
+async function publicIcon(universeId) {
+    const response = await fetch(`https://thumbnails.roblox.com/v1/games/icons?universeIds=${universeId}&size=512x512&format=Png`);
+    return response.ok ? response.json() : response.status;
+}
+function canonical(value) {
+    const data = value?.data;
+    if (!Array.isArray(data)) {
+        return JSON.stringify(value);
+    }
+    return JSON.stringify(data.map((entry) => JSON.stringify(entry)).sort());
+}
+function sourceCode(state) {
+    return String(state.source?.languageCode ?? "");
+}
+const APPROVAL_POLL_MS = 10 * 1000;
+const SETTLE_POLL_MS = 3 * 1000;
+const SETTLE_MAX_MS = 60 * 1000;
+const WAITING_STATES = ["PendingReview", "UnAvailable", "missing"];
+function iconState(list, languageCode) {
+    const entry = (list?.data ?? []).find((icon) => icon.languageCode === languageCode);
+    return entry ? String(entry.state) : "missing";
+}
+async function waitForApproval(options, languageCode) {
+    const started = Date.now();
+    let last = "";
+    while (Date.now() - started < options.approvalWaitMs && !options.shouldStop()) {
+        const state = iconState(await options.cloud.listIcons(), languageCode);
+        if (state !== last) {
+            options.log(`[swap] ${languageCode} icon is ${state} after ${Math.round((Date.now() - started) / 1000)}s`);
+            last = state;
+        }
+        if (!WAITING_STATES.includes(state)) {
+            return state;
+        }
+        await new Promise((done) => setTimeout(done, APPROVAL_POLL_MS));
+    }
+    options.log(`[swap] gave up waiting for review after ${Math.round((Date.now() - started) / 1000)}s`);
+    return last;
+}
+async function settledSnapshot(universeId, expectedSource) {
+    const started = Date.now();
+    let state = await snapshot(universeId);
+    while (sourceCode(state) !== expectedSource && Date.now() - started < SETTLE_MAX_MS) {
+        await new Promise((done) => setTimeout(done, SETTLE_POLL_MS));
+        state = await snapshot(universeId);
+    }
+    return state;
+}
+async function hold(options) {
+    for (let waited = 0; waited < options.holdMs && !options.shouldStop(); waited += 1000) {
+        await new Promise((done) => setTimeout(done, 1000));
+    }
+}
+export async function languageSwapExperiment(options) {
+    const { cloud, universeId, log } = options;
+    const before = await snapshot(universeId);
+    const original = sourceCode(before);
+    log(`[swap] source language before: ${original}`);
+    log(`[swap] icons before: ${JSON.stringify(await cloud.listIcons())}`);
+    if (original === options.swapTo) {
+        throw new Error(`Source is already ${options.swapTo}; pick another language to swap to`);
+    }
+    let swapped = false;
+    let uploaded = false;
+    try {
+        await cloud.setSourceLanguage(options.swapTo);
+        swapped = true;
+        log(`[swap] source language now: ${sourceCode(await snapshot(universeId))}`);
+        await cloud.setIcon(options.icon, original);
+        uploaded = true;
+        log(`[swap] uploaded test icon as the ${original} translation`);
+        log(`[swap] icons now: ${JSON.stringify(await cloud.listIcons())}`);
+        const state = await waitForApproval(options, original);
+        if (state === "Approved") {
+            log(`[swap] public icon now: ${JSON.stringify(await publicIcon(universeId))}`);
+        }
+        log(`[swap] holding ${Math.round(options.holdMs / 1000)}s: look at the game page now`);
+        await hold(options);
+    }
+    finally {
+        if (uploaded) {
+            await cloud.deleteIcon(original).then(() => log(`[swap] removed the ${original} translation icon`), (error) => log(`[swap] FAILED to remove ${original} icon: ${error.message}`));
+        }
+        if (swapped) {
+            await cloud.setSourceLanguage(original).then(() => log(`[swap] source language restored to ${original}`), (error) => log(`[swap] FAILED to restore source language: ${error.message}`));
+        }
+        const after = await settledSnapshot(universeId, original);
+        log(`[swap] icons after: ${JSON.stringify(await cloud.listIcons().catch((error) => error.message))}`);
+        for (const key of Object.keys(before)) {
+            const same = canonical(before[key]) === canonical(after[key]);
+            log(`[swap] ${key}: ${same ? "unchanged" : `CHANGED\n  before ${JSON.stringify(before[key])}\n  after  ${JSON.stringify(after[key])}`}`);
+        }
+    }
+}
+async function waitMs(ctx, ms) {
+    for (let waited = 0; waited < ms && !ctx.shouldStop(); waited += 1000) {
+        await new Promise((done) => setTimeout(done, 1000));
+    }
+}
+export async function nameChange(ctx) {
+    const { cloud, universeId, log } = ctx;
+    const universe = await cloud.request("GET", `/cloud/v2/universes/${universeId}`, "read universe");
+    const placeId = Number(String(universe.rootPlace).split("/").pop());
+    const placePath = `/cloud/v2/universes/${universeId}/places/${placeId}`;
+    const before = await cloud.request("GET", placePath, "read place");
+    const translationsBefore = await publicJson(`/v1/name-description/games/${universeId}`);
+    log(`[name] universe displayName: ${JSON.stringify(universe.displayName)}`);
+    log(`[name] root place ${placeId}: ${JSON.stringify(before.displayName)} / ${JSON.stringify(String(before.description ?? "").slice(0, 60))}`);
+    const testName = ctx.params.get("testName") || `[TEST] ${before.displayName}`;
+    const testDescription = `${before.description ?? ""}\n\nUpdateDay test ${new Date().toISOString()}`;
+    let changed = false;
+    try {
+        const updated = await cloud.json("PATCH", `${placePath}?updateMask=displayName,description`, "set name", { displayName: testName, description: testDescription });
+        changed = true;
+        log(`[name] wrote: ${JSON.stringify(updated.displayName)}`);
+        const universeAfter = await cloud.request("GET", `/cloud/v2/universes/${universeId}`, "read universe");
+        log(`[name] universe displayName now: ${JSON.stringify(universeAfter.displayName)}`);
+        log(`[name] translations now: ${JSON.stringify(await publicJson(`/v1/name-description/games/${universeId}`)).slice(0, 200)}`);
+        const holdSeconds = Number(ctx.params.get("hold")) || 120;
+        log(`[name] holding ${holdSeconds}s: check the game page now`);
+        await waitMs(ctx, holdSeconds * 1000);
+    }
+    finally {
+        if (changed) {
+            await cloud.json("PATCH", `${placePath}?updateMask=displayName,description`, "restore name", { displayName: before.displayName, description: before.description ?? "" }).then(() => log("[name] restored name and description"), (error) => log(`[name] FAILED to restore: ${error.message}`));
+        }
+        const after = await cloud.request("GET", placePath, "read place");
+        const same = after.displayName === before.displayName && (after.description ?? "") === (before.description ?? "");
+        log(`[name] place after: ${same ? "matches original" : `DIFFERS ${JSON.stringify(after.displayName)}`}`);
+        const translationsAfter = await publicJson(`/v1/name-description/games/${universeId}`);
+        log(`[name] translations: ${canonical(translationsBefore) === canonical(translationsAfter) ? "unchanged" : "CHANGED"}`);
+    }
+}
+export async function clearTestDescriptions(ctx) {
+    const { cloud, universeId, log } = ctx;
+    const marker = ctx.params.get("marker") ?? "";
+    if (!marker) {
+        throw new Error("Pass the marker text that identifies the test descriptions");
+    }
+    const current = (await publicJson(`/v1/name-description/games/${universeId}`));
+    const targets = (current.data ?? []).filter((entry) => String(entry.description ?? "").includes(marker));
+    log(`[clear] ${targets.length} languages carry the test description`);
+    if (targets.length === 0) {
+        return;
+    }
+    const data = targets.map((entry) => ({ description: "", updateType: "Description", languageCode: entry.languageCode }));
+    await cloud.json("PATCH", `/legacy-game-internationalization/v1/name-description/games/${universeId}`, "clear descriptions", { data });
+    await new Promise((done) => setTimeout(done, 3000));
+    const after = (await publicJson(`/v1/name-description/games/${universeId}`));
+    const left = (after.data ?? []).filter((entry) => String(entry.description ?? "").includes(marker));
+    log(`[clear] languages still carrying it: ${left.length ? left.map((entry) => entry.languageCode).join(", ") : "none"}`);
+}
+export async function listShapes(ctx) {
+    const { cloud, universeId, log } = ctx;
+    const passes = await cloud.request("GET", `/game-passes/v1/universes/${universeId}/game-passes/creator?pageSize=2`, "list passes");
+    log(`[shape] passes keys: ${Object.keys(passes).join(",")}`);
+    log(`[shape] pass item: ${JSON.stringify((passes.gamePasses ?? passes.data ?? [])[0])}`);
+    const products = await cloud.request("GET", `/developer-products/v2/universes/${universeId}/developer-products/creator?pageSize=2`, "list products");
+    log(`[shape] products keys: ${Object.keys(products).join(",")}`);
+    log(`[shape] product item: ${JSON.stringify((products.developerProducts ?? products.data ?? [])[0])}`);
+}
+export async function pageShapes(ctx) {
+    const { cloud, universeId, log } = ctx;
+    const events = await cloud.request("GET", `/virtual-events/v3/universes/${universeId}/game-events`, "list events");
+    log(`[page] events keys: ${Object.keys(events ?? {}).join(",")}`);
+    log(`[page] event item: ${JSON.stringify((events?.gameEvents ?? events?.data ?? events?.events ?? [])[0]).slice(0, 900)}`);
+    const universe = await cloud.request("GET", `/cloud/v2/universes/${universeId}`, "read universe");
+    log(`[page] universe: ${JSON.stringify(universe).slice(0, 600)}`);
+    log(`[page] thumbnails: ${JSON.stringify(await publicJson(`/v1/game-thumbnails/games/${universeId}/images`)).slice(0, 400)}`);
+    const games = await fetch(`https://games.roblox.com/v1/games?universeIds=${universeId}`).then((r) => r.json());
+    log(`[page] games api: ${JSON.stringify(games).slice(0, 300)}`);
+}
+export async function eventCategories(ctx) {
+    const { cloud, universeId, log } = ctx;
+    const list = await cloud.request("GET", `/virtual-events/v3/universes/${universeId}/game-events`, "list events");
+    const event = (list?.gameEvents ?? []).find((item) => item.title === "UpdateDay events test");
+    if (!event) {
+        log("[cat] test event not found");
+        return;
+    }
+    log(`[cat] test event ${event.id}, categories now ${JSON.stringify(event.categories)}`);
+    const tries = [
+        [{ category: "newContent", rank: 0 }],
+        [{ category: "NewContent", rank: 0 }],
+        [{ category: "NewContent", rank: 1 }],
+        [{ category: "newContent", rank: 1 }, { category: "newFeature", rank: 2 }],
+        [{ category: "contentUpdate", rank: 0 }],
+    ];
+    for (const categories of tries) {
+        try {
+            const result = await cloud.json("PATCH", `/virtual-events/v3/game-events/${event.id}`, "patch categories", { categories });
+            log(`[cat] OK ${JSON.stringify(categories)} -> ${JSON.stringify(result?.categories)}`);
+        }
+        catch (error) {
+            log(`[cat] NO ${JSON.stringify(categories)}: ${String(error.message).slice(0, 160)}`);
+        }
+    }
+    if (ctx.params.get("delete") === "1") {
+        await cloud.request("DELETE", `/virtual-events/v3/game-events/${event.id}`, "delete event");
+        log("[cat] deleted the test event");
+    }
+}
+export async function eventCategoryList(ctx) {
+    const { cloud, universeId, log } = ctx;
+    const list = await cloud.request("GET", `/virtual-events/v3/universes/${universeId}/game-events`, "list events");
+    const event = (list?.gameEvents ?? []).find((item) => item.title === "UpdateDay live test");
+    if (!event) {
+        log("[cats] live test event not found");
+        return;
+    }
+    const all = ["contentUpdate", "locationUpdate", "systemUpdate", "activity", "newContent", "itemDrop", "newSeason", "newLocation", "newMap", "moreLevels", "newFeature", "earlyAccess", "expansion", "challenge", "quest", "festival"];
+    const accepted = [];
+    const refused = [];
+    for (const category of all) {
+        try {
+            await cloud.json("PATCH", `/virtual-events/v3/game-events/${event.id}`, "patch", { categories: [{ category, rank: 0 }] });
+            accepted.push(category);
+        }
+        catch {
+            refused.push(category);
+        }
+    }
+    await cloud.json("PATCH", `/virtual-events/v3/game-events/${event.id}`, "reset", { categories: [] }).catch((error) => log(`[cats] reset failed: ${error.message.slice(0, 120)}`));
+    log(`[cats] accepted: ${accepted.join(", ")}`);
+    log(`[cats] refused: ${refused.join(", ")}`);
+}
+export async function iconUrls(ctx) {
+    const list = await ctx.cloud.listIcons();
+    for (const icon of list?.data ?? []) {
+        ctx.log(`[icons] ${icon.languageCode} ${icon.state} ${icon.imageUrl ?? ""}`);
+    }
+}
+async function freshImage(label) {
+    const sharp = (await import("sharp")).default;
+    const stamp = new Date().toISOString();
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="512" height="512">
+	<rect width="512" height="512" fill="#1d2633"/>
+	<text x="256" y="250" text-anchor="middle" font-family="Arial Black, Arial" font-weight="900" font-size="88" fill="#ffffff">${label}</text>
+	<text x="256" y="330" text-anchor="middle" font-family="Arial" font-size="22" fill="#8fa3bf">${stamp}</text>
+</svg>`;
+    const png = await sharp(Buffer.from(svg)).png().toBuffer();
+    return new Blob([new Uint8Array(png)], { type: "image/png" });
+}
+async function assetState(ctx, assetId) {
+    const asset = await ctx.cloud.request("GET", `/assets/v1/assets/${assetId}?readMask=moderationResult`, "read asset");
+    return String(asset?.moderationResult?.moderationState ?? "unknown");
+}
+async function iconStates(ctx) {
+    const states = {};
+    for (const icon of (await ctx.cloud.listIcons())?.data ?? []) {
+        states[icon.languageCode] = icon.state;
+    }
+    return states;
+}
+export async function preReview(ctx) {
+    const { cloud, log } = ctx;
+    const reviewed = await freshImage("TEST A");
+    const unreviewed = await freshImage("TEST B");
+    const started = Date.now();
+    const seconds = () => Math.round((Date.now() - started) / 1000);
+    const assetId = await cloud.uploadImage(reviewed, "UpdateDay pre-review test");
+    log(`[pre] uploaded image A as asset ${assetId} after ${seconds()}s`);
+    let state = "";
+    const assetWaitMs = (Number(ctx.params.get("assetWait")) || 600) * 1000;
+    while (Date.now() - started < assetWaitMs && !ctx.shouldStop()) {
+        const now = await assetState(ctx, assetId);
+        if (now !== state) {
+            log(`[pre] asset A is ${now} at ${seconds()}s`);
+            state = now;
+        }
+        if (now !== "Reviewing" && now !== "unknown") {
+            break;
+        }
+        await waitMs(ctx, 5000);
+    }
+    const iconStart = Date.now();
+    await cloud.setIcon(reviewed, "es");
+    await cloud.setIcon(unreviewed, "de");
+    log("[pre] set A (pre-reviewed) as the es icon and B (fresh) as the de icon");
+    const seen = {};
+    const iconWaitMs = (Number(ctx.params.get("iconWait")) || 300) * 1000;
+    try {
+        while (Date.now() - iconStart < iconWaitMs && !ctx.shouldStop()) {
+            const states = await iconStates(ctx);
+            for (const code of ["es", "de"]) {
+                if (states[code] !== seen[code]) {
+                    log(`[pre] ${code} icon is ${states[code]} ${Math.round((Date.now() - iconStart) / 1000)}s after upload`);
+                    seen[code] = states[code];
+                }
+            }
+            if (seen.es === "Approved" && seen.de === "Approved") {
+                break;
+            }
+            await waitMs(ctx, 5000);
+        }
+    }
+    finally {
+        for (const code of ["es", "de"]) {
+            await cloud.deleteIcon(code).then(() => log(`[pre] removed the ${code} test icon`), (error) => log(`[pre] FAILED to remove ${code} icon: ${error.message}`));
+        }
+    }
+}
+export async function stageTiming(ctx) {
+    const { cloud, log } = ctx;
+    const source = String((await publicJson(`/v1/source-language/games/${ctx.universeId}`)).languageCode);
+    const supported = ((await publicJson(`/v1/supported-languages/games/${ctx.universeId}`)).data ?? []).map((item) => item.languageCode).filter((code) => code !== source);
+    const image = await freshImage("STAGE");
+    const started = Date.now();
+    for (const code of supported) {
+        await cloud.setIcon(image, code);
+        await waitMs(ctx, 250);
+    }
+    log(`[stage] uploaded to ${supported.length} languages in ${Math.round((Date.now() - started) / 1000)}s`);
+    const approvedAt = {};
+    try {
+        while (Date.now() - started < 600000 && !ctx.shouldStop() && Object.keys(approvedAt).length < supported.length) {
+            const states = await iconStates(ctx);
+            for (const code of supported) {
+                if (!approvedAt[code] && states[code] === "Approved") {
+                    approvedAt[code] = Math.round((Date.now() - started) / 1000);
+                }
+            }
+            await waitMs(ctx, 5000);
+        }
+        const times = Object.values(approvedAt).sort((a, b) => a - b);
+        log(`[stage] approved ${times.length}/${supported.length}; first ${times[0]}s, median ${times[Math.floor(times.length / 2)]}s, last ${times[times.length - 1]}s`);
+        log(`[stage] per language: ${JSON.stringify(approvedAt)}`);
+    }
+    finally {
+        for (const code of supported) {
+            await cloud.deleteIcon(code).catch((error) => log(`[stage] FAILED to remove ${code}: ${error.message}`));
+            await waitMs(ctx, 250);
+        }
+        log(`[stage] removed the test icons; left: ${JSON.stringify(Object.keys(await iconStates(ctx)))}`);
+    }
+}

package/dist/gamePage.js

@@ -0,0 +1,143 @@
+const GAMES_API = "https://games.roblox.com/v1/games";
+const ICON_API = "https://thumbnails.roblox.com/v1/games/icons";
+const ASSET_THUMBS_API = "https://thumbnails.roblox.com/v1/assets";
+const I18N_API = "https://gameinternationalization.roblox.com/v1/game-thumbnails/games";
+const USERS_API = "https://users.roblox.com/v1/users";
+const GROUPS_API = "https://groups.roblox.com/v1/groups";
+const RECOMMENDED_THUMBNAILS = 3;
+const EVENT_WINDOW_MS = 24 * 60 * 60 * 1000;
+const UPDATE_TAG = /\[[^\]]*update[^\]]*\]|\bupd(ate)?\b|🆕|🎃|🔥|✨|⭐/i;
+const PLACEHOLDER = /^\[.*UNAVAILABLE\]$/;
+async function getJson(url) {
+    const response = await fetch(url);
+    return response.ok ? response.json() : null;
+}
+async function publicDetails(universeId) {
+    const [games, votes] = await Promise.all([
+        getJson(`${GAMES_API}?universeIds=${universeId}`),
+        getJson(`${GAMES_API}/votes?universeIds=${universeId}`),
+    ]);
+    const game = games?.data?.[0];
+    if (!game || PLACEHOLDER.test(String(game.name))) {
+        return null;
+    }
+    const vote = votes?.data?.[0];
+    const totalVotes = (vote?.upVotes ?? 0) + (vote?.downVotes ?? 0);
+    return { ...game, likeRatio: totalVotes ? Math.round((vote.upVotes / totalVotes) * 100) : null };
+}
+async function iconUrl(universeId) {
+    const json = await getJson(`${ICON_API}?universeIds=${universeId}&size=512x512&format=Png&isCircular=false`);
+    return json?.data?.[0]?.imageUrl ?? null;
+}
+async function thumbnailUrls(universeId, languageCode) {
+    const json = await getJson(`${I18N_API}/${universeId}/images`);
+    const entry = (json?.data ?? []).find((item) => item.languageCode === languageCode) ?? json?.data?.[0];
+    const assetIds = (entry?.mediaAssets ?? []).map((asset) => Number(asset.mediaAssetId ?? asset.id ?? asset)).filter(Boolean);
+    if (assetIds.length === 0) {
+        return [];
+    }
+    const thumbs = await getJson(`${ASSET_THUMBS_API}?assetIds=${assetIds.join(",")}&size=768x432&format=Png`);
+    return (thumbs?.data ?? []).map((item) => item.imageUrl).filter(Boolean);
+}
+async function creatorName(owner) {
+    const match = /^(users|groups)\/(\d+)$/.exec(owner ?? "");
+    if (!match) {
+        return null;
+    }
+    const json = await getJson(`${match[1] === "users" ? USERS_API : GROUPS_API}/${match[2]}`);
+    return json?.name ? (match[1] === "groups" ? `${json.name} (group)` : `@${json.name}`) : null;
+}
+function devicesOf(universe) {
+    const names = {
+        desktopEnabled: "Computer",
+        mobileEnabled: "Phone",
+        tabletEnabled: "Tablet",
+        consoleEnabled: "Console",
+        vrEnabled: "VR",
+    };
+    return Object.entries(names).filter(([key]) => universe?.[key]).map(([, label]) => label);
+}
+function eventsNearUpdate(events, updateAt) {
+    return events.filter((event) => Math.abs(Date.parse(event.startTime) - updateAt.getTime()) <= EVENT_WINDOW_MS);
+}
+function buildChecks(config, report, updatedAt) {
+    const checks = [];
+    const updateAt = new Date(config.updateAt);
+    if (report.visibility === "PRIVATE") {
+        checks.push({ level: "warn", title: "The game is private", detail: "Players can't see the countdown, sale or event until it's public." });
+    }
+    if (report.thumbnails.length < RECOMMENDED_THUMBNAILS) {
+        checks.push({
+            level: "warn",
+            title: report.thumbnails.length === 0 ? "No thumbnails" : `Only ${report.thumbnails.length} thumbnail${report.thumbnails.length === 1 ? "" : "s"}`,
+            detail: "Game pages usually show 3 or more; the first one is the one most players see.",
+        });
+    }
+    else {
+        checks.push({ level: "ok", title: `${report.thumbnails.length} thumbnails` });
+    }
+    if (!report.description.trim()) {
+        checks.push({ level: "warn", title: "No description", detail: "Say what's new in this update; it shows on the game page." });
+    }
+    const nearby = eventsNearUpdate(report.events, updateAt);
+    if (nearby.length > 0) {
+        checks.push({ level: "ok", title: `Event for the update: ${nearby[0].title}` });
+    }
+    else if (config.event) {
+        checks.push({ level: "info", title: "Event will be created", detail: `UpdateDay creates "${config.event.title}" when it starts.` });
+    }
+    else {
+        checks.push({ level: "warn", title: "No event for this update", detail: "Events show on the game page and in players' calendars." });
+    }
+    const plannedRename = (config.nameChanges ?? []).some((change) => change.name);
+    if (UPDATE_TAG.test(report.name)) {
+        checks.push({ level: "ok", title: "Title has an update tag" });
+    }
+    else if (plannedRename) {
+        checks.push({ level: "ok", title: "A title change is scheduled" });
+    }
+    else {
+        checks.push({ level: "info", title: "Title has no update tag", detail: "Many games add [UPDATE] or an emoji to the title while the update is fresh." });
+    }
+    if (updatedAt) {
+        const days = Math.floor((Date.now() - Date.parse(updatedAt)) / EVENT_WINDOW_MS);
+        checks.push({ level: "info", title: days <= 0 ? "Last update today" : `Last update ${days} day${days === 1 ? "" : "s"} ago` });
+    }
+    if (config.sale) {
+        checks.push({ level: "ok", title: `Sale planned: ${config.sale.percentOff}% off` });
+    }
+    return checks;
+}
+export async function pageReport(config, cloud) {
+    const [details, icon, thumbnails] = await Promise.all([
+        publicDetails(config.universeId),
+        iconUrl(config.universeId),
+        thumbnailUrls(config.universeId, config.languageCode),
+    ]);
+    const universe = cloud ? await cloud.getUniverse().catch(() => null) : null;
+    const events = cloud ? await cloud.request("GET", `/virtual-events/v3/universes/${config.universeId}/game-events`, "list events").then((json) => json?.gameEvents ?? []).catch(() => []) : [];
+    const report = {
+        name: String(universe?.displayName ?? details?.name ?? config.name),
+        description: String(universe?.description ?? details?.description ?? ""),
+        creator: universe ? await creatorName(universe.user ?? universe.group) : details?.creator?.name ?? null,
+        visibility: universe?.visibility ?? (details ? "PUBLIC" : null),
+        ageRating: universe?.ageRating ?? null,
+        devices: devicesOf(universe),
+        iconUrl: icon,
+        thumbnails,
+        stats: details ? {
+            playing: details.playing ?? null,
+            visits: details.visits ?? null,
+            favorites: details.favoritedCount ?? null,
+            liked: details.likeRatio,
+            serverSize: details.maxPlayers ?? null,
+            genre: details.genre ?? null,
+            updated: details.updated ?? null,
+        } : null,
+        events,
+        checks: [],
+        keyUsed: Boolean(cloud),
+    };
+    report.checks = buildChecks(config, report, details?.updated ?? null);
+    return report;
+}

package/dist/gifts.js

@@ -0,0 +1,55 @@
+import { randomUUID } from "node:crypto";
+import { readEntry, saveEntry } from "./playerData.js";
+export const DEFAULT_GIFT_STORE = "UpdateDayGifts";
+export const GIFT_TOPIC = "UpdateDayGifts";
+const MAX_AMOUNT = 50;
+const SAVE_ATTEMPTS = 3;
+function giftsOf(value) {
+    const gifts = value?.gifts;
+    return Array.isArray(gifts) ? gifts : [];
+}
+function validate(input) {
+    if (!input.category?.trim() || !input.item?.trim()) {
+        throw new Error("Pick what to give");
+    }
+    if (!Number.isInteger(input.amount) || input.amount < 1 || input.amount > MAX_AMOUNT) {
+        throw new Error(`Amount must be 1 to ${MAX_AMOUNT}`);
+    }
+}
+export async function pendingGifts(cloud, store, userId) {
+    const entry = await readEntry(cloud, store, String(userId));
+    return giftsOf(entry?.value);
+}
+async function changeGifts(cloud, baseDir, store, userId, reason, change) {
+    let lastError = null;
+    for (let attempt = 0; attempt < SAVE_ATTEMPTS; attempt++) {
+        const entry = await readEntry(cloud, store, String(userId));
+        const next = change(giftsOf(entry?.value));
+        try {
+            await saveEntry(cloud, baseDir, store, String(userId), { gifts: next }, entry?.etag ?? null, reason);
+            return next;
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    throw lastError;
+}
+export async function sendGift(cloud, baseDir, store, userId, input) {
+    validate(input);
+    const gift = {
+        id: randomUUID(),
+        category: input.category.trim(),
+        item: input.item.trim(),
+        tier: input.tier?.trim() || null,
+        amount: input.amount,
+        sentAt: new Date().toISOString(),
+        note: input.note?.trim() || null,
+    };
+    await changeGifts(cloud, baseDir, store, userId, `gift ${gift.amount}x ${gift.item}`, (gifts) => [...gifts, gift]);
+    await cloud.publishMessage(GIFT_TOPIC, JSON.stringify({ userId })).catch(() => null);
+    return gift;
+}
+export async function cancelGift(cloud, baseDir, store, userId, giftId) {
+    return changeGifts(cloud, baseDir, store, userId, `cancel gift ${giftId}`, (gifts) => gifts.filter((gift) => gift.id !== giftId));
+}

package/dist/history.js

@@ -0,0 +1,68 @@
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { setLogSink } from "./state.js";
+const HISTORY_FILE = "updateday-history.jsonl";
+const DEFAULT_LIMIT = 500;
+export function historyPath(baseDir) {
+    return join(baseDir, HISTORY_FILE);
+}
+export function kindOf(text) {
+    if (/^(FAILED|ERROR)\b|failed|refused|couldn't/i.test(text)) {
+        return "error";
+    }
+    if (/^RUN\b/.test(text)) {
+        return "step";
+    }
+    if (/^SKIP\b/.test(text)) {
+        return "skip";
+    }
+    if (/^REMINDER\b/.test(text)) {
+        return "reminder";
+    }
+    if (/->|restored|renamed|name restored/.test(text)) {
+        return "sale";
+    }
+    return "info";
+}
+export function appendHistory(baseDir, config, text) {
+    const clean = text.trim();
+    if (!clean) {
+        return;
+    }
+    const entry = { at: new Date().toISOString(), game: config.name, universeId: config.universeId, kind: kindOf(clean), text: clean };
+    try {
+        appendFileSync(historyPath(baseDir), JSON.stringify(entry) + "\n");
+    }
+    catch {
+    }
+}
+export async function recording(config, task) {
+    setLogSink((message) => appendHistory(config.baseDir, config, message));
+    try {
+        return await task();
+    }
+    finally {
+        setLogSink(null);
+    }
+}
+export function readHistory(baseDir, universeId, limit = DEFAULT_LIMIT) {
+    const path = historyPath(baseDir);
+    if (!existsSync(path)) {
+        return [];
+    }
+    const entries = [];
+    for (const line of readFileSync(path, "utf8").split("\n")) {
+        if (!line.trim()) {
+            continue;
+        }
+        try {
+            const entry = JSON.parse(line);
+            if (universeId === undefined || entry.universeId === universeId) {
+                entries.push(entry);
+            }
+        }
+        catch {
+        }
+    }
+    return entries.slice(-limit).reverse();
+}