@playdrop/playdrop-cli 0.12.42 → 0.13.1

package/config/client-meta.json

@@ -1,7 +1,7 @@
 {
-  "version": "0.12.42",
+  "version": "0.13.1",
   "build": 1,
-  "runtimeSdkVersion": "0.12.42",
+  "runtimeSdkVersion": "0.13.1",
   "runtimeSdkBuild": 1,
   "clients": {
     "all": {

package/dist/apps/index.d.ts

@@ -19,6 +19,7 @@ export type AppPipelineOptions = {
     token?: string | null;
     user?: UserResponse | null;
     runLocalLoadCheck?: boolean;
+    devRouterPort?: number;
     runStagedUploadLoadCheck?: boolean;
     loadCheckTimeoutMs?: number;
     ensureRegisteredAppShell?: boolean;
@@ -27,6 +28,7 @@ export type AppPipelineOptions = {
     mediaCaptureRequired?: boolean;
     machineCausalGateRequired?: boolean;
     captureSession?: TaskCaptureSession | null;
+    artifacts?: AppBuildArtifacts;
 };
 export declare function runAppPipeline(client: ApiClient, task: AppTask, options?: AppPipelineOptions): Promise<AppPipelineResult>;
 export { collectAppValidationWarnings, validateAppTask, buildApp, uploadApp, runFormatScript };

package/dist/apps/index.js

@@ -29,7 +29,7 @@ async function runAppPipeline(client, task, options) {
             agentTaskId: options.agentTaskId,
         });
     }
-    const artifacts = isExternal ? null : await (0, build_1.buildApp)(task);
+    const artifacts = isExternal ? null : options?.artifacts ?? await (0, build_1.buildApp)(task);
     const warnings = (0, validate_1.collectAppValidationWarnings)(task, isExternal ? 'source' : 'bundle');
     if (!isExternal && options?.runLocalLoadCheck) {
         const creatorUsername = typeof options.creatorUsername === 'string' ? options.creatorUsername.trim() : '';
@@ -46,6 +46,7 @@ async function runAppPipeline(client, task, options) {
             webBase: options.webBase,
             creatorUsername,
             task,
+            devRouterPort: options.devRouterPort,
             timeoutMs: options.loadCheckTimeoutMs,
             token: options.token ?? null,
             currentUser: options.user ?? null,

package/dist/apps/loadCheck.d.ts

@@ -90,7 +90,10 @@ export declare function runUploadedHostedLoadCheck(input: {
     postReadyWaitMs?: number;
 }): Promise<HostedLoadCheckResult>;
 export declare function sliceFirstPrimaryVerbAction(tape: AppPlaytestTape): AppPlaytestTape;
-export declare function compareCausalFrames(firstPath: string, secondPath: string): Promise<AppUploadCausalComparison>;
+export declare function compareCausalFrames(firstPath: string, secondPath: string, thresholds?: {
+    meanDeltaMin: number;
+    changedPixelRatioMin: number;
+}): Promise<AppUploadCausalComparison>;
 export declare function runUploadedHostedCausalCheck(input: {
     client: ApiClient;
     creatorUsername: string;

package/dist/apps/loadCheck.js

@@ -41,6 +41,10 @@ const DEFAULT_HOSTED_LOAD_TIMEOUT_MS = 15000;
 const POST_READY_SETTLE_MS = 750;
 const CAUSAL_FRAME_MEAN_DELTA_MIN = 0.025;
 const CAUSAL_FRAME_CHANGED_PIXEL_RATIO_MIN = 0.12;
+const CAUSAL_START_FRAME_MEAN_DELTA_MIN = 0.02;
+const CAUSAL_START_FRAME_CHANGED_PIXEL_RATIO_MIN = 0.08;
+const CAUSAL_PROGRESS_FRAME_MEAN_DELTA_MIN = 0.012;
+const CAUSAL_PROGRESS_FRAME_CHANGED_PIXEL_RATIO_MIN = 0.05;
 const LOAD_CHECK_SURFACE_ORDER = ['DESKTOP', 'MOBILE_LANDSCAPE', 'MOBILE_PORTRAIT'];
 const GOOGLE_TELEMETRY_HOSTS = [
     'analytics.google.com',
@@ -1124,7 +1128,10 @@ function sliceFirstPrimaryVerbAction(tape) {
 async function hashFile(path) {
     return (0, node_crypto_1.createHash)('sha256').update(await (0, promises_1.readFile)(path)).digest('hex');
 }
-async function compareCausalFrames(firstPath, secondPath) {
+async function compareCausalFrames(firstPath, secondPath, thresholds = {
+    meanDeltaMin: CAUSAL_FRAME_MEAN_DELTA_MIN,
+    changedPixelRatioMin: CAUSAL_FRAME_CHANGED_PIXEL_RATIO_MIN,
+}) {
     const readPixels = async (path) => {
         return await (0, sharp_1.default)(path)
             .resize(64, 64, { fit: 'fill' })
@@ -1149,7 +1156,7 @@ async function compareCausalFrames(firstPath, secondPath) {
     return {
         meanDelta,
         changedPixelRatio,
-        passed: meanDelta >= CAUSAL_FRAME_MEAN_DELTA_MIN || changedPixelRatio >= CAUSAL_FRAME_CHANGED_PIXEL_RATIO_MIN,
+        passed: meanDelta >= thresholds.meanDeltaMin || changedPixelRatio >= thresholds.changedPixelRatioMin,
     };
 }
 async function runUploadedHostedCausalCheck(input) {
@@ -1218,20 +1225,43 @@ async function runUploadedHostedCausalCheck(input) {
             throw new Error('agent_task_machine_causal_gate_artifact_changed_during_check');
         }
         const comparisons = {
-            startOnlyVsReady: await compareCausalFrames(paths.startOnlyReady, paths.startOnly),
-            startOnlyVsZeroInput: await compareCausalFrames(paths.zeroInput, paths.startOnly),
-            fullTapeVsZeroInput: await compareCausalFrames(paths.zeroInput, paths.fullTape),
-            fullTapeVsStartOnly: await compareCausalFrames(paths.startOnly, paths.fullTape),
-            fullTapeVsFirstAction: await compareCausalFrames(paths.firstAction, paths.fullTape),
+            startOnlyVsReady: await compareCausalFrames(paths.startOnlyReady, paths.startOnly, {
+                meanDeltaMin: CAUSAL_START_FRAME_MEAN_DELTA_MIN,
+                changedPixelRatioMin: CAUSAL_START_FRAME_CHANGED_PIXEL_RATIO_MIN,
+            }),
+            startOnlyVsZeroInput: await compareCausalFrames(paths.zeroInput, paths.startOnly, {
+                meanDeltaMin: CAUSAL_START_FRAME_MEAN_DELTA_MIN,
+                changedPixelRatioMin: CAUSAL_START_FRAME_CHANGED_PIXEL_RATIO_MIN,
+            }),
+            fullTapeVsZeroInput: await compareCausalFrames(paths.zeroInput, paths.fullTape, {
+                meanDeltaMin: CAUSAL_PROGRESS_FRAME_MEAN_DELTA_MIN,
+                changedPixelRatioMin: CAUSAL_PROGRESS_FRAME_CHANGED_PIXEL_RATIO_MIN,
+            }),
+            fullTapeVsStartOnly: await compareCausalFrames(paths.startOnly, paths.fullTape, {
+                meanDeltaMin: CAUSAL_PROGRESS_FRAME_MEAN_DELTA_MIN,
+                changedPixelRatioMin: CAUSAL_PROGRESS_FRAME_CHANGED_PIXEL_RATIO_MIN,
+            }),
+            fullTapeVsFirstAction: await compareCausalFrames(paths.firstAction, paths.fullTape, {
+                meanDeltaMin: CAUSAL_PROGRESS_FRAME_MEAN_DELTA_MIN,
+                changedPixelRatioMin: CAUSAL_PROGRESS_FRAME_CHANGED_PIXEL_RATIO_MIN,
+            }),
         };
         if (!comparisons.startOnlyVsReady.passed || !comparisons.startOnlyVsZeroInput.passed) {
-            throw new Error('agent_task_machine_causal_gate_failed:start-only did not provably leave the title state. Fix the start action or ready-relative timing.');
+            throw new Error(`agent_task_machine_causal_gate_failed:start-only did not provably leave the title state. `
+                + `ready(mean=${comparisons.startOnlyVsReady.meanDelta.toFixed(4)},changed=${comparisons.startOnlyVsReady.changedPixelRatio.toFixed(4)}); `
+                + `zero(mean=${comparisons.startOnlyVsZeroInput.meanDelta.toFixed(4)},changed=${comparisons.startOnlyVsZeroInput.changedPixelRatio.toFixed(4)}). `
+                + 'Fix the start action, visible start-only outcome, or ready-relative timing.');
         }
         if (!comparisons.fullTapeVsZeroInput.passed || !comparisons.fullTapeVsStartOnly.passed) {
-            throw new Error('agent_task_machine_causal_gate_failed:full tape did not meaningfully beat zero-input and start-only controls. Fix the game or tape before upload.');
+            throw new Error(`agent_task_machine_causal_gate_failed:full tape did not meaningfully beat zero-input and start-only controls. `
+                + `zero(mean=${comparisons.fullTapeVsZeroInput.meanDelta.toFixed(4)},changed=${comparisons.fullTapeVsZeroInput.changedPixelRatio.toFixed(4)}); `
+                + `start(mean=${comparisons.fullTapeVsStartOnly.meanDelta.toFixed(4)},changed=${comparisons.fullTapeVsStartOnly.changedPixelRatio.toFixed(4)}). `
+                + 'Fix the game or tape before upload.');
         }
         if (!comparisons.fullTapeVsFirstAction.passed) {
-            throw new Error('agent_task_machine_causal_gate_failed:first primary action trivially reached the full-tape outcome. Add a sustained causal loop before upload.');
+            throw new Error(`agent_task_machine_causal_gate_failed:first primary action trivially reached the full-tape outcome. `
+                + `action(mean=${comparisons.fullTapeVsFirstAction.meanDelta.toFixed(4)},changed=${comparisons.fullTapeVsFirstAction.changedPixelRatio.toFixed(4)}). `
+                + 'Add a sustained causal loop before upload.');
         }
         const teachingText = input.teachingText.trim();
         const evidence = {

package/dist/apps/staticHtml.d.ts

@@ -0,0 +1,28 @@
+import type { AppSurface } from '@playdrop/types';
+import type { AppTask } from '../catalogue';
+import { type AppBuildArtifacts } from './build';
+export type StaticHtmlMetadata = {
+    title: string;
+    description: string | null;
+    imagePath: string | null;
+    warnings: string[];
+};
+export type PreparedStaticHtmlProject = {
+    sourceTask: AppTask;
+    runtimeTask: AppTask;
+    artifacts: AppBuildArtifacts;
+    sourceHash: string;
+    runtimeHash: string;
+    metadata: StaticHtmlMetadata;
+    runtimeDir: string;
+    cleanup: () => Promise<void>;
+};
+export declare function parseStaticHtmlMetadata(projectDir: string, entryPoint?: string): StaticHtmlMetadata;
+export declare function buildStaticGameSlug(title: string, taskId?: number): string;
+export declare function prepareStaticHtmlProject(input: {
+    projectDir: string;
+    taskId?: number;
+    appName?: string;
+    primarySurface: AppSurface;
+}): Promise<PreparedStaticHtmlProject>;
+export declare function sha256File(filePath: string): string;

package/dist/apps/staticHtml.js

@@ -0,0 +1,343 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStaticHtmlMetadata = parseStaticHtmlMetadata;
+exports.buildStaticGameSlug = buildStaticGameSlug;
+exports.prepareStaticHtmlProject = prepareStaticHtmlProject;
+exports.sha256File = sha256File;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const parse5_1 = require("parse5");
+const build_1 = require("./build");
+const STATIC_GAME_SURFACES = ['DESKTOP', 'MOBILE_LANDSCAPE', 'MOBILE_PORTRAIT'];
+const STATIC_SOURCE_EXCLUDES = ['AGENTS.md', 'CLAUDE.md', '.playdrop/', 'bin/playdrop'];
+const STATIC_BUNDLE_EXCLUDES = [...STATIC_SOURCE_EXCLUDES];
+function attribute(node, name) {
+    return node.attrs?.find((entry) => entry.name.toLowerCase() === name)?.value.trim() ?? null;
+}
+function walk(node, visit) {
+    visit(node);
+    for (const child of node.childNodes ?? []) {
+        walk(child, visit);
+    }
+}
+function findElement(node, tagName) {
+    if (node.tagName === tagName)
+        return node;
+    for (const child of node.childNodes ?? []) {
+        const match = findElement(child, tagName);
+        if (match)
+            return match;
+    }
+    return null;
+}
+function textContent(node) {
+    if (typeof node.value === 'string') {
+        return node.value;
+    }
+    return (node.childNodes ?? []).map(textContent).join('');
+}
+function isPngFile(filePath) {
+    const signature = (0, node_fs_1.readFileSync)(filePath).subarray(0, 8);
+    return signature.length === 8
+        && signature.equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]));
+}
+function isInside(root, candidate) {
+    const rel = (0, node_path_1.relative)(root, candidate);
+    return rel === '' || (!rel.startsWith(`..${node_path_1.sep}`) && rel !== '..' && !(0, node_path_1.isAbsolute)(rel));
+}
+function localReferencePath(projectDir, rawReference, code) {
+    const reference = rawReference.trim();
+    if (!reference || reference.startsWith('#') || reference.startsWith('data:') || reference.startsWith('blob:')) {
+        return null;
+    }
+    if (/^(?:https?:)?\/\//i.test(reference) || /^[a-z][a-z0-9+.-]*:/i.test(reference)) {
+        throw new Error(`${code}:remote_reference:${reference}`);
+    }
+    if (reference.startsWith('/')) {
+        throw new Error(`${code}:root_reference:${reference}`);
+    }
+    let decoded;
+    try {
+        decoded = decodeURIComponent(reference.split(/[?#]/, 1)[0] ?? '');
+    }
+    catch {
+        throw new Error(`${code}:invalid_reference:${reference}`);
+    }
+    const absoluteRoot = (0, node_path_1.resolve)(projectDir);
+    const resolvedPath = (0, node_path_1.resolve)(absoluteRoot, decoded);
+    const realRoot = (0, node_fs_1.realpathSync)(absoluteRoot);
+    if (!isInside(absoluteRoot, resolvedPath) || !(0, node_fs_1.existsSync)(resolvedPath) || !(0, node_fs_1.statSync)(resolvedPath).isFile()) {
+        throw new Error(`${code}:missing_or_outside:${reference}`);
+    }
+    const realFile = (0, node_fs_1.realpathSync)(resolvedPath);
+    if (!isInside(realRoot, realFile)) {
+        throw new Error(`${code}:outside_project:${reference}`);
+    }
+    return realFile;
+}
+function validateHtmlRuntimeReferences(projectDir, document) {
+    walk(document, (node) => {
+        const tag = node.tagName?.toLowerCase();
+        if (!tag)
+            return;
+        if (tag === 'base') {
+            throw new Error('static_game_artifact_base_tag_unsupported');
+        }
+        const rel = attribute(node, 'rel')?.toLowerCase().split(/\s+/) ?? [];
+        const reference = tag === 'script'
+            ? attribute(node, 'src')
+            : tag === 'link' && (rel.includes('stylesheet') || rel.includes('icon') || rel.includes('preload'))
+                ? attribute(node, 'href')
+                : ['img', 'audio', 'video', 'source', 'track', 'embed', 'object', 'iframe'].includes(tag)
+                    ? attribute(node, tag === 'object' ? 'data' : 'src')
+                    : null;
+        if (reference) {
+            localReferencePath(projectDir, reference, 'static_game_artifact_invalid_local_path');
+        }
+        const srcset = tag === 'img' || tag === 'source' ? attribute(node, 'srcset') : null;
+        for (const candidate of srcset?.split(',') ?? []) {
+            const referenceValue = candidate.trim().split(/\s+/, 1)[0];
+            if (referenceValue) {
+                localReferencePath(projectDir, referenceValue, 'static_game_artifact_invalid_local_path');
+            }
+        }
+    });
+}
+function parseStaticHtmlProject(projectDir, entryPoint = 'index.html') {
+    const root = (0, node_path_1.resolve)(projectDir);
+    const entryPath = (0, node_path_1.resolve)(root, entryPoint);
+    if (!isInside(root, entryPath) || (0, node_path_1.basename)(entryPath).toLowerCase() !== 'index.html') {
+        throw new Error('static_game_artifact_invalid_entry_point');
+    }
+    if (!(0, node_fs_1.existsSync)(entryPath) || !(0, node_fs_1.statSync)(entryPath).isFile()) {
+        throw new Error('static_game_artifact_index_missing');
+    }
+    const html = (0, node_fs_1.readFileSync)(entryPath, 'utf8');
+    if (html.includes('data-playdrop-static-sdk') || html.includes('data-playdrop-static-bootstrap')) {
+        throw new Error('static_game_artifact_injected_sdk_already_present');
+    }
+    const document = (0, parse5_1.parse)(html, { sourceCodeLocationInfo: true });
+    const head = findElement(document, 'head');
+    const body = findElement(document, 'body');
+    if (!head) {
+        throw new Error('static_game_artifact_head_missing');
+    }
+    const titles = [];
+    const metas = [];
+    let headEndOffset = null;
+    walk(head, (node) => {
+        if (node.tagName === 'title')
+            titles.push(node);
+        if (node.tagName === 'meta')
+            metas.push(node);
+        if (node.tagName === 'head' && Number.isInteger(node.sourceCodeLocation?.endTag?.startOffset)) {
+            headEndOffset = Number(node.sourceCodeLocation.endTag.startOffset);
+        }
+    });
+    if (titles.length !== 1) {
+        throw new Error(`static_game_artifact_title_count:${titles.length}`);
+    }
+    const title = textContent(titles[0]).replace(/\s+/g, ' ').trim();
+    if (!title || title.length > 120) {
+        throw new Error('static_game_artifact_title_invalid');
+    }
+    if (headEndOffset === null && body) {
+        const explicitBodyStart = body.sourceCodeLocation?.startTag?.startOffset
+            ?? body.sourceCodeLocation?.startOffset;
+        const firstBodyChildStart = (body.childNodes ?? [])
+            .map((node) => node.sourceCodeLocation?.startOffset)
+            .find((offset) => Number.isInteger(offset));
+        const finalHeadChildEnd = [...(head.childNodes ?? [])]
+            .reverse()
+            .map((node) => node.sourceCodeLocation?.endOffset)
+            .find((offset) => Number.isInteger(offset));
+        headEndOffset = explicitBodyStart ?? firstBodyChildStart ?? finalHeadChildEnd ?? null;
+    }
+    if (headEndOffset === null) {
+        throw new Error('static_game_artifact_html_injection_point_missing');
+    }
+    for (const meta of metas) {
+        const httpEquiv = attribute(meta, 'http-equiv')?.toLowerCase();
+        if (httpEquiv === 'content-security-policy') {
+            throw new Error('static_game_artifact_blocking_csp');
+        }
+    }
+    validateHtmlRuntimeReferences(root, document);
+    const readMeta = (...keys) => {
+        for (const key of keys) {
+            const match = metas.find((node) => (attribute(node, 'name')?.toLowerCase() === key
+                || attribute(node, 'property')?.toLowerCase() === key));
+            const value = match ? attribute(match, 'content') : null;
+            if (value)
+                return value;
+        }
+        return null;
+    };
+    const description = readMeta('description', 'og:description');
+    const image = readMeta('og:image', 'twitter:image');
+    const warnings = [];
+    let imagePath = null;
+    if (image) {
+        try {
+            const resolvedImage = localReferencePath(root, image, 'static_game_artifact_image_invalid');
+            if (resolvedImage && (0, node_path_1.extname)(resolvedImage).toLowerCase() === '.png' && isPngFile(resolvedImage)) {
+                imagePath = resolvedImage;
+            }
+            else {
+                warnings.push('Optional HTML image metadata was ignored because it is not a local PNG.');
+            }
+        }
+        catch {
+            warnings.push('Optional HTML image metadata was ignored because it does not resolve to a local PNG.');
+        }
+    }
+    return {
+        html,
+        headEndOffset,
+        metadata: { title, description, imagePath, warnings },
+    };
+}
+function parseStaticHtmlMetadata(projectDir, entryPoint = 'index.html') {
+    return parseStaticHtmlProject(projectDir, entryPoint).metadata;
+}
+function buildStaticGameSlug(title, taskId) {
+    const base = title.normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '') || 'game';
+    const suffix = taskId === undefined ? '' : `-t${taskId}`;
+    return `${base.slice(0, 128 - suffix.length).replace(/-+$/g, '')}${suffix}`;
+}
+function buildListing(imagePath, primarySurface) {
+    if (!imagePath)
+        return undefined;
+    return {
+        ...(primarySurface === 'MOBILE_PORTRAIT'
+            ? { heroPortraitPath: imagePath }
+            : { heroLandscapePath: imagePath }),
+        screenshotPortraitPaths: [],
+        screenshotLandscapePaths: [],
+        videoPortraitPaths: [],
+        videoLandscapePaths: [],
+    };
+}
+function buildStaticAppTask(input) {
+    return {
+        kind: 'app',
+        name: input.name,
+        cataloguePath: input.entryPath,
+        catalogueAbsolutePath: input.entryPath,
+        catalogueDir: input.projectDir,
+        filePath: input.entryPath,
+        relativeFile: 'index.html',
+        projectDir: input.projectDir,
+        packageJsonPath: null,
+        isTypescriptProject: false,
+        hasValidateScript: false,
+        hasFormatScript: false,
+        displayName: input.metadata.title,
+        ...(input.metadata.description ? { description: input.metadata.description } : {}),
+        type: 'GAME',
+        surfaceTargets: [...STATIC_GAME_SURFACES],
+        primarySurface: input.primarySurface,
+        missingMetadata: [],
+        version: '1.0.0',
+        releaseNotes: 'Initial static game upload',
+        versionVisibility: 'PRIVATE',
+        sourceArchiveExcludeRelativeFiles: STATIC_SOURCE_EXCLUDES,
+        bundleArchiveExcludeRelativeFiles: STATIC_BUNDLE_EXCLUDES,
+        license: 'CLOSED',
+        tags: [],
+        hostingMode: 'HOSTED',
+        authMode: 'NONE',
+        previewable: true,
+        ...(buildListing(input.metadata.imagePath, input.primarySurface)
+            ? { listing: buildListing(input.metadata.imagePath, input.primarySurface) }
+            : {}),
+        achievements: [],
+        leaderboards: [],
+        ownedAssets: [],
+        assetSpecSupport: [],
+        uses: { assets: [], packs: [] },
+        graph: { relations: [] },
+    };
+}
+const STATIC_SDK_BOOTSTRAP = [
+    '<script src="/sdk/playdrop.js" data-playdrop-static-sdk></script>',
+    '<script data-playdrop-static-bootstrap>',
+    'window.addEventListener("load", async () => {',
+    '  const sdk = await window.playdrop.init();',
+    '  await sdk.host.ready();',
+    '}, { once: true });',
+    '</script>',
+].join('\n');
+async function prepareStaticHtmlProject(input) {
+    const sourceRoot = (0, node_fs_1.realpathSync)((0, node_path_1.resolve)(input.projectDir));
+    const sourceEntryPath = (0, node_path_1.join)(sourceRoot, 'index.html');
+    const parsedProject = parseStaticHtmlProject(sourceRoot);
+    const metadata = parsedProject.metadata;
+    const requestedAppName = input.appName?.trim() ?? '';
+    if (requestedAppName && (requestedAppName.length > 128 || !/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/.test(requestedAppName))) {
+        throw new Error('static_game_artifact_claimed_slug_invalid');
+    }
+    const name = requestedAppName || buildStaticGameSlug(metadata.title, input.taskId);
+    const sourceTask = buildStaticAppTask({
+        projectDir: sourceRoot,
+        entryPath: sourceEntryPath,
+        name,
+        metadata,
+        primarySurface: input.primarySurface,
+    });
+    const sourceArtifacts = await (0, build_1.buildApp)(sourceTask);
+    const runtimeDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), `playdrop-static-${name}-`));
+    try {
+        await (0, promises_1.cp)(sourceRoot, runtimeDir, {
+            recursive: true,
+            filter: (source) => {
+                const rel = (0, node_path_1.relative)(sourceRoot, source).replace(/\\/g, '/');
+                return !rel || !STATIC_SOURCE_EXCLUDES.some((excluded) => (excluded.endsWith('/') ? rel === excluded.slice(0, -1) || rel.startsWith(excluded) : rel === excluded));
+            },
+        });
+        const runtimeEntryPath = (0, node_path_1.join)(runtimeDir, 'index.html');
+        const sourceHtml = parsedProject.html;
+        const runtimeHtml = `${sourceHtml.slice(0, parsedProject.headEndOffset)}${STATIC_SDK_BOOTSTRAP}\n${sourceHtml.slice(parsedProject.headEndOffset)}`;
+        await (0, promises_1.writeFile)(runtimeEntryPath, runtimeHtml, 'utf8');
+        const runtimeTask = buildStaticAppTask({
+            projectDir: runtimeDir,
+            entryPath: runtimeEntryPath,
+            name,
+            metadata: {
+                ...metadata,
+                imagePath: metadata.imagePath ? (0, node_path_1.join)(runtimeDir, (0, node_path_1.relative)(sourceRoot, metadata.imagePath)) : null,
+            },
+            primarySurface: input.primarySurface,
+        });
+        const runtimeArtifacts = await (0, build_1.buildApp)(runtimeTask);
+        const artifacts = {
+            ...runtimeArtifacts,
+            sourceFile: sourceArtifacts.sourceFile,
+            sourceHash: sourceArtifacts.sourceHash,
+        };
+        return {
+            sourceTask,
+            runtimeTask,
+            artifacts,
+            sourceHash: sourceArtifacts.sourceHash,
+            runtimeHash: runtimeArtifacts.bundleHash,
+            metadata,
+            runtimeDir,
+            cleanup: async () => { await (0, promises_1.rm)(runtimeDir, { recursive: true, force: true }); },
+        };
+    }
+    catch (error) {
+        await (0, promises_1.rm)(runtimeDir, { recursive: true, force: true });
+        throw error;
+    }
+}
+function sha256File(filePath) {
+    return (0, node_crypto_1.createHash)('sha256').update((0, node_fs_1.readFileSync)(filePath)).digest('hex');
+}

package/dist/apps/validate.js

@@ -43,6 +43,7 @@ const LEGACY_SDK_SYMBOL_PATTERNS = [
 ];
 const SDK_REFERENCE_PATTERNS = [
     /https:\/\/assets\.playdrop\.ai\/sdk\/playdrop\.js/g,
+    /["']\/sdk\/playdrop\.js(?:[?"'])/g,
     /@playdrop\/sdk(?:\/browser)?/g,
 ];
 const SDK_INIT_PATTERNS = [
@@ -487,7 +488,7 @@ function collectAppValidationWarnings(task, mode = 'source') {
     const hasSdkReady = primaryDetection.hasSdkReady || sourceDetection.hasSdkReady;
     const warnings = [];
     if (!hasSdkReference) {
-        warnings.push(`[apps][validate] Could not detect the Playdrop SDK loader or @playdrop/sdk import for ${task.name}. We could not find https://assets.playdrop.ai/sdk/playdrop.js or @playdrop/sdk in the app files, so it might not work once uploaded.`);
+        warnings.push(`[apps][validate] Could not detect the Playdrop SDK loader or @playdrop/sdk import for ${task.name}. We could not find /sdk/playdrop.js, https://assets.playdrop.ai/sdk/playdrop.js, or @playdrop/sdk in the app files, so it might not work once uploaded.`);
     }
     if (!hasSdkInit) {
         warnings.push(`[apps][validate] Could not detect Playdrop SDK initialization for ${task.name}. We could not find playdrop.init() in the app files, so it might not work once uploaded.`);

package/dist/commands/captureListing.d.ts

@@ -85,7 +85,7 @@ export declare function buildListingCaptureFrameUrl({ webBase, currentUsername,
 export declare function resolveListingCaptureSceneId(width: number, height: number): 'listing-landscape' | 'listing-portrait';
 export declare function parseCaptureListingOptions(targetArg: string | undefined, options?: CaptureListingOptions): ParsedCaptureListingOptions;
 export declare function assertSupportedListingEnvironment(platform?: NodeJS.Platform, macosVersion?: string): void;
-export declare function resolveListingRecorderPath(baseDir?: string): string;
+export declare function resolveListingRecorderPath(workerHome?: string): string;
 export declare function buildSurfaceOutputPaths(outputDir: string, surface: AppSurface, useSurfacePrefix: boolean): {
     rawVideoPath: string;
     metadataPath: string;

package/dist/commands/captureListing.js

@@ -59,6 +59,7 @@ const commandContext_1 = require("../commandContext");
 const http_1 = require("../http");
 const messages_1 = require("../messages");
 const playwright_1 = require("../playwright");
+const recorderRelease_1 = require("../recorderRelease");
 const listingCaptureLease_1 = require("../listingCaptureLease");
 const dev_1 = require("./dev");
 const devRuntimeAssets_1 = require("./devRuntimeAssets");
@@ -204,8 +205,8 @@ function commandExists(command) {
 async function ensureExecutableFile(filePath) {
     await (0, promises_1.access)(filePath);
 }
-function resolveListingRecorderPath(baseDir = __dirname) {
-    return (0, node_path_1.resolve)(baseDir, '..', '..', '..', '..', 'clients', 'apple', 'playdrop-listing-recorder', '.build', 'release', 'playdrop-listing-recorder');
+function resolveListingRecorderPath(workerHome) {
+    return (0, recorderRelease_1.resolveMacWorkerRecorderPath)(workerHome);
 }
 function buildTimestampFolder(date = new Date()) {
     const iso = date.toISOString();
@@ -755,7 +756,7 @@ async function ensureListingRecorderAvailable(recorderPath) {
         return true;
     }
     catch {
-        (0, messages_1.printErrorWithHelp)(`Native recorder binary was not found at ${recorderPath}.`, ['Build it with: (cd clients/apple/playdrop-listing-recorder && swift build -c release)'], { command: 'project capture' });
+        (0, messages_1.printErrorWithHelp)(`Native recorder binary was not found at ${recorderPath}.`, ['Start the PlayDrop worker once on this Mac to install the recorder from the PlayDrop CDN.'], { command: 'project capture' });
         process.exitCode = 1;
         return false;
     }

package/dist/commands/devServer.js

@@ -651,6 +651,25 @@ function createDevRouterServer(initialPort = exports.DEV_ROUTER_PORT) {
             });
             return;
         }
+        if (pathname.startsWith('/sdk/') && (method === 'GET' || method === 'HEAD')) {
+            const assetsBase = process.env.ASSETS_BASE_URL?.trim();
+            if (!assetsBase) {
+                respondWithText(res, method, 500, 'ASSETS_BASE_URL is required to serve the development SDK.');
+                return;
+            }
+            let sdkUrl;
+            try {
+                sdkUrl = new URL(`${pathname}${requestUrl.search}`, `${assetsBase.replace(/\/$/, '')}/`);
+            }
+            catch {
+                respondWithText(res, method, 500, 'ASSETS_BASE_URL is invalid.');
+                return;
+            }
+            res.statusCode = 307;
+            res.setHeader('Location', sdkUrl.toString());
+            res.end();
+            return;
+        }
         if (pathname.startsWith(`${CONTROL_PREFIX}/apps/dev/`) && pathname.endsWith('/runtime-assets') && method === 'GET') {
             cleanupStaleRouterMounts();
             const segments = pathname.split('/').filter(Boolean);

package/dist/commands/feedback.d.ts

@@ -6,9 +6,11 @@ type FeedbackSendOptions = {
     json?: boolean;
 };
 type FeedbackBrowseOptions = {
+    admin?: boolean;
     limit?: string | number;
     offset?: string | number;
     client?: string;
+    sinceHours?: string | number;
     userId?: string | number;
     json?: boolean;
 };