@playdrop/playdrop-cli 0.16.5 → 0.16.11

package/dist/apps/upload.js

@@ -10,39 +10,39 @@ const node_path_1 = require("node:path");
 const http_1 = require("../http");
 const loadCheck_1 = require("./loadCheck");
 const EXTENSION_TO_MIME = {
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.webp': 'image/webp',
-    '.gif': 'image/gif',
-    '.mp4': 'video/mp4',
-    '.webm': 'video/webm',
-    '.mp3': 'audio/mpeg',
-    '.wav': 'audio/wav',
-    '.ogg': 'audio/ogg',
-    '.json': 'application/json',
-    '.gltf': 'model/gltf+json',
-    '.glb': 'model/gltf-binary',
-    '.vox': 'application/octet-stream',
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".ogg": "audio/ogg",
+    ".json": "application/json",
+    ".gltf": "model/gltf+json",
+    ".glb": "model/gltf-binary",
+    ".vox": "application/octet-stream",
 };
 function isPngSignature(content) {
     if (content.length < 8) {
         return false;
     }
-    return (content[0] === 0x89
-        && content[1] === 0x50
-        && content[2] === 0x4e
-        && content[3] === 0x47
-        && content[4] === 0x0d
-        && content[5] === 0x0a
-        && content[6] === 0x1a
-        && content[7] === 0x0a);
+    return (content[0] === 0x89 &&
+        content[1] === 0x50 &&
+        content[2] === 0x4e &&
+        content[3] === 0x47 &&
+        content[4] === 0x0d &&
+        content[5] === 0x0a &&
+        content[6] === 0x1a &&
+        content[7] === 0x0a);
 }
 function isMp4Signature(content) {
     if (content.length < 12) {
         return false;
     }
-    return content.toString('ascii', 4, 8) === 'ftyp';
+    return content.toString("ascii", 4, 8) === "ftyp";
 }
 function createUploadValidationError(code, message) {
     const error = new Error(`${code}: ${message}`);
@@ -73,9 +73,9 @@ async function bufferFromFile(file) {
     return Buffer.from(await file.arrayBuffer());
 }
 function computeSha256Hex(buffer) {
-    return (0, node_crypto_1.createHash)('sha256').update(buffer).digest('hex');
+    return (0, node_crypto_1.createHash)("sha256").update(buffer).digest("hex");
 }
-function resolveMimeType(filename, fallback = 'application/octet-stream') {
+function resolveMimeType(filename, fallback = "application/octet-stream") {
     const type = EXTENSION_TO_MIME[(0, node_path_1.extname)(filename).toLowerCase()];
     return type ?? fallback;
 }
@@ -116,7 +116,11 @@ async function prepareOwnedAssetUpload(task) {
         description: task.description,
         category: task.category,
         subcategory: task.subcategory,
-        format: task.format || (0, node_path_1.extname)(files[0]?.filename || '').replace(/^\./, '').toUpperCase() || 'GLB',
+        format: task.format ||
+            (0, node_path_1.extname)(files[0]?.filename || "")
+                .replace(/^\./, "")
+                .toUpperCase() ||
+            "GLB",
         visibility: task.visibility,
         license: task.license,
         assetSpec: task.assetSpec,
@@ -138,7 +142,7 @@ function ensurePreparedArtifactSize(file, maxBytes, code, label) {
 function accumulateUploadBytes(taskName, currentTotal, nextBytes) {
     const nextTotal = currentTotal + nextBytes;
     if (nextTotal > config_1.MAX_VERSION_TOTAL_BYTES) {
-        throw createUploadValidationError('upload_too_large', `Total upload for "${taskName}" exceeds ${formatLimitBytes(config_1.MAX_VERSION_TOTAL_BYTES)}. Received ${nextTotal} bytes.`);
+        throw createUploadValidationError("upload_too_large", `Total upload for "${taskName}" exceeds ${formatLimitBytes(config_1.MAX_VERSION_TOTAL_BYTES)}. Received ${nextTotal} bytes.`);
     }
     return nextTotal;
 }
@@ -160,55 +164,55 @@ async function prepareAppUploadFiles(task, artifacts) {
         }
     }
     for (const definition of task.achievements ?? []) {
-        const prepared = createFileFromPath(definition.iconPath, 'image/png', config_1.MAX_VERSION_ICON_BYTES, 'achievement_icon_too_large', 'invalid_achievement_icon_content_type', `Achievement icon "${definition.key}"`, isPngSignature);
+        const prepared = createFileFromPath(definition.iconPath, "image/png", config_1.MAX_VERSION_ICON_BYTES, "achievement_icon_too_large", "invalid_achievement_icon_content_type", `Achievement icon "${definition.key}"`, isPngSignature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
         sessionFiles.push(await buildPreparedSessionFile(`achievementIcon:${definition.key}`, prepared.file));
     }
-    if (task.hostingMode === 'EXTERNAL') {
+    if (task.hostingMode === "EXTERNAL") {
         // no hosted files
     }
     else if (artifacts) {
-        totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.bundleFile, config_1.MAX_VERSION_BUNDLE_BYTES, 'bundle_too_large', 'Bundle');
-        totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.sourceFile, config_1.MAX_APP_SOURCE_BYTES, 'source_too_large', 'Source archive');
-        sessionFiles.push(await buildPreparedSessionFile('bundle', artifacts.bundleFile));
-        sessionFiles.push(await buildPreparedSessionFile('source', artifacts.sourceFile));
+        totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.bundleFile, config_1.MAX_VERSION_BUNDLE_BYTES, "bundle_too_large", "Bundle");
+        totalUploadBytes = pushPreparedArtifact(task, totalUploadBytes, artifacts.sourceFile, config_1.MAX_APP_SOURCE_BYTES, "source_too_large", "Source archive");
+        sessionFiles.push(await buildPreparedSessionFile("bundle", artifacts.bundleFile));
+        sessionFiles.push(await buildPreparedSessionFile("source", artifacts.sourceFile));
     }
     if (listing?.iconPath) {
-        const prepared = createFileFromPath(listing.iconPath, 'image/png', config_1.MAX_VERSION_ICON_BYTES, 'icon_too_large', 'invalid_icon_content_type', 'Icon', isPngSignature);
+        const prepared = createFileFromPath(listing.iconPath, "image/png", config_1.MAX_VERSION_ICON_BYTES, "icon_too_large", "invalid_icon_content_type", "Icon", isPngSignature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        sessionFiles.push(await buildPreparedSessionFile('icon', prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile("icon", prepared.file));
     }
     if (listing?.heroPortraitPath) {
-        const prepared = createFileFromPath(listing.heroPortraitPath, 'image/png', config_1.MAX_VERSION_HERO_BYTES, 'hero_portrait_too_large', 'invalid_hero_portrait_content_type', 'Hero portrait', isPngSignature);
+        const prepared = createFileFromPath(listing.heroPortraitPath, "image/png", config_1.MAX_VERSION_HERO_BYTES, "hero_portrait_too_large", "invalid_hero_portrait_content_type", "Hero portrait", isPngSignature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        sessionFiles.push(await buildPreparedSessionFile('heroPortrait', prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile("heroPortrait", prepared.file));
     }
     if (listing?.heroLandscapePath) {
-        const prepared = createFileFromPath(listing.heroLandscapePath, 'image/png', config_1.MAX_VERSION_HERO_BYTES, 'hero_landscape_too_large', 'invalid_hero_landscape_content_type', 'Hero landscape', isPngSignature);
+        const prepared = createFileFromPath(listing.heroLandscapePath, "image/png", config_1.MAX_VERSION_HERO_BYTES, "hero_landscape_too_large", "invalid_hero_landscape_content_type", "Hero landscape", isPngSignature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
-        sessionFiles.push(await buildPreparedSessionFile('heroLandscape', prepared.file));
+        sessionFiles.push(await buildPreparedSessionFile("heroLandscape", prepared.file));
     }
     for (let index = 0; index < (listing?.screenshotPortraitPaths ?? []).length; index += 1) {
         const filePath = listing.screenshotPortraitPaths[index];
-        const prepared = createFileFromPath(filePath, 'image/png', config_1.MAX_VERSION_SCREENSHOT_BYTES, 'screenshot_portrait_too_large', 'invalid_screenshot_portrait_content_type', `Portrait screenshot ${index + 1}`, isPngSignature);
+        const prepared = createFileFromPath(filePath, "image/png", config_1.MAX_VERSION_SCREENSHOT_BYTES, "screenshot_portrait_too_large", "invalid_screenshot_portrait_content_type", `Portrait screenshot ${index + 1}`, isPngSignature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
         sessionFiles.push(await buildPreparedSessionFile(`screenshotsPortrait:${index}`, prepared.file));
     }
     for (let index = 0; index < (listing?.screenshotLandscapePaths ?? []).length; index += 1) {
         const filePath = listing.screenshotLandscapePaths[index];
-        const prepared = createFileFromPath(filePath, 'image/png', config_1.MAX_VERSION_SCREENSHOT_BYTES, 'screenshot_landscape_too_large', 'invalid_screenshot_landscape_content_type', `Landscape screenshot ${index + 1}`, isPngSignature);
+        const prepared = createFileFromPath(filePath, "image/png", config_1.MAX_VERSION_SCREENSHOT_BYTES, "screenshot_landscape_too_large", "invalid_screenshot_landscape_content_type", `Landscape screenshot ${index + 1}`, isPngSignature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
         sessionFiles.push(await buildPreparedSessionFile(`screenshotsLandscape:${index}`, prepared.file));
     }
     for (let index = 0; index < (listing?.videoPortraitPaths ?? []).length; index += 1) {
         const filePath = listing.videoPortraitPaths[index];
-        const prepared = createFileFromPath(filePath, 'video/mp4', config_1.MAX_VERSION_VIDEO_BYTES, 'video_portrait_too_large', 'invalid_video_portrait_content_type', `Portrait video ${index + 1}`, isMp4Signature);
+        const prepared = createFileFromPath(filePath, "video/mp4", config_1.MAX_VERSION_VIDEO_BYTES, "video_portrait_too_large", "invalid_video_portrait_content_type", `Portrait video ${index + 1}`, isMp4Signature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
         sessionFiles.push(await buildPreparedSessionFile(`videosPortrait:${index}`, prepared.file));
     }
     for (let index = 0; index < (listing?.videoLandscapePaths ?? []).length; index += 1) {
         const filePath = listing.videoLandscapePaths[index];
-        const prepared = createFileFromPath(filePath, 'video/mp4', config_1.MAX_VERSION_VIDEO_BYTES, 'video_landscape_too_large', 'invalid_video_landscape_content_type', `Landscape video ${index + 1}`, isMp4Signature);
+        const prepared = createFileFromPath(filePath, "video/mp4", config_1.MAX_VERSION_VIDEO_BYTES, "video_landscape_too_large", "invalid_video_landscape_content_type", `Landscape video ${index + 1}`, isMp4Signature);
         totalUploadBytes = pushPreparedFile(task.name, totalUploadBytes, prepared);
         sessionFiles.push(await buildPreparedSessionFile(`videosLandscape:${index}`, prepared.file));
     }
@@ -226,21 +230,21 @@ async function uploadApp(client, task, artifacts, options) {
  * Upload an app version using the versioned API.
  */
 async function uploadAppVersion(client, task, artifacts, options) {
-    const creatorUsername = typeof options?.creatorUsername === 'string' ? options.creatorUsername.trim() : '';
+    const creatorUsername = typeof options?.creatorUsername === "string" ? options.creatorUsername.trim() : "";
     if (!creatorUsername) {
         throw new Error(`Missing creator username for app "${task.name}" upload.`);
     }
     const achievements = task.achievements ?? [];
     const leaderboards = task.leaderboards ?? [];
     const listing = task.listing;
-    const { sessionFiles: preparedSessionFiles, ownedAssets: preparedOwnedAssets, } = await prepareAppUploadFiles(task, artifacts);
+    const { sessionFiles: preparedSessionFiles, ownedAssets: preparedOwnedAssets } = await prepareAppUploadFiles(task, artifacts);
     const initializeRequest = {
         version: task.version,
         agentTaskId: options?.agentTaskId,
         playtestProof: options?.playtestProof,
         releaseNotes: task.releaseNotes,
         visibility: task.versionVisibility,
-        setAsCurrent: task.versionVisibility === 'PRIVATE' ? false : undefined,
+        setAsCurrent: task.versionVisibility === "PRIVATE" ? false : undefined,
         license: task.license,
         remixRef: task.remix,
         usesAssets: task.uses.assets.map((entry) => ({
@@ -291,7 +295,7 @@ async function uploadAppVersion(client, task, artifacts, options) {
             ...(definition.unitLabel ? { unitLabel: definition.unitLabel } : {}),
             status: definition.status,
         })),
-        externalUrl: task.hostingMode === 'EXTERNAL' ? task.externalUrl : undefined,
+        externalUrl: task.hostingMode === "EXTERNAL" ? task.externalUrl : undefined,
         listingMedia: listing?.mediaMetadata,
         files: preparedSessionFiles.map((file) => ({
             fileKey: file.fileKey,
@@ -328,7 +332,7 @@ async function uploadAppVersion(client, task, artifacts, options) {
     try {
         const initialized = await client.initializeAppUpload(creatorUsername, task.name, initializeRequest);
         sessionId = initialized.session.id;
-        if (initialized.status !== 'finalized') {
+        if (initialized.status !== "finalized") {
             const uploadedFileKeys = new Set(initialized.session.uploadedFileKeys);
             const uploadedOwnedAssetKeys = new Set(initialized.session.uploadedOwnedAssetKeys);
             for (const file of preparedSessionFiles) {
@@ -352,9 +356,7 @@ async function uploadAppVersion(client, task, artifacts, options) {
                     })),
                 });
             }
-            if (task.hostingMode !== 'EXTERNAL'
-                && !task.externalUrl
-                && options?.playtestSmokeCheckRequired) {
+            if (task.hostingMode !== "EXTERNAL" && !task.externalUrl && options?.playtestSmokeCheckRequired) {
                 await (0, loadCheck_1.runUploadedHostedPlaytestSmokeCheck)({
                     client,
                     creatorUsername,
@@ -366,9 +368,7 @@ async function uploadAppVersion(client, task, artifacts, options) {
                     captureSession: options?.captureSession,
                 });
             }
-            else if (task.hostingMode !== 'EXTERNAL'
-                && !task.externalUrl
-                && options?.runStagedUploadLoadCheck) {
+            else if (task.hostingMode !== "EXTERNAL" && !task.externalUrl && options?.runStagedUploadLoadCheck) {
                 const loadCheck = await (0, loadCheck_1.runUploadedHostedLoadCheck)({
                     client,
                     creatorUsername,
@@ -379,11 +379,11 @@ async function uploadAppVersion(client, task, artifacts, options) {
                     currentUser: options?.user ?? null,
                     captureSession: options?.captureSession,
                 });
-                if (loadCheck.status !== 'PASSED') {
-                    throw new Error((0, loadCheck_1.formatHostedLoadCheckFailure)(task.name, loadCheck, 'staged'));
+                if (loadCheck.status !== "PASSED") {
+                    throw new Error((0, loadCheck_1.formatHostedLoadCheckFailure)(task.name, loadCheck, "staged"));
                 }
             }
-            if (task.editorSupported && task.hostingMode !== 'EXTERNAL' && !task.externalUrl) {
+            if (task.editorSupported && task.hostingMode !== "EXTERNAL" && !task.externalUrl) {
                 const editorLoadCheck = await (0, loadCheck_1.runUploadedHostedLoadCheck)({
                     client,
                     creatorUsername,
@@ -393,31 +393,27 @@ async function uploadAppVersion(client, task, artifacts, options) {
                     token: options?.token ?? null,
                     currentUser: options?.user ?? null,
                     captureSession: options?.captureSession,
-                    phase: 'editor',
+                    phase: "editor",
                     verifyEditorPhaseRoundTrip: true,
                 });
-                if (editorLoadCheck.status !== 'PASSED') {
-                    throw new Error((0, loadCheck_1.formatHostedLoadCheckFailure)(task.name, editorLoadCheck, 'editor'));
+                if (editorLoadCheck.status !== "PASSED") {
+                    throw new Error((0, loadCheck_1.formatHostedLoadCheckFailure)(task.name, editorLoadCheck, "editor"));
                 }
             }
         }
-        const finalized = initialized.status === 'finalized'
+        const finalized = initialized.status === "finalized"
             ? initialized.finalized
             : await client.finalizeAppUpload(creatorUsername, task.name, sessionId);
         if (!finalized) {
             throw new Error(`Upload failed for ${task.name}: missing finalized app upload payload`);
         }
-        const version = initialized.status === 'finalized'
-            ? finalized?.version
-            : finalized.version;
-        const versionNodeId = initialized.status === 'finalized'
-            ? finalized?.versionNodeId
-            : finalized.versionNodeId;
+        const version = initialized.status === "finalized" ? finalized?.version : finalized.version;
+        const versionNodeId = initialized.status === "finalized" ? finalized?.versionNodeId : finalized.versionNodeId;
         return {
             versionCreated: true,
             version: version?.version,
-            versionId: typeof version?.id === 'number' ? version.id : undefined,
-            versionNodeId: typeof versionNodeId === 'string' ? versionNodeId : undefined,
+            versionId: typeof version?.id === "number" ? version.id : undefined,
+            versionNodeId: typeof versionNodeId === "string" ? versionNodeId : undefined,
         };
     }
     catch (unknownError) {
@@ -430,34 +426,32 @@ async function uploadAppVersion(client, task, artifacts, options) {
             }
         }
         if (unknownError instanceof types_1.UnsupportedClientError) {
-            (0, http_1.handleUnsupportedError)(unknownError, 'Upload app version');
+            (0, http_1.handleUnsupportedError)(unknownError, "Upload app version");
         }
         if (unknownError instanceof http_1.CLIUnsupportedClientError) {
             throw unknownError;
         }
         if (unknownError instanceof types_1.ApiError) {
             const detail = unknownError.message?.trim();
-            if (unknownError.code === 'version_limit_reached') {
+            if (unknownError.code === "version_limit_reached") {
                 const appRef = `${creatorUsername}/app/${task.name}`;
-                throw new Error(`${detail || `App "${task.name}" has reached the maximum version count.`}\n`
-                    + `Review versions: playdrop versions browse ${appRef}\n`
-                    + `Delete one old version: playdrop creations apps versions delete ${task.name} <version>`);
+                throw new Error(`${detail || `App "${task.name}" has reached the maximum version count.`}\n` +
+                    `Review versions: playdrop versions browse ${appRef}\n` +
+                    `Delete one old version: playdrop creations apps versions delete ${task.name} <version>`);
             }
-            if (unknownError.status === 409 && unknownError.code === 'version_exists') {
+            if (unknownError.status === 409 && unknownError.code === "version_exists") {
                 if (options?.agentTaskId !== undefined) {
                     throw new Error(`Version ${task.version} already exists for app "${task.name}".\n` +
-                        'This task has a fixed outputVersion; do not bump catalogue.json. The required task version has already been consumed by an upload attempt, so fail the task with the operational reason.');
+                        "This task has a fixed outputVersion; do not bump catalogue.json. The required task version has already been consumed by an upload attempt, so fail the task with the operational reason.");
                 }
                 throw new Error(`Version ${task.version} already exists for app "${task.name}".\n` +
                     `Hint: Update "version" in catalogue.json to a new version (e.g., bump to the next patch).`);
             }
             const statusText = `status ${unknownError.status}`;
-            const errorCode = typeof unknownError.code === 'string' && unknownError.code.trim().length > 0
-                ? unknownError.code.trim()
-                : '';
+            const errorCode = typeof unknownError.code === "string" && unknownError.code.trim().length > 0 ? unknownError.code.trim() : "";
             const annotatedMessage = detail
-                ? `${errorCode ? `${errorCode}: ` : ''}${detail}`
-                : `${statusText}${errorCode ? ` (${errorCode})` : ''}`;
+                ? `${errorCode ? `${errorCode}: ` : ""}${detail}`
+                : `${statusText}${errorCode ? ` (${errorCode})` : ""}`;
             throw new Error(`Upload failed for ${task.name}: ${annotatedMessage}`);
         }
         throw unknownError;

package/dist/apps/validate.d.ts

@@ -1,5 +1,5 @@
-import type { AppTask } from '../catalogue';
-export type AppValidationWarningMode = 'source' | 'bundle';
+import type { AppTask } from "../catalogue";
+export type AppValidationWarningMode = "source" | "bundle";
 export declare function collectAppValidationWarnings(task: AppTask, _mode?: AppValidationWarningMode): string[];
 export declare function runFormatScript(task: AppTask): Promise<boolean>;
 export declare function validateAppTask(task: AppTask): Promise<void>;

package/dist/apps/validate.js

@@ -13,7 +13,7 @@ const projectFormatCache = new Map();
 function ensureWithinProject(task) {
     const relativePath = (0, node_path_1.relative)(task.projectDir, task.filePath);
     const segments = relativePath.split(/[/\\]+/);
-    if (!relativePath || relativePath.startsWith('..') || segments.includes('..')) {
+    if (!relativePath || relativePath.startsWith("..") || segments.includes("..")) {
         throw new Error(`[apps][validate] Bundle path for ${task.name} must remain inside ${task.projectDir}. Update catalogue entry ${task.cataloguePath}.`);
     }
 }
@@ -22,14 +22,14 @@ async function ensureValidateScript(task) {
         return;
     }
     if (!projectValidateCache.has(task.projectDir)) {
-        const promise = (0, build_1.runNpmScript)(task.projectDir, 'validate');
+        const promise = (0, build_1.runNpmScript)(task.projectDir, "validate");
         projectValidateCache.set(task.projectDir, promise);
     }
     await projectValidateCache.get(task.projectDir);
 }
 function safeReadFile(filePath) {
     try {
-        return (0, node_fs_1.readFileSync)(filePath, 'utf8');
+        return (0, node_fs_1.readFileSync)(filePath, "utf8");
     }
     catch {
         return null;
@@ -54,27 +54,23 @@ function collectOutdatedSdkVersionWarnings(task) {
     if (!(0, semver_1.valid)(cliVersion)) {
         return [];
     }
-    const sdkTypesDependency = typeof packageJson?.devDependencies?.['playdrop-sdk-types'] === 'string'
-        ? packageJson.devDependencies['playdrop-sdk-types']
-        : typeof packageJson?.dependencies?.['playdrop-sdk-types'] === 'string'
-            ? packageJson.dependencies['playdrop-sdk-types']
-            : '';
-    const sdkTypesVersion = typeof packageJson?.playdrop?.sdkTypesVersion === 'string'
-        ? packageJson.playdrop.sdkTypesVersion.trim()
-        : '';
-    const usesVendoredSdkTypes = sdkTypesDependency.includes('playdrop-sdk-types')
-        && (sdkTypesDependency.startsWith('file:') || sdkTypesDependency.includes('.tgz'));
-    if (!usesVendoredSdkTypes
-        || !(0, semver_1.valid)(sdkTypesVersion)
-        || !(0, semver_1.lt)(sdkTypesVersion, cliVersion)) {
+    const sdkTypesDependency = typeof packageJson?.devDependencies?.["playdrop-sdk-types"] === "string"
+        ? packageJson.devDependencies["playdrop-sdk-types"]
+        : typeof packageJson?.dependencies?.["playdrop-sdk-types"] === "string"
+            ? packageJson.dependencies["playdrop-sdk-types"]
+            : "";
+    const sdkTypesVersion = typeof packageJson?.playdrop?.sdkTypesVersion === "string" ? packageJson.playdrop.sdkTypesVersion.trim() : "";
+    const usesVendoredSdkTypes = sdkTypesDependency.includes("playdrop-sdk-types") &&
+        (sdkTypesDependency.startsWith("file:") || sdkTypesDependency.includes(".tgz"));
+    if (!usesVendoredSdkTypes || !(0, semver_1.valid)(sdkTypesVersion) || !(0, semver_1.lt)(sdkTypesVersion, cliVersion)) {
         return [];
     }
     return [
         `[apps][validate] ${task.name} vendors playdrop-sdk-types.tgz at ${sdkTypesVersion}, which is older than this CLI version ${cliVersion}. Refresh vendor/playdrop-sdk-types.tgz and package.json playdrop.sdkTypesVersion before upload.`,
     ];
 }
-function collectAppValidationWarnings(task, _mode = 'source') {
-    const isExternal = task.hostingMode === 'EXTERNAL' || !!task.externalUrl;
+function collectAppValidationWarnings(task, _mode = "source") {
+    const isExternal = task.hostingMode === "EXTERNAL" || !!task.externalUrl;
     if (isExternal) {
         return [];
     }
@@ -85,22 +81,22 @@ async function runFormatScript(task) {
         return false;
     }
     if (!projectFormatCache.has(task.projectDir)) {
-        projectFormatCache.set(task.projectDir, (0, build_1.runNpmScript)(task.projectDir, 'format'));
+        projectFormatCache.set(task.projectDir, (0, build_1.runNpmScript)(task.projectDir, "format"));
     }
     await projectFormatCache.get(task.projectDir);
     return true;
 }
 async function validateAppTask(task) {
     if (!task.name) {
-        throw new Error('[apps][validate] App entry is missing a name.');
+        throw new Error("[apps][validate] App entry is missing a name.");
     }
     // External apps don't need file validation - they're hosted elsewhere
-    const isExternal = task.hostingMode === 'EXTERNAL' || !!task.externalUrl;
+    const isExternal = task.hostingMode === "EXTERNAL" || !!task.externalUrl;
     if (isExternal) {
         if (!task.externalUrl) {
             throw new Error(`[apps][validate] ${task.name} is marked as EXTERNAL but missing externalUrl.`);
         }
-        if (!task.externalUrl.startsWith('https://')) {
+        if (!task.externalUrl.startsWith("https://")) {
             throw new Error(`[apps][validate] ${task.name} externalUrl must be HTTPS.`);
         }
         // External apps pass validation - no local files needed

package/dist/assetSpecs.d.ts

@@ -1,5 +1,5 @@
-import { type AssetSpecCapability, type AssetSpecContract, type AssetSpecValidationKind } from '@playdrop/types';
-export declare function resolveCustomAssetRoleContentType(filePath: string, roleContract?: Pick<AssetSpecContract['roles'][number], 'contentTypes'> | null): string;
+import { type AssetSpecCapability, type AssetSpecContract, type AssetSpecValidationKind } from "@playdrop/types";
+export declare function resolveCustomAssetRoleContentType(filePath: string, roleContract?: Pick<AssetSpecContract["roles"][number], "contentTypes"> | null): string;
 export type AssetSpecSupportDeclaration = {
     assetSpec: string;
     versionRange: string;

package/dist/assetSpecs.js

@@ -15,23 +15,23 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const semver_1 = require("semver");
 const LOCAL_EXTENSION_TO_MIME = {
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.webp': 'image/webp',
-    '.gif': 'image/gif',
-    '.aseprite': 'application/octet-stream',
-    '.mp4': 'video/mp4',
-    '.webm': 'video/webm',
-    '.mp3': 'audio/mpeg',
-    '.wav': 'audio/wav',
-    '.ogg': 'audio/ogg',
-    '.vox': 'application/octet-stream',
-    '.gltf': 'model/gltf+json',
-    '.glb': 'model/gltf-binary',
-    '.json': 'application/json',
-    '.md': 'text/markdown',
-    '.txt': 'text/plain',
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+    ".aseprite": "application/octet-stream",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".ogg": "audio/ogg",
+    ".vox": "application/octet-stream",
+    ".gltf": "model/gltf+json",
+    ".glb": "model/gltf-binary",
+    ".json": "application/json",
+    ".md": "text/markdown",
+    ".txt": "text/plain",
 };
 const ajv = new ajv_1.default({
     allErrors: true,
@@ -41,8 +41,8 @@ const ajv = new ajv_1.default({
 const validateContractMetaSchema = ajv.compile(types_1.ASSET_SPEC_CONTRACT_META_SCHEMA);
 function formatAjvErrors(prefix) {
     return (validateContractMetaSchema.errors ?? []).map((issue) => {
-        const path = issue.instancePath || issue.schemaPath || '/';
-        return `${prefix} contract is invalid at ${path}: ${issue.message ?? 'schema validation failed'}.`;
+        const path = issue.instancePath || issue.schemaPath || "/";
+        return `${prefix} contract is invalid at ${path}: ${issue.message ?? "schema validation failed"}.`;
     });
 }
 function createContractValidator() {
@@ -53,7 +53,7 @@ function createContractValidator() {
     });
 }
 function resolveMimeTypeFromPath(filePath) {
-    return LOCAL_EXTENSION_TO_MIME[(0, node_path_1.extname)(filePath).toLowerCase()] ?? 'application/octet-stream';
+    return LOCAL_EXTENSION_TO_MIME[(0, node_path_1.extname)(filePath).toLowerCase()] ?? "application/octet-stream";
 }
 function resolveCustomAssetRoleContentType(filePath, roleContract) {
     const resolvedContentType = resolveMimeTypeFromPath(filePath);
@@ -67,7 +67,7 @@ function resolveCustomAssetRoleContentType(filePath, roleContract) {
             return contentType.trim();
         }
     }
-    if ((0, node_path_1.extname)(filePath).toLowerCase() === '.json') {
+    if ((0, node_path_1.extname)(filePath).toLowerCase() === ".json") {
         const jsonLikeContentType = roleContract.contentTypes.find((contentType) => (0, types_1.isJsonLikeAssetSpecContentType)(contentType));
         if (jsonLikeContentType) {
             return jsonLikeContentType.trim();
@@ -86,17 +86,17 @@ function normalizeAssetSpecSupportEntries(raw, errors, context) {
     const rows = [];
     for (let index = 0; index < raw.length; index += 1) {
         const entry = raw[index];
-        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
             errors.push(`${context} assetSpecSupport[${index}] must be an object.`);
             continue;
         }
-        const assetSpec = typeof entry.assetSpec === 'string' ? entry.assetSpec.trim() : '';
+        const assetSpec = typeof entry.assetSpec === "string" ? entry.assetSpec.trim() : "";
         const parsedAssetSpec = (0, types_1.parseAssetSpecFamilyRef)(assetSpec);
         if (!assetSpec || !parsedAssetSpec) {
             errors.push(`${context} assetSpecSupport[${index}].assetSpec must be an asset spec family ref.`);
             continue;
         }
-        const versionRange = typeof entry.versionRange === 'string' ? entry.versionRange.trim() : '';
+        const versionRange = typeof entry.versionRange === "string" ? entry.versionRange.trim() : "";
         if (!versionRange || !(0, semver_1.validRange)(versionRange)) {
             errors.push(`${context} assetSpecSupport[${index}].versionRange must be a valid semver range.`);
             continue;
@@ -142,7 +142,7 @@ function loadAndValidateAssetSpecContract(catalogueDir, relativeContractPath, er
             errors.push(`${context} contract exceeds the ${types_1.ASSET_SPEC_CONTRACT_MAX_BYTES} byte limit.`);
             return null;
         }
-        rawText = (0, node_fs_1.readFileSync)(contractPath, 'utf8');
+        rawText = (0, node_fs_1.readFileSync)(contractPath, "utf8");
     }
     catch {
         errors.push(`${context} contract file not found at ${contractPath}.`);
@@ -153,7 +153,7 @@ function loadAndValidateAssetSpecContract(catalogueDir, relativeContractPath, er
         parsed = JSON.parse(rawText);
     }
     catch (error) {
-        errors.push(`${context} contract must be valid JSON (${error?.message ?? 'parse failed'}).`);
+        errors.push(`${context} contract must be valid JSON (${error?.message ?? "parse failed"}).`);
         return null;
     }
     if (!validateContractMetaSchema(parsed)) {
@@ -183,7 +183,7 @@ function loadAndValidateAssetSpecContract(catalogueDir, relativeContractPath, er
                 schemaAjv.compile(role.jsonSchema);
             }
             catch (error) {
-                errors.push(`${context} contract role "${role.name}" jsonSchema is invalid (${error?.message ?? 'compile failed'}).`);
+                errors.push(`${context} contract role "${role.name}" jsonSchema is invalid (${error?.message ?? "compile failed"}).`);
                 hasContractError = true;
             }
         }
@@ -207,7 +207,7 @@ function loadAndValidateAssetSpecContract(catalogueDir, relativeContractPath, er
     }
     return {
         contract,
-        validationKind: contract.roles.some((role) => role.jsonSchema) ? 'JSON_SCHEMA' : 'NONE',
+        validationKind: contract.roles.some((role) => role.jsonSchema) ? "JSON_SCHEMA" : "NONE",
         contractPath,
     };
 }
@@ -226,28 +226,28 @@ function validateCustomAssetFilesAgainstContract(contract, filePaths, errors, co
         if (roleContract.extensions?.length) {
             const allowedExtensions = roleContract.extensions.map((value) => value.trim().toLowerCase());
             if (!allowedExtensions.includes(extension)) {
-                errors.push(`${context} role "${rawRole}" must use one of ${allowedExtensions.join(', ')}.`);
+                errors.push(`${context} role "${rawRole}" must use one of ${allowedExtensions.join(", ")}.`);
             }
         }
         const resolvedContentType = resolveCustomAssetRoleContentType(filePath, roleContract);
         const normalizedContentTypes = roleContract.contentTypes.map((value) => value.trim().toLowerCase());
         if (!normalizedContentTypes.includes(resolvedContentType.toLowerCase())) {
-            errors.push(`${context} role "${rawRole}" must use one of ${normalizedContentTypes.join(', ')}.`);
+            errors.push(`${context} role "${rawRole}" must use one of ${normalizedContentTypes.join(", ")}.`);
         }
         if (roleContract.jsonSchema) {
             try {
-                const rawText = (0, node_fs_1.readFileSync)(filePath, 'utf8');
+                const rawText = (0, node_fs_1.readFileSync)(filePath, "utf8");
                 const parsedJson = JSON.parse(rawText);
                 const schemaAjv = createContractValidator();
                 const validateJson = schemaAjv.compile(roleContract.jsonSchema);
                 if (!validateJson(parsedJson)) {
                     const firstIssue = validateJson.errors?.[0];
-                    const issuePath = firstIssue?.instancePath || firstIssue?.schemaPath || '/';
-                    errors.push(`${context} role "${rawRole}" JSON content failed schema validation at ${issuePath}: ${firstIssue?.message ?? 'schema validation failed'}.`);
+                    const issuePath = firstIssue?.instancePath || firstIssue?.schemaPath || "/";
+                    errors.push(`${context} role "${rawRole}" JSON content failed schema validation at ${issuePath}: ${firstIssue?.message ?? "schema validation failed"}.`);
                 }
             }
             catch (error) {
-                errors.push(`${context} role "${rawRole}" JSON content is invalid (${error?.message ?? 'parse failed'}).`);
+                errors.push(`${context} role "${rawRole}" JSON content is invalid (${error?.message ?? "parse failed"}).`);
             }
         }
     }
@@ -261,7 +261,7 @@ function normalizeAssetSpecVersionRef(raw, errors, context) {
     if (raw === undefined || raw === null) {
         return undefined;
     }
-    if (typeof raw !== 'string' || raw.trim().length === 0) {
+    if (typeof raw !== "string" || raw.trim().length === 0) {
         errors.push(`${context} assetSpec must be an exact asset spec version ref.`);
         return undefined;
     }

package/dist/assets/model-artifacts.d.ts

@@ -1,4 +1,4 @@
-import type { AssetTask, OwnedAssetTask, PackOwnedAssetTask } from '../catalogue';
+import type { AssetTask, OwnedAssetTask, PackOwnedAssetTask } from "../catalogue";
 type ModelAssetTask = AssetTask | OwnedAssetTask | PackOwnedAssetTask;
 export declare function isGeneratedModel3DAssetTask(task: ModelAssetTask, format?: string): boolean;
 export declare function assertGeneratedModel3DAssetRoles(task: ModelAssetTask, format?: string): void;