@playdrop/playdrop-cli 0.12.41 → 0.13.0

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/upload.d.ts

@@ -23,6 +23,7 @@ export type AppUploadOptions = {
     agentTaskId?: number;
     playtestProof?: AgentTaskPlaytestProof;
     mediaCaptureRequired?: boolean;
+    machineCausalGateRequired?: boolean;
     captureSession?: TaskCaptureSession | null;
 };
 export declare function uploadApp(client: ApiClient, task: AppTask, artifacts: AppBuildArtifacts | null, options?: AppUploadOptions): Promise<AppUploadResult>;

package/dist/apps/upload.js

@@ -9,6 +9,7 @@ const node_path_1 = require("node:path");
 const http_1 = require("../http");
 const loadCheck_1 = require("./loadCheck");
 const listingPreflight_1 = require("../listingPreflight");
+const playtestContract_1 = require("./playtestContract");
 const EXTENSION_TO_MIME = {
     '.png': 'image/png',
     '.jpg': 'image/jpeg',
@@ -353,6 +354,22 @@ async function uploadAppVersion(client, task, artifacts, options) {
                 await client.recordAppUploadMediaCapture(creatorUsername, task.name, sessionId, mediaCaptureProof);
             }
             if (task.hostingMode !== 'EXTERNAL'
+                && !task.externalUrl
+                && options?.machineCausalGateRequired) {
+                const teachingText = (0, playtestContract_1.assertPrimaryVerbTeachingParity)(task);
+                await (0, loadCheck_1.runUploadedHostedCausalCheck)({
+                    client,
+                    creatorUsername,
+                    task,
+                    sessionId,
+                    teachingText,
+                    timeoutMs: options.loadCheckTimeoutMs,
+                    token: options?.token ?? null,
+                    currentUser: options?.user ?? null,
+                    captureSession: options?.captureSession,
+                });
+            }
+            else if (task.hostingMode !== 'EXTERNAL'
                 && !task.externalUrl
                 && options?.runStagedUploadLoadCheck) {
                 const loadCheck = await (0, loadCheck_1.runUploadedHostedLoadCheck)({

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/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;
 };

package/dist/commands/feedback.js

@@ -16,7 +16,7 @@ const output_1 = require("../output");
 const clientInfo_1 = require("../clientInfo");
 const MAX_FEEDBACK_TITLE_LENGTH = 70;
 const MAX_FEEDBACK_COMMENT_LENGTH = 10000;
-const FEEDBACK_CATEGORY_SET = new Set(types_1.FEEDBACK_CATEGORY_VALUES);
+const FEEDBACK_CATEGORY_SET = new Set(types_1.MANUAL_FEEDBACK_CATEGORY_VALUES);
 function parsePositiveInteger(raw, label, command, options = {}) {
     if (raw === undefined) {
         return null;
@@ -32,7 +32,7 @@ function parsePositiveInteger(raw, label, command, options = {}) {
 function parseFeedbackCategory(raw, command) {
     const normalized = typeof raw === 'string' && raw.trim().length > 0 ? raw.trim() : 'other';
     if (!FEEDBACK_CATEGORY_SET.has(normalized)) {
-        (0, messages_1.printErrorWithHelp)(`Feedback category must be one of: ${types_1.FEEDBACK_CATEGORY_VALUES.join(', ')}.`, [], { command });
+        (0, messages_1.printErrorWithHelp)(`Feedback category must be one of: ${types_1.MANUAL_FEEDBACK_CATEGORY_VALUES.join(', ')}.`, [], { command });
         process.exitCode = 1;
         return null;
     }
@@ -137,8 +137,50 @@ async function browseFeedback(options = {}) {
         process.exitCode = 1;
         return;
     }
+    const sinceHours = options.sinceHours !== undefined
+        ? parsePositiveInteger(options.sinceHours, '--since-hours', 'feedback browse')
+        : null;
+    if (options.sinceHours !== undefined && sinceHours === null) {
+        return;
+    }
     await (0, commandContext_1.withEnvironment)('feedback browse', 'Browsing feedback', async ({ client }) => {
         try {
+            if (options.admin) {
+                const cutoff = sinceHours === null ? null : Date.now() - sinceHours * 60 * 60 * 1000;
+                const items = [];
+                let nextOffset = offset ?? 0;
+                let hasMore = true;
+                while (hasMore && (limit === null || items.length < limit)) {
+                    const page = await client.fetchAdminFeedback({ limit: 100, offset: nextOffset });
+                    for (const item of page.feedback ?? []) {
+                        if (cutoff !== null && new Date(item.createdAt).getTime() < cutoff) {
+                            hasMore = false;
+                            break;
+                        }
+                        items.push(item);
+                        if (limit !== null && items.length >= limit) {
+                            break;
+                        }
+                    }
+                    nextOffset += page.feedback?.length ?? 0;
+                    hasMore = hasMore && Boolean(page.pagination?.hasMore) && (page.feedback?.length ?? 0) > 0;
+                }
+                if (options.json) {
+                    (0, output_1.printJson)({ items, sinceHours, count: items.length });
+                    return;
+                }
+                if (items.length === 0) {
+                    console.log('No feedback entries found.');
+                    return;
+                }
+                console.log('Feedback:\n');
+                for (const item of items) {
+                    console.log(`#${item.id} | ${item.category} | ${item.client} | ${(0, output_1.formatTimestamp)(item.createdAt)}`);
+                    console.log(`  ${item.title}`);
+                    console.log(`  ${item.comment}`);
+                }
+                return;
+            }
             const response = await client.listFeedback({
                 limit: limit ?? undefined,
                 offset: offset ?? undefined,

package/dist/commands/upload.d.ts

@@ -5,6 +5,7 @@ export type UploadCommandOptions = {
     env?: string;
     skipReview?: boolean;
     clearTags?: boolean;
+    json?: boolean;
 };
 export declare function resolveUploadOwner(actorUsername: string | null | undefined, workspaceOwnerUsername: string | null | undefined): string;
 export declare function resolveDefaultUploadCreator(owner: string | null | undefined, actorUsername: string | null | undefined): string;
@@ -35,6 +36,28 @@ export type WorkerAppPublishResult = {
     creatorUsername: string;
     warnings: string[];
 };
+export type StaticHtmlPublishInput = {
+    client: ApiClient;
+    projectDir: string;
+    creatorUsername: string;
+    primarySurface: 'DESKTOP' | 'MOBILE_LANDSCAPE' | 'MOBILE_PORTRAIT';
+    apiBase: string;
+    webBase?: string | null;
+    token: string;
+    user: UserResponse;
+    taskId?: number;
+    taskToken?: string;
+    claimedAppName?: string | null;
+    devRouterPort?: number;
+};
+export type StaticHtmlPublishResult = WorkerAppPublishResult & {
+    sourceHash: string;
+    runtimeHash: string;
+    playUrl: string;
+    sourceContainsInjectedSdk: false;
+    runtimeContainsInjectedSdk: true;
+    hostedLoadCheckPassed: true;
+};
 export type WorkerPlaydropAssetRequirement = 'PACK' | 'ASSET_OR_PACK';
 export declare function resolveWorkerPlaydropAssetRequirement(value: unknown): WorkerPlaydropAssetRequirement | null;
 export declare function assertAgentNewGamePlaytestContract(task: AppTask): void;
@@ -50,3 +73,4 @@ export declare function assertWorkerAppLocalUploadPreflight(input: {
     creatorRequest?: string | null;
 }): Promise<AgentTaskPlaytestProof | null>;
 export declare function publishWorkerAppProject(input: WorkerAppPublishInput): Promise<WorkerAppPublishResult>;
+export declare function publishStaticHtmlProject(input: StaticHtmlPublishInput): Promise<StaticHtmlPublishResult>;