@playdrop/playdrop-cli 0.16.12 → 0.17.0

package/dist/commands/worker/e2e-fixtures.js

@@ -0,0 +1,466 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLAYDROP_E2E_MARKERS = void 0;
+exports.detectPlaydropE2EFixture = detectPlaydropE2EFixture;
+exports.isPlaydropE2EGameKind = isPlaydropE2EGameKind;
+exports.isPlaydropE2EMediaKind = isPlaydropE2EMediaKind;
+exports.buildPlaydropE2EScreeningOutput = buildPlaydropE2EScreeningOutput;
+exports.writePlaydropE2EPng = writePlaydropE2EPng;
+exports.validatePlaydropE2EGameFixture = validatePlaydropE2EGameFixture;
+exports.replaceWithPlaydropE2EGameFixture = replaceWithPlaydropE2EGameFixture;
+exports.buildPlaydropE2EMetadata = buildPlaydropE2EMetadata;
+exports.buildPlaydropE2ETriangleGlb = buildPlaydropE2ETriangleGlb;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+exports.PLAYDROP_E2E_MARKERS = {
+    NEW_GAME: "[PLAYDROP-E2E:NEW:v1]",
+    GAME_UPDATE: "[PLAYDROP-E2E:UPDATE:v1]",
+    REMIX_GAME: "[PLAYDROP-E2E:REMIX:v1]",
+    IMAGE: "[PLAYDROP-E2E:IMAGE:v1]",
+    MODEL_3D: "[PLAYDROP-E2E:MODEL_3D:v1]",
+    VIDEO: "[PLAYDROP-E2E:VIDEO:v1]",
+    SFX: "[PLAYDROP-E2E:SFX:v1]",
+    SPEECH: "[PLAYDROP-E2E:SPEECH:v1]",
+    MUSIC: "[PLAYDROP-E2E:MUSIC:v1]",
+};
+const PLAYDROP_E2E_MARKER_ENTRIES = Object.entries(exports.PLAYDROP_E2E_MARKERS);
+function detectPlaydropE2EFixture(input) {
+    const matches = PLAYDROP_E2E_MARKER_ENTRIES.filter(([, marker]) => input.includes(marker));
+    if (matches.length > 1) {
+        throw new Error(`playdrop_e2e_marker_ambiguous:${matches.map(([, marker]) => marker).join(",")}`);
+    }
+    return matches[0]?.[0] ?? null;
+}
+function isPlaydropE2EGameKind(kind) {
+    return kind === "NEW_GAME" || kind === "GAME_UPDATE" || kind === "REMIX_GAME";
+}
+function isPlaydropE2EMediaKind(kind) {
+    return kind === "IMAGE" || kind === "MODEL_3D" || kind === "VIDEO" || kind === "SFX" || kind === "SPEECH" || kind === "MUSIC";
+}
+function buildPlaydropE2EScreeningOutput(prompt) {
+    return {
+        promptLanguage: "en",
+        promptEnglishTranslation: prompt,
+        decision: "proceed",
+        effort: "simple",
+        rejectCategory: null,
+        flags: [],
+        reason: null,
+    };
+}
+function escapeHtml(value) {
+    return value
+        .replace(/&/gu, "&amp;")
+        .replace(/</gu, "&lt;")
+        .replace(/>/gu, "&gt;")
+        .replace(/"/gu, "&quot;")
+        .replace(/'/gu, "&#39;");
+}
+async function writePlaydropE2EPng(input) {
+    const sharp = (await Promise.resolve().then(() => __importStar(require("sharp")))).default;
+    const fontSize = Math.max(28, Math.round(Math.min(input.width, input.height) * 0.08));
+    const svg = Buffer.from(`
+    <svg xmlns="http://www.w3.org/2000/svg" width="${input.width}" height="${input.height}" viewBox="0 0 ${input.width} ${input.height}">
+      <defs>
+        <linearGradient id="background" x1="0" y1="0" x2="1" y2="1">
+          <stop offset="0" stop-color="#7138ff"/>
+          <stop offset="1" stop-color="#171027"/>
+        </linearGradient>
+      </defs>
+      <rect width="100%" height="100%" fill="url(#background)"/>
+      <circle cx="${Math.round(input.width * 0.76)}" cy="${Math.round(input.height * 0.24)}" r="${Math.round(Math.min(input.width, input.height) * 0.14)}" fill="#ffcc33"/>
+      <rect x="${Math.round(input.width * 0.1)}" y="${Math.round(input.height * 0.42)}" width="${Math.round(input.width * 0.8)}" height="${Math.round(input.height * 0.28)}" rx="${Math.round(Math.min(input.width, input.height) * 0.04)}" fill="#241944" fill-opacity="0.9"/>
+      <text x="50%" y="56%" dominant-baseline="middle" text-anchor="middle" fill="white" font-family="system-ui, sans-serif" font-size="${fontSize}" font-weight="800">${escapeHtml(input.label)}</text>
+      <text x="50%" y="64%" dominant-baseline="middle" text-anchor="middle" fill="#d8cff5" font-family="system-ui, sans-serif" font-size="${Math.max(18, Math.round(fontSize * 0.42))}">Deterministic fixture v1</text>
+    </svg>
+  `);
+    await sharp(svg).png().toFile(input.filePath);
+}
+function buildGameHtml(input) {
+    const displayName = escapeHtml(input.displayName);
+    const kind = escapeHtml(input.kind);
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="playdrop-e2e-fixture" content="v1" />
+    <title>${displayName}</title>
+    <style>
+      :root { color-scheme: dark; font-family: ui-rounded, system-ui, sans-serif; }
+      * { box-sizing: border-box; }
+      html, body { margin: 0; min-height: 100%; }
+      body { display: grid; place-items: center; background: radial-gradient(circle at top, #7138ff, #151026 65%); color: white; }
+      main { width: min(92vw, 560px); padding: 40px; border: 2px solid #bda8ff; border-radius: 28px; background: #21183dcc; text-align: center; box-shadow: 0 24px 80px #080411aa; }
+      body[data-scored="true"] { background: radial-gradient(circle at bottom, #ffcc33, #361a70 70%); }
+      body[data-scored="true"] main { border-color: #ffcc33; background: #4b258d; transform: scale(1.04); }
+      h1 { margin: 0 0 8px; font-size: clamp(2rem, 8vw, 4rem); }
+      p { color: #d8cff5; }
+      #score { display: block; margin: 28px 0; font-size: 5rem; font-weight: 900; }
+      button { min-width: 180px; padding: 16px 24px; border: 0; border-radius: 999px; background: #ffcc33; color: #211000; font: inherit; font-weight: 800; cursor: pointer; }
+      small { display: block; margin-top: 24px; color: #a89bc9; }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>${displayName}</h1>
+      <p>Deterministic PlayDrop Cloud worker fixture</p>
+      <output id="score">0</output>
+      <button id="add" type="button">Score a point</button>
+      <small>Task ${input.taskId} · ${kind}</small>
+    </main>
+    <script src="https://assets.playdrop.ai/sdk/playdrop.js"></script>
+    <script>
+      const score = document.querySelector("#score");
+      window.addEventListener("pointerdown", () => {
+        score.textContent = String(Number(score.textContent) + 1);
+        document.body.dataset.scored = "true";
+      });
+      void (async () => {
+        const sdk = await window.playdrop.init();
+        sdk.host.ready();
+      })().catch((error) => {
+        window.playdrop?.host?.error(String(error));
+        throw error;
+      });
+    </script>
+  </body>
+</html>
+`;
+}
+const PLAYDROP_E2E_PROCEDURAL_ASSET_NAME = "playdrop-e2e-procedural";
+function buildPlaydropE2EProceduralManifest() {
+    return {
+        manifestProtocol: "playdrop-procedural-manifest@1",
+        protocol: "playdrop-procedural@1",
+        id: PLAYDROP_E2E_PROCEDURAL_ASSET_NAME,
+        title: "PlayDrop E2E Procedural Beacon",
+        version: "1.0.0",
+        kind: "model",
+        summary: "A deterministic procedural Three.js beacon created by the PlayDrop Cloud worker update fixture.",
+        tags: ["playdrop", "e2e", "procedural"],
+        pack: {
+            id: "playdrop-e2e-fixtures",
+            title: "PlayDrop E2E Fixtures",
+            sourceProject: ".",
+        },
+        sourceEntry: `assets/${PLAYDROP_E2E_PROCEDURAL_ASSET_NAME}.ts`,
+        distFile: `assets/${PLAYDROP_E2E_PROCEDURAL_ASSET_NAME}.mjs`,
+        requirements: { renderer: "webgl", three: "0.183.2" },
+        presentation: {
+            scene: "dark",
+            camera: { view: "perspective", azimuth: -32, elevation: 18, padding: 1.25 },
+        },
+        platformAssetRef: null,
+        parameters: {
+            color: {
+                type: "color",
+                label: "Beacon color",
+                default: "#7138ff",
+                affects: "material",
+            },
+        },
+        animations: [],
+        parts: ["beacon"],
+        sockets: [],
+        capabilities: { controls: true, selection: true, timeline: false, character: false },
+    };
+}
+function buildPlaydropE2EProceduralModule() {
+    return `import * as THREE from "three";
+
+export const info = {
+  protocol: "playdrop-procedural@1",
+  id: "${PLAYDROP_E2E_PROCEDURAL_ASSET_NAME}",
+  title: "PlayDrop E2E Procedural Beacon",
+  version: "1.0.0",
+  kind: "model",
+  summary: "A deterministic procedural Three.js beacon created by the PlayDrop Cloud worker update fixture.",
+  tags: ["playdrop", "e2e", "procedural"],
+  pack: { id: "playdrop-e2e-fixtures", title: "PlayDrop E2E Fixtures", sourceProject: "." },
+  sourceEntry: "assets/${PLAYDROP_E2E_PROCEDURAL_ASSET_NAME}.ts",
+  distFile: "assets/${PLAYDROP_E2E_PROCEDURAL_ASSET_NAME}.mjs",
+  requirements: { renderer: "webgl", three: "0.183.2" }
+};
+
+export function create(context = {}) {
+  const color = context.parameters?.color ?? "#7138ff";
+  const root = new THREE.Group();
+  root.name = "playdrop-e2e-procedural-beacon";
+  const geometry = new THREE.TorusKnotGeometry(0.72, 0.2, 128, 20);
+  const material = new THREE.MeshStandardMaterial({ color, metalness: 0.35, roughness: 0.28 });
+  const beacon = new THREE.Mesh(geometry, material);
+  beacon.name = "beacon";
+  beacon.castShadow = true;
+  beacon.receiveShadow = true;
+  root.add(beacon);
+  return {
+    object: root,
+    capabilities: {
+      controls: {
+        parameters: {
+          color: { type: "color", label: "Beacon color", default: "#7138ff", affects: "material" }
+        },
+        values: () => ({ color: "#" + material.color.getHexString() }),
+        configure: (values) => {
+          if (typeof values.color === "string") material.color.set(values.color);
+        }
+      },
+      selection: { parts: { beacon }, sockets: {} }
+    },
+    update: (_deltaSeconds, elapsedSeconds) => { beacon.rotation.y = elapsedSeconds * 0.45; },
+    dispose: () => { geometry.dispose(); material.dispose(); }
+  };
+}
+`;
+}
+async function writePlaydropE2EProceduralAsset(projectDir) {
+    const JSZip = (await Promise.resolve().then(() => __importStar(require("jszip")))).default;
+    const assetDir = node_path_1.default.join(projectDir, "assets");
+    await (0, promises_1.mkdir)(assetDir, { recursive: true });
+    const source = buildPlaydropE2EProceduralModule();
+    const archive = new JSZip();
+    archive.file(`assets/${PLAYDROP_E2E_PROCEDURAL_ASSET_NAME}.ts`, source, {
+        date: new Date("1980-01-01T00:00:00.000Z"),
+        createFolders: true,
+    });
+    archive.file("README.md", "# PlayDrop E2E procedural fixture\n", {
+        date: new Date("1980-01-01T00:00:00.000Z"),
+    });
+    const sourceZip = await archive.generateAsync({
+        type: "nodebuffer",
+        compression: "DEFLATE",
+        compressionOptions: { level: 9 },
+    });
+    await Promise.all([
+        (0, promises_1.writeFile)(node_path_1.default.join(assetDir, `${PLAYDROP_E2E_PROCEDURAL_ASSET_NAME}.mjs`), source, "utf8"),
+        (0, promises_1.writeFile)(node_path_1.default.join(assetDir, `${PLAYDROP_E2E_PROCEDURAL_ASSET_NAME}.manifest.json`), `${JSON.stringify(buildPlaydropE2EProceduralManifest(), null, 2)}\n`, "utf8"),
+        writePlaydropE2EPng({
+            filePath: node_path_1.default.join(assetDir, `${PLAYDROP_E2E_PROCEDURAL_ASSET_NAME}.png`),
+            width: 768,
+            height: 768,
+            label: "PROCEDURAL 3D",
+        }),
+        (0, promises_1.writeFile)(node_path_1.default.join(assetDir, `${PLAYDROP_E2E_PROCEDURAL_ASSET_NAME}-source.zip`), sourceZip),
+        (0, promises_1.writeFile)(node_path_1.default.join(assetDir, `${PLAYDROP_E2E_PROCEDURAL_ASSET_NAME}.LICENSE.txt`), "CC0 1.0 Universal\n", "utf8"),
+    ]);
+}
+async function validatePlaydropE2EGameFixture(input) {
+    const htmlPath = node_path_1.default.join(input.projectDir, "index.html");
+    const actualHtml = await (0, promises_1.readFile)(htmlPath, "utf8").catch(() => {
+        throw new Error("playdrop_e2e_fixture_html_missing");
+    });
+    const expectedHtml = buildGameHtml({
+        displayName: input.displayName,
+        taskId: input.taskId,
+        kind: input.kind,
+    });
+    if (actualHtml !== expectedHtml) {
+        throw new Error("playdrop_e2e_fixture_html_mismatch");
+    }
+    if (input.kind === "GAME_UPDATE") {
+        const manifestPath = node_path_1.default.join(input.projectDir, "assets", `${PLAYDROP_E2E_PROCEDURAL_ASSET_NAME}.manifest.json`);
+        const manifest = JSON.parse(await (0, promises_1.readFile)(manifestPath, "utf8"));
+        if (manifest.id !== PLAYDROP_E2E_PROCEDURAL_ASSET_NAME || manifest.platformAssetRef !== null) {
+            throw new Error("playdrop_e2e_fixture_procedural_manifest_mismatch");
+        }
+    }
+}
+async function replaceWithPlaydropE2EGameFixture(input) {
+    if (!node_path_1.default.isAbsolute(input.projectDir) || !(0, node_fs_1.existsSync)(node_path_1.default.join(input.projectDir, ".git"))) {
+        throw new Error("playdrop_e2e_game_source_git_required");
+    }
+    for (const entry of await (0, promises_1.readdir)(input.projectDir, { withFileTypes: true })) {
+        if (entry.name === ".git")
+            continue;
+        await (0, promises_1.rm)(node_path_1.default.join(input.projectDir, entry.name), { recursive: true, force: true });
+    }
+    const listingDir = node_path_1.default.join(input.projectDir, "listing");
+    await (0, promises_1.mkdir)(listingDir, { recursive: true });
+    const playtestTape = {
+        version: 1,
+        primaryVerb: "tap",
+        durationMs: 2500,
+        startOnlyEventCount: 0,
+        successSignals: [
+            {
+                kind: "VISIBLE_PROGRESS",
+                description: "The visible score increases while an idle run remains unchanged.",
+            },
+        ],
+        events: [{ type: "tap", atMs: 1000, x: 0.5, y: 0.5, durationMs: 100 }],
+    };
+    const catalogue = {
+        apps: [
+            {
+                name: input.appName,
+                version: input.outputVersion,
+                displayName: input.displayName,
+                subtitle: input.subtitle,
+                description: "A deterministic score-chasing game produced by the PlayDrop Cloud worker fixture, where players tap to earn points and verify every publishing, loading, and runtime integration.",
+                emoji: "test",
+                color: "#7138FF",
+                type: "GAME",
+                authMode: "NONE",
+                controllerMode: "UNSUPPORTED",
+                previewable: true,
+                file: "index.html",
+                primarySurface: input.primarySurface,
+                surfaceTargets: {
+                    desktop: true,
+                    mobileLandscape: true,
+                    mobilePortrait: true,
+                },
+                listing: {
+                    icon: "listing/icon.png",
+                    heroPortrait: "listing/hero-portrait.png",
+                    heroLandscape: "listing/hero-landscape.png",
+                },
+                playtestTapes: {
+                    DESKTOP: playtestTape,
+                    MOBILE_LANDSCAPE: playtestTape,
+                    MOBILE_PORTRAIT: playtestTape,
+                },
+                releaseNotes: `Deterministic ${input.kind} E2E fixture.`,
+                hostingMode: "HOSTED",
+                // The fixture also serves as the deterministic source for the browser remix journey.
+                license: "PLAYDROP",
+                ...(input.kind === "GAME_UPDATE"
+                    ? {
+                        ownedAssets: [
+                            {
+                                name: PLAYDROP_E2E_PROCEDURAL_ASSET_NAME,
+                                runtimeKey: "fixtureProceduralBeacon",
+                                displayName: "PlayDrop E2E Procedural Beacon",
+                                description: "A deterministic procedural Three.js asset produced during the update fixture.",
+                                category: "MODEL_3D",
+                                subcategory: "procedural",
+                                format: "CUSTOM",
+                                visibility: "PUBLIC",
+                                license: "CC0",
+                                files: {
+                                    primary: `assets/${PLAYDROP_E2E_PROCEDURAL_ASSET_NAME}.mjs`,
+                                    manifest: `assets/${PLAYDROP_E2E_PROCEDURAL_ASSET_NAME}.manifest.json`,
+                                    preview: `assets/${PLAYDROP_E2E_PROCEDURAL_ASSET_NAME}.png`,
+                                    source: `assets/${PLAYDROP_E2E_PROCEDURAL_ASSET_NAME}-source.zip`,
+                                    license: `assets/${PLAYDROP_E2E_PROCEDURAL_ASSET_NAME}.LICENSE.txt`,
+                                },
+                            },
+                        ],
+                    }
+                    : {}),
+                ...(input.kind === "REMIX_GAME" && input.remixSourceRef ? { remix: input.remixSourceRef } : {}),
+            },
+        ],
+    };
+    await Promise.all([
+        (0, promises_1.writeFile)(node_path_1.default.join(input.projectDir, "catalogue.json"), `${JSON.stringify(catalogue, null, 2)}\n`, "utf8"),
+        (0, promises_1.writeFile)(node_path_1.default.join(input.projectDir, "index.html"), buildGameHtml({ displayName: input.displayName, taskId: input.taskId, kind: input.kind }), "utf8"),
+        writePlaydropE2EPng({
+            filePath: node_path_1.default.join(listingDir, "icon.png"),
+            width: 512,
+            height: 512,
+            label: "PLAYDROP E2E",
+        }),
+        writePlaydropE2EPng({
+            filePath: node_path_1.default.join(listingDir, "hero-portrait.png"),
+            width: 720,
+            height: 1280,
+            label: "PLAYDROP E2E GAME",
+        }),
+        writePlaydropE2EPng({
+            filePath: node_path_1.default.join(listingDir, "hero-landscape.png"),
+            width: 1280,
+            height: 720,
+            label: "PLAYDROP E2E GAME",
+        }),
+        ...(input.kind === "GAME_UPDATE" ? [writePlaydropE2EProceduralAsset(input.projectDir)] : []),
+    ]);
+}
+function buildPlaydropE2EMetadata(kind) {
+    const label = kind === "MODEL_3D" ? "3D Model" : kind[0] + kind.slice(1).toLowerCase();
+    return {
+        title: `PlayDrop E2E ${label}`,
+        description: `Deterministic ${label.toLowerCase()} generated by the PlayDrop Cloud worker E2E fixture.`,
+        tags: ["playdrop", "e2e", kind.toLowerCase()],
+    };
+}
+function buildPlaydropE2ETriangleGlb() {
+    const positions = Buffer.alloc(36);
+    const vertices = [-0.8, -0.6, 0, 0.8, -0.6, 0, 0, 0.8, 0];
+    vertices.forEach((value, index) => positions.writeFloatLE(value, index * 4));
+    const indices = Buffer.alloc(8);
+    indices.writeUInt16LE(0, 0);
+    indices.writeUInt16LE(1, 2);
+    indices.writeUInt16LE(2, 4);
+    const binary = Buffer.concat([positions, indices]);
+    const json = {
+        asset: { version: "2.0", generator: "PlayDrop E2E Fixture v1" },
+        scene: 0,
+        scenes: [{ nodes: [0] }],
+        nodes: [{ mesh: 0 }],
+        meshes: [{ primitives: [{ attributes: { POSITION: 0 }, indices: 1, material: 0 }] }],
+        materials: [{ pbrMetallicRoughness: { baseColorFactor: [0.45, 0.22, 1, 1], metallicFactor: 0, roughnessFactor: 0.7 } }],
+        buffers: [{ byteLength: binary.length }],
+        bufferViews: [
+            { buffer: 0, byteOffset: 0, byteLength: positions.length, target: 34962 },
+            { buffer: 0, byteOffset: positions.length, byteLength: 6, target: 34963 },
+        ],
+        accessors: [
+            { bufferView: 0, componentType: 5126, count: 3, type: "VEC3", min: [-0.8, -0.6, 0], max: [0.8, 0.8, 0] },
+            { bufferView: 1, componentType: 5123, count: 3, type: "SCALAR" },
+        ],
+    };
+    const rawJson = Buffer.from(JSON.stringify(json), "utf8");
+    const paddedJson = Buffer.alloc(Math.ceil(rawJson.length / 4) * 4, 0x20);
+    rawJson.copy(paddedJson);
+    const output = Buffer.alloc(12 + 8 + paddedJson.length + 8 + binary.length);
+    output.write("glTF", 0, "ascii");
+    output.writeUInt32LE(2, 4);
+    output.writeUInt32LE(output.length, 8);
+    output.writeUInt32LE(paddedJson.length, 12);
+    output.writeUInt32LE(0x4e4f534a, 16);
+    paddedJson.copy(output, 20);
+    const binaryHeader = 20 + paddedJson.length;
+    output.writeUInt32LE(binary.length, binaryHeader);
+    output.writeUInt32LE(0x004e4942, binaryHeader + 4);
+    binary.copy(output, binaryHeader + 8);
+    return output;
+}

package/dist/commands/worker/game-server-infra.d.ts

@@ -0,0 +1,80 @@
+import { spawnSync } from "node:child_process";
+export declare const WORKER_REDIS_VERSION = "7.4.5";
+export declare const WORKER_MONGODB_VERSION = "8.0.26";
+export declare const WORKER_REDIS_RUNTIME_COMMANDS: readonly ["+auth", "+select", "+ping", "+quit", "+info", "+client|setinfo", "+client|setname", "+publish", "+subscribe", "+unsubscribe", "+pubsub", "+get", "+set", "+setex", "+expire", "+del", "+exists", "+sadd", "+smembers", "+sismember", "+srem", "+scard", "+sinter", "+hset", "+hincrby", "+hget", "+hgetall", "+hdel", "+hlen", "+hexists", "+incr", "+decr", "+llen", "+rpush", "+lpush", "+rpop", "+lpop", "+brpop", "+multi", "+exec"];
+export interface ManagedWorkerGameServerPaths {
+    root: string;
+    toolchainsRoot: string;
+    redisRoot: string;
+    redisBinary: string;
+    redisCliBinary: string;
+    mongoRoot: string;
+    mongodBinary: string;
+    credentialsPath: string;
+    redisConfigPath: string;
+    redisAclPath: string;
+    mongoConfigPath: string;
+    mongoKeyFilePath: string;
+    redisDataPath: string;
+    mongoDataPath: string;
+    logsPath: string;
+}
+export interface ManagedWorkerGameServerInfrastructure {
+    redisAdminUrl: string;
+    mongoAdminUrl: string;
+    redisVersion: typeof WORKER_REDIS_VERSION;
+    mongoVersion: typeof WORKER_MONGODB_VERSION;
+    paths: ManagedWorkerGameServerPaths;
+}
+export interface WorkerGameServerDevLease {
+    scope: string;
+    redisNamespace: string;
+    redisUrl: string;
+    mongoUrl: string;
+    cleanup(): Promise<void>;
+}
+export declare function resolveManagedWorkerGameServerPaths(workerHomeDir: string): ManagedWorkerGameServerPaths;
+export declare function installManagedWorkerGameServerToolchains(input: {
+    workerHomeDir: string;
+    platform?: NodeJS.Platform;
+    architecture?: string;
+}): Promise<ManagedWorkerGameServerPaths>;
+export declare function writeManagedWorkerGameServerConfiguration(input: {
+    workerHomeDir: string;
+}): ManagedWorkerGameServerInfrastructure;
+export declare function buildManagedWorkerGameServerLaunchAgents(input: {
+    workerHomeDir: string;
+}): Array<{
+    label: string;
+    plistPath: string;
+    contents: string;
+}>;
+export declare function syncManagedWorkerGameServerLaunchAgents(definitions: ReturnType<typeof buildManagedWorkerGameServerLaunchAgents>, deps?: {
+    spawn: typeof spawnSync;
+}): void;
+export declare function setupManagedWorkerGameServerInfrastructure(input: {
+    workerHomeDir: string;
+    platform?: NodeJS.Platform;
+    architecture?: string;
+    startLaunchAgents?: boolean;
+}): Promise<ManagedWorkerGameServerInfrastructure>;
+export declare function probeManagedWorkerGameServerInfrastructure(input: {
+    redisAdminUrl: string;
+    mongoAdminUrl: string;
+}): Promise<void>;
+export declare function cleanupStaleWorkerGameServerDevResources(input: {
+    redisAdminUrl: string;
+    mongoAdminUrl: string;
+}): Promise<{
+    redisUsers: number;
+    redisKeys: number;
+    mongoDatabases: number;
+}>;
+export declare function provisionWorkerGameServerDevLease(input: {
+    taskId: number;
+    attempt: number;
+    environment: string;
+    redisAdminUrl: string;
+    mongoAdminUrl: string;
+    requireRedisAcl?: boolean;
+}): Promise<WorkerGameServerDevLease>;