@nodetool-ai/websocket 0.8.2 → 0.8.3

package/dist/trpc/routers/games.js

@@ -3,23 +3,32 @@ import { join } from "node:path";
 import { z } from "zod";
 import sharp from "sharp";
 import { createLogger, getManagedWorkspaceDir, managedWorkspaceKey, workspaceStorageKind } from "@nodetool-ai/config";
-import { AmbiguousGameIdError, InvalidGameDocumentError, Asset, Game, Project, Workspace } from "@nodetool-ai/models";
-import { exampleGameSummary, anyGameAssetBinding, gameAssetBinding, gameAssetBinding3D, gamePreparedCollider3D, gameModelImportSettings3D, parseGameDocument, anyGameDocument as gameDocument, installExampleGameInput } from "@nodetool-ai/protocol";
+import { AmbiguousGameIdError, InvalidGameDocumentError, MissingGameDraftSourceError, Asset, Game, Project, Workspace } from "@nodetool-ai/models";
+import { exampleGameSummary, anyGameAssetBinding, gameAssetBinding, gameAssetBinding3D, gameAssetSiblingRebinds, gamePreparedCollider3D, gameModelImportSettings3D, parseGameDocument, anyGameDocument as gameDocument, installExampleGameInput, stagedGameCandidateRecord, stagedGameCandidateRecordPath } from "@nodetool-ai/protocol";
 import { createTopDownRoomGame, createNative3DGame, anyGameDocumentOp as gameDocumentOp, GameOpError, decodePreparedGameCollider3D, trackGameAuthoringEdits, validateAnyGame } from "@nodetool-ai/game-runtime";
 import { normalizeGameModel3D, prepareGameModelBinding3D } from "@nodetool-ai/game-renderer/preparation3d";
-import { createCapabilityRun, gateFromContext } from "@nodetool-ai/agents";
+import { contextSecretAvailability, createCapabilityRun, gateFromContext } from "@nodetool-ai/agents";
 import { gameAuthoringCandidate, gameAuthoringProgram, gameAuthoringConflict } from "@nodetool-ai/protocol";
 import { PERMISSION_GATE_CONTEXT_KEY, ProcessingContext, headlessGate } from "@nodetool-ai/runtime";
 import { getAssetAdapter } from "../../lib/storage.js";
 import { getAssetStorageKey, retrieveAssetBytes } from "../../lib/asset-paths.js";
 import { getExampleGameBundle, installExampleGameAssets, listExampleGames } from "../../lib/example-games.js";
 import { workspaceFromRow } from "../../lib/workflow-workspace.js";
+import { loadConfiguredProviders } from "../../configured-providers.js";
+import { createRuntimeContext } from "../../session/model-interfaces.js";
 import { ApiErrorCode } from "../../error-codes.js";
 import { router } from "../index.js";
 import { protectedProcedure } from "../middleware.js";
 import { throwApiError } from "../error-formatter.js";
 import { boundedGameDraftHistory, MAX_GAME_DRAFT_OPS } from "./gameDraftHistory.js";
 const log = createLogger("nodetool.games");
+const gameProcedure = protectedProcedure.use(async ({ next }) => {
+    const result = await next();
+    if (!result.ok && result.error.cause instanceof MissingGameDraftSourceError) {
+        throwApiError(ApiErrorCode.SERVICE_UNAVAILABLE, result.error.cause.message, "PRECONDITION_FAILED");
+    }
+    return result;
+});
 const idInput = z.object({ id: z.string() });
 const gameInfo = z.object({
     id: z.string(),
@@ -41,6 +50,27 @@ const authoringPreview = z.object({
     changed_dependencies: z.array(z.string()),
     restart_required: z.boolean()
 });
+const assetBrowserInfo = z.object({
+    dimension: z.enum(["2d", "3d"]),
+    draft_updated_at: z.string(),
+    candidate_workspace_id: z.string(),
+    candidates: z.array(z.object({
+        digest: z.string(), extension: z.string(), media_kind: z.enum(["image", "audio", "font", "model", "collider"]), path: z.string(),
+        size: z.number(), modified_at: z.string(), bound_slots: z.array(z.string()), slot: z.string().optional(), prompt: z.string().optional(),
+        source: z.string().optional(), recorded: z.boolean()
+    })),
+    slot_requests: z.record(z.string(), z.object({ kind: z.string(), prompt: z.string().optional(),
+        preparation: z.record(z.string(), z.unknown()).optional(), source: z.string() }))
+});
+const assetFrame = z.object({ x: z.number(), y: z.number(), width: z.number(), height: z.number() });
+const generatedAssetResult = z.object({
+    error: z.string().optional(),
+    binding: anyGameAssetBinding.optional(),
+    frames: z.array(assetFrame).optional(),
+    tiles: z.array(z.object({ mask: z.number().int(), frame: assetFrame })).optional()
+}).loose();
+const stagedCandidateBinding = z.object({ error: z.string().optional(), binding: anyGameAssetBinding.optional() }).loose();
+const generatedAsset = gameWithDocument.extend({ stagedDigest: z.string().nullable(), installed: z.boolean() });
 const gameRevisionInfo = z.object({ revision: z.string(), modifiedAt: z.number(), current: z.boolean(), message: z.string().nullable() });
 function info(game) {
     return {
@@ -63,8 +93,18 @@ function authoringRun(userId) {
     context.set(PERMISSION_GATE_CONTEXT_KEY, headlessGate("game.authoring"));
     return createCapabilityRun({ context, gate: gateFromContext(context, "game.authoring") });
 }
+/** A run that can reach the user's configured media providers, for editor-initiated asset generation. */
+async function assetGenerationRun(userId, game, workspace) {
+    const context = createRuntimeContext({ jobId: `game-asset-${randomUUID()}`, userId, projectId: game.project_id, workspace });
+    context.set(PERMISSION_GATE_CONTEXT_KEY, headlessGate("game.assets"));
+    return createCapabilityRun({ context, gate: gateFromContext(context, "game.assets"), projectId: game.project_id,
+        availableSecrets: contextSecretAvailability(context), providers: await loadConfiguredProviders(userId) });
+}
 function checkAuthoringResult(result) {
     if (result !== null && typeof result === "object" && "error" in result && typeof result.error === "string") {
+        if ("code" in result && result.code === "game_draft_source_unavailable") {
+            throwApiError(ApiErrorCode.SERVICE_UNAVAILABLE, result.error, "PRECONDITION_FAILED");
+        }
         const code = /stale|concurrent|changed since/i.test(result.error)
             ? ApiErrorCode.ALREADY_EXISTS : ApiErrorCode.INVALID_INPUT;
         throwApiError(code, result.error);
@@ -100,7 +140,8 @@ async function gameWorkspace(userId, game) {
     }
     return workspace;
 }
-async function persistGameAsset(userId, game, workspace, draftUpdatedAt, slot, binding, bytes, extension, contentType) {
+const CONCURRENT_DRAFT_EDIT = "Game draft was modified concurrently";
+async function persistGameAsset(userId, game, workspace, draftUpdatedAt, slot, binding, bytes, extension, contentType, siblingBindings) {
     await workspace.write(`${game.source_root}/assets/${binding.digest}.${extension}`, bytes, contentType);
     const installed = await Asset.create({
         user_id: userId, project_id: game.project_id, parent_id: userId,
@@ -116,9 +157,12 @@ async function persistGameAsset(userId, game, workspace, draftUpdatedAt, slot, b
     try {
         uri = await storage.store(getAssetStorageKey(userId, installed.id, contentType), bytes, contentType);
         const op = gameDocumentOp.parse({ op: "bind_asset", slot, binding: { ...binding, assetId: installed.id } });
-        const saved = await Game.updateDraft(userId, game.id, draftUpdatedAt, [op], workspace, { actor: "user" });
+        const parent = siblingBindings ? gameAssetBinding.safeParse({ ...binding, assetId: installed.id }) : null;
+        const siblings = siblingBindings && parent?.success
+            ? Object.entries(siblingBindings(parent.data)).map(([sibling, siblingBinding]) => gameDocumentOp.parse({ op: "bind_asset", slot: sibling, binding: siblingBinding })) : [];
+        const saved = await Game.updateDraft(userId, game.id, draftUpdatedAt, [op, ...siblings], workspace, { actor: "user" });
         if (!saved) {
-            throwApiError(ApiErrorCode.ALREADY_EXISTS, "Game draft was modified concurrently");
+            throwApiError(ApiErrorCode.ALREADY_EXISTS, CONCURRENT_DRAFT_EDIT);
         }
         return { game: info(saved.game), document: saved.document };
     }
@@ -279,8 +323,167 @@ async function createGame(userId, projectId, name, source, dimension = "2d") {
         throwApiError(ApiErrorCode.ALREADY_EXISTS, "Game already exists");
     return { game: info(game), document };
 }
+const installCandidateInput = idInput.extend({
+    baseRevision: z.string().optional(),
+    baseUpdatedAt: z.string().optional(),
+    slot: z.string().min(1),
+    candidateWorkspaceId: z.string().optional(),
+    binding: anyGameAssetBinding
+});
+function siblingBindingsFor(slot, assets, options) {
+    const { frames, tiles } = options;
+    if (frames?.length) {
+        return (installed) => Object.fromEntries(frames.map((frame, index) => [`${slot}.frame.${index}`, { ...installed, frame }]));
+    }
+    if (tiles?.length) {
+        return (installed) => Object.fromEntries(tiles.map((tile) => [`${slot}.tile.${tile.mask}`, { ...installed, frame: tile.frame }]));
+    }
+    if (!options.replaceInPlace) {
+        return undefined;
+    }
+    return (installed) => Object.fromEntries(gameAssetSiblingRebinds(assets, slot, installed).ops.map((op) => [op.slot, op.binding]));
+}
+/** Install a staged candidate's bytes into the draft, with the sibling bindings `options` names. */
+async function installCandidateBinding(userId, input, options = {}) {
+    const ctx = { userId };
+    const game = await ownedGame(ctx.userId, input.id);
+    const workspace = await gameWorkspace(ctx.userId, game);
+    const candidateRow = input.candidateWorkspaceId
+        ? await Workspace.find(ctx.userId, input.candidateWorkspaceId)
+        : null;
+    if (input.candidateWorkspaceId && (!candidateRow || candidateRow.project_id !== game.project_id)) {
+        throwApiError(ApiErrorCode.NOT_FOUND, "Candidate workspace not found");
+    }
+    const candidateWorkspace = candidateRow ? workspaceFromRow(candidateRow) : workspace;
+    if (!candidateWorkspace) {
+        throwApiError(ApiErrorCode.SERVICE_UNAVAILABLE, "Candidate workspace storage is unavailable");
+    }
+    const digest = input.binding.digest;
+    if (!/^[a-f0-9]{64}$/.test(digest)) {
+        throwApiError(ApiErrorCode.INVALID_INPUT, "Invalid candidate digest");
+    }
+    if (input.binding.mediaKind === "font" && !input.binding.fontFormat) {
+        throwApiError(ApiErrorCode.INVALID_INPUT, "Font binding needs a TrueType or OpenType format");
+    }
+    if (input.binding.mediaKind === "hdri") {
+        throwApiError(ApiErrorCode.INVALID_INPUT, "HDRI candidates cannot be installed until HDRI preparation verifies their bytes and dimensions");
+    }
+    const formats = input.binding.mediaKind === "model"
+        ? [["glb", "model/gltf-binary"]]
+        : input.binding.mediaKind === "collider"
+            ? [["json", "application/json"]]
+            : input.binding.mediaKind === "audio"
+                ? [["wav", "audio/wav"], ["mp3", "audio/mpeg"], ["ogg", "audio/ogg"]]
+                : input.binding.mediaKind === "font"
+                    ? [[input.binding.fontFormat, `font/${input.binding.fontFormat}`]]
+                    : [["png", "image/png"], ["jpg", "image/jpeg"], ["webp", "image/webp"]];
+    let candidate = null;
+    for (const [extension, contentType] of formats) {
+        if (!extension || !contentType)
+            continue;
+        const path = `${game.source_root}/assets/${digest}.${extension}`;
+        const bytes = await candidateWorkspace.read(path);
+        if (bytes) {
+            candidate = { extension, contentType, bytes };
+            break;
+        }
+    }
+    if (!candidate || createHash("sha256").update(candidate.bytes).digest("hex") !== digest) {
+        throwApiError(ApiErrorCode.INVALID_INPUT, "Candidate asset is missing or changed");
+    }
+    const { extension, contentType, bytes } = candidate;
+    let binding = input.binding;
+    if (binding.mediaKind === "model") {
+        const prepared = await prepareGameModelBinding3D(bytes, { assetId: binding.assetId, expectedDigest: digest });
+        if (!prepared.ok) {
+            throwApiError(ApiErrorCode.INVALID_INPUT, prepared.diagnostics.map((issue) => issue.message).join("; "));
+        }
+        const sourceAsset = binding.sourceAssetId ? await Asset.find(ctx.userId, binding.sourceAssetId) : null;
+        if (binding.sourceAssetId && !sourceAsset) {
+            throwApiError(ApiErrorCode.INVALID_INPUT, "Model source asset is not owned");
+        }
+        const canonical = { ...prepared.binding, required: binding.required };
+        if (binding.provenance) {
+            canonical.provenance = binding.provenance;
+        }
+        if (binding.importSettings) {
+            canonical.importSettings = binding.importSettings;
+        }
+        if (binding.sourceDigest) {
+            canonical.sourceDigest = binding.sourceDigest;
+        }
+        if (sourceAsset) {
+            canonical.sourceAssetId = sourceAsset.id;
+        }
+        binding = canonical;
+    }
+    else if (binding.mediaKind === "collider") {
+        let geometry;
+        try {
+            geometry = JSON.parse(new TextDecoder().decode(bytes));
+        }
+        catch {
+            throwApiError(ApiErrorCode.INVALID_INPUT, "Prepared collider is not valid JSON");
+        }
+        const parsed = gamePreparedCollider3D.safeParse(geometry);
+        if (!parsed.success || binding.shape === "triangleMesh" && !parsed.data.indices?.length) {
+            throwApiError(ApiErrorCode.INVALID_INPUT, "Prepared collider has invalid vertices or triangle indices");
+        }
+        const { vertices, indices } = parsed.data;
+        const minimum = { x: Infinity, y: Infinity, z: Infinity };
+        const maximum = { x: -Infinity, y: -Infinity, z: -Infinity };
+        for (let index = 0; index < vertices.length; index += 3) {
+            minimum.x = Math.min(minimum.x, vertices[index]);
+            maximum.x = Math.max(maximum.x, vertices[index]);
+            minimum.y = Math.min(minimum.y, vertices[index + 1]);
+            maximum.y = Math.max(maximum.y, vertices[index + 1]);
+            minimum.z = Math.min(minimum.z, vertices[index + 2]);
+            maximum.z = Math.max(maximum.z, vertices[index + 2]);
+        }
+        binding = { ...binding, preparationVersion: "1", bounds: { min: minimum, max: maximum }, vertices: vertices.length / 3, triangles: (indices?.length ?? 0) / 3 };
+        try {
+            await decodePreparedGameCollider3D(bytes, gameAssetBinding3D.options[1].parse(binding));
+        }
+        catch (error) {
+            throwApiError(ApiErrorCode.INVALID_INPUT, error instanceof Error ? error.message : "Prepared collider is invalid");
+        }
+    }
+    if (input.baseRevision && game.current_revision !== input.baseRevision) {
+        throwApiError(ApiErrorCode.ALREADY_EXISTS, "Game was modified concurrently");
+    }
+    const draft = await Game.readDraft(ctx.userId, game.id, workspace);
+    if (!draft)
+        throwApiError(ApiErrorCode.NOT_FOUND, "Game draft not found");
+    if (input.baseUpdatedAt && draft.game.draft_updated_at !== input.baseUpdatedAt) {
+        throwApiError(ApiErrorCode.ALREADY_EXISTS, "Game draft was modified concurrently");
+    }
+    const targetBinding = draft.document.schemaVersion === 3 ? gameAssetBinding3D.safeParse(binding) :
+        gameAssetBinding.safeParse(binding);
+    if (!targetBinding.success || draft.document.schemaVersion !== 3 && (binding.mediaKind === "model" || binding.mediaKind === "collider")) {
+        throwApiError(ApiErrorCode.INVALID_INPUT, "Asset binding does not match the game dimension");
+    }
+    return persistGameAsset(ctx.userId, game, workspace, draft.game.draft_updated_at, input.slot, targetBinding.data, bytes, extension, contentType, draft.document.schemaVersion !== 3 ? siblingBindingsFor(input.slot, draft.document.assets, options) : undefined);
+}
+/**
+ * Install into whichever draft is current when the bytes are ready. An editor
+ * session saves while a generation runs, so a slot binding must not depend on
+ * the draft token the request started from. The write itself stays a
+ * compare-and-swap, retried when a save lands between the read and the write.
+ */
+async function installOnLatestDraft(userId, input, options) {
+    for (let attempt = 1;; attempt++) {
+        try {
+            return await installCandidateBinding(userId, input, options);
+        }
+        catch (error) {
+            if (attempt >= 3 || !(error instanceof Error) || error.message !== CONCURRENT_DRAFT_EDIT) {
+                throw error;
+            }
+        }
+    }
+}
 export const gamesRouter = router({
-    list: protectedProcedure
+    list: gameProcedure
         .input(z.object({ projectId: z.string() }))
         .output(z.array(gameInfo))
         .query(async ({ ctx, input }) => {
@@ -289,7 +492,7 @@ export const gamesRouter = router({
         }
         return (await Game.listByProject(ctx.userId, input.projectId)).map(info);
     }),
-    create: protectedProcedure
+    create: gameProcedure
         .input(z.object({ projectId: z.string(), name: z.string().min(1).max(200), dimension: z.enum(["2d", "3d"]).optional(), document: gameDocument.optional() }))
         .output(gameWithDocument)
         .mutation(({ ctx, input }) => {
@@ -298,10 +501,10 @@ export const gamesRouter = router({
         }
         return createGame(ctx.userId, input.projectId, input.name, input.document, input.dimension);
     }),
-    examples: protectedProcedure
+    examples: gameProcedure
         .output(z.array(exampleGameSummary))
         .query(({ ctx }) => listExampleGames(ctx.apiOptions)),
-    example: protectedProcedure
+    example: gameProcedure
         .input(z.object({ slug: z.string().min(1) }))
         .output(z.object({ name: z.string(), document: gameDocument }))
         .query(({ ctx, input }) => {
@@ -311,7 +514,7 @@ export const gamesRouter = router({
         }
         return { name: bundle.name, document: bundle.document };
     }),
-    installExample: protectedProcedure
+    installExample: gameProcedure
         .input(installExampleGameInput)
         .output(gameWithDocument)
         .mutation(async ({ ctx, input }) => {
@@ -331,7 +534,7 @@ export const gamesRouter = router({
             throw error;
         }
     }),
-    get: protectedProcedure
+    get: gameProcedure
         .input(idInput.extend({ revision: z.string().optional() }))
         .output(gameWithDocument)
         .query(async ({ ctx, input }) => {
@@ -339,7 +542,7 @@ export const gamesRouter = router({
         const workspace = await gameWorkspace(ctx.userId, game);
         return { game: info(game), document: await readRevision(workspace, game, input.revision ?? game.current_revision) };
     }),
-    getDraft: protectedProcedure
+    getDraft: gameProcedure
         .input(idInput)
         .output(gameWithDocument)
         .query(async ({ ctx, input }) => {
@@ -349,7 +552,7 @@ export const gamesRouter = router({
             throwApiError(ApiErrorCode.NOT_FOUND, "Game draft not found");
         return { game: info(draft.game), document: draft.document };
     }),
-    saveDraft: protectedProcedure
+    saveDraft: gameProcedure
         .input(idInput.extend({ baseUpdatedAt: z.string(), ops: z.array(gameDocumentOp).min(1).max(MAX_GAME_DRAFT_OPS) }))
         .output(gameWithDocument)
         .mutation(async ({ ctx, input }) => {
@@ -370,7 +573,25 @@ export const gamesRouter = router({
             throw error;
         }
     }),
-    previewAuthoring: protectedProcedure
+    saveDraftDocument: gameProcedure
+        .input(idInput.extend({ baseUpdatedAt: z.string(), document: gameDocument }))
+        .output(gameWithDocument)
+        .mutation(async ({ ctx, input }) => {
+        const game = await ownedGame(ctx.userId, input.id);
+        try {
+            const saved = await Game.saveDraftDocument(ctx.userId, game.id, input.baseUpdatedAt, input.document, await gameWorkspace(ctx.userId, game));
+            if (!saved)
+                throwApiError(ApiErrorCode.ALREADY_EXISTS, "Game draft was modified concurrently");
+            return { game: info(saved.game), document: saved.document };
+        }
+        catch (error) {
+            if (error instanceof InvalidGameDocumentError) {
+                throwApiError(ApiErrorCode.INVALID_INPUT, error.message);
+            }
+            throw error;
+        }
+    }),
+    previewAuthoring: gameProcedure
         .input(idInput.extend({ program: gameAuthoringProgram.optional() }).strict())
         .output(authoringPreview)
         .mutation(async ({ ctx, input }) => {
@@ -383,7 +604,7 @@ export const gamesRouter = router({
         checkAuthoringResult(result);
         return authoringPreview.parse(result);
     }),
-    applyAuthoring: protectedProcedure
+    applyAuthoring: gameProcedure
         .input(idInput.extend({ candidate: gameAuthoringCandidate }).strict())
         .output(gameWithDocument)
         .mutation(async ({ ctx, input }) => {
@@ -398,7 +619,7 @@ export const gamesRouter = router({
         }
         return { game: info(draft.game), document: draft.document };
     }),
-    draftChanges: protectedProcedure
+    draftChanges: gameProcedure
         .input(idInput)
         .output(z.array(z.object({
         id: z.string(), actor: z.enum(["agent", "user"]), threadId: z.string().nullable(),
@@ -410,7 +631,7 @@ export const gamesRouter = router({
         const game = await ownedGame(ctx.userId, input.id);
         return boundedGameDraftHistory((await Game.listDraftChanges(ctx.userId, game.id)).map(({ gameId: _gameId, ...change }) => change));
     }),
-    draftBeforeChange: protectedProcedure
+    draftBeforeChange: gameProcedure
         .input(idInput.extend({ changeId: z.string() }))
         .output(gameDocument)
         .query(async ({ ctx, input }) => {
@@ -420,7 +641,7 @@ export const gamesRouter = router({
             throwApiError(ApiErrorCode.NOT_FOUND, "Game draft change not found");
         return document;
     }),
-    revisions: protectedProcedure
+    revisions: gameProcedure
         .input(idInput)
         .output(z.array(gameRevisionInfo))
         .query(async ({ ctx, input }) => {
@@ -435,11 +656,11 @@ export const gamesRouter = router({
         });
         return revisions.sort((a, b) => b.modifiedAt - a.modifiedAt);
     }),
-    publish: protectedProcedure
+    publish: gameProcedure
         .input(idInput.extend({ baseRevision: z.string(), baseUpdatedAt: z.string().optional(), expectedDigest: z.string().regex(/^[a-f0-9]{64}$/).optional(), document: gameDocument.optional(), message: z.string().trim().max(500).optional() }))
         .output(gameWithDocument)
         .mutation(async ({ ctx, input }) => publishDocument(ctx.userId, await ownedGame(ctx.userId, input.id), input.baseRevision, input.document, input.message, false, input.baseUpdatedAt, input.expectedDigest)),
-    restore: protectedProcedure
+    restore: gameProcedure
         .input(idInput.extend({ baseRevision: z.string(), baseUpdatedAt: z.string(), revision: z.string() }))
         .output(gameWithDocument)
         .mutation(async ({ ctx, input }) => {
@@ -448,7 +669,7 @@ export const gamesRouter = router({
         const oldDocument = await readRevision(workspace, game, input.revision);
         return publishDocument(ctx.userId, game, input.baseRevision, oldDocument, undefined, true, input.baseUpdatedAt);
     }),
-    restoreDraft: protectedProcedure
+    restoreDraft: gameProcedure
         .input(idInput.extend({ baseUpdatedAt: z.string(), revision: z.string() }))
         .output(gameWithDocument)
         .mutation(async ({ ctx, input }) => {
@@ -468,7 +689,7 @@ export const gamesRouter = router({
             throw error;
         }
     }),
-    installAsset: protectedProcedure
+    installAsset: gameProcedure
         .input(idInput.extend({ baseRevision: z.string().optional(), baseUpdatedAt: z.string().optional(), slot: z.string().min(1),
         assetId: z.string(), expectedDigest: z.string().optional(), importSettings: gameModelImportSettings3D.partial().optional(),
         dependencyAssetIds: z.record(z.string(), z.string()).refine((value) => Object.keys(value).length <= 320, "Too many model dependencies").optional() }))
@@ -545,130 +766,86 @@ export const gamesRouter = router({
         }
         return { game: info(saved.game), document: saved.document };
     }),
-    installCandidate: protectedProcedure
+    installCandidate: gameProcedure
+        .input(installCandidateInput)
+        .output(gameWithDocument)
+        .mutation(async ({ ctx, input }) => installCandidateBinding(ctx.userId, input)),
+    /** Staged candidates and per-slot generation requests for the asset browser. The catalog itself is computed client-side from the draft. */
+    assetBrowser: gameProcedure
+        .input(idInput)
+        .output(assetBrowserInfo)
+        .query(async ({ ctx, input }) => {
+        const game = await ownedGame(ctx.userId, input.id);
+        const result = await authoringRun(ctx.userId).invoke("browse_native_game_assets", { game_id: game.id });
+        checkAuthoringResult(result);
+        return assetBrowserInfo.parse(result);
+    }),
+    /**
+     * Generate an asset for one slot through `generate_game_asset`, record the
+     * prompt beside the staged bytes, and bind it in place on the draft that is
+     * current when the bytes are ready. The editor keeps saving while a
+     * generation runs, so the request carries no draft token: a sheet's frame
+     * bindings, or the slot's existing frame and tile bindings, are written in
+     * the same compare-and-swap as the slot, as the user who asked. A
+     * provider and model pin the generator; without them the capability picks one.
+     */
+    generateAsset: gameProcedure
         .input(idInput.extend({
-        baseRevision: z.string().optional(),
-        baseUpdatedAt: z.string().optional(),
         slot: z.string().min(1),
-        candidateWorkspaceId: z.string().optional(),
-        binding: anyGameAssetBinding
-    }))
-        .output(gameWithDocument)
+        kind: z.enum(["image", "audio", "music"]),
+        prompt: z.string().trim().min(1).max(4000),
+        preparation: z.record(z.string(), z.unknown()).optional(),
+        provider: z.string().min(1).optional(),
+        model: z.string().min(1).optional()
+    }).strict().refine((value) => (value.provider === undefined) === (value.model === undefined), "Pass provider and model together"))
+        .output(generatedAsset)
         .mutation(async ({ ctx, input }) => {
         const game = await ownedGame(ctx.userId, input.id);
         const workspace = await gameWorkspace(ctx.userId, game);
-        const candidateRow = input.candidateWorkspaceId
-            ? await Workspace.find(ctx.userId, input.candidateWorkspaceId)
-            : null;
-        if (input.candidateWorkspaceId && (!candidateRow || candidateRow.project_id !== game.project_id)) {
-            throwApiError(ApiErrorCode.NOT_FOUND, "Candidate workspace not found");
-        }
-        const candidateWorkspace = candidateRow ? workspaceFromRow(candidateRow) : workspace;
-        if (!candidateWorkspace) {
-            throwApiError(ApiErrorCode.SERVICE_UNAVAILABLE, "Candidate workspace storage is unavailable");
-        }
-        const digest = input.binding.digest;
-        if (!/^[a-f0-9]{64}$/.test(digest)) {
-            throwApiError(ApiErrorCode.INVALID_INPUT, "Invalid candidate digest");
-        }
-        if (input.binding.mediaKind === "font" && !input.binding.fontFormat) {
-            throwApiError(ApiErrorCode.INVALID_INPUT, "Font binding needs a TrueType or OpenType format");
-        }
-        const formats = input.binding.mediaKind === "model"
-            ? [["glb", "model/gltf-binary"]]
-            : input.binding.mediaKind === "collider"
-                ? [["json", "application/json"]]
-                : input.binding.mediaKind === "audio"
-                    ? [["wav", "audio/wav"], ["mp3", "audio/mpeg"], ["ogg", "audio/ogg"]]
-                    : input.binding.mediaKind === "font"
-                        ? [[input.binding.fontFormat, `font/${input.binding.fontFormat}`]]
-                        : [["png", "image/png"], ["jpg", "image/jpeg"], ["webp", "image/webp"]];
-        let candidate = null;
-        for (const [extension, contentType] of formats) {
-            if (!extension || !contentType)
-                continue;
-            const path = `${game.source_root}/assets/${digest}.${extension}`;
-            const bytes = await candidateWorkspace.read(path);
-            if (bytes) {
-                candidate = { extension, contentType, bytes };
-                break;
-            }
-        }
-        if (!candidate || createHash("sha256").update(candidate.bytes).digest("hex") !== digest) {
-            throwApiError(ApiErrorCode.INVALID_INPUT, "Candidate asset is missing or changed");
-        }
-        const { extension, contentType, bytes } = candidate;
-        let binding = input.binding;
-        if (binding.mediaKind === "model") {
-            const prepared = await prepareGameModelBinding3D(bytes, { assetId: binding.assetId, expectedDigest: digest });
-            if (!prepared.ok) {
-                throwApiError(ApiErrorCode.INVALID_INPUT, prepared.diagnostics.map((issue) => issue.message).join("; "));
-            }
-            const sourceAsset = binding.sourceAssetId ? await Asset.find(ctx.userId, binding.sourceAssetId) : null;
-            if (binding.sourceAssetId && !sourceAsset) {
-                throwApiError(ApiErrorCode.INVALID_INPUT, "Model source asset is not owned");
-            }
-            const canonical = { ...prepared.binding, required: binding.required };
-            if (binding.provenance) {
-                canonical.provenance = binding.provenance;
-            }
-            if (binding.importSettings) {
-                canonical.importSettings = binding.importSettings;
-            }
-            if (binding.sourceDigest) {
-                canonical.sourceDigest = binding.sourceDigest;
-            }
-            if (sourceAsset) {
-                canonical.sourceAssetId = sourceAsset.id;
-            }
-            binding = canonical;
-        }
-        else if (binding.mediaKind === "collider") {
-            let geometry;
-            try {
-                geometry = JSON.parse(new TextDecoder().decode(bytes));
-            }
-            catch {
-                throwApiError(ApiErrorCode.INVALID_INPUT, "Prepared collider is not valid JSON");
-            }
-            const parsed = gamePreparedCollider3D.safeParse(geometry);
-            if (!parsed.success || binding.shape === "triangleMesh" && !parsed.data.indices?.length) {
-                throwApiError(ApiErrorCode.INVALID_INPUT, "Prepared collider has invalid vertices or triangle indices");
-            }
-            const { vertices, indices } = parsed.data;
-            const minimum = { x: Infinity, y: Infinity, z: Infinity };
-            const maximum = { x: -Infinity, y: -Infinity, z: -Infinity };
-            for (let index = 0; index < vertices.length; index += 3) {
-                minimum.x = Math.min(minimum.x, vertices[index]);
-                maximum.x = Math.max(maximum.x, vertices[index]);
-                minimum.y = Math.min(minimum.y, vertices[index + 1]);
-                maximum.y = Math.max(maximum.y, vertices[index + 1]);
-                minimum.z = Math.min(minimum.z, vertices[index + 2]);
-                maximum.z = Math.max(maximum.z, vertices[index + 2]);
-            }
-            binding = { ...binding, preparationVersion: "1", bounds: { min: minimum, max: maximum }, vertices: vertices.length / 3, triangles: (indices?.length ?? 0) / 3 };
-            try {
-                await decodePreparedGameCollider3D(bytes, gameAssetBinding3D.options[1].parse(binding));
-            }
-            catch (error) {
-                throwApiError(ApiErrorCode.INVALID_INPUT, error instanceof Error ? error.message : "Prepared collider is invalid");
-            }
-        }
-        if (input.baseRevision && game.current_revision !== input.baseRevision) {
-            throwApiError(ApiErrorCode.ALREADY_EXISTS, "Game was modified concurrently");
-        }
-        const draft = await Game.readDraft(ctx.userId, game.id, workspace);
-        if (!draft)
-            throwApiError(ApiErrorCode.NOT_FOUND, "Game draft not found");
-        if (input.baseUpdatedAt && draft.game.draft_updated_at !== input.baseUpdatedAt) {
-            throwApiError(ApiErrorCode.ALREADY_EXISTS, "Game draft was modified concurrently");
+        const args = { game_id: game.id, slot: input.slot, kind: input.kind, prompt: input.prompt, install: false };
+        if (input.preparation) {
+            args["preparation"] = input.preparation;
+        }
+        if (input.provider && input.model) {
+            args["provider"] = input.provider;
+            args["model"] = input.model;
+        }
+        const run = await assetGenerationRun(ctx.userId, game, workspace);
+        const result = generatedAssetResult.safeParse(await run.invoke("generate_game_asset", args));
+        if (!result.success) {
+            throwApiError(ApiErrorCode.INTERNAL_ERROR, "Asset generation returned an invalid result");
+        }
+        checkAuthoringResult(result.data);
+        const { binding, frames, tiles } = result.data;
+        if (!binding) {
+            throwApiError(ApiErrorCode.INTERNAL_ERROR, "Asset generation did not stage an asset");
+        }
+        await workspace.write(stagedGameCandidateRecordPath(game.source_root, binding.digest), JSON.stringify(stagedGameCandidateRecord.parse({
+            version: 1, digest: binding.digest, slot: input.slot, prompt: input.prompt, source: "generate", stagedAt: new Date().toISOString(), binding
+        })), "application/json");
+        const installed = await installOnLatestDraft(ctx.userId, { id: game.id, slot: input.slot, binding }, { replaceInPlace: true, frames, tiles });
+        return { ...installed, stagedDigest: binding.digest, installed: true };
+    }),
+    /** Bind a staged candidate to a slot on the current draft. A 2D slot's frame and tile bindings move onto the new bytes. */
+    installStagedCandidate: gameProcedure
+        .input(idInput.extend({
+        slot: z.string().min(1),
+        digest: z.string().regex(/^[a-f0-9]{64}$/)
+    }).strict())
+        .output(gameWithDocument)
+        .mutation(async ({ ctx, input }) => {
+        const game = await ownedGame(ctx.userId, input.id);
+        const picked = stagedCandidateBinding.safeParse(await authoringRun(ctx.userId).invoke("browse_native_game_assets", {
+            game_id: game.id, digest: input.digest, slot: input.slot
+        }));
+        if (!picked.success) {
+            throwApiError(ApiErrorCode.INTERNAL_ERROR, "Candidate lookup returned an invalid result");
         }
-        const targetBinding = draft.document.schemaVersion === 3 ? gameAssetBinding3D.safeParse(binding) :
-            gameAssetBinding.safeParse(binding);
-        if (!targetBinding.success || draft.document.schemaVersion !== 3 && (binding.mediaKind === "model" || binding.mediaKind === "collider")) {
-            throwApiError(ApiErrorCode.INVALID_INPUT, "Asset binding does not match the game dimension");
+        checkAuthoringResult(picked.data);
+        if (!picked.data.binding) {
+            throwApiError(ApiErrorCode.NOT_FOUND, "Staged candidate not found");
         }
-        return persistGameAsset(ctx.userId, game, workspace, draft.game.draft_updated_at, input.slot, targetBinding.data, bytes, extension, contentType);
+        return installOnLatestDraft(ctx.userId, { id: game.id, slot: input.slot, binding: picked.data.binding }, { replaceInPlace: true });
     })
 });
 //# sourceMappingURL=games.js.map