@playdrop/playdrop-cli 0.17.21 → 0.17.24

package/README.md

@@ -123,6 +123,18 @@ playdrop project dev my-app
 playdrop project publish --env dev .
 ```
 
+Procedural asset packs use the same dev command after their compiled `.mjs`, manifest, and preview files exist:
+
+```bash
+npm run build
+playdrop project dev .
+playdrop project dev --asset vfx-cinder-fall .
+playdrop project validate .
+playdrop project publish .
+```
+
+With no `--asset`, the printed hosted local-dev URL shows the pack grid. `--asset <name>` prints a URL that selects one local pack member directly in the canonical procedural viewer. Source type checking verifies `ProceduralAssetModuleV1`; `project validate` runs the compiled module unchanged in Chromium, and publish repeats that runtime gate.
+
 ## Game server SDK
 
 For a game with a `server` declaration, `project build`, `project check`, `project dev`, and upload preflight select the SDK reported by the environment's rooms runtime. The CLI verifies and downloads `playdrop-server-<version>.tgz` from the SDK CDN, installs its matching dependencies, and records them in `package.json`, `package-lock.json`, and `vendor/playdrop/`. Keep these files with the project. There is no npm registry release of `@playdrop/server` to install manually.

package/config/client-meta.json

@@ -1,8 +1,8 @@
 {
-  "version": "0.17.21",
-  "build": 1,
-  "runtimeSdkVersion": "0.17.21",
-  "runtimeSdkBuild": 1,
+  "version": "0.17.24",
+  "build": 4,
+  "runtimeSdkVersion": "0.17.24",
+  "runtimeSdkBuild": 4,
   "clients": {
     "all": {
       "minimumVersion": "0.7.4"

package/dist/appUrls.d.ts

@@ -25,6 +25,12 @@ export declare function buildPlatformDevUrl(webBase: string | null | undefined,
     localDevPort?: number | string | null;
     captureSession?: TaskCaptureSession | null;
 }): string;
+export declare function buildPlatformProceduralPackDevUrl(webBase: string | null | undefined, input: {
+    creatorUsername: string;
+    packName: string;
+    assetName?: string | null;
+    localDevPort?: number | string | null;
+}): string;
 export declare function buildUploadLaunchCheckUrl(webBase: string | null | undefined, input: AppUrlInput & {
     sessionId: string;
 }): string;

package/dist/appUrls.js

@@ -8,6 +8,7 @@ exports.getAppTypeSlug = getAppTypeSlug;
 exports.buildPlatformPlayUrl = buildPlatformPlayUrl;
 exports.buildPlatformPrivateDraftPlayUrl = buildPlatformPrivateDraftPlayUrl;
 exports.buildPlatformDevUrl = buildPlatformDevUrl;
+exports.buildPlatformProceduralPackDevUrl = buildPlatformProceduralPackDevUrl;
 exports.buildUploadLaunchCheckUrl = buildUploadLaunchCheckUrl;
 const DEFAULT_WEB_BASE = "https://www.playdrop.ai";
 function appendTaskCaptureSession(url, session) {
@@ -102,6 +103,24 @@ function buildPlatformDevUrl(webBase, input) {
     appendTaskCaptureSession(url, input.captureSession);
     return url.toString();
 }
+function buildPlatformProceduralPackDevUrl(webBase, input) {
+    const base = normalizePlaydropWebBase(webBase);
+    const creator = encodeURIComponent(input.creatorUsername);
+    const packName = encodeURIComponent(input.packName);
+    const url = new URL(`${base}/creators/${creator}/asset-packs/${packName}/dev`);
+    if (input.assetName?.trim())
+        url.searchParams.set("asset", input.assetName.trim());
+    if (input.localDevPort !== null && input.localDevPort !== undefined) {
+        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");
+        }
+        url.searchParams.set("localDevPort", String(port));
+    }
+    return url.toString();
+}
 function buildUploadLaunchCheckUrl(webBase, input) {
     const base = normalizePlaydropWebBase(webBase);
     const creator = encodeURIComponent(input.creatorUsername);

package/dist/commands/dev.d.ts

@@ -3,6 +3,7 @@ export declare function formatDevRuntimeAssetManifestFailure(error: unknown): {
     suggestions: string[];
 };
 export declare function dev(targetArg: string | undefined, appOption?: string, devOptions?: {
+    asset?: string;
     devAuth?: string;
     player?: string | number;
 }): Promise<void>;

package/dist/commands/dev.js

@@ -20,6 +20,116 @@ const tweakStaleness_1 = require("../tweakStaleness");
 const devShared_1 = require("./devShared");
 const devGameServer_1 = require("./devGameServer");
 const taskCaptureSession_1 = require("./taskCaptureSession");
+const devProceduralAssets_1 = require("./devProceduralAssets");
+async function devProceduralPack(target, devRouterPort) {
+    const cataloguePath = (0, node_path_1.resolve)(target.rootDir, target.pack.cataloguePath);
+    const projectInfo = (0, devShared_1.findProjectInfo)(cataloguePath);
+    const devScriptAvailable = Boolean(projectInfo.projectDir && projectInfo.packageJson && typeof projectInfo.packageJson.scripts?.dev === "string");
+    await (0, commandContext_1.withEnvironment)("project dev", "Starting the procedural asset pack dev server", async ({ client, envConfig, account, workspaceAuth }) => {
+        let currentUsername = workspaceAuth?.config.ownerUsername?.trim() ?? account?.username?.trim() ?? target.pack.username?.trim() ?? "";
+        if (!currentUsername) {
+            try {
+                currentUsername = await (0, devShared_1.fetchDevUsername)(client);
+            }
+            catch (error) {
+                if (error instanceof http_1.CLIUnsupportedClientError)
+                    return;
+                if (error instanceof types_1.UnsupportedClientError) {
+                    (0, http_1.handleUnsupportedError)(error, "Authentication");
+                    process.exitCode = 1;
+                    return;
+                }
+                if (error instanceof types_1.ApiError) {
+                    (0, messages_1.printErrorWithHelp)(`Could not fetch your account (status ${error.status}).`, ['Run "playdrop auth login" to refresh your session.'], { command: "project dev" });
+                    process.exitCode = 1;
+                    return;
+                }
+                if ((0, devShared_1.isNetworkError)(error)) {
+                    (0, messages_1.printNetworkIssue)("Could not reach the Playdrop API to resolve your account.", "project dev");
+                    process.exitCode = 1;
+                    return;
+                }
+                throw error;
+            }
+        }
+        let registration;
+        try {
+            registration = (0, devProceduralAssets_1.buildLocalProceduralPackManifest)({
+                creatorUsername: currentUsername,
+                target,
+                port: devRouterPort,
+            });
+        }
+        catch (error) {
+            (0, messages_1.printErrorWithHelp)(error instanceof Error ? error.message : "Could not prepare the procedural asset pack.", ['Run the pack build, then retry "playdrop project dev".'], { command: "project dev" });
+            process.exitCode = 1;
+            return;
+        }
+        let handle;
+        try {
+            handle = await (0, devServer_1.startProceduralPackDevServer)({
+                creatorUsername: currentUsername,
+                packName: target.pack.name,
+                cataloguePath,
+                rootDir: target.rootDir,
+                port: devRouterPort,
+                projectInfo,
+                proceduralPackManifest: registration,
+            });
+        }
+        catch (error) {
+            const message = typeof error?.message === "string" ? error.message : "";
+            const mountConflict = (0, devServer_1.parseMountConflictError)(message);
+            if (mountConflict) {
+                (0, messages_1.printErrorWithHelp)(`A different dev session already owns ${mountConflict.ref}.`, [`Active owner pid: ${mountConflict.ownerPid}.`, `Mounted project: ${mountConflict.repoRoot}.`], { command: "project dev" });
+            }
+            else if (message.startsWith("dev_router_incompatible:")) {
+                (0, messages_1.printErrorWithHelp)(`An incompatible shared dev router is already running on port ${devRouterPort}.`, ['Stop the existing dev router process, then retry "playdrop project dev".'], { command: "project dev" });
+            }
+            else {
+                (0, messages_1.printErrorWithHelp)(error?.message || `Failed to start the shared dev router on port ${devRouterPort}.`, ["Close the conflicting process or wait for the stale mount to exit."], { command: "project dev" });
+            }
+            process.exitCode = 1;
+            return;
+        }
+        let shuttingDown = false;
+        const handleShutdown = () => {
+            if (shuttingDown)
+                return;
+            shuttingDown = true;
+            process.off("SIGINT", handleShutdown);
+            process.off("SIGTERM", handleShutdown);
+            handle.close().catch((closeError) => {
+                console.error(closeError instanceof Error ? closeError.message : closeError);
+            });
+        };
+        process.on("SIGINT", handleShutdown);
+        process.on("SIGTERM", handleShutdown);
+        console.log(`Procedural asset pack mounted at ${handle.manifestUrl}`);
+        console.log(`Serving ${target.assets.length} assets from ${(0, node_path_1.relative)(process.cwd(), cataloguePath) || cataloguePath}`);
+        if (projectInfo.projectDir && !devScriptAvailable && projectInfo.packageJsonPath) {
+            const projectLabel = (0, devShared_1.formatProjectLabel)(projectInfo);
+            if (projectLabel) {
+                console.log(`package.json detected at ${projectLabel}, but no "dev" script was found. Run your build/watch scripts manually if needed.`);
+            }
+        }
+        if (envConfig.webBase) {
+            const viewerUrl = (0, appUrls_1.buildPlatformProceduralPackDevUrl)(envConfig.webBase, {
+                creatorUsername: currentUsername,
+                packName: target.pack.name,
+                assetName: target.selectedAssetName,
+                localDevPort: devRouterPort === devServer_1.DEV_ROUTER_PORT ? null : devRouterPort,
+            });
+            console.log("\nTest your procedural asset pack at:");
+            console.log(`  ${viewerUrl}`);
+            console.log("\nValidate before publishing with:");
+            console.log(`playdrop project validate ${target.rootDir}`);
+        }
+        else {
+            console.log(`\nOpen ${handle.manifestUrl} to inspect the local pack manifest.`);
+        }
+    }, { workspacePath: target.rootDir });
+}
 function formatDevRuntimeAssetManifestFailure(error) {
     const rawMessage = error instanceof Error ? error.message : String(error ?? "unknown_error");
     if (rawMessage.startsWith("dev_runtime_asset_ref_invalid:")) {
@@ -116,8 +226,29 @@ function formatDevRuntimeAssetManifestFailure(error) {
 async function dev(targetArg, appOption, devOptions = {}) {
     const devRouterPort = resolveCliDevRouterPort();
     let resolvedTarget;
+    let proceduralPackTarget;
     try {
-        resolvedTarget = (0, devShared_1.resolveDevTarget)(targetArg, appOption);
+        if (appOption && devOptions.asset) {
+            const error = new Error("Use either --app or --asset, not both.");
+            error.code = "dev_selector_conflict";
+            throw error;
+        }
+        if (devOptions.asset) {
+            proceduralPackTarget = (0, devProceduralAssets_1.resolveProceduralPackDevTarget)(targetArg, devOptions.asset);
+        }
+        else {
+            try {
+                resolvedTarget = (0, devShared_1.resolveDevTarget)(targetArg, appOption);
+            }
+            catch (error) {
+                if (!appOption && error?.code === "empty_catalogue") {
+                    proceduralPackTarget = (0, devProceduralAssets_1.resolveProceduralPackDevTarget)(targetArg);
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
     }
     catch (error) {
         const code = error?.code;
@@ -146,6 +277,23 @@ async function dev(targetArg, appOption, devOptions = {}) {
             case "invalid_catalogue":
                 suggestions = ['Fix the catalogue.json file and rerun "playdrop project dev".'];
                 break;
+            case "dev_selector_conflict":
+                suggestions = ["Choose an app with --app or one procedural pack member with --asset."];
+                break;
+            case "invalid_asset_target":
+                suggestions = ['Pass the procedural pack directory, for example "playdrop project dev --asset sword .".'];
+                break;
+            case "procedural_pack_missing":
+            case "procedural_pack_required":
+            case "procedural_pack_empty":
+            case "procedural_pack_remote_member":
+            case "procedural_pack_duplicate_member":
+            case "procedural_pack_asset_unsupported":
+            case "procedural_asset_not_found":
+                suggestions = [
+                    "Use a directory containing exactly one procedural asset pack whose members are local owned assets.",
+                ];
+                break;
             default:
                 suggestions = ["Provide an app name, HTML file path, or run inside a Playdrop workspace."];
                 break;
@@ -154,6 +302,18 @@ async function dev(targetArg, appOption, devOptions = {}) {
         process.exitCode = 1;
         return;
     }
+    if (proceduralPackTarget) {
+        if (devOptions.devAuth || devOptions.player !== undefined) {
+            (0, messages_1.printErrorWithHelp)("--dev-auth and --player apply only to app development.", ["Remove the app authentication options when previewing a procedural asset pack."], { command: "project dev" });
+            process.exitCode = 1;
+            return;
+        }
+        await devProceduralPack(proceduralPackTarget, devRouterPort);
+        return;
+    }
+    if (!resolvedTarget) {
+        throw new Error("dev_target_resolution_missing");
+    }
     let appName = resolvedTarget.appName;
     const filePath = resolvedTarget.htmlPath;
     if (!(0, node_fs_1.existsSync)(filePath) || !(0, node_fs_1.statSync)(filePath).isFile()) {

package/dist/commands/devProceduralAssets.d.ts

@@ -0,0 +1,66 @@
+import type { AssetPackTask, PackOwnedAssetTask } from "../catalogue";
+export declare const LOCAL_PROCEDURAL_PACK_PROTOCOL: "playdrop-local-procedural-pack@1";
+export type ResolvedProceduralPackDevTarget = {
+    rootDir: string;
+    pack: AssetPackTask;
+    assets: PackOwnedAssetTask[];
+    selectedAssetName: string | null;
+};
+export type LocalProceduralPackFileRecord = {
+    absolutePath: string;
+    contentType: string;
+    sizeBytes: number;
+};
+export type LocalProceduralPackManifest = {
+    protocol: typeof LOCAL_PROCEDURAL_PACK_PROTOCOL;
+    pack: {
+        creatorUsername: string;
+        name: string;
+        displayName: string;
+        version: string;
+    };
+    assets: Array<{
+        name: string;
+        displayName: string;
+        description: string | null;
+        category: "MODEL_3D";
+        subcategory: "procedural";
+        format: "CUSTOM";
+        files: {
+            primary: {
+                url: string;
+                contentType: "text/javascript";
+            };
+            manifest: {
+                url: string;
+                contentType: "application/json";
+            };
+            preview: {
+                url: string;
+                contentType: string;
+            };
+        };
+    }>;
+};
+export type LocalProceduralPackManifestRegistration = {
+    response: LocalProceduralPackManifest;
+    assetFiles: Record<string, Record<"primary" | "manifest" | "preview", LocalProceduralPackFileRecord>>;
+};
+export declare function resolveProceduralPackDevTarget(targetArg: string | undefined, assetName?: string): ResolvedProceduralPackDevTarget;
+export declare function buildLocalProceduralPackManifestUrl(input: {
+    creatorUsername: string;
+    packName: string;
+    port: number;
+}): string;
+export declare function buildLocalProceduralAssetFileUrl(input: {
+    creatorUsername: string;
+    packName: string;
+    assetName: string;
+    role: "primary" | "manifest" | "preview";
+    port: number;
+}): string;
+export declare function buildLocalProceduralPackManifest(input: {
+    creatorUsername: string;
+    target: ResolvedProceduralPackDevTarget;
+    port: number;
+}): LocalProceduralPackManifestRegistration;

package/dist/commands/devProceduralAssets.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOCAL_PROCEDURAL_PACK_PROTOCOL = void 0;
+exports.resolveProceduralPackDevTarget = resolveProceduralPackDevTarget;
+exports.buildLocalProceduralPackManifestUrl = buildLocalProceduralPackManifestUrl;
+exports.buildLocalProceduralAssetFileUrl = buildLocalProceduralAssetFileUrl;
+exports.buildLocalProceduralPackManifest = buildLocalProceduralPackManifest;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const catalogue_1 = require("../catalogue");
+const devShared_1 = require("./devShared");
+exports.LOCAL_PROCEDURAL_PACK_PROTOCOL = "playdrop-local-procedural-pack@1";
+function findNearestCatalogue(startDir) {
+    let current = (0, node_path_1.resolve)(startDir);
+    while (true) {
+        const candidate = (0, node_path_1.join)(current, "catalogue.json");
+        if ((0, node_fs_1.existsSync)(candidate) && (0, node_fs_1.statSync)(candidate).isFile())
+            return candidate;
+        const parent = (0, node_path_1.dirname)(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+function resolveTargetRoot(targetArg) {
+    if (!targetArg) {
+        const cataloguePath = findNearestCatalogue(process.cwd());
+        if (!cataloguePath) {
+            throw (0, devShared_1.createDevError)("catalogue_missing", 'Run "playdrop project dev" inside a workspace or provide a directory containing catalogue.json.');
+        }
+        return (0, node_path_1.dirname)(cataloguePath);
+    }
+    const target = (0, node_path_1.resolve)(targetArg);
+    if (!(0, node_fs_1.existsSync)(target) || !(0, node_fs_1.statSync)(target).isDirectory()) {
+        throw (0, devShared_1.createDevError)("invalid_asset_target", "Procedural asset pack development requires a workspace directory containing catalogue.json.");
+    }
+    if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(target, "catalogue.json"))) {
+        throw (0, devShared_1.createDevError)("catalogue_missing", `Directory ${target} does not contain catalogue.json.`);
+    }
+    return target;
+}
+function resolveOrderedLocalAssets(pack) {
+    const ownedByName = new Map(pack.ownedAssets.map((asset) => [asset.name, asset]));
+    const ordered = [];
+    const seen = new Set();
+    for (const member of pack.assets) {
+        const normalized = member.trim();
+        const direct = ownedByName.get(normalized);
+        const prefixedName = pack.username && normalized.startsWith(`${pack.username}/`)
+            ? normalized.slice(pack.username.length + 1)
+            : null;
+        const asset = direct ?? (prefixedName ? ownedByName.get(prefixedName) : undefined);
+        if (!asset) {
+            throw (0, devShared_1.createDevError)("procedural_pack_remote_member", `Asset pack "${pack.name}" contains non-local member "${member}". Local procedural pack dev supports owned assets only.`);
+        }
+        if (seen.has(asset.name)) {
+            throw (0, devShared_1.createDevError)("procedural_pack_duplicate_member", `Asset pack "${pack.name}" contains duplicate member "${asset.name}".`);
+        }
+        seen.add(asset.name);
+        ordered.push(asset);
+    }
+    if (ordered.length === 0) {
+        throw (0, devShared_1.createDevError)("procedural_pack_empty", `Asset pack "${pack.name}" has no local members to preview.`);
+    }
+    return ordered;
+}
+function assertProceduralAssetShape(asset) {
+    if (asset.category !== "MODEL_3D" || asset.subcategory !== "procedural" || asset.format !== "CUSTOM") {
+        throw (0, devShared_1.createDevError)("procedural_pack_asset_unsupported", `Asset "${asset.name}" must use category MODEL_3D, subcategory procedural, and format CUSTOM.`);
+    }
+}
+function resolveProceduralPackDevTarget(targetArg, assetName) {
+    const rootDir = resolveTargetRoot(targetArg);
+    const lookup = (0, catalogue_1.resolveCatalogueEntries)(rootDir);
+    if (lookup.errors.length > 0) {
+        const details = lookup.errors.join("\n");
+        if (/file not found|non-empty file/iu.test(details)) {
+            throw (0, devShared_1.createDevError)("procedural_asset_unbuilt", `${details}\nBuild the pack before running project dev.`);
+        }
+        throw (0, devShared_1.createDevError)("invalid_catalogue", details);
+    }
+    if (lookup.assetPacks.length === 0) {
+        throw (0, devShared_1.createDevError)("procedural_pack_missing", `No asset pack was found under ${rootDir}.`);
+    }
+    if (lookup.assetPacks.length > 1) {
+        throw (0, devShared_1.createDevError)("procedural_pack_required", `Multiple asset packs were found under ${rootDir}. Run the command from a directory containing one pack.`);
+    }
+    const pack = lookup.assetPacks[0];
+    const assets = resolveOrderedLocalAssets(pack);
+    assets.forEach(assertProceduralAssetShape);
+    const selectedAssetName = assetName?.trim() || null;
+    if (selectedAssetName && !assets.some((asset) => asset.name === selectedAssetName)) {
+        throw (0, devShared_1.createDevError)("procedural_asset_not_found", `Asset "${selectedAssetName}" was not found in local members of pack "${pack.name}".`);
+    }
+    return { rootDir, pack, assets, selectedAssetName };
+}
+function buildLocalProceduralPackManifestUrl(input) {
+    return `http://127.0.0.1:${input.port}/_playdrop/asset-packs/dev/${encodeURIComponent(input.creatorUsername)}/${encodeURIComponent(input.packName)}/manifest`;
+}
+function buildLocalProceduralAssetFileUrl(input) {
+    return `http://127.0.0.1:${input.port}/_playdrop/asset-packs/dev/${encodeURIComponent(input.creatorUsername)}/${encodeURIComponent(input.packName)}/assets/${encodeURIComponent(input.assetName)}/files/${input.role}`;
+}
+function previewContentType(path) {
+    switch ((0, node_path_1.extname)(path).toLowerCase()) {
+        case ".png":
+            return "image/png";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".webp":
+            return "image/webp";
+        default:
+            throw (0, devShared_1.createDevError)("procedural_preview_unsupported", `Procedural preview ${path} must be PNG, JPEG, or WebP.`);
+    }
+}
+function requireBuiltFile(asset, role, rootDir) {
+    const absolutePath = asset.filePaths[role];
+    if (!absolutePath) {
+        throw (0, devShared_1.createDevError)("procedural_asset_unbuilt", `Asset "${asset.name}" is missing files.${role}. Build the pack before running project dev.`);
+    }
+    let stats;
+    try {
+        stats = (0, node_fs_1.statSync)(absolutePath);
+    }
+    catch {
+        throw (0, devShared_1.createDevError)("procedural_asset_unbuilt", `Asset "${asset.name}" files.${role} was not found at ${absolutePath}. Build the pack before running project dev.`);
+    }
+    if (!stats.isFile() || stats.size === 0) {
+        throw (0, devShared_1.createDevError)("procedural_asset_unbuilt", `Asset "${asset.name}" files.${role} must be an existing, non-empty file.`);
+    }
+    let canonicalRoot;
+    let canonicalPath;
+    try {
+        canonicalRoot = (0, node_fs_1.realpathSync)(rootDir);
+        canonicalPath = (0, node_fs_1.realpathSync)(absolutePath);
+    }
+    catch {
+        throw (0, devShared_1.createDevError)("procedural_asset_unbuilt", `Asset "${asset.name}" files.${role} is no longer accessible. Build the pack before running project dev.`);
+    }
+    const pathFromRoot = (0, node_path_1.relative)(canonicalRoot, canonicalPath);
+    if (pathFromRoot === ".." || pathFromRoot.startsWith(`..${node_path_1.sep}`) || (0, node_path_1.isAbsolute)(pathFromRoot)) {
+        throw (0, devShared_1.createDevError)("procedural_asset_outside_root", `Asset "${asset.name}" files.${role} must stay inside the procedural pack directory.`);
+    }
+    if (role === "primary" && (0, node_path_1.extname)(absolutePath).toLowerCase() !== ".mjs") {
+        throw (0, devShared_1.createDevError)("procedural_asset_unbuilt", `Asset "${asset.name}" files.primary must be a compiled .mjs file.`);
+    }
+    return {
+        absolutePath,
+        contentType: role === "primary" ? "text/javascript" : role === "manifest" ? "application/json" : previewContentType(absolutePath),
+        sizeBytes: stats.size,
+    };
+}
+function buildLocalProceduralPackManifest(input) {
+    const assetFiles = {};
+    const assets = input.target.assets.map((asset) => {
+        const primary = requireBuiltFile(asset, "primary", input.target.rootDir);
+        const manifest = requireBuiltFile(asset, "manifest", input.target.rootDir);
+        const preview = requireBuiltFile(asset, "preview", input.target.rootDir);
+        assetFiles[asset.name] = { primary, manifest, preview };
+        const buildUrl = (role) => buildLocalProceduralAssetFileUrl({
+            creatorUsername: input.creatorUsername,
+            packName: input.target.pack.name,
+            assetName: asset.name,
+            role,
+            port: input.port,
+        });
+        return {
+            name: asset.name,
+            displayName: asset.displayName?.trim() || asset.name,
+            description: asset.description?.trim() || null,
+            category: "MODEL_3D",
+            subcategory: "procedural",
+            format: "CUSTOM",
+            files: {
+                primary: { url: buildUrl("primary"), contentType: "text/javascript" },
+                manifest: { url: buildUrl("manifest"), contentType: "application/json" },
+                preview: { url: buildUrl("preview"), contentType: preview.contentType },
+            },
+        };
+    });
+    return {
+        response: {
+            protocol: exports.LOCAL_PROCEDURAL_PACK_PROTOCOL,
+            pack: {
+                creatorUsername: input.creatorUsername,
+                name: input.target.pack.name,
+                displayName: input.target.pack.displayName?.trim() || input.target.pack.name,
+                version: input.target.pack.version,
+            },
+            assets,
+        },
+        assetFiles,
+    };
+}

package/dist/commands/devServer.d.ts

@@ -1,6 +1,7 @@
 import { type ChildProcess } from "node:child_process";
 import http from "node:http";
 import type { DevRuntimeAssetManifestRegistration } from "./devRuntimeAssets";
+import { type LocalProceduralPackManifestRegistration } from "./devProceduralAssets";
 import type { ProjectInfo } from "./devShared";
 export interface StartDevServerOptions {
     appName: string;
@@ -21,6 +22,12 @@ export interface DevServerHandle {
     appUrl: string;
     close(): Promise<void>;
 }
+export interface ProceduralPackDevServerHandle {
+    devProcess: ChildProcess | null;
+    startedDevProcess: boolean;
+    manifestUrl: string;
+    close(): Promise<void>;
+}
 export declare const DEV_ROUTER_PORT = 8888;
 type MountConflictDetails = {
     ref: string;
@@ -46,6 +53,15 @@ export declare function updateMountedDevRuntimeAssetManifest(input: {
     port?: number;
 }): Promise<void>;
 export declare function startDevServer(options: StartDevServerOptions): Promise<DevServerHandle>;
+export declare function startProceduralPackDevServer(options: {
+    creatorUsername: string;
+    packName: string;
+    cataloguePath: string;
+    rootDir: string;
+    port: number;
+    projectInfo: ProjectInfo;
+    proceduralPackManifest: LocalProceduralPackManifestRegistration;
+}): Promise<ProceduralPackDevServerHandle>;
 export declare function isDevServerAvailable(input: {
     creatorUsername: string;
     appType: string;