@playdrop/playdrop-cli 0.16.5 → 0.16.11

package/bin/playdrop

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
-require('../dist/index.js');
-
+require("../dist/index.js");

package/config/client-meta.json

@@ -1,8 +1,8 @@
 {
-  "version": "0.16.5",
-  "build": 6,
-  "runtimeSdkVersion": "0.16.5",
-  "runtimeSdkBuild": 6,
+  "version": "0.16.11",
+  "build": 1,
+  "runtimeSdkVersion": "0.16.11",
+  "runtimeSdkBuild": 1,
   "clients": {
     "all": {
       "minimumVersion": "0.7.4"

package/dist/apiClient.d.ts

@@ -1,5 +1,5 @@
-import { type ApiClient } from '@playdrop/api-client';
-import { type AiClient } from '@playdrop/ai-client';
+import { type ApiClient } from "@playdrop/api-client";
+import { type AiClient } from "@playdrop/ai-client";
 type ClientOptions = {
     baseUrl: string;
     token?: string | null;

package/dist/apiClient.js

@@ -15,50 +15,46 @@ function readPositiveIntEnv(name) {
     return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
 }
 function readWorkerTaskTokenEnv() {
-    if (process.env.PLAYDROP_WORKER_CONTEXT !== '1') {
-        return '';
+    if (process.env.PLAYDROP_WORKER_CONTEXT !== "1") {
+        return "";
     }
-    const token = process.env.PLAYDROP_WORKER_TASK_TOKEN?.trim() ?? '';
+    const token = process.env.PLAYDROP_WORKER_TASK_TOKEN?.trim() ?? "";
     if (!token) {
-        throw new Error('worker_task_token_missing');
+        throw new Error("worker_task_token_missing");
     }
     return token;
 }
 function createCliClientHeaders(input) {
     const onBehalfCreatorUsername = input.onBehalfCreatorUsername;
-    const creatorUsername = typeof onBehalfCreatorUsername === 'string'
-        ? onBehalfCreatorUsername.trim()
-        : '';
-    const explicitAgentTaskToken = typeof input.agentTaskToken === 'string'
-        ? input.agentTaskToken.trim()
-        : '';
+    const creatorUsername = typeof onBehalfCreatorUsername === "string" ? onBehalfCreatorUsername.trim() : "";
+    const explicitAgentTaskToken = typeof input.agentTaskToken === "string" ? input.agentTaskToken.trim() : "";
     const workerTaskToken = readWorkerTaskTokenEnv();
     if (explicitAgentTaskToken && workerTaskToken && explicitAgentTaskToken !== workerTaskToken) {
-        throw new Error('worker_task_token_mismatch');
+        throw new Error("worker_task_token_mismatch");
     }
     const agentTaskToken = explicitAgentTaskToken || workerTaskToken;
     const agentTaskId = Number.isInteger(input.agentTaskId) && Number(input.agentTaskId) > 0
         ? Number(input.agentTaskId)
-        : readPositiveIntEnv('PLAYDROP_WORKER_TASK_ID');
+        : readPositiveIntEnv("PLAYDROP_WORKER_TASK_ID");
     const agentTaskAttempt = Number.isInteger(input.agentTaskAttempt) && Number(input.agentTaskAttempt) > 0
         ? Number(input.agentTaskAttempt)
-        : readPositiveIntEnv('PLAYDROP_WORKER_TASK_ATTEMPT');
-    if (agentTaskToken && process.env.PLAYDROP_WORKER_CONTEXT === '1' && (!agentTaskId || !agentTaskAttempt)) {
-        throw new Error('worker_ai_generation_task_context_missing');
+        : readPositiveIntEnv("PLAYDROP_WORKER_TASK_ATTEMPT");
+    if (agentTaskToken && process.env.PLAYDROP_WORKER_CONTEXT === "1" && (!agentTaskId || !agentTaskAttempt)) {
+        throw new Error("worker_ai_generation_task_context_missing");
     }
     return {
         ...(0, clientInfo_1.createClientHeaders)(),
         ...(creatorUsername
             ? {
-                'x-playdrop-creator-username': creatorUsername,
-                'x-playdrop-ai-paid-by': 'creator',
+                "x-playdrop-creator-username": creatorUsername,
+                "x-playdrop-ai-paid-by": "creator",
             }
             : {}),
         ...(agentTaskToken
             ? {
-                'x-playdrop-agent-task-token': agentTaskToken,
-                ...(agentTaskId ? { 'x-playdrop-agent-task-id': String(agentTaskId) } : {}),
-                ...(agentTaskAttempt ? { 'x-playdrop-agent-task-attempt': String(agentTaskAttempt) } : {}),
+                "x-playdrop-agent-task-token": agentTaskToken,
+                ...(agentTaskId ? { "x-playdrop-agent-task-id": String(agentTaskId) } : {}),
+                ...(agentTaskAttempt ? { "x-playdrop-agent-task-attempt": String(agentTaskAttempt) } : {}),
             }
             : {}),
     };

package/dist/appUrls.d.ts

@@ -1,4 +1,4 @@
-import type { AppType } from '@playdrop/types';
+import type { AppType } from "@playdrop/types";
 export type AppUrlInput = {
     creatorUsername: string;
     appName: string;
@@ -19,7 +19,7 @@ export declare function buildPlatformPrivateDraftPlayUrl(webBase: string | null
     version: string;
 }): string;
 export declare function buildPlatformDevUrl(webBase: string | null | undefined, input: AppUrlInput & {
-    devAuth?: 'prompt' | 'anonymous' | 'viewer' | 'player';
+    devAuth?: "prompt" | "anonymous" | "viewer" | "player";
     player?: string | null;
     launchCheck?: boolean;
     localDevPort?: number | string | null;

package/dist/appUrls.js

@@ -9,50 +9,50 @@ exports.buildPlatformPlayUrl = buildPlatformPlayUrl;
 exports.buildPlatformPrivateDraftPlayUrl = buildPlatformPrivateDraftPlayUrl;
 exports.buildPlatformDevUrl = buildPlatformDevUrl;
 exports.buildUploadLaunchCheckUrl = buildUploadLaunchCheckUrl;
-const DEFAULT_WEB_BASE = 'https://www.playdrop.ai';
+const DEFAULT_WEB_BASE = "https://www.playdrop.ai";
 function appendTaskCaptureSession(url, session) {
     if (!session) {
         return;
     }
     if (!Number.isInteger(session.appId) || session.appId <= 0) {
-        throw new Error('invalid_capture_app_id');
+        throw new Error("invalid_capture_app_id");
     }
     if (!Number.isInteger(session.taskId) || session.taskId <= 0 || !session.taskToken.trim()) {
-        throw new Error('invalid_capture_task_session');
+        throw new Error("invalid_capture_task_session");
     }
-    url.searchParams.set('captureAppId', String(session.appId));
-    url.searchParams.set('captureTaskId', String(session.taskId));
-    url.searchParams.set('captureTaskToken', session.taskToken.trim());
+    url.searchParams.set("captureAppId", String(session.appId));
+    url.searchParams.set("captureTaskId", String(session.taskId));
+    url.searchParams.set("captureTaskToken", session.taskToken.trim());
 }
 function redactTaskCaptureSession(url) {
     const redacted = new URL(url);
-    if (redacted.searchParams.has('captureTaskToken')) {
-        redacted.searchParams.set('captureTaskToken', '<redacted>');
+    if (redacted.searchParams.has("captureTaskToken")) {
+        redacted.searchParams.set("captureTaskToken", "<redacted>");
     }
     return redacted.toString();
 }
 function redactTaskCaptureToken(text, sourceUrl) {
-    const taskToken = new URL(sourceUrl).searchParams.get('captureTaskToken')?.trim() ?? '';
-    return taskToken ? text.split(taskToken).join('<redacted>') : text;
+    const taskToken = new URL(sourceUrl).searchParams.get("captureTaskToken")?.trim() ?? "";
+    return taskToken ? text.split(taskToken).join("<redacted>") : text;
 }
 function normalizePlaydropWebBase(webBase) {
-    const base = typeof webBase === 'string' && webBase.trim().length > 0 ? webBase.trim() : DEFAULT_WEB_BASE;
-    return base.replace(/\/$/, '');
+    const base = typeof webBase === "string" && webBase.trim().length > 0 ? webBase.trim() : DEFAULT_WEB_BASE;
+    return base.replace(/\/$/, "");
 }
 function getAppTypeSlug(type) {
-    if (typeof type !== 'string') {
-        return 'game';
+    if (typeof type !== "string") {
+        return "game";
     }
     switch (type) {
-        case 'DEMO':
-            return 'demo';
-        case 'TOOL':
-            return 'tool';
-        case 'TEMPLATE':
-            return 'template';
-        case 'GAME':
+        case "DEMO":
+            return "demo";
+        case "TOOL":
+            return "tool";
+        case "TEMPLATE":
+            return "template";
+        case "GAME":
         default:
-            return 'game';
+            return "game";
     }
 }
 function buildPlatformPlayUrl(webBase, input) {
@@ -69,7 +69,7 @@ function buildPlatformPrivateDraftPlayUrl(webBase, input) {
     const appName = encodeURIComponent(input.appName);
     const version = encodeURIComponent(input.version.trim());
     if (!version) {
-        throw new Error('invalid_private_draft_play_version');
+        throw new Error("invalid_private_draft_play_version");
     }
     return `${base}/_auth/creators/${creator}/apps/${typeSlug}/${appName}/play?v=${version}`;
 }
@@ -79,23 +79,21 @@ function buildPlatformDevUrl(webBase, input) {
     const typeSlug = getAppTypeSlug(input.appType);
     const appName = encodeURIComponent(input.appName);
     const url = new URL(`${base}/creators/${creator}/apps/${typeSlug}/${appName}/dev`);
-    if (typeof input.devAuth === 'string' && input.devAuth.trim().length > 0) {
-        url.searchParams.set('devAuth', input.devAuth.trim());
+    if (typeof input.devAuth === "string" && input.devAuth.trim().length > 0) {
+        url.searchParams.set("devAuth", input.devAuth.trim());
     }
-    if (typeof input.player === 'string' && input.player.trim().length > 0) {
-        url.searchParams.set('player', input.player.trim());
+    if (typeof input.player === "string" && input.player.trim().length > 0) {
+        url.searchParams.set("player", input.player.trim());
     }
     if (input.launchCheck) {
-        url.searchParams.set('launchCheck', '1');
+        url.searchParams.set("launchCheck", "1");
     }
     if (input.localDevPort !== null && input.localDevPort !== undefined) {
-        const port = typeof input.localDevPort === 'number'
-            ? input.localDevPort
-            : Number.parseInt(String(input.localDevPort), 10);
+        const port = typeof input.localDevPort === "number" ? input.localDevPort : Number.parseInt(String(input.localDevPort), 10);
         if (!Number.isInteger(port) || port <= 0 || port > 65535) {
-            throw new Error('invalid_local_dev_port');
+            throw new Error("invalid_local_dev_port");
         }
-        url.searchParams.set('localDevPort', String(port));
+        url.searchParams.set("localDevPort", String(port));
     }
     appendTaskCaptureSession(url, input.captureSession);
     return url.toString();

package/dist/apps/build.d.ts

@@ -1,5 +1,5 @@
-import type { AppPlaytestTapes, AppSurface, AppType } from '@playdrop/types';
-import type { AppTask } from '../catalogue';
+import type { AppPlaytestTapes, AppSurface, AppType } from "@playdrop/types";
+import type { AppTask } from "../catalogue";
 export type AppBuildMetadata = {
     displayName?: string;
     subtitle?: string;

package/dist/apps/build.js

@@ -9,36 +9,36 @@ const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 const node_zlib_1 = require("node:zlib");
 const BASE_SOURCE_IGNORE_PATTERNS = [
-    'node_modules/',
-    'dist/',
-    'build/',
-    'out/',
-    '.next/',
-    '.turbo/',
-    '.cache/',
-    '.git/',
-    '.idea/',
-    '.svelte-kit/',
-    '.DS_Store',
-    '*.log',
-    '*.tmp',
-    '*.zip',
-    'tmp/',
-    'logs/',
-    'coverage/',
-    '.vercel/',
-    '.netlify/',
+    "node_modules/",
+    "dist/",
+    "build/",
+    "out/",
+    ".next/",
+    ".turbo/",
+    ".cache/",
+    ".git/",
+    ".idea/",
+    ".svelte-kit/",
+    ".DS_Store",
+    "*.log",
+    "*.tmp",
+    "*.zip",
+    "tmp/",
+    "logs/",
+    "coverage/",
+    ".vercel/",
+    ".netlify/",
 ];
 const projectBuildCache = new Map();
 const typescriptSourceCache = new Map();
 async function runNpmScript(projectDir, script) {
     await (0, promises_1.mkdir)(projectDir, { recursive: true });
-    const npmCommand = process.platform === 'win32' ? process.env.ComSpec || 'cmd.exe' : 'npm';
-    const npmArgs = process.platform === 'win32' ? ['/d', '/s', '/c', `npm run ${script}`] : ['run', script];
+    const npmCommand = process.platform === "win32" ? process.env.ComSpec || "cmd.exe" : "npm";
+    const npmArgs = process.platform === "win32" ? ["/d", "/s", "/c", `npm run ${script}`] : ["run", script];
     await new Promise((resolveRun, rejectRun) => {
         const child = (0, node_child_process_1.spawn)(npmCommand, npmArgs, {
             cwd: projectDir,
-            stdio: 'inherit',
+            stdio: "inherit",
             env: { ...process.env },
         });
         const settleFromClose = (code) => {
@@ -46,14 +46,14 @@ async function runNpmScript(projectDir, script) {
                 resolveRun();
                 return;
             }
-            rejectRun(new Error(`npm run ${script} failed with exit code ${code ?? 'unknown'}`));
+            rejectRun(new Error(`npm run ${script} failed with exit code ${code ?? "unknown"}`));
         };
-        child.once('error', rejectRun);
-        child.once('close', settleFromClose);
+        child.once("error", rejectRun);
+        child.once("close", settleFromClose);
     });
 }
 function readPackageJson(packageJsonPath) {
-    const raw = (0, node_fs_1.readFileSync)(packageJsonPath, 'utf8');
+    const raw = (0, node_fs_1.readFileSync)(packageJsonPath, "utf8");
     return JSON.parse(raw);
 }
 async function ensureProjectBuild(task) {
@@ -64,41 +64,41 @@ async function ensureProjectBuild(task) {
         const promise = (async () => {
             const pkg = readPackageJson(task.packageJsonPath);
             const scripts = pkg?.scripts ?? {};
-            if (typeof scripts.build !== 'string') {
+            if (typeof scripts.build !== "string") {
                 throw new Error(`package.json in ${task.projectDir} is missing a "build" script.`);
             }
-            await runNpmScript(task.projectDir, 'build');
+            await runNpmScript(task.projectDir, "build");
         })();
         projectBuildCache.set(task.projectDir, promise);
     }
     await projectBuildCache.get(task.projectDir);
 }
 function globToRegExp(glob) {
-    let pattern = '^';
+    let pattern = "^";
     for (let i = 0; i < glob.length; i += 1) {
         const char = glob[i];
-        if (char === '*') {
+        if (char === "*") {
             const next = glob[i + 1];
-            if (next === '*') {
-                pattern += '.*';
+            if (next === "*") {
+                pattern += ".*";
                 i += 1;
             }
             else {
-                pattern += '[^/]*';
+                pattern += "[^/]*";
             }
             continue;
         }
-        if (char === '?') {
-            pattern += '.';
+        if (char === "?") {
+            pattern += ".";
             continue;
         }
-        if ('+.^$|()[]{}'.includes(char) || char === '\\') {
+        if ("+.^$|()[]{}".includes(char) || char === "\\") {
             pattern += `\\${char}`;
             continue;
         }
         pattern += char;
     }
-    pattern += '$';
+    pattern += "$";
     return new RegExp(pattern);
 }
 function readIgnorePatterns(projectDir, filename) {
@@ -107,7 +107,7 @@ function readIgnorePatterns(projectDir, filename) {
         return [];
     }
     try {
-        const content = (0, node_fs_1.readFileSync)(filePath, 'utf8');
+        const content = (0, node_fs_1.readFileSync)(filePath, "utf8");
         return content.split(/\r?\n/);
     }
     catch {
@@ -116,16 +116,16 @@ function readIgnorePatterns(projectDir, filename) {
 }
 function buildIgnoreRules(projectDir) {
     const patterns = [...BASE_SOURCE_IGNORE_PATTERNS];
-    patterns.push(...readIgnorePatterns(projectDir, '.playdropignore'));
-    patterns.push(...readIgnorePatterns(projectDir, '.gitignore'));
+    patterns.push(...readIgnorePatterns(projectDir, ".playdropignore"));
+    patterns.push(...readIgnorePatterns(projectDir, ".gitignore"));
     const rules = [];
     for (const rawPattern of patterns) {
         const trimmed = rawPattern.trim();
-        if (!trimmed || trimmed.startsWith('#')) {
+        if (!trimmed || trimmed.startsWith("#")) {
             continue;
         }
-        const normalized = trimmed.replace(/\\/g, '/');
-        if (normalized.endsWith('/')) {
+        const normalized = trimmed.replace(/\\/g, "/");
+        if (normalized.endsWith("/")) {
             const segment = normalized.slice(0, -1);
             const regex = globToRegExp(`**/${segment}/**`);
             rules.push({
@@ -140,39 +140,39 @@ function buildIgnoreRules(projectDir) {
             });
             continue;
         }
-        if (!normalized.includes('/') && !normalized.includes('*') && !normalized.includes('?')) {
+        if (!normalized.includes("/") && !normalized.includes("*") && !normalized.includes("?")) {
             const name = normalized;
             rules.push({
-                matches: path => {
+                matches: (path) => {
                     if (path === name)
                         return true;
                     if (path.endsWith(`/${name}`))
                         return true;
-                    return path.split('/').includes(name);
+                    return path.split("/").includes(name);
                 },
             });
             continue;
         }
-        if (!normalized.includes('*') && !normalized.includes('?')) {
+        if (!normalized.includes("*") && !normalized.includes("?")) {
             const target = normalized;
             rules.push({
-                matches: path => path === target || path.startsWith(`${target}/`),
+                matches: (path) => path === target || path.startsWith(`${target}/`),
             });
             continue;
         }
         const regex = globToRegExp(normalized);
         rules.push({
-            matches: path => regex.test(path),
+            matches: (path) => regex.test(path),
         });
     }
     return rules;
 }
 function shouldIgnore(pathFragment, isDir, rules) {
-    return rules.some(rule => rule.matches(pathFragment, isDir));
+    return rules.some((rule) => rule.matches(pathFragment, isDir));
 }
 function normalizeRelativePath(root, target) {
-    const rel = (0, node_path_1.relative)(root, target).split(node_path_1.sep).join('/');
-    return rel.replace(/^\/+/, '');
+    const rel = (0, node_path_1.relative)(root, target).split(node_path_1.sep).join("/");
+    return rel.replace(/^\/+/, "");
 }
 function isPathWithinRoot(rootDir, targetPath) {
     const normalizedRoot = (0, node_path_1.resolve)(rootDir);
@@ -192,11 +192,11 @@ function readProjectDirEntries(current) {
     }
 }
 function appendIncludedProjectFile(rootDir, includePath, excludedRelativeFiles, fileByRelativePath, results, enforceReservedBundleNames) {
-    const normalizedIncludePath = (0, node_path_1.normalize)(includePath).split(node_path_1.sep).join('/');
-    if (!normalizedIncludePath || normalizedIncludePath === '.') {
+    const normalizedIncludePath = (0, node_path_1.normalize)(includePath).split(node_path_1.sep).join("/");
+    if (!normalizedIncludePath || normalizedIncludePath === ".") {
         return;
     }
-    if (normalizedIncludePath.startsWith('..')) {
+    if (normalizedIncludePath.startsWith("..")) {
         throw new Error(`[apps][build] Invalid include file path "${includePath}".`);
     }
     if (excludedRelativeFiles.has(normalizedIncludePath)) {
@@ -227,8 +227,8 @@ function appendIncludedProjectFile(rootDir, includePath, excludedRelativeFiles,
     fileByRelativePath.set(record.relativePath, record);
 }
 function appendIncludedProjectDirectory(rootDir, includeDirectory, excludedRelativeFiles, fileByRelativePath, results, enforceReservedBundleNames) {
-    const normalizedDirectory = (0, node_path_1.normalize)(includeDirectory).split(node_path_1.sep).join('/').replace(/\/+$/, '');
-    if (!normalizedDirectory || normalizedDirectory === '.' || normalizedDirectory.startsWith('..')) {
+    const normalizedDirectory = (0, node_path_1.normalize)(includeDirectory).split(node_path_1.sep).join("/").replace(/\/+$/, "");
+    if (!normalizedDirectory || normalizedDirectory === "." || normalizedDirectory.startsWith("..")) {
         throw new Error(`[apps][build] Invalid include directory path "${includeDirectory}".`);
     }
     const absoluteDirectory = (0, node_path_1.resolve)(rootDir, normalizedDirectory);
@@ -262,8 +262,8 @@ function collectProjectFiles(rootDir, rules, options) {
     const includeRelativeFiles = options?.includeRelativeFiles ?? [];
     const includeRelativeDirectories = options?.includeRelativeDirectories ?? [];
     const excludeRelativeFiles = new Set(Array.from(options?.excludeRelativeFiles ?? [])
-        .map((filePath) => (0, node_path_1.normalize)(filePath).split(node_path_1.sep).join('/'))
-        .filter((filePath) => filePath.length > 0 && filePath !== '.'));
+        .map((filePath) => (0, node_path_1.normalize)(filePath).split(node_path_1.sep).join("/"))
+        .filter((filePath) => filePath.length > 0 && filePath !== "."));
     const enforceReservedBundleNames = options?.enforceReservedBundleNames ?? false;
     const results = [];
     const fileByRelativePath = new Map();
@@ -309,7 +309,7 @@ function collectProjectFiles(rootDir, rules, options) {
                 continue;
             const record = {
                 absolutePath,
-                relativePath: relativePath.split('/').join('/'),
+                relativePath: relativePath.split("/").join("/"),
             };
             results.push(record);
             fileByRelativePath.set(record.relativePath, record);
@@ -329,17 +329,17 @@ function isExcludedRelativePath(relativePath, excludedRelativeFiles) {
         return true;
     }
     for (const excludedPath of excludedRelativeFiles) {
-        if (excludedPath.endsWith('/') && relativePath.startsWith(excludedPath)) {
+        if (excludedPath.endsWith("/") && relativePath.startsWith(excludedPath)) {
             return true;
         }
     }
     return false;
 }
 // Files that are uploaded separately and should not be included in the bundle zip.
-const RESERVED_BUNDLE_FILES = new Set(['source.zip']);
+const RESERVED_BUNDLE_FILES = new Set(["source.zip"]);
 function isReservedBundlePath(relativePath) {
-    const normalized = relativePath.replace(/\\/g, '/');
-    const basenameValue = normalized.split('/').pop()?.toLowerCase() || '';
+    const normalized = relativePath.replace(/\\/g, "/");
+    const basenameValue = normalized.split("/").pop()?.toLowerCase() || "";
     return RESERVED_BUNDLE_FILES.has(basenameValue);
 }
 function resolveRuntimeRoot(task) {
@@ -347,7 +347,7 @@ function resolveRuntimeRoot(task) {
 }
 function resolveBundleEntryPoint(task, runtimeRoot) {
     const entryPoint = normalizeRelativePath(runtimeRoot, task.filePath);
-    if (!entryPoint || entryPoint.startsWith('..')) {
+    if (!entryPoint || entryPoint.startsWith("..")) {
         throw new Error(`[apps][build] App entry file for ${task.name} must remain inside runtime root ${runtimeRoot}.`);
     }
     return entryPoint;
@@ -361,13 +361,13 @@ function normalizeBundleArchiveExclusions(task, runtimeRoot) {
         if (!trimmed) {
             continue;
         }
-        const isDirectory = trimmed.replace(/\\/g, '/').endsWith('/');
+        const isDirectory = trimmed.replace(/\\/g, "/").endsWith("/");
         const absolutePath = (0, node_path_1.resolve)(task.projectDir, trimmed);
         if (!isPathWithinRoot(runtimeRootAbsolute, absolutePath)) {
             continue;
         }
         const runtimeRelativePath = normalizeRelativePath(runtimeRootAbsolute, absolutePath);
-        if (!runtimeRelativePath || runtimeRelativePath.startsWith('..')) {
+        if (!runtimeRelativePath || runtimeRelativePath.startsWith("..")) {
             continue;
         }
         normalized.push(isDirectory ? `${runtimeRelativePath}/` : runtimeRelativePath);
@@ -392,7 +392,7 @@ function collectBundleFiles(task) {
 function createBundleArchive(task) {
     const { entries, entryPoint } = collectBundleFiles(task);
     const buffer = createZipArchive(entries);
-    const hash = (0, node_crypto_1.createHash)('sha256').update(buffer).digest('hex');
+    const hash = (0, node_crypto_1.createHash)("sha256").update(buffer).digest("hex");
     return { buffer, hash, entryPoint };
 }
 const CRC32_TABLE = (() => {
@@ -440,7 +440,7 @@ function createZipArchive(entries) {
         const compressed = (0, node_zlib_1.deflateRawSync)(data);
         const crc = crc32(data);
         const { dosDate, dosTime } = toDosDateTime(ZIP_STABLE_TIMESTAMP);
-        const fileNameBuffer = Buffer.from(entry.relativePath, 'utf8');
+        const fileNameBuffer = Buffer.from(entry.relativePath, "utf8");
         const localHeader = Buffer.alloc(30);
         let cursor = 0;
         localHeader.writeUInt32LE(0x04034b50, cursor);
@@ -531,7 +531,7 @@ function createZipArchive(entries) {
 }
 function createSourceArchive(task) {
     const rules = buildIgnoreRules(task.projectDir);
-    const includeFiles = ['README.md', 'AGENTS.md'];
+    const includeFiles = ["README.md", "AGENTS.md"];
     for (const heroPath of [task.listing?.heroPortraitPath, task.listing?.heroLandscapePath]) {
         if (heroPath) {
             includeFiles.push(normalizeRelativePath(task.projectDir, heroPath));
@@ -539,65 +539,65 @@ function createSourceArchive(task) {
     }
     const excludedFiles = task.sourceArchiveExcludeRelativeFiles ?? [];
     if (task.catalogueAbsolutePath && (0, node_fs_1.existsSync)(task.catalogueAbsolutePath)) {
-        const relativeCataloguePath = normalizeRelativePath(task.projectDir, task.catalogueAbsolutePath) || 'catalogue.json';
+        const relativeCataloguePath = normalizeRelativePath(task.projectDir, task.catalogueAbsolutePath) || "catalogue.json";
         includeFiles.push(relativeCataloguePath);
     }
     if (task.isTypescriptProject) {
-        const cacheKey = [task.projectDir, ...excludedFiles].join('\u0000');
+        const cacheKey = [task.projectDir, ...excludedFiles].join("\u0000");
         const cached = typescriptSourceCache.get(cacheKey);
         if (cached) {
             return cached;
         }
         const entries = collectProjectFiles(task.projectDir, rules, {
             includeRelativeFiles: includeFiles,
-            includeRelativeDirectories: ['assets/art-direction'],
+            includeRelativeDirectories: ["assets/art-direction"],
             excludeRelativeFiles: excludedFiles,
         });
         const buffer = createZipArchive(entries);
-        const hash = (0, node_crypto_1.createHash)('sha256').update(buffer).digest('hex');
+        const hash = (0, node_crypto_1.createHash)("sha256").update(buffer).digest("hex");
         const record = { buffer, hash };
         typescriptSourceCache.set(cacheKey, record);
         return record;
     }
     const entries = collectProjectFiles(task.projectDir, rules, {
         includeRelativeFiles: includeFiles,
-        includeRelativeDirectories: ['assets/art-direction'],
+        includeRelativeDirectories: ["assets/art-direction"],
         excludeRelativeFiles: excludedFiles,
     });
     const buffer = createZipArchive(entries);
-    const hash = (0, node_crypto_1.createHash)('sha256').update(buffer).digest('hex');
+    const hash = (0, node_crypto_1.createHash)("sha256").update(buffer).digest("hex");
     return { buffer, hash };
 }
 async function buildApp(task) {
     await ensureProjectBuild(task);
     if (!(0, node_fs_1.existsSync)(task.filePath) || !(0, node_fs_1.statSync)(task.filePath).isFile()) {
-        const locationHint = task.cataloguePath || 'catalogue.json';
+        const locationHint = task.cataloguePath || "catalogue.json";
         const bundlePath = task.relativeFile || (0, node_path_1.basename)(task.filePath);
         const buildAdvice = task.isTypescriptProject
-            ? 'Run `npm run build` in the project directory and confirm the bundle path.'
-            : 'Confirm the catalogue entry points to an existing HTML file.';
+            ? "Run `npm run build` in the project directory and confirm the bundle path."
+            : "Confirm the catalogue entry points to an existing HTML file.";
         throw new Error([
             `Bundle not found for ${task.name}: ${bundlePath}`,
             `Check the "file" value in ${locationHint}.`,
             buildAdvice,
-        ].join(' '));
+        ].join(" "));
     }
     // Create bundle zip for versioned upload
     const bundleArchive = createBundleArchive(task);
     const bundleFileName = `${task.name}-bundle.zip`;
     const bundleBlobPart = Uint8Array.from(bundleArchive.buffer);
-    const bundleFile = new File([bundleBlobPart], bundleFileName, { type: 'application/zip' });
+    const bundleFile = new File([bundleBlobPart], bundleFileName, { type: "application/zip" });
     const bundleHash = bundleArchive.hash;
     const sourceArchive = createSourceArchive(task);
     const sourceFileName = `${task.name}-source.zip`;
     const sourceBlobPart = Uint8Array.from(sourceArchive.buffer);
-    const sourceFile = new File([sourceBlobPart], sourceFileName, { type: 'application/zip' });
+    const sourceFile = new File([sourceBlobPart], sourceFileName, { type: "application/zip" });
     const metadata = {};
     if (task.displayName)
         metadata.displayName = task.displayName;
     if (task.subtitle)
         metadata.subtitle = task.subtitle;
-    if (typeof task.description === 'string')
+    if (typeof task.description === "string")
         metadata.description = task.description;
     if (task.type)
         metadata.type = task.type;