@nodetool-ai/agents 0.8.2 → 0.8.4-a24.1

package/dist/capabilities/game.js

@@ -1,19 +1,23 @@
 import { createHash, randomUUID } from "node:crypto";
 import { mkdtemp, readFile, readdir, rm } from "node:fs/promises";
 import { join } from "node:path";
+import { z } from "zod";
+import { importPack } from "@nodetool-ai/node-catalog";
 import { createLogger, getManagedWorkspaceDir, managedWorkspaceKey, workspaceStorageKind } from "@nodetool-ai/config";
-import { AmbiguousGameIdError, Asset, Game, Prediction, Project, Workspace } from "@nodetool-ai/models";
+import { AmbiguousGameIdError, MissingGameDraftSourceError, Asset, Game, Prediction, Project, Workspace } from "@nodetool-ai/models";
 import { anyGameAssetBinding as gameAssetBinding, gameAssetBinding as legacyAssetBinding, gameAssetBinding3D, anyGameDocument as gameDocument, gameInputFrame, shortResourceId } from "@nodetool-ai/protocol";
-import { autoplayNativeGame, MAX_GAME_ROUTE_TICKS, createScriptedGameSession, createTopDownRoomGame, createNative3DGame, decodePreparedGameCollider3D, validateAnyGame, trackGameAuthoringEdits, anyGameDocumentOp as gameDocumentOp, GameOpError } from "@nodetool-ai/game-runtime";
+import { autoplayNativeGame, MAX_GAME_ROUTE_TICKS, createMemoryGameSaveStorage, createScriptedGameSession, GamePlayerSaves, createTopDownRoomGame, createNative3DGame, decodePreparedGameCollider3D, validateAnyGame, trackGameAuthoringEdits, anyGameDocumentOp as gameDocumentOp, GameOpError } from "@nodetool-ai/game-runtime";
 import { workspaceFromRow } from "@nodetool-ai/execution/service";
 import { assetKeyCandidates, assetObjectKey } from "@nodetool-ai/storage";
+import { loadCanvas } from "@nodetool-ai/runtime";
 import { gameOutline3D, inputFrames3D, playtestGame3D, captureFrames3D, colliderBinding3D, stageModelGameAsset3D } from "./game3d.js";
 import { gameSpecs } from "./game.specs.js";
 import { persistOutput } from "../tools/asset-persist.js";
 import { getExampleGameBundle, installExampleGameAssets, listExampleGames } from "../game-examples.js";
 import { previewGameAuthoring, applyGameAuthoring } from "../game-authoring.js";
 import { gameDocumentDigest } from "../game-code-bake.js";
-import { previewGameAuthoringSpec, applyGameAuthoringSpec } from "./game.specs.js";
+import { previewGameAuthoringSpec, applyGameAuthoringSpec, browseGameAssetsSpec } from "./game.specs.js";
+import { browseGameAssets } from "./game-asset-browser.js";
 const log = createLogger("capabilities.game");
 const MAX_PLAYTEST_TICKS = MAX_GAME_ROUTE_TICKS;
 const MAX_CAPTURE_FRAMES = 8;
@@ -121,7 +125,8 @@ function outline(document) {
             inputActions: document.inputActions,
             collisionLayers: document.collisionLayers,
             renderEffects: document.renderEffects,
-            hudEffectOrder: document.hudEffectOrder
+            hudEffectOrder: document.hudEffectOrder,
+            audio: document.audio
         },
         scenes: document.scenes.map((scene) => ({
             id: scene.id,
@@ -183,7 +188,9 @@ async function captureFrames(run, user, document, ticks, inputs, seed, options)
         wallTimeLimited = Date.now() >= deadlineAt;
         return cancelled || wallTimeLimited;
     };
-    const { captureGameFrame } = await import("@nodetool-ai/game-renderer/node");
+    const { captureGameFrame } = await importPack("game", "@nodetool-ai/game-renderer/node");
+    const { GameParticles2D } = await importPack("game", "@nodetool-ai/game-renderer");
+    const particles = new GameParticles2D(document.tickRate);
     const diagnostics = [];
     const storage = run.context.assetStorage;
     const assetCache = new Map();
@@ -221,7 +228,9 @@ async function captureFrames(run, user, document, ticks, inputs, seed, options)
                 if (budgetReached()) {
                     break;
                 }
-                simulatedTicks = session.step(inputs[simulatedTicks] ?? { pressed: [], justPressed: [] }).tick;
+                const step = session.step(inputs[simulatedTicks] ?? { pressed: [], justPressed: [] });
+                particles.tick(step.frame, session.takePresentationEvents());
+                simulatedTicks = step.tick;
             }
             if (budgetReached()) {
                 break;
@@ -238,11 +247,11 @@ async function captureFrames(run, user, document, ticks, inputs, seed, options)
             const start = diagnostics.length;
             let png;
             try {
-                png = await captureGameFrame(frame, { resolveAsset, scale, effects: document.renderEffects, hudEffectOrder: document.hudEffectOrder, backend: document.renderEffects?.length ? "webgpu" : "canvas2d", onDiagnostic: (message) => diagnostics.push(message) });
+                png = await captureGameFrame(frame, { resolveAsset, scale, particles, effects: document.renderEffects, hudEffectOrder: document.hudEffectOrder, backend: document.renderEffects?.length ? "webgpu" : "canvas2d", onDiagnostic: (message) => diagnostics.push(message) });
             }
             catch (error) {
                 diagnostics.push(`WebGPU capture failed: ${error instanceof Error ? error.message : String(error)}`);
-                png = await captureGameFrame(frame, { resolveAsset, scale, backend: "canvas2d", onDiagnostic: (message) => diagnostics.push(message) });
+                png = await captureGameFrame(frame, { resolveAsset, scale, particles, backend: "canvas2d", onDiagnostic: (message) => diagnostics.push(message) });
             }
             if (budgetReached()) {
                 break;
@@ -250,7 +259,7 @@ async function captureFrames(run, user, document, ticks, inputs, seed, options)
             const pixelScale = frame.pixelsPerUnit * frame.camera.zoom * scale;
             const overlays = Array.isArray(options.overlays) ? options.overlays.filter((value) => typeof value === "string") : [];
             if (overlays.length > 0) {
-                const { createCanvas, loadImage } = await import("@napi-rs/canvas");
+                const { createCanvas, loadImage } = await loadCanvas();
                 const source = await loadImage(Buffer.from(png));
                 const canvas = createCanvas(source.width, source.height);
                 const context = canvas.getContext("2d");
@@ -415,7 +424,7 @@ export async function createNativeGame(user, projectId, name, source, dimension
         return { error: "Project workspace is unavailable" };
     const id = randomUUID().replace(/-/g, "");
     const revision = randomUUID().replace(/-/g, "");
-    const document = validateSource(source ?? (dimension === "3d" ? createNative3DGame(id) : { ...createTopDownRoomGame(id), schemaVersion: 2 }), id, revision);
+    const document = validateSource(source ?? (dimension === "3d" ? createNative3DGame(id) : { ...createTopDownRoomGame(id), schemaVersion: 4, engineVersion: "3" }), id, revision);
     if ("error" in document)
         return document;
     if (source && ((document.schemaVersion === 3) !== (dimension === "3d"))) {
@@ -559,6 +568,9 @@ const install = {
         if (parsed.data.mediaKind === "font" && !parsed.data.fontFormat) {
             return { error: "Font binding needs a TrueType or OpenType format" };
         }
+        if (parsed.data.mediaKind === "hdri") {
+            return { error: "HDRI candidates cannot be installed until HDRI preparation verifies their bytes and dimensions" };
+        }
         const workspace = await workspaceOf(user, game);
         if (!workspace)
             return { error: "Game workspace is unavailable" };
@@ -596,7 +608,9 @@ const install = {
         if (!candidate || createHash("sha256").update(candidate.bytes).digest("hex") !== parsed.data.digest) {
             return { error: "Candidate asset is missing or changed" };
         }
-        const { path, extension, contentType, bytes } = candidate;
+        const { path, bytes } = candidate;
+        let { extension, contentType } = candidate;
+        let targetPath = path;
         if (base !== undefined && base !== game.current_revision)
             return { error: "Game was modified concurrently" };
         const draft = await Game.readDraft(user, game.id, workspace);
@@ -605,8 +619,19 @@ const install = {
         const expectedUpdatedAt = typeof args["base_updated_at"] === "string" ? args["base_updated_at"] : draft.game.draft_updated_at;
         let binding = parsed.data;
         try {
-            if (binding.mediaKind === "model") {
-                const { prepareGameModelBinding3D } = await import("@nodetool-ai/game-renderer/preparation3d");
+            if (draft.document.schemaVersion === 3 && binding.mediaKind === "image") {
+                const { prepareGameImage3D } = await importPack("game", "@nodetool-ai/game-renderer/preparation3d");
+                const prepared = await prepareGameImage3D(bytes, { assetId: binding.assetId, expectedDigest: binding.digest, signal: run.context.signal });
+                if (!prepared.ok) {
+                    return { error: "Image preparation failed", diagnostics: prepared.diagnostics };
+                }
+                binding = { ...prepared.image.binding, required: binding.required ?? true };
+                extension = prepared.image.binding.format === "jpeg" ? "jpg" : prepared.image.binding.format;
+                contentType = `image/${prepared.image.binding.format}`;
+                targetPath = `${game.source_root}/assets/${binding.digest}.${extension}`;
+            }
+            else if (binding.mediaKind === "model") {
+                const { prepareGameModelBinding3D } = await importPack("game", "@nodetool-ai/game-renderer/preparation3d");
                 const prepared = await prepareGameModelBinding3D(bytes, { assetId: binding.assetId, expectedDigest: binding.digest, signal: run.context.signal });
                 if (!prepared.ok) {
                     return { error: "Model preparation failed", diagnostics: prepared.diagnostics };
@@ -645,8 +670,8 @@ const install = {
         const storage = run.context.assetStorage;
         if (!storage)
             return { error: "Asset storage is unavailable" };
-        if (candidateWorkspace !== workspace)
-            await workspace.write(path, bytes, contentType);
+        if (candidateWorkspace !== workspace || targetPath !== path)
+            await workspace.write(targetPath, bytes, contentType);
         const installed = await Asset.create({
             user_id: user,
             project_id: game.project_id,
@@ -744,6 +769,8 @@ const playtest = {
         let wallTimeLimited = false;
         let cancelled = false;
         let scriptError = null;
+        // Script saves stay in memory for the playtest, so a run never reads or writes a player's saves.
+        const saves = new GamePlayerSaves(createMemoryGameSaveStorage());
         try {
             for (const input of inputs) {
                 if (state.tick % 240 === 0)
@@ -758,7 +785,11 @@ const playtest = {
                 }
                 let result;
                 try {
-                    result = session.step(input);
+                    result = session.step(saves.withLoaded(input));
+                    if (result.saveRequests) {
+                        saves.handle(result.saveRequests, () => session.snapshot());
+                        await saves.idle();
+                    }
                 }
                 catch (error) {
                     scriptError = { tick: state.tick + 1, message: error instanceof Error ? error.message : String(error) };
@@ -914,8 +945,11 @@ const generateAsset = {
                 return { error: error instanceof Error ? error.message : String(error) };
             }
         }
-        if (draft.document.schemaVersion === 3 && kind === "image") {
-            return { error: "3D games use model assets with embedded textures" };
+        if (draft.document.schemaVersion === 3 && kind === "image" && args["preparation"] !== undefined) {
+            const preparation = z.record(z.string(), z.unknown()).safeParse(args["preparation"]);
+            if (!preparation.success || Object.keys(preparation.data).length > 0) {
+                return { error: "3D images do not support sprite preparation. Set UV tiling and offset on the material's texture slots." };
+            }
         }
         const reference = typeof args["reference_slot"] === "string" ? draft.document.assets[args["reference_slot"]] : undefined;
         if (args["reference_slot"] !== undefined && !reference) {
@@ -924,7 +958,7 @@ const generateAsset = {
         if (reference && kind !== "image") {
             return { error: "reference_slot requires kind image" };
         }
-        const { imagePreparationSettings, prepareGameImage, imagePreparationMetadata, gameFontFormat } = await import("@nodetool-ai/game-nodes");
+        const { imagePreparationSettings, prepareGameImage, imagePreparationMetadata, gameFontFormat } = await importPack("game", "@nodetool-ai/game-nodes");
         const settings = kind === "image" ? imagePreparationSettings.safeParse(args["preparation"] ?? {}) : null;
         if (settings && !settings.success) {
             return { error: "Invalid image preparation", issues: settings.error.issues };
@@ -1048,6 +1082,20 @@ const generateAsset = {
         if (sourceBytes.byteLength > MAX_BUILD_ASSET_BYTES) {
             return { error: "Game asset exceeds the supported asset size" };
         }
+        if (draft.document.schemaVersion === 3 && kind === "image") {
+            const { prepareGameImage3D } = await importPack("game", "@nodetool-ai/game-renderer/preparation3d");
+            const digest = createHash("sha256").update(sourceBytes).digest("hex");
+            const prepared = await prepareGameImage3D(sourceBytes, { assetId: `generated:${digest}`, expectedDigest: digest, signal: run.context.signal });
+            if (!prepared.ok) {
+                return { error: "Image preparation failed", diagnostics: prepared.diagnostics };
+            }
+            const binding = prepared.image.binding;
+            const extension = binding.format === "jpeg" ? "jpg" : binding.format;
+            await workspace.write(`${game.source_root}/assets/${binding.digest}.${extension}`, prepared.image.bytes, `image/${binding.format}`);
+            return { game_id: shortResourceId(game.id), slot, binding, candidate_workspace_id: game.workspace_id,
+                draft_updated_at: draft.game.draft_updated_at, installed: false,
+                next: "Call install_native_game_asset with this binding to install the verified candidate." };
+        }
         let bytes = sourceBytes;
         let width = 1;
         let height = 1;
@@ -1085,7 +1133,7 @@ const generateAsset = {
             if (prepared.baseline !== undefined && frames?.[0]) {
                 binding.pivot = { x: 0.5, y: (prepared.baseline + 1) / frames[0].height };
             }
-            if (draft.document.schemaVersion === 2) {
+            if (draft.document.schemaVersion !== 1) {
                 binding.preparation = imagePreparationMetadata(settings.data);
                 binding.originalDimensions = { width: prepared.originalWidth, height: prepared.originalHeight };
                 if (prepared.trim) {
@@ -1123,7 +1171,7 @@ const generateAsset = {
         binding.digest = digest;
         binding.width = width;
         binding.height = height;
-        if (draft.document.schemaVersion === 2) {
+        if (draft.document.schemaVersion !== 1 && draft.document.schemaVersion !== 3) {
             binding.provenance = typeof inputFile === "string" ? `import:${inputFile}`
                 : makeLut ? "generated:color-cube" : kind === "sfx" ? `node:${args["node_type"]}` : `${provider}:${model}:${generated.generation_id ?? ""}`;
         }
@@ -1139,6 +1187,25 @@ const generateAsset = {
             return { game_id: shortResourceId(game.id), slot, binding: parsedBinding.data, candidate_workspace_id: game.workspace_id,
                 draft_updated_at: draft.game.draft_updated_at, installed: false, next: "Call install_native_game_asset with this binding to install the candidate." };
         }
+        if (args["install"] === false) {
+            const parsedBinding = legacyAssetBinding.safeParse(binding);
+            if (!parsedBinding.success) {
+                return { error: "Invalid asset binding", diagnostics: parsedBinding.error.issues };
+            }
+            const staged = { game_id: shortResourceId(game.id), slot, binding: parsedBinding.data, candidate_workspace_id: game.workspace_id,
+                draft_updated_at: draft.game.draft_updated_at, installed: false, generation_id: generated.generation_id,
+                next: "Call install_native_game_asset with this binding to install the candidate." };
+            if (frames) {
+                staged.frames = frames;
+            }
+            if (tiles) {
+                staged.tiles = tiles;
+            }
+            if (lutSize) {
+                staged.lut_size = lutSize;
+            }
+            return staged;
+        }
         const installed = await install.impl(run, { game_id: game.id, slot, binding, base_updated_at: draft.game.draft_updated_at });
         if (typeof installed !== "object" || installed === null) {
             return { generation_id: generated.generation_id, result: installed };
@@ -1165,141 +1232,177 @@ const generateAsset = {
         return { generation_id: generated.generation_id, ...installed, ...extras };
     }
 };
-const buildGame = {
-    spec: gameSpecs[5],
-    impl: async (run, args) => {
-        const user = userId(run);
-        const id = args["game_id"];
-        if (!user || typeof id !== "string")
-            return { error: "game_id is required in a user session" };
-        const game = await ownedGame(user, id);
-        if (!game)
-            return { error: "Game not found" };
-        const workspace = await workspaceOf(user, game);
-        if (!workspace)
-            return { error: "Game workspace is unavailable" };
-        const revision = typeof args["revision"] === "string" ? args["revision"] : game.current_revision;
-        const document = await readDocument(workspace, game, revision);
-        if (!document)
-            return { error: "Game revision not found" };
-        if (Object.keys(document.assets).length > MAX_BUILD_ASSETS) {
-            return { error: `A standalone build supports at most ${MAX_BUILD_ASSETS} assets` };
+const BUILD_CONTENT_TYPES = {
+    js: "text/javascript", css: "text/css", json: "application/json", html: "text/html", png: "image/png", jpg: "image/jpeg",
+    webp: "image/webp", wav: "audio/wav", ogg: "audio/ogg", mp3: "audio/mpeg", ttf: "font/ttf", otf: "font/otf",
+    glb: "model/gltf-binary", wasm: "application/wasm", md: "text/markdown", toml: "text/plain", rs: "text/plain",
+    ico: "image/vnd.microsoft.icon", icns: "image/icns"
+};
+/**
+ * Builds an owned, published game revision into its project workspace: a static web player under
+ * `game-builds/<game-id>/<revision>`, or a Tauri desktop project under `game-builds/<game-id>/<revision>-tauri-<settings>`.
+ * The capability and the editor's export download share this path.
+ */
+export async function buildOwnedNativeGame(request) {
+    const user = request.userId;
+    const target = request.target ?? "web";
+    const game = await ownedGame(user, request.gameId);
+    if (!game)
+        return { error: "Game not found" };
+    const workspace = await workspaceOf(user, game);
+    if (!workspace)
+        return { error: "Game workspace is unavailable" };
+    const revision = request.revision ?? game.current_revision;
+    const document = await readDocument(workspace, game, revision);
+    if (!document)
+        return { error: "Game revision not found" };
+    if (Object.keys(document.assets).length > MAX_BUILD_ASSETS) {
+        return { error: `A standalone build supports at most ${MAX_BUILD_ASSETS} assets` };
+    }
+    const expectedDigests = new Map();
+    for (const binding of Object.values(document.assets)) {
+        if (binding.assetId.startsWith("builtin:"))
+            continue;
+        const digests = expectedDigests.get(binding.assetId) ?? new Set();
+        digests.add(binding.digest);
+        expectedDigests.set(binding.assetId, digests);
+    }
+    if ([...expectedDigests.values()].some((digests) => digests.size !== 1)) {
+        return { error: "One source asset has conflicting digests in this revision" };
+    }
+    let buildPath = `game-builds/${game.id}/${revision}`;
+    let entryPath = `${buildPath}/index.html`;
+    let tauriApp;
+    let metadata;
+    if (target === "tauri") {
+        tauriApp = { name: game.name };
+        const { tauriAppMetadata } = await importPack("game", "@nodetool-ai/game-renderer/build-tauri");
+        try {
+            metadata = tauriAppMetadata(document, tauriApp);
         }
-        const expectedDigests = new Map();
-        for (const binding of Object.values(document.assets)) {
-            if (binding.assetId.startsWith("builtin:"))
-                continue;
-            const digests = expectedDigests.get(binding.assetId) ?? new Set();
-            digests.add(binding.digest);
-            expectedDigests.set(binding.assetId, digests);
+        catch (error) {
+            return { error: error instanceof Error ? error.message : String(error) };
+        }
+        // The app name comes from the game row, which can change without a new revision.
+        const settings = createHash("sha256").update(JSON.stringify(metadata)).digest("hex").slice(0, 12);
+        buildPath = `game-builds/${game.id}/${revision}-tauri-${settings}`;
+        entryPath = `${buildPath}/src-tauri/tauri.conf.json`;
+    }
+    const done = { game_id: game.id, revision, target, build_path: buildPath, entry_path: entryPath, workspace, app: metadata ?? null };
+    if (await workspace.exists(entryPath)) {
+        return { ...done, cached: true };
+    }
+    const storage = request.storage;
+    const cache = new Map();
+    let totalAssetBytes = 0;
+    const resolveAsset = async (assetId) => {
+        const cached = cache.get(assetId);
+        if (cached)
+            return cached;
+        if (!/^[a-f0-9]{32}$/.test(assetId))
+            return null;
+        const asset = await Asset.find(user, assetId);
+        if (!asset || !storage)
+            return null;
+        const extension = MEDIA_EXTENSIONS[asset.content_type];
+        if (!extension || (asset.size !== null && asset.size > MAX_BUILD_ASSET_BYTES))
+            return null;
+        const keys = assetKeyCandidates(user, `${asset.id}.${extension}`);
+        let bytes = null;
+        for (const key of keys) {
+            bytes = await storage.retrieve(storage.uriForKey(key));
+            if (bytes)
+                break;
         }
-        if ([...expectedDigests.values()].some((digests) => digests.size !== 1)) {
-            return { error: "One source asset has conflicting digests in this revision" };
+        if (!bytes || bytes.byteLength > MAX_BUILD_ASSET_BYTES)
+            return null;
+        const digest = createHash("sha256").update(bytes).digest("hex");
+        if (!expectedDigests.get(assetId)?.has(digest)) {
+            throw new Error(`Asset digest changed for ${assetId}`);
         }
-        const buildPath = `game-builds/${game.id}/${revision}`;
-        const indexPath = `${buildPath}/index.html`;
-        if (await workspace.exists(indexPath)) {
-            return { game_id: game.id, revision, build_path: buildPath, entry_path: indexPath, cached: true };
+        totalAssetBytes += bytes.byteLength;
+        if (totalAssetBytes > MAX_BUILD_BYTES) {
+            throw new Error(`A standalone build supports at most ${MAX_BUILD_BYTES} asset bytes`);
         }
-        const storage = run.context.assetStorage;
-        const cache = new Map();
-        let totalAssetBytes = 0;
-        const resolveAsset = async (assetId) => {
-            const cached = cache.get(assetId);
-            if (cached)
-                return cached;
-            if (!/^[a-f0-9]{32}$/.test(assetId))
-                return null;
-            const asset = await Asset.find(user, assetId);
-            if (!asset || !storage)
-                return null;
-            const extension = MEDIA_EXTENSIONS[asset.content_type];
-            if (!extension || (asset.size !== null && asset.size > MAX_BUILD_ASSET_BYTES))
-                return null;
-            const keys = assetKeyCandidates(user, `${asset.id}.${extension}`);
-            let bytes = null;
-            for (const key of keys) {
-                bytes = await storage.retrieve(storage.uriForKey(key));
-                if (bytes)
-                    break;
-            }
-            if (!bytes || bytes.byteLength > MAX_BUILD_ASSET_BYTES)
-                return null;
-            const digest = createHash("sha256").update(bytes).digest("hex");
-            if (!expectedDigests.get(assetId)?.has(digest)) {
-                throw new Error(`Asset digest changed for ${assetId}`);
-            }
-            totalAssetBytes += bytes.byteLength;
-            if (totalAssetBytes > MAX_BUILD_BYTES) {
-                throw new Error(`A standalone build supports at most ${MAX_BUILD_BYTES} asset bytes`);
-            }
-            const resolved = { bytes, mimeType: asset.content_type };
-            cache.set(assetId, resolved);
-            return resolved;
-        };
-        const scratch = await workspace.scratchDir();
-        const staging = await mkdtemp(join(scratch, ".native-game-build-"));
-        try {
-            if (document.schemaVersion === 3) {
-                const { buildStandaloneGame3D } = await import("@nodetool-ai/game-renderer/build3d");
-                await buildStandaloneGame3D({ document, outputDir: join(staging, "player"), resolveAsset, signal: run.context.signal });
-            }
-            else {
-                const { buildStandaloneGame } = await import("@nodetool-ai/game-renderer/build");
-                await buildStandaloneGame({ document, outputDir: join(staging, "player"), resolveAsset });
-            }
-            const files = [];
-            const pending = [""];
-            let totalBytes = 0;
-            while (pending.length > 0) {
-                const directory = pending.pop() ?? "";
-                for (const entry of await readdir(join(staging, "player", directory), { withFileTypes: true })) {
-                    const path = directory ? `${directory}/${entry.name}` : entry.name;
-                    if (entry.isDirectory()) {
-                        pending.push(path);
-                    }
-                    else if (entry.isFile()) {
-                        const bytes = await readFile(join(staging, "player", path));
-                        totalBytes += bytes.byteLength;
-                        if (files.length >= MAX_BUILD_FILES || totalBytes > MAX_BUILD_BYTES) {
-                            throw new Error("Standalone build exceeds file or byte limits");
-                        }
-                        files.push({ path, bytes });
+        const resolved = { bytes, mimeType: asset.content_type };
+        cache.set(assetId, resolved);
+        return resolved;
+    };
+    const scratch = await workspace.scratchDir();
+    const staging = await mkdtemp(join(scratch, ".native-game-build-"));
+    try {
+        const output = join(staging, "player");
+        if (tauriApp) {
+            const { buildTauriGameProject } = await importPack("game", "@nodetool-ai/game-renderer/build-tauri");
+            await buildTauriGameProject({ document, outputDir: output, resolveAsset, app: tauriApp, signal: request.signal });
+        }
+        else if (document.schemaVersion === 3) {
+            const { buildStandaloneGame3D } = await importPack("game", "@nodetool-ai/game-renderer/build3d");
+            await buildStandaloneGame3D({ document, outputDir: output, resolveAsset, signal: request.signal });
+        }
+        else {
+            const { buildStandaloneGame } = await importPack("game", "@nodetool-ai/game-renderer/build");
+            await buildStandaloneGame({ document, outputDir: output, resolveAsset });
+        }
+        const files = [];
+        const pending = [""];
+        let totalBytes = 0;
+        while (pending.length > 0) {
+            const directory = pending.pop() ?? "";
+            for (const entry of await readdir(join(output, directory), { withFileTypes: true })) {
+                const path = directory ? `${directory}/${entry.name}` : entry.name;
+                if (entry.isDirectory()) {
+                    pending.push(path);
+                }
+                else if (entry.isFile()) {
+                    const bytes = await readFile(join(output, path));
+                    totalBytes += bytes.byteLength;
+                    if (files.length >= MAX_BUILD_FILES || totalBytes > MAX_BUILD_BYTES) {
+                        throw new Error("Standalone build exceeds file or byte limits");
                     }
+                    files.push({ path, bytes });
                 }
             }
-            if (!files.some((file) => file.path === "index.html")) {
-                throw new Error("Standalone player entry is missing");
-            }
-            for (const file of files.filter((item) => item.path !== "index.html")) {
-                const contentType = file.path.endsWith(".js") ? "text/javascript"
-                    : file.path.endsWith(".css") ? "text/css"
-                        : file.path.endsWith(".json") ? "application/json"
-                            : file.path.endsWith(".png") ? "image/png"
-                                : file.path.endsWith(".jpg") ? "image/jpeg"
-                                    : file.path.endsWith(".webp") ? "image/webp"
-                                        : file.path.endsWith(".wav") ? "audio/wav"
-                                            : file.path.endsWith(".ogg") ? "audio/ogg"
-                                                : file.path.endsWith(".mp3") ? "audio/mpeg"
-                                                    : file.path.endsWith(".ttf") ? "font/ttf"
-                                                        : file.path.endsWith(".otf") ? "font/otf"
-                                                            : file.path.endsWith(".glb") ? "model/gltf-binary"
-                                                                : file.path.endsWith(".wasm") ? "application/wasm"
-                                                                    : "application/octet-stream";
-                await workspace.write(`${buildPath}/${file.path}`, file.bytes, contentType);
-            }
-            const index = files.find((file) => file.path === "index.html");
-            if (!index)
-                throw new Error("Standalone player entry is missing");
-            await workspace.write(indexPath, index.bytes, "text/html");
-            return { game_id: game.id, revision, build_path: buildPath, entry_path: indexPath, cached: false };
-        }
-        catch (error) {
-            return { error: error instanceof Error ? error.message : String(error) };
-        }
-        finally {
-            await rm(staging, { recursive: true, force: true });
         }
+        const entryFile = entryPath.slice(buildPath.length + 1);
+        const entry = files.find((file) => file.path === entryFile);
+        if (!entry)
+            throw new Error("Standalone build entry is missing");
+        const contentType = (path) => BUILD_CONTENT_TYPES[path.slice(path.lastIndexOf(".") + 1)] ?? "application/octet-stream";
+        // The entry file is written last, so its presence marks a complete build for the cache check above.
+        for (const file of files.filter((item) => item !== entry)) {
+            await workspace.write(`${buildPath}/${file.path}`, file.bytes, contentType(file.path));
+        }
+        await workspace.write(entryPath, entry.bytes, contentType(entry.path));
+        return { ...done, cached: false };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : String(error) };
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true });
+    }
+}
+const buildGame = {
+    spec: gameSpecs[5],
+    impl: async (run, args) => {
+        const user = userId(run);
+        const id = args["game_id"];
+        if (!user || typeof id !== "string")
+            return { error: "game_id is required in a user session" };
+        const target = args["target"] ?? "web";
+        if (target !== "web" && target !== "tauri")
+            return { error: "target must be web or tauri" };
+        const revision = args["revision"];
+        const result = await buildOwnedNativeGame({ userId: user, gameId: id, revision: typeof revision === "string" ? revision : undefined,
+            target, storage: run.context.assetStorage, signal: run.context.signal });
+        if ("error" in result)
+            return { error: result.error };
+        const report = { game_id: result.game_id, revision: result.revision, target: result.target, build_path: result.build_path,
+            entry_path: result.entry_path, cached: result.cached };
+        return target === "tauri"
+            ? { ...report, next: "The project builds desktop installers with `npm install && npm run build` in a checkout that has Rust and the Tauri prerequisites." }
+            : report;
     }
 };
 const listExamples = {
@@ -1423,10 +1526,24 @@ const autoplay = {
         return { game_id: shortResourceId(game.id), revision: document.revision, ...route, win_tick: winTick, reached_targets: reachedTargets, level_stats: levelStats, state: snapshot };
     }
 };
+function withDraftRecovery(capability) {
+    return { ...capability, impl: async (run, args) => {
+            try {
+                return await capability.impl(run, args);
+            }
+            catch (error) {
+                if (error instanceof MissingGameDraftSourceError) {
+                    return { error: error.message, code: "game_draft_source_unavailable" };
+                }
+                throw error;
+            }
+        } };
+}
 export const module = {
     module: "game",
     exports: [create, get, save, install, playtest, buildGame, edit, capture, generateAsset, listExamples, getExample, installExample, autoplay,
         { spec: previewGameAuthoringSpec, impl: previewGameAuthoring },
-        { spec: applyGameAuthoringSpec, impl: applyGameAuthoring }]
+        { spec: applyGameAuthoringSpec, impl: applyGameAuthoring },
+        { spec: browseGameAssetsSpec, impl: browseGameAssets }].map(withDraftRecovery)
 };
 //# sourceMappingURL=game.js.map