@playdrop/playdrop-cli 0.3.5-build.1 → 0.3.8-build.2

package/config/client-meta.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.3.5",
+  "version": "0.3.8",
   "build": 1,
   "platforms": {
     "ios": {
@@ -26,19 +26,19 @@
   },
   "clients": {
     "web": {
-      "minimumVersion": "0.3.5",
+      "minimumVersion": "0.3.8",
       "minimumBuild": 1
     },
     "admin": {
-      "minimumVersion": "0.3.5",
+      "minimumVersion": "0.3.8",
       "minimumBuild": 1
     },
     "apple": {
-      "minimumVersion": "0.3.5",
+      "minimumVersion": "0.3.8",
       "minimumBuild": 1
     },
     "cli": {
-      "minimumVersion": "0.3.5",
+      "minimumVersion": "0.3.8",
       "minimumBuild": 1
     }
   }

package/dist/apps/upload.js

@@ -55,6 +55,7 @@ async function uploadAppVersion(client, task, artifacts, options) {
         version: task.version,
         releaseNotes: task.releaseNotes,
         visibility: task.versionVisibility,
+        remixRef: task.remix,
         surfaceTargets: task.surfaceTargets,
         entryPoint: artifacts?.metadata?.entryPoint ?? undefined,
         // App metadata (used when creating app if it doesn't exist)

package/dist/catalogue.d.ts

@@ -30,6 +30,7 @@ export type AppCatalogueEntry = {
     color?: string | null;
     templateSource?: string | null;
     remixSource?: string | null;
+    remix?: string;
     surfaceTargets?: Record<string, unknown> | AppSurface[] | null;
     version?: string;
     releaseNotes?: string;
@@ -54,6 +55,7 @@ export type AssetCatalogueEntry = {
     category?: string;
     subcategory?: string;
     format?: string;
+    remix?: string;
     username?: string;
     files?: Record<string, string>;
     visibility?: string;
@@ -77,6 +79,7 @@ export type EmbeddedAssetCatalogueEntry = {
 export type AssetPackCatalogueEntry = {
     name: string;
     version?: string;
+    remix?: string;
     username?: string;
     assets?: string[];
     hostingMode?: string;
@@ -138,6 +141,7 @@ export type AppTask = {
     externalUrl?: string;
     listing?: ResolvedListingAssets;
     username?: string;
+    remix?: string;
     embeddedAssets: EmbeddedAssetTask[];
     uses: {
         assets: string[];
@@ -158,6 +162,7 @@ export type AssetTask = {
     category: string;
     subcategory: string;
     username?: string;
+    remix?: string;
     format?: string;
     visibility?: string;
     shopListed?: boolean;
@@ -186,9 +191,11 @@ export type EmbeddedAssetTask = {
 export type AssetPackTask = {
     kind: 'asset-pack';
     name: string;
+    displayName?: string;
     version: string;
     cataloguePath: string;
     username?: string;
+    remix?: string;
     assets: string[];
     hostingMode?: AppHostingMode;
     externalUrl?: string;

package/dist/catalogue.js

@@ -111,6 +111,59 @@ function validateListingAssetExtension(relativePath, fieldName, kind) {
 function resolveListingAssetPath(baseDir, relativePath) {
     return (0, node_path_1.resolve)(baseDir, relativePath);
 }
+function normalizeCatalogueRemixRef(value, expectedKind, errors, context) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        errors.push(`${context} remix must be a canonical ${expectedKind} version ref string.`);
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed.length) {
+        errors.push(`${context} remix must be a canonical ${expectedKind} version ref string.`);
+        return undefined;
+    }
+    const parsed = (0, types_1.parseContentVersionRef)(trimmed);
+    if (!parsed) {
+        errors.push(`${context} remix must use canonical version ref format.`);
+        return undefined;
+    }
+    if (parsed.kind !== expectedKind) {
+        errors.push(`${context} remix must point to a ${expectedKind} version.`);
+        return undefined;
+    }
+    return (0, types_1.formatContentVersionRef)(parsed);
+}
+function normalizeCatalogueRelations(value, errors, context) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const rows = [];
+    for (const relation of value) {
+        if (!relation || typeof relation !== 'object') {
+            continue;
+        }
+        const type = typeof relation.type === 'string' ? relation.type.trim().toUpperCase() : '';
+        const to = typeof relation.to === 'string' ? relation.to.trim() : '';
+        if (!type || !to) {
+            continue;
+        }
+        if (type === 'REMIXES') {
+            errors.push(`${context} relations must not use REMIXES. Use the dedicated remix field instead.`);
+            continue;
+        }
+        rows.push({ type, to });
+    }
+    return rows.length > 0 ? rows : undefined;
+}
+function rejectLegacyShopPriceCoinsField(value, errors, context) {
+    if (Object.prototype.hasOwnProperty.call(value, 'shopPriceCoins')) {
+        errors.push(`${context} uses legacy shopPriceCoins. Rename it to shopPriceCredits.`);
+        return true;
+    }
+    return false;
+}
 function normalizeRelativePath(root, target) {
     const rel = (0, node_path_1.relative)(root, target).split(node_path_1.sep).join('/');
     return rel.replace(/^\/+/, '');
@@ -787,21 +840,8 @@ function buildAppTasks(rootDir, catalogues, options) {
             const usesPacks = Array.isArray(entry.uses?.packs)
                 ? entry.uses.packs.filter((value) => typeof value === 'string' && value.trim().length > 0)
                 : [];
-            const graphRelations = [];
-            if (Array.isArray(entry.relations)) {
-                for (const relation of entry.relations) {
-                    if (!relation || typeof relation !== 'object')
-                        continue;
-                    const type = typeof relation.type === 'string' ? relation.type.trim() : '';
-                    const to = typeof relation.to === 'string' ? relation.to.trim() : '';
-                    if (!type || !to)
-                        continue;
-                    graphRelations.push({
-                        type,
-                        to,
-                    });
-                }
-            }
+            const remix = normalizeCatalogueRemixRef(entry.remix, 'app', errors, `[${label}] App "${rawName}"`);
+            const graphRelations = normalizeCatalogueRelations(entry.relations, errors, `[${label}] App "${rawName}"`) ?? [];
             const embeddedAssets = [];
             const rawEmbeddedAssets = Array.isArray(entry.embeddedAssets)
                 ? entry.embeddedAssets
@@ -885,6 +925,9 @@ function buildAppTasks(rootDir, catalogues, options) {
                         continue;
                     }
                 }
+                if (rejectLegacyShopPriceCoinsField(embedded, errors, `[${label}] Embedded asset "${embeddedName}"`)) {
+                    continue;
+                }
                 embeddedAssets.push({
                     kind: 'embedded-asset',
                     appName: rawName,
@@ -931,6 +974,7 @@ function buildAppTasks(rootDir, catalogues, options) {
                 listing,
                 // Admin-only field
                 username,
+                remix,
                 embeddedAssets,
                 uses: {
                     assets: usesAssets,
@@ -1045,18 +1089,14 @@ function buildAssetTasks(catalogues) {
                     continue;
                 }
             }
-            const relations = Array.isArray(entry.relations)
-                ? entry.relations
-                    .filter((row) => !!row && typeof row === 'object')
-                    .map((row) => ({
-                    type: typeof row.type === 'string' ? row.type : '',
-                    to: typeof row.to === 'string' ? row.to : '',
-                }))
-                    .filter((row) => row.type.trim().length > 0 && row.to.trim().length > 0)
-                : undefined;
+            const remix = normalizeCatalogueRemixRef(entry.remix, 'asset', errors, `[${label}] Asset "${name}"`);
+            const relations = normalizeCatalogueRelations(entry.relations, errors, `[${label}] Asset "${name}"`);
             const username = typeof entry.username === 'string' && entry.username.trim().length > 0
                 ? entry.username.trim()
                 : undefined;
+            if (rejectLegacyShopPriceCoinsField(entry, errors, `[${label}] Asset "${name}"`)) {
+                continue;
+            }
             tasks.push({
                 kind: 'asset',
                 name,
@@ -1065,6 +1105,7 @@ function buildAssetTasks(catalogues) {
                 category,
                 subcategory,
                 username,
+                remix,
                 format,
                 visibility: normalizeAssetVisibilityValue(entry.visibility, errors, `${label} asset \"${name}\"`),
                 shopListed: typeof entry.shopListed === 'boolean' ? entry.shopListed : undefined,
@@ -1096,6 +1137,7 @@ function buildAssetPackTasks(catalogues) {
                 errors.push(`[${label}] assetPacks[${index}] is missing a name.`);
                 continue;
             }
+            const displayName = typeof entry.displayName === 'string' ? entry.displayName.trim() : '';
             const version = typeof entry.version === 'string' ? entry.version.trim() : '';
             if (!SEMVER_REGEX.test(version)) {
                 errors.push(`[${label}] Asset pack "${name}" must define a semver version.`);
@@ -1148,15 +1190,8 @@ function buildAssetPackTasks(catalogues) {
                 errors.push(`[${label}] Asset pack "${name}" must reference at least one asset.`);
                 continue;
             }
-            const relations = Array.isArray(entry.relations)
-                ? entry.relations
-                    .filter((row) => !!row && typeof row === 'object')
-                    .map((row) => ({
-                    type: typeof row.type === 'string' ? row.type : '',
-                    to: typeof row.to === 'string' ? row.to : '',
-                }))
-                    .filter((row) => row.type.trim().length > 0 && row.to.trim().length > 0)
-                : undefined;
+            const remix = normalizeCatalogueRemixRef(entry.remix, 'pack', errors, `[${label}] Asset pack "${name}@${version}"`);
+            const relations = normalizeCatalogueRelations(entry.relations, errors, `[${label}] Asset pack "${name}@${version}"`);
             const username = typeof entry.username === 'string' && entry.username.trim().length > 0
                 ? entry.username.trim()
                 : undefined;
@@ -1319,9 +1354,11 @@ function buildAssetPackTasks(catalogues) {
             tasks.push({
                 kind: 'asset-pack',
                 name,
+                displayName: displayName || undefined,
                 version,
                 cataloguePath: label,
                 username,
+                remix,
                 assets,
                 hostingMode,
                 externalUrl,

package/dist/commands/create.js

@@ -166,12 +166,6 @@ const DEFAULT_SURFACE_TARGETS = {
     mobilePortrait: app_1.DEFAULT_APP_SURFACE_TARGETS.includes('MOBILE_PORTRAIT'),
 };
 const DEFAULT_APP_VERSION = '1.0.0';
-const APP_TYPE_SLUGS = {
-    game: 'GAME',
-    template: 'TEMPLATE',
-    tool: 'TOOL',
-    demo: 'DEMO',
-};
 function makeDefaultAppEntry(name, filePath) {
     return {
         name,
@@ -189,8 +183,8 @@ function buildCatalogueEntry(name, metadata, sourceInfo, relativeFilePath) {
         if (sourceInfo.templateSlug) {
             entry.templateSource = sourceInfo.templateSlug;
         }
-        if (sourceInfo.remixSlug) {
-            entry.remixSource = sourceInfo.remixSlug;
+        if (sourceInfo.remixRef) {
+            entry.remix = sourceInfo.remixRef;
         }
         return entry;
     }
@@ -257,14 +251,14 @@ function buildCatalogueEntry(name, metadata, sourceInfo, relativeFilePath) {
     else if (sourceInfo.templateSlug) {
         entry.templateSource = sourceInfo.templateSlug;
     }
-    if (Object.prototype.hasOwnProperty.call(metadata, 'remixSource')) {
-        const remixSource = metadata.remixSource;
-        if (remixSource === null || typeof remixSource === 'string') {
-            entry.remixSource = remixSource;
+    if (Object.prototype.hasOwnProperty.call(metadata, 'remix')) {
+        const remix = metadata.remix;
+        if (remix === null || typeof remix === 'string') {
+            entry.remix = remix;
         }
     }
-    else if (sourceInfo.remixSlug) {
-        entry.remixSource = sourceInfo.remixSlug;
+    else if (sourceInfo.remixRef) {
+        entry.remix = sourceInfo.remixRef;
     }
     return entry;
 }
@@ -416,8 +410,8 @@ function updateExtractedProjectCatalogue(name, metadata, projectCataloguePath, s
         if (sourceInfo.templateSlug) {
             existing.templateSource = sourceInfo.templateSlug;
         }
-        if (sourceInfo.remixSlug) {
-            existing.remixSource = sourceInfo.remixSlug;
+        if (sourceInfo.remixRef) {
+            existing.remix = sourceInfo.remixRef;
         }
         apps[targetIndex] = existing;
     }
@@ -451,6 +445,40 @@ function logProjectCatalogueOutcome(result, name) {
     }
     return true;
 }
+function buildPendingExternalRemixTask(name, metadata, sourceInfo, cataloguePath, htmlFilePath) {
+    const absoluteCataloguePath = (0, node_path_1.resolve)(cataloguePath);
+    const catalogueDir = (0, node_path_1.dirname)(absoluteCataloguePath);
+    const absoluteHtmlPath = (0, node_path_1.resolve)(htmlFilePath);
+    const relativeFilePath = (0, node_path_1.relative)(catalogueDir, absoluteHtmlPath) || `${name}.html`;
+    const entry = buildCatalogueEntry(name, metadata, sourceInfo, relativeFilePath.replace(/\\/g, '/'));
+    const surfaceTargets = (0, catalogue_utils_1.parseSurfaceTargets)(entry.surfaceTargets ?? DEFAULT_SURFACE_TARGETS).list;
+    return {
+        kind: 'app',
+        name,
+        cataloguePath: (0, node_path_1.relative)(process.cwd(), absoluteCataloguePath) || CATALOGUE_FILENAME,
+        catalogueAbsolutePath: absoluteCataloguePath,
+        catalogueDir,
+        filePath: absoluteHtmlPath,
+        relativeFile: entry.file ?? relativeFilePath,
+        projectDir: (0, node_path_1.dirname)(absoluteHtmlPath),
+        packageJsonPath: null,
+        isTypescriptProject: false,
+        hasValidateScript: false,
+        hasFormatScript: false,
+        displayName: entry.displayName,
+        description: entry.description,
+        type: typeof entry.type === 'string' ? ((0, app_1.parseAppType)(entry.type) ?? undefined) : undefined,
+        emoji: entry.emoji,
+        color: entry.color,
+        surfaceTargets,
+        missingMetadata: [],
+        version: entry.version,
+        remix: typeof entry.remix === 'string' ? entry.remix : undefined,
+        embeddedAssets: [],
+        uses: { assets: [], packs: [] },
+        graph: { relations: [] },
+    };
+}
 function logNextSteps(name, options) {
     console.log('\nNext steps:');
     if (options.hasCatalogue && options.catalogueLabel) {
@@ -471,10 +499,19 @@ function logNextSteps(name, options) {
         }
         console.log(` - The bundled HTML entry point is ${options.entryPointLabel}.`);
     }
+    else if (options.externalListingUrl) {
+        console.log(` - Open the external listing at ${options.externalListingUrl} and fetch the real source yourself.`);
+        console.log(` - Keep ${options.entryPointLabel} as the app entry point, or update catalogue.json if your source uses a different file.`);
+    }
     else {
         console.log(` - Build your app in ${options.entryPointLabel}.`);
     }
-    console.log(` - Test locally with "playdrop project dev ${name}".`);
+    if (options.externalListingUrl) {
+        console.log(` - After you add the real source for ${options.entryPointLabel}, test locally with "playdrop project dev ${name}".`);
+    }
+    else {
+        console.log(` - Test locally with "playdrop project dev ${name}".`);
+    }
     if (options.hasCatalogue) {
         console.log(` - Publish a single app with "playdrop project publish ${name}" or everything in the catalogue with "playdrop project publish .".`);
     }
@@ -495,7 +532,7 @@ async function ensureLocalCatalogue(cataloguePath) {
     if ((0, node_fs_1.existsSync)(cataloguePath)) {
         return { path: cataloguePath, initSummary: null, created: false };
     }
-    const shouldInit = await promptInit();
+    const shouldInit = node_process_1.stdin.isTTY && node_process_1.stdout.isTTY ? await promptInit() : true;
     if (!shouldInit) {
         (0, messages_1.printErrorWithHelp)('A local catalogue.json is required to register app metadata next to the app file.', [
             'Run "playdrop project init ." in this directory to create catalogue.json and starter docs before running "playdrop project create app".'
@@ -553,56 +590,67 @@ function parseTemplateKey(value) {
     }
     return null;
 }
-function parseRemixKey(value) {
-    const parts = value.split('/').map((part) => part.trim()).filter(Boolean);
-    if (parts.length < 3) {
-        return null;
-    }
-    const [creator, typeSegment, ...rest] = parts;
-    if (!creator) {
-        return null;
-    }
-    const normalizedType = typeSegment.toLowerCase();
-    const mappedType = APP_TYPE_SLUGS[normalizedType];
-    if (!mappedType) {
-        return null;
-    }
-    const name = rest.join('/');
-    if (!name) {
+function parseRemixRef(value) {
+    const parsed = (0, types_1.parseContentVersionRef)(value);
+    if (!parsed || parsed.kind !== 'app') {
         return null;
     }
     return {
-        creator,
-        name,
-        type: mappedType,
-        typeSlug: mappedType.toLowerCase(),
+        creator: parsed.creatorUsername,
+        name: parsed.name,
+        version: parsed.version,
+        ref: (0, types_1.formatContentVersionRef)(parsed),
     };
 }
-async function fetchRemixScaffold(client, creator, app) {
+async function fetchRemixScaffold(client, creator, app, version) {
     try {
-        const response = await client.fetchRemixScaffold(creator, app);
+        const response = await client.fetchRemixScaffold(creator, app, version);
+        const remixMode = typeof response?.remixMode === 'string' ? response.remixMode : '';
         const archiveUrl = typeof response?.archiveUrl === 'string' && response.archiveUrl.trim().length > 0
             ? response.archiveUrl.trim()
             : null;
         const htmlContent = typeof response?.html === 'string' ? response.html : null;
-        if (!archiveUrl && !htmlContent) {
-            throw new Error('Remix response missing scaffold content');
-        }
+        const externalListingUrl = typeof response?.externalListingUrl === 'string' && response.externalListingUrl.trim().length > 0
+            ? response.externalListingUrl.trim()
+            : null;
         const metadata = response.metadata;
         const entryPoint = extractEntryPointFromMetadata(metadata);
-        const sourceVersion = archiveUrl
-            ? (await client.fetchAppBySlug(creator, app)).app.currentVersion ?? null
-            : null;
-        if (archiveUrl && !sourceVersion) {
-            throw new Error('Remix source archive is missing a current version');
+        if (remixMode === 'archive') {
+            if (!archiveUrl) {
+                throw new Error('Remix response missing archiveUrl');
+            }
+            return {
+                html: null,
+                metadata,
+                archiveUrl,
+                entryPoint,
+                sourceVersion: version,
+            };
+        }
+        if (remixMode === 'inline-html') {
+            if (!htmlContent) {
+                throw new Error('Remix response missing html');
+            }
+            return {
+                html: htmlContent,
+                metadata,
+                entryPoint,
+                sourceVersion: null,
+            };
+        }
+        if (remixMode === 'external-metadata-only') {
+            if (!externalListingUrl) {
+                throw new Error('Remix response missing externalListingUrl');
+            }
+            return {
+                html: null,
+                metadata,
+                externalListingUrl,
+                entryPoint,
+                sourceVersion: null,
+            };
         }
-        return {
-            html: htmlContent,
-            metadata,
-            archiveUrl,
-            entryPoint,
-            sourceVersion,
-        };
+        throw new Error(`Unsupported remix mode: ${remixMode || 'missing'}`);
     }
     catch (unknownError) {
         if (unknownError instanceof types_1.UnsupportedClientError) {
@@ -702,9 +750,7 @@ async function create(name, options = {}) {
         return;
     }
     if (templateOptionRaw && remixOptionRaw) {
-        (0, messages_1.printErrorWithHelp)('Cannot use --template and --remix at the same time.', [
-            'Choose one source: use "--remix {creator}/{type}/{name}" to remix an existing app, or "--template {creator}/template/{name}" to start from a template.'
-        ], { command: 'project create app' });
+        (0, messages_1.printErrorWithHelp)('Cannot use --template and --remix at the same time.', ['Choose one source: use "--remix app:creator/name@1.2.3" to remix an app version, or "--template {creator}/template/{name}" to start from a template.'], { command: 'project create app' });
         process.exitCode = 1;
         return;
     }
@@ -712,7 +758,7 @@ async function create(name, options = {}) {
         if (!reuseExistingApp) {
             (0, messages_1.printErrorWithHelp)('Specify either --template or --remix when creating an app.', [
                 'Use "playdrop browse --kind app --app-type template" to discover available templates.',
-                'Browse https://playdrop.ai, pick an app, and pass its key with "--remix creator/type/name".'
+                'Browse https://playdrop.ai, pick an app version, and pass its canonical ref with "--remix app:creator/name@1.2.3".'
             ], { command: 'project create app' });
             process.exitCode = 1;
             return;
@@ -759,21 +805,20 @@ async function create(name, options = {}) {
     let scaffold = null;
     let provenanceMessage = '';
     if (!reuseExistingApp && remixOption) {
-        const parsed = parseRemixKey(remixOption);
+        const parsed = parseRemixRef(remixOption);
         if (!parsed) {
-            (0, messages_1.printErrorWithHelp)('The --remix value must use the {creator}/{type}/{name} key format.', [
-                'Example: playdrop/game/hangingout.',
+            (0, messages_1.printErrorWithHelp)('The --remix value must use canonical app version ref format.', [
+                'Example: app:playdrop/hangingout@1.2.3.',
                 'Use "playdrop browse --kind app" or "playdrop search <query> --kind app" to find remixable apps.'
             ], { command: 'project create app' });
             process.exitCode = 1;
             return;
         }
-        const remixKeyDisplay = `${parsed.creator}/${parsed.typeSlug}/${parsed.name}`;
-        remixSourceTarget = { creator: parsed.creator, name: parsed.name };
-        sourceInfo.remixSlug = remixKeyDisplay;
+        remixSourceTarget = { creator: parsed.creator, name: parsed.name, version: parsed.version };
+        sourceInfo.remixRef = parsed.ref;
         try {
-            scaffold = await fetchRemixScaffold(client, parsed.creator, parsed.name);
-            provenanceMessage = `Remixed from ${remixKeyDisplay}.`;
+            scaffold = await fetchRemixScaffold(client, parsed.creator, parsed.name, parsed.version);
+            provenanceMessage = `Remixed from ${parsed.ref}.`;
         }
         catch (error) {
             if (error instanceof http_1.CLIUnsupportedClientError) {
@@ -836,12 +881,15 @@ async function create(name, options = {}) {
     if (!reuseExistingApp && !scaffold) {
         (0, messages_1.printErrorWithHelp)('Failed to retrieve scaffold data. Specify a valid --template or --remix key and try again.', [
             'Use "playdrop browse --kind app --app-type template" to discover available templates.',
-            'Browse https://playdrop.ai and copy an app key to pass with "--remix".'
+            'Browse https://playdrop.ai and copy an exact app version ref to pass with "--remix".'
         ], { command: 'project create app' });
         process.exitCode = 1;
         return;
     }
     const hasArchive = !reuseExistingApp && typeof scaffold?.archiveUrl === 'string' && scaffold.archiveUrl?.trim().length > 0;
+    const externalRemixListingUrl = !reuseExistingApp && typeof scaffold?.externalListingUrl === 'string' && scaffold.externalListingUrl.trim().length > 0
+        ? scaffold.externalListingUrl.trim()
+        : null;
     let htmlFilePath = reuseExistingApp && existingTask ? existingTask.filePath : '';
     let projectDir = reuseExistingApp && existingTask ? existingTask.projectDir : null;
     let packageJsonPath = reuseExistingApp && existingTask ? existingTask.packageJsonPath ?? null : null;
@@ -867,7 +915,7 @@ async function create(name, options = {}) {
         }
         try {
             const archiveBuffer = remixSourceTarget
-                ? new Uint8Array(await (await client.downloadAppSource(remixSourceTarget.creator, remixSourceTarget.name, scaffold.sourceVersion)).blob.arrayBuffer())
+                ? new Uint8Array(await (await client.downloadAppSource(remixSourceTarget.creator, remixSourceTarget.name, remixSourceTarget.version)).blob.arrayBuffer())
                 : await downloadArchive(scaffold.archiveUrl);
             const extraction = extractProjectArchive(archiveBuffer, projectDir);
             const extractedCatalogue = (0, node_path_1.resolve)(projectDir, CATALOGUE_FILENAME);
@@ -930,12 +978,15 @@ async function create(name, options = {}) {
             packageJsonPath = existingTask.packageJsonPath ?? null;
             cataloguePathToUse = existingTask.catalogueAbsolutePath;
         }
+        else if (externalRemixListingUrl) {
+            htmlFilePath = file;
+        }
         else if (!scaffold?.html) {
             (0, messages_1.printNetworkIssue)('Unable to retrieve template content for playdrop project create app.', 'project create app');
             process.exitCode = 1;
             return;
         }
-        if (!reuseExistingApp) {
+        if (!reuseExistingApp && !externalRemixListingUrl) {
             htmlFilePath = file;
             const scaffoldHtml = scaffold.html;
             (0, node_fs_1.writeFileSync)(htmlFilePath, scaffoldHtml);
@@ -990,6 +1041,13 @@ async function create(name, options = {}) {
     if (reuseExistingApp && existingTask) {
         registrationTask = existingTask;
     }
+    else if (!reuseExistingApp && externalRemixListingUrl && !(0, node_fs_1.existsSync)(htmlFilePath)) {
+        const pendingCataloguePath = workspaceCatalogueResult?.path ?? cataloguePathToUse;
+        if (!pendingCataloguePath) {
+            throw new Error('Missing catalogue path for external remix scaffold.');
+        }
+        registrationTask = buildPendingExternalRemixTask(name, scaffold.metadata, sourceInfo, pendingCataloguePath, htmlFilePath);
+    }
     else {
         const registrationLookup = (0, catalogue_1.resolveCatalogueEntries)(process.cwd(), { filterName: name });
         if (registrationLookup.errors.length > 0) {
@@ -1207,6 +1265,7 @@ async function create(name, options = {}) {
         entryPointLabel,
         hasPackageJson,
         dependenciesInstalled,
+        externalListingUrl: externalRemixListingUrl,
     });
     if (workspaceCatalogueUpdated && workspaceCatalogueResult) {
         warnMissingWorkspaceReadme(workspaceCatalogueResult.path);

package/dist/commands/createRemixContent.d.ts

@@ -0,0 +1,3 @@
+export declare function createAssetRemix(name: string, remixRef: string): Promise<void>;
+export declare function createPackRemix(name: string, remixRef: string): Promise<void>;
+export declare function createRemixContent(kind: 'asset' | 'pack', name: string, remixRef: string): Promise<void>;