@playdrop/playdrop-cli 0.5.5 → 0.5.6

package/dist/commands/dev.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatDevRuntimeAssetManifestFailure = formatDevRuntimeAssetManifestFailure;
 exports.dev = dev;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
@@ -7,12 +8,132 @@ const types_1 = require("@playdrop/types");
 const commandContext_1 = require("../commandContext");
 const http_1 = require("../http");
 const messages_1 = require("../messages");
+const catalogue_1 = require("../catalogue");
 const catalogue_utils_1 = require("../catalogue-utils");
 const devShared_1 = require("./devShared");
 const appUrls_1 = require("../appUrls");
 const devServer_1 = require("./devServer");
+const devRuntimeAssets_1 = require("./devRuntimeAssets");
+const devAuth_1 = require("../devAuth");
 const DEFAULT_ROOM_BASE = 'http://localhost:3001';
-async function dev(targetArg, _port, appOption) {
+function formatDevRuntimeAssetManifestFailure(error) {
+    const rawMessage = error instanceof Error ? error.message : String(error ?? 'unknown_error');
+    if (rawMessage.startsWith('dev_runtime_asset_ref_invalid:')) {
+        const ref = rawMessage.slice('dev_runtime_asset_ref_invalid:'.length);
+        return {
+            message: `Invalid uses.assets ref "${ref}" in catalogue.json.`,
+            suggestions: [
+                'Use an exact canonical asset ref like asset:creator/name@r1.',
+            ],
+        };
+    }
+    if (rawMessage.startsWith('dev_runtime_asset_version_not_found:')) {
+        const ref = rawMessage.slice('dev_runtime_asset_version_not_found:'.length);
+        return {
+            message: `Exact direct asset dependency "${ref}" does not exist on the server.`,
+            suggestions: [
+                'Publish that exact asset revision first or update uses.assets to a valid exact ref.',
+            ],
+        };
+    }
+    if (rawMessage.startsWith('dev_runtime_asset_not_public:')) {
+        const ref = rawMessage.slice('dev_runtime_asset_not_public:'.length);
+        return {
+            message: `Direct asset dependency "${ref}" is not publicly readable for project dev.`,
+            suggestions: [
+                'Make the asset public or remove it from uses.assets for this first-pass dev flow.',
+            ],
+        };
+    }
+    if (rawMessage.startsWith('dev_runtime_pack_ref_invalid:')) {
+        const ref = rawMessage.slice('dev_runtime_pack_ref_invalid:'.length);
+        return {
+            message: `Invalid uses.packs ref "${ref}" in catalogue.json.`,
+            suggestions: [
+                'Use an exact canonical pack ref like pack:creator/name@1.2.3.',
+            ],
+        };
+    }
+    if (rawMessage.startsWith('dev_runtime_pack_version_not_found:')) {
+        const ref = rawMessage.slice('dev_runtime_pack_version_not_found:'.length);
+        return {
+            message: `Exact pack dependency "${ref}" does not exist on the server.`,
+            suggestions: [
+                'Publish that exact pack version first or update uses.packs to a valid exact ref.',
+            ],
+        };
+    }
+    if (rawMessage.startsWith('dev_runtime_pack_not_public:')) {
+        const ref = rawMessage.slice('dev_runtime_pack_not_public:'.length);
+        return {
+            message: `Pack dependency "${ref}" is not publicly readable for project dev.`,
+            suggestions: [
+                'Make the pack public or remove it from uses.packs for this first-pass dev flow.',
+            ],
+        };
+    }
+    if (rawMessage.startsWith('dev_runtime_key_duplicate:')) {
+        const runtimeKey = rawMessage.split(':')[1] ?? 'unknown';
+        return {
+            message: `Duplicate runtimeKey "${runtimeKey}" detected while building dev runtime assets.`,
+            suggestions: [
+                'Give every owned asset and direct dependency a unique runtimeKey in catalogue.json.',
+            ],
+        };
+    }
+    if (rawMessage.startsWith('dev_runtime_owned_asset_duplicate:')) {
+        const ownedAssetName = rawMessage.slice('dev_runtime_owned_asset_duplicate:'.length);
+        return {
+            message: `Duplicate owned asset name "${ownedAssetName}" detected in catalogue.json.`,
+            suggestions: [
+                'Owned asset names must be unique inside the app catalogue entry.',
+            ],
+        };
+    }
+    if (rawMessage.startsWith('dev_runtime_asset_files_missing:')) {
+        const ref = rawMessage.slice('dev_runtime_asset_files_missing:'.length);
+        return {
+            message: `Dependency "${ref}" has no runtime file manifest on the server.`,
+            suggestions: [
+                'Republish the dependency so it has declared file roles before using it in project dev.',
+            ],
+        };
+    }
+    if (rawMessage.startsWith('dev_runtime_asset_spec_invalid:')) {
+        const [, ref = 'unknown', assetSpecVersion = 'unknown'] = rawMessage.split(':');
+        return {
+            message: `Dependency "${ref}" returned an invalid asset spec version ref "${assetSpecVersion}".`,
+            suggestions: [
+                'Republish the dependency with a valid assetSpecVersionRef or remove it from uses.assets.',
+            ],
+        };
+    }
+    if (rawMessage.startsWith('dev_runtime_asset_spec_unsupported:')) {
+        const [, ref = 'unknown', assetSpecVersion = 'unknown'] = rawMessage.split(':');
+        return {
+            message: `Dependency "${ref}" uses unsupported custom asset version "${assetSpecVersion}" for this app.`,
+            suggestions: [
+                'Update assetSpecSupport in catalogue.json or pin uses.assets to a supported custom asset revision.',
+            ],
+        };
+    }
+    if (rawMessage.startsWith('dev_runtime_app_type_missing:')) {
+        const appName = rawMessage.slice('dev_runtime_app_type_missing:'.length);
+        return {
+            message: `App "${appName}" is missing a valid type in catalogue.json.`,
+            suggestions: [
+                'Set "type" in the app catalogue entry before running "playdrop project dev".',
+            ],
+        };
+    }
+    return {
+        message: 'Failed to build the local runtime asset manifest for project dev.',
+        suggestions: [
+            rawMessage,
+        ],
+    };
+}
+async function dev(targetArg, _port, appOption, devOptions = {}) {
     let resolvedTarget;
     try {
         resolvedTarget = (0, devShared_1.resolveDevTarget)(targetArg, appOption);
@@ -73,6 +194,26 @@ async function dev(targetArg, _port, appOption) {
             return;
         }
     }
+    let devAuthSelection;
+    try {
+        devAuthSelection = (0, devAuth_1.parseHostedDevAuthSelection)({
+            devAuth: devOptions.devAuth,
+            player: devOptions.player,
+            defaultMode: 'prompt',
+            allowPrompt: true,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'dev_auth_invalid';
+        if (message === 'dev_auth_player_slot_required') {
+            (0, messages_1.printErrorWithHelp)('Use --player 1, 2, 3, or 4 when --dev-auth player is selected.', [], { command: 'project dev' });
+        }
+        else {
+            (0, messages_1.printErrorWithHelp)('Use --dev-auth prompt, anonymous, viewer, or player.', ['If you choose --dev-auth player, also pass --player 1, 2, 3, or 4.'], { command: 'project dev' });
+        }
+        process.exitCode = 1;
+        return;
+    }
     const workspacePath = resolvedTarget.cataloguePath ?? (0, node_path_1.dirname)(filePath);
     await (0, commandContext_1.withEnvironment)('project dev', 'Starting the dev server', 
     // eslint-disable-next-line complexity
@@ -147,6 +288,36 @@ async function dev(targetArg, _port, appOption) {
         }
         const projectInfo = (0, devShared_1.findProjectInfo)(filePath);
         const devScriptAvailable = Boolean(projectInfo.projectDir && projectInfo.packageJson && typeof projectInfo.packageJson.scripts?.dev === 'string');
+        const taskLookup = (0, catalogue_1.findAppTaskByFile)(filePath);
+        if (taskLookup.errors.length > 0) {
+            (0, messages_1.printErrorWithHelp)(taskLookup.errors[0] || 'Failed to resolve the app task from catalogue.json.', taskLookup.errors.slice(1), { command: 'project dev' });
+            process.exitCode = 1;
+            return;
+        }
+        const localDevAppUrl = (0, devServer_1.buildLocalDevAppUrl)({
+            creatorUsername: currentUsername,
+            appType: appTypeSlug,
+            appName,
+            port: devServer_1.DEV_ROUTER_PORT,
+        });
+        let runtimeAssetManifest = (0, devRuntimeAssets_1.createEmptyDevRuntimeAssetManifest)();
+        if (taskLookup.task) {
+            try {
+                runtimeAssetManifest = await (0, devRuntimeAssets_1.buildDevRuntimeAssetManifest)({
+                    client,
+                    apiBase: envConfig.apiBase,
+                    task: taskLookup.task,
+                    creatorUsername: currentUsername,
+                    appBaseUrl: new URL('.', localDevAppUrl).toString(),
+                });
+            }
+            catch (error) {
+                const formatted = formatDevRuntimeAssetManifestFailure(error);
+                (0, messages_1.printErrorWithHelp)(formatted.message, formatted.suggestions, { command: 'project dev' });
+                process.exitCode = 1;
+                return;
+            }
+        }
         if (resolvedTarget.ecsPath && resolvedTarget.serverScriptPath && appResponse?.id) {
             try {
                 if (!(0, node_fs_1.existsSync)(resolvedTarget.ecsPath) || !(0, node_fs_1.existsSync)(resolvedTarget.serverScriptPath)) {
@@ -198,6 +369,7 @@ async function dev(targetArg, _port, appOption) {
                 htmlPath: filePath,
                 port: devServer_1.DEV_ROUTER_PORT,
                 projectInfo,
+                runtimeAssetManifest,
             });
         }
         catch (error) {
@@ -210,6 +382,12 @@ async function dev(targetArg, _port, appOption) {
                     `Mounted HTML path: ${mountConflict.htmlPath}.`,
                 ], { command: 'project dev' });
             }
+            else if (message.startsWith('dev_router_incompatible:')) {
+                (0, messages_1.printErrorWithHelp)(`An incompatible shared dev router is already running on port ${devServer_1.DEV_ROUTER_PORT}.`, [
+                    'Stop the existing dev router process, then retry "playdrop project dev".',
+                    `If needed, rebuild the local CLI first with "npm run build --workspace @playdrop/playdrop-cli" from /Users/oliviermichon/Documents/playdrop.`,
+                ], { command: 'project dev' });
+            }
             else {
                 (0, messages_1.printErrorWithHelp)(error?.message || `Failed to start the shared dev router on port ${devServer_1.DEV_ROUTER_PORT}.`, [
                     'Close the conflicting process or wait for the stale mount to exit.',
@@ -247,7 +425,7 @@ async function dev(targetArg, _port, appOption) {
             }
         }
         if (webUrl) {
-            const iframeUrl = `${webUrl}/creators/${encodeURIComponent(currentUsername)}/apps/${appTypeSlug}/${encodeURIComponent(appName)}/dev`;
+            const iframeUrl = (0, devAuth_1.applyHostedDevAuthSelectionToUrl)(`${webUrl}/creators/${encodeURIComponent(currentUsername)}/apps/${appTypeSlug}/${encodeURIComponent(appName)}/dev`, devAuthSelection);
             console.log('\nTest your app at:');
             console.log(`  ${iframeUrl}`);
             console.log('\nMake something fun then share it with');

package/dist/commands/devRuntimeAssets.d.ts

@@ -0,0 +1,34 @@
+import type { ApiClient } from '@playdrop/api-client';
+import { type AppAuthMode, type AppControllerMode, type AppMetadataAssetSpecSupport, type AppRuntimeAssetsResponse, type AppSurface, type AppType } from '@playdrop/types';
+import type { AppTask } from '../catalogue';
+export type LocalOwnedRuntimeAssetFileRecord = {
+    absolutePath: string;
+    contentType: string | null;
+    sizeBytes: number | null;
+};
+export type LocalDevAppMetadata = {
+    type: AppType;
+    surfaceTargets: AppSurface[];
+    authMode: AppAuthMode;
+    controllerMode: AppControllerMode;
+    previewable: boolean;
+    assetSpecSupport: AppMetadataAssetSpecSupport[];
+    version: string | null;
+};
+export type DevRuntimeAssetsResponse = AppRuntimeAssetsResponse & {
+    localAppMetadata: LocalDevAppMetadata;
+};
+export type DevRuntimeAssetManifestRegistration = {
+    response: DevRuntimeAssetsResponse;
+    ownedAssetFiles: Record<string, Record<string, LocalOwnedRuntimeAssetFileRecord>>;
+};
+export declare function createEmptyDevRuntimeAssetManifest(): DevRuntimeAssetManifestRegistration;
+export declare function buildLocalDevRuntimeAssetsUrl(appBaseUrl: string): string;
+export declare function buildLocalDevRuntimeAssetFileUrl(appBaseUrl: string, ownedAssetName: string, role: string): string;
+export declare function buildDevRuntimeAssetManifest(input: {
+    client: ApiClient;
+    apiBase: string;
+    task: AppTask;
+    creatorUsername: string;
+    appBaseUrl: string;
+}): Promise<DevRuntimeAssetManifestRegistration>;

package/dist/commands/devRuntimeAssets.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEmptyDevRuntimeAssetManifest = createEmptyDevRuntimeAssetManifest;
+exports.buildLocalDevRuntimeAssetsUrl = buildLocalDevRuntimeAssetsUrl;
+exports.buildLocalDevRuntimeAssetFileUrl = buildLocalDevRuntimeAssetFileUrl;
+exports.buildDevRuntimeAssetManifest = buildDevRuntimeAssetManifest;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const semver_1 = require("semver");
+const types_1 = require("@playdrop/types");
+function createEmptyDevRuntimeAssetManifest() {
+    return {
+        response: {
+            appVersionId: 0,
+            appVersion: 'dev',
+            assets: [],
+            localAppMetadata: {
+                type: 'GAME',
+                surfaceTargets: Array.from(types_1.DEFAULT_APP_SURFACE_TARGETS),
+                authMode: types_1.DEFAULT_APP_AUTH_MODE,
+                controllerMode: types_1.DEFAULT_APP_CONTROLLER_MODE,
+                previewable: types_1.DEFAULT_APP_PREVIEWABLE,
+                assetSpecSupport: [],
+                version: null,
+            },
+        },
+        ownedAssetFiles: {},
+    };
+}
+const CONTENT_TYPE_BY_EXTENSION = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'application/javascript; charset=utf-8',
+    '.mjs': 'application/javascript; charset=utf-8',
+    '.cjs': 'application/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.svg': 'image/svg+xml',
+    '.webp': 'image/webp',
+    '.glb': 'model/gltf-binary',
+    '.gltf': 'model/gltf+json',
+    '.wasm': 'application/wasm',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.ogg': 'audio/ogg',
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+};
+function inferContentType(filePath) {
+    const extension = (0, node_path_1.extname)(filePath).toLowerCase();
+    return CONTENT_TYPE_BY_EXTENSION[extension] ?? null;
+}
+function normalizeManifestFiles(fileManifest) {
+    const files = fileManifest && typeof fileManifest === 'object' && Array.isArray(fileManifest.files)
+        ? fileManifest.files
+        : [];
+    return files
+        .filter((entry) => Boolean(entry && typeof entry === 'object'))
+        .map((entry) => ({
+        role: typeof entry.role === 'string' ? entry.role.trim().toLowerCase() : '',
+        key: typeof entry.key === 'string' ? entry.key.trim() : '',
+        contentType: typeof entry.contentType === 'string' ? entry.contentType : null,
+        sizeBytes: typeof entry.sizeBytes === 'number' && Number.isFinite(entry.sizeBytes) ? entry.sizeBytes : null,
+        sha256: typeof entry.sha256 === 'string' ? entry.sha256 : null,
+    }))
+        .filter((entry) => entry.role.length > 0);
+}
+function buildPublishedAssetFileUrl(apiBase, creatorUsername, assetName, revision, role) {
+    const path = `/assets/${encodeURIComponent(creatorUsername)}/${encodeURIComponent(assetName)}/versions/${encodeURIComponent(`r${revision}`)}/file?role=${encodeURIComponent(role)}`;
+    return new URL(path, apiBase).toString();
+}
+function buildSyntheticLocalAssetRef(creatorUsername, appName, ownedAssetName) {
+    return (0, types_1.formatContentVersionRef)({
+        kind: 'asset',
+        creatorUsername: `${creatorUsername}-dev`,
+        name: `${appName}-${ownedAssetName}`,
+        revision: 1,
+    });
+}
+function buildLocalDevRuntimeAssetsUrl(appBaseUrl) {
+    const base = appBaseUrl.endsWith('/') ? appBaseUrl.slice(0, -1) : appBaseUrl;
+    return `${base}/_playdrop/runtime-assets`;
+}
+function buildLocalDevRuntimeAssetFileUrl(appBaseUrl, ownedAssetName, role) {
+    const base = appBaseUrl.endsWith('/') ? appBaseUrl.slice(0, -1) : appBaseUrl;
+    return `${base}/_playdrop/runtime-assets/files/${encodeURIComponent(ownedAssetName)}?role=${encodeURIComponent(role)}`;
+}
+async function findAssetVersionByRevision(client, creatorUsername, assetName, revision) {
+    let offset = 0;
+    for (let page = 0; page < 200; page += 1) {
+        const response = await client.listAssetVersions(creatorUsername, assetName, {
+            limit: 100,
+            offset,
+        });
+        const version = (response.versions ?? []).find((entry) => entry.revision === revision);
+        if (version) {
+            return version;
+        }
+        if (!response.pagination?.hasMore) {
+            break;
+        }
+        offset += response.pagination.limit;
+    }
+    throw new Error(`dev_runtime_asset_version_not_found:${creatorUsername}/${assetName}@r${revision}`);
+}
+async function findPackVersion(client, creatorUsername, packName, versionString) {
+    let offset = 0;
+    for (let page = 0; page < 200; page += 1) {
+        const response = await client.listAssetPackVersions(creatorUsername, packName, {
+            limit: 100,
+            offset,
+        });
+        const version = (response.versions ?? []).find((entry) => entry.version === versionString);
+        if (version) {
+            return version;
+        }
+        if (!response.pagination?.hasMore) {
+            break;
+        }
+        offset += response.pagination.limit;
+    }
+    throw new Error(`dev_runtime_pack_version_not_found:${creatorUsername}/${packName}@${versionString}`);
+}
+function createPublishedAssetSummary(input) {
+    const files = normalizeManifestFiles(input.version.fileManifest).map((file) => ({
+        role: file.role,
+        url: buildPublishedAssetFileUrl(input.apiBase, input.creatorUsername, input.assetName, input.revision, file.role),
+        contentType: file.contentType ?? null,
+        sizeBytes: file.sizeBytes ?? null,
+        sha256: file.sha256 ?? null,
+    }));
+    if (files.length === 0) {
+        throw new Error(`dev_runtime_asset_files_missing:${input.creatorUsername}/${input.assetName}@r${input.revision}`);
+    }
+    return {
+        assetRef: (0, types_1.formatContentVersionRef)({
+            kind: 'asset',
+            creatorUsername: input.creatorUsername,
+            name: input.assetName,
+            revision: input.revision,
+        }),
+        runtimeKey: input.runtimeKey?.trim() || null,
+        sourceType: input.sourceType,
+        ...(input.sourcePackRef ? { sourcePackRef: input.sourcePackRef } : {}),
+        files,
+    };
+}
+async function resolvePublishedAssetSummary(client, apiBase, assetRef, options) {
+    const parsed = (0, types_1.parseContentVersionRef)(assetRef);
+    if (!parsed || parsed.kind !== 'asset') {
+        throw new Error(`dev_runtime_asset_ref_invalid:${assetRef}`);
+    }
+    const version = await findAssetVersionByRevision(client, parsed.creatorUsername, parsed.name, parsed.revision);
+    if (version.visibility !== 'PUBLIC') {
+        throw new Error(`dev_runtime_asset_not_public:${assetRef}`);
+    }
+    return createPublishedAssetSummary({
+        apiBase,
+        creatorUsername: parsed.creatorUsername,
+        assetName: parsed.name,
+        revision: parsed.revision,
+        version,
+        runtimeKey: options.runtimeKey,
+        sourceType: options.sourceType,
+        sourcePackRef: options.sourcePackRef,
+    });
+}
+function createLocalOwnedAssetSummary(task, creatorUsername, appBaseUrl, ownedAsset) {
+    const files = {};
+    const runtimeFiles = [];
+    for (const [role, absolutePath] of Object.entries(ownedAsset.filePaths)) {
+        const stats = (0, node_fs_1.statSync)(absolutePath);
+        const contentType = inferContentType(absolutePath);
+        files[role] = {
+            absolutePath,
+            contentType,
+            sizeBytes: stats.size,
+        };
+        runtimeFiles.push({
+            role,
+            url: buildLocalDevRuntimeAssetFileUrl(appBaseUrl, ownedAsset.name, role),
+            contentType,
+            sizeBytes: stats.size,
+            sha256: null,
+        });
+    }
+    return {
+        asset: {
+            assetRef: buildSyntheticLocalAssetRef(creatorUsername, task.name, ownedAsset.name),
+            runtimeKey: ownedAsset.runtimeKey?.trim() || null,
+            sourceType: 'OWNED',
+            files: runtimeFiles,
+        },
+        files,
+    };
+}
+function assertRuntimeKeyAvailable(seenRuntimeKeys, runtimeKey, context) {
+    const normalized = typeof runtimeKey === 'string' ? runtimeKey.trim() : '';
+    if (!normalized) {
+        return;
+    }
+    if (seenRuntimeKeys.has(normalized)) {
+        throw new Error(`dev_runtime_key_duplicate:${normalized}:${context}`);
+    }
+    seenRuntimeKeys.add(normalized);
+}
+function buildLocalAppMetadata(task) {
+    if (!task.type) {
+        throw new Error(`dev_runtime_app_type_missing:${task.name}`);
+    }
+    return {
+        type: task.type,
+        surfaceTargets: task.surfaceTargets.length > 0 ? Array.from(task.surfaceTargets) : Array.from(types_1.DEFAULT_APP_SURFACE_TARGETS),
+        authMode: task.authMode ?? types_1.DEFAULT_APP_AUTH_MODE,
+        controllerMode: task.controllerMode ?? types_1.DEFAULT_APP_CONTROLLER_MODE,
+        previewable: task.previewable ?? types_1.DEFAULT_APP_PREVIEWABLE,
+        assetSpecSupport: task.assetSpecSupport.map((entry) => ({
+            assetSpecRef: entry.assetSpec,
+            versionRange: entry.versionRange,
+            capabilities: Array.from(entry.capabilities),
+        })),
+        version: typeof task.version === 'string' && task.version.trim().length > 0 ? task.version.trim() : null,
+    };
+}
+function assertCustomAssetVersionSupported(task, assetRef, version) {
+    if (typeof version.assetSpecVersionRef !== 'string' || version.assetSpecVersionRef.trim().length === 0) {
+        return;
+    }
+    const parsedAssetSpecVersion = (0, types_1.parseAssetSpecVersionRef)(version.assetSpecVersionRef);
+    if (!parsedAssetSpecVersion) {
+        throw new Error(`dev_runtime_asset_spec_invalid:${assetRef}:${version.assetSpecVersionRef}`);
+    }
+    const assetSpecFamilyRef = (0, types_1.formatAssetSpecFamilyRef)({
+        kind: 'asset-spec',
+        creatorUsername: parsedAssetSpecVersion.creatorUsername,
+        name: parsedAssetSpecVersion.name,
+    });
+    const supported = task.assetSpecSupport.some((entry) => (entry.assetSpec === assetSpecFamilyRef
+        && entry.capabilities.includes('READ')
+        && (0, semver_1.satisfies)(parsedAssetSpecVersion.version, entry.versionRange, { includePrerelease: false })));
+    if (!supported) {
+        throw new Error(`dev_runtime_asset_spec_unsupported:${assetRef}:${version.assetSpecVersionRef}`);
+    }
+}
+async function buildDevRuntimeAssetManifest(input) {
+    const localAppMetadata = buildLocalAppMetadata(input.task);
+    const assets = [];
+    const ownedAssetFiles = {};
+    const seenRuntimeKeys = new Set();
+    const seenOwnedAssetNames = new Set();
+    for (const ownedAsset of input.task.ownedAssets) {
+        if (seenOwnedAssetNames.has(ownedAsset.name)) {
+            throw new Error(`dev_runtime_owned_asset_duplicate:${ownedAsset.name}`);
+        }
+        seenOwnedAssetNames.add(ownedAsset.name);
+        assertRuntimeKeyAvailable(seenRuntimeKeys, ownedAsset.runtimeKey, ownedAsset.name);
+        const localAsset = createLocalOwnedAssetSummary(input.task, input.creatorUsername, input.appBaseUrl, ownedAsset);
+        assets.push(localAsset.asset);
+        ownedAssetFiles[ownedAsset.name] = localAsset.files;
+    }
+    for (const dependency of input.task.uses.assets) {
+        assertRuntimeKeyAvailable(seenRuntimeKeys, dependency.runtimeKey, dependency.ref);
+        const parsedDependencyRef = (0, types_1.parseContentVersionRef)(dependency.ref);
+        if (!parsedDependencyRef || parsedDependencyRef.kind !== 'asset') {
+            throw new Error(`dev_runtime_asset_ref_invalid:${dependency.ref}`);
+        }
+        const dependencyVersion = await findAssetVersionByRevision(input.client, parsedDependencyRef.creatorUsername, parsedDependencyRef.name, parsedDependencyRef.revision);
+        assertCustomAssetVersionSupported(input.task, dependency.ref, dependencyVersion);
+        assets.push(await resolvePublishedAssetSummary(input.client, input.apiBase, dependency.ref, {
+            runtimeKey: dependency.runtimeKey,
+            sourceType: 'DIRECT',
+        }));
+    }
+    for (const packRef of input.task.uses.packs) {
+        const parsedPackRef = (0, types_1.parseContentVersionRef)(packRef);
+        if (!parsedPackRef || parsedPackRef.kind !== 'pack') {
+            throw new Error(`dev_runtime_pack_ref_invalid:${packRef}`);
+        }
+        const packVersion = await findPackVersion(input.client, parsedPackRef.creatorUsername, parsedPackRef.name, parsedPackRef.version);
+        if (packVersion.visibility !== 'PUBLIC') {
+            throw new Error(`dev_runtime_pack_not_public:${packRef}`);
+        }
+        for (const member of packVersion.assets) {
+            const memberRef = (0, types_1.formatContentVersionRef)({
+                kind: 'asset',
+                creatorUsername: member.creatorUsername,
+                name: member.name,
+                revision: member.revision,
+            });
+            const memberVersion = await findAssetVersionByRevision(input.client, member.creatorUsername, member.name, member.revision);
+            assertCustomAssetVersionSupported(input.task, memberRef, memberVersion);
+            assets.push(await resolvePublishedAssetSummary(input.client, input.apiBase, memberRef, {
+                sourceType: 'PACK',
+                sourcePackRef: packRef,
+            }));
+        }
+    }
+    return {
+        response: {
+            ...createEmptyDevRuntimeAssetManifest().response,
+            assets,
+            localAppMetadata,
+        },
+        ownedAssetFiles,
+    };
+}

package/dist/commands/devServer.d.ts

@@ -1,5 +1,7 @@
+import http from 'node:http';
 import { type ChildProcess } from 'node:child_process';
 import type { ProjectInfo } from './devShared';
+import type { DevRuntimeAssetManifestRegistration } from './devRuntimeAssets';
 export interface StartDevServerOptions {
     appName: string;
     appType: string;
@@ -7,6 +9,7 @@ export interface StartDevServerOptions {
     htmlPath: string;
     port: number;
     projectInfo: ProjectInfo;
+    runtimeAssetManifest?: DevRuntimeAssetManifestRegistration | null;
 }
 export interface DevServerHandle {
     server: null;
@@ -30,6 +33,12 @@ export declare function buildLocalDevAppUrl(input: {
     port?: number;
 }): string;
 export declare function ensureDevRouterRunning(port?: number): Promise<void>;
+export declare function updateMountedDevRuntimeAssetManifest(input: {
+    creatorUsername: string;
+    appName: string;
+    runtimeAssetManifest: DevRuntimeAssetManifestRegistration | null;
+    port?: number;
+}): Promise<void>;
 export declare function startDevServer(options: StartDevServerOptions): Promise<DevServerHandle>;
 export declare function isDevServerAvailable(input: {
     creatorUsername: string;
@@ -37,5 +46,7 @@ export declare function isDevServerAvailable(input: {
     appName: string;
     port?: number;
 }, timeoutMs?: number): Promise<boolean>;
+export declare function createDevRouterServer(initialPort?: number): http.Server;
+export declare function listenDevRouterServer(server: http.Server, port?: number): Promise<number>;
 export declare function runDevRouterServer(port?: number): Promise<void>;
 export {};