@payloadcms/figma 0.1.0-alpha.2 → 0.1.0-alpha.4

package/dist/utils/build-lambda-zip.js

@@ -2,6 +2,8 @@ import archiver from 'archiver';
 import { createWriteStream } from 'fs';
 import fs from 'fs/promises';
 import path from 'path';
+import { inspectNextjsOutput } from './deploy-output/inspectNextjsOutput.js';
+import { resolveOutputPath } from './deploy-output/resolveOutputPath.js';
 import { getDirectorySize } from './fs-utils.js';
 /**
  * AWS Lambda's hard limit on unzipped deployment code size (250 MB). The unzipped
@@ -14,66 +16,43 @@ import { getDirectorySize } from './fs-utils.js';
  * Build Lambda deployment zip using pure Node.js
  *
  * Cross-platform replacement for build_for_lambda.sh:
- * 1. Copies .next/static to .next/standalone/.next/static
- * 2. Copies run.sh to .next/standalone/run.sh
- * 3. Creates lambda.zip from .next/standalone/
+ * 1. Adds a generated run.sh directly to the archive
+ * 2. Creates lambda.zip from the standalone output
  *
- * Note: public/ is NOT included in the zip — those files are uploaded
- * as static assets and served via CDN, not from the Lambda function.
+ * The output's static/ and the project's public/ directories are not copied into the zip. Those
+ * files are uploaded separately and served by Gatekeeper, not the Lambda function.
  *
  * @param projectPath - Path to project root
  * @returns The built bundle: its unzipped byte size and the absolute zip path.
  * @throws Error if standalone directory missing or zip creation fails
- */ export async function buildLambdaZip(projectPath) {
-    const standalonePath = path.join(projectPath, '.next', 'standalone');
-    const staticPath = path.join(projectPath, '.next', 'static');
-    const runShPath = path.join(projectPath, 'run.sh');
-    const zipPath = path.join(projectPath, 'lambda.zip');
-    if (!await isDirectory(standalonePath)) {
-        throw new Error('Standalone build not found at .next/standalone. ' + 'Ensure next.config has output: "standalone" and run build first.');
-    }
-    if (await isDirectory(staticPath)) {
-        const destStatic = path.join(standalonePath, '.next', 'static');
-        await copyDirectory(staticPath, destStatic);
-    }
-    try {
-        await fs.copyFile(runShPath, path.join(standalonePath, 'run.sh'));
-    } catch  {
-    // run.sh may not exist in all setups
+ */ export async function buildLambdaZip(projectPath, output) {
+    const outputPath = resolveOutputPath(projectPath, 'nextjs', output);
+    const layout = await inspectNextjsOutput(outputPath);
+    if (!layout) {
+        throw new Error(`Standalone build not found at ${outputPath}`);
     }
-    const unzippedBytes = await getDirectorySize(standalonePath);
-    await createZip(standalonePath, zipPath);
+    const serverEntry = path.relative(layout.standalonePath, layout.serverEntryPath).split(path.sep).join('/');
+    const runScript = createRunScript(serverEntry);
+    const zipPath = path.join(projectPath, 'lambda.zip');
+    const existingRunScriptBytes = await getFileSize(path.join(layout.standalonePath, 'run.sh'));
+    const unzippedBytes = await getDirectorySize(layout.standalonePath) - existingRunScriptBytes + Buffer.byteLength(runScript);
+    await createZip(layout.standalonePath, zipPath, runScript);
     return {
         unzippedBytes,
         zipPath
     };
 }
-async function isDirectory(dirPath) {
-    try {
-        const stats = await fs.stat(dirPath);
-        return stats.isDirectory();
-    } catch  {
-        return false;
-    }
+function createRunScript(serverEntry) {
+    const escapedEntry = serverEntry.replaceAll("'", "'\\''");
+    return `#!/bin/bash -x
+[ ! -d '/tmp/cache' ] && mkdir -p /tmp/cache
+NODE_ENV=production exec node '${escapedEntry}'
+`;
 }
-async function copyDirectory(src, dest) {
-    await fs.mkdir(dest, {
-        recursive: true
-    });
-    const entries = await fs.readdir(src, {
-        withFileTypes: true
-    });
-    for (const entry of entries){
-        const srcPath = path.join(src, entry.name);
-        const destPath = path.join(dest, entry.name);
-        if (entry.isDirectory()) {
-            await copyDirectory(srcPath, destPath);
-        } else {
-            await fs.copyFile(srcPath, destPath);
-        }
-    }
+async function getFileSize(filePath) {
+    return fs.stat(filePath).then((stat)=>stat.isFile() ? stat.size : 0).catch(()=>0);
 }
-function createZip(sourceDir, zipPath) {
+function createZip(sourceDir, zipPath, runScript) {
     return new Promise((resolve, reject)=>{
         const output = createWriteStream(zipPath);
         const archive = archiver('zip', {
@@ -84,7 +63,11 @@ function createZip(sourceDir, zipPath) {
         output.on('close', ()=>resolve());
         archive.on('error', (err)=>reject(err));
         archive.pipe(output);
-        archive.directory(sourceDir, false);
+        archive.directory(sourceDir, false, (entry)=>entry.name === 'run.sh' ? false : entry);
+        archive.append(runScript, {
+            name: 'run.sh',
+            mode: 0o755
+        });
         void archive.finalize();
     });
 }

package/dist/utils/deploy-adapter.d.ts

@@ -24,13 +24,13 @@ export interface LambdaBundle {
     zipPath: string;
 }
 export interface DeployAdapter {
-    collectAssets(projectPath: string): Promise<AssetCollection>;
-    collectPages(projectPath: string): Promise<PageCollection>;
+    collectAssets(projectPath: string, output?: string): Promise<AssetCollection>;
+    collectPages(projectPath: string, output?: string): Promise<PageCollection>;
     /** SPA fallback path (e.g., "/index.html"). Undefined for SSR/SSG apps. */
     fallback?: string;
     name: AdapterName;
     /** Assembles and zips the server bundle. Returns the bundle, or null if no server (e.g., Vite SPA). */
-    prepareLambdaBundle(projectPath: string): Promise<LambdaBundle | null>;
+    prepareLambdaBundle(projectPath: string, output?: string): Promise<LambdaBundle | null>;
 }
 /**
  * Auto-detect the framework adapter based on build output.
@@ -42,4 +42,4 @@ export interface DeployAdapter {
  * @param projectPath - Path to project root
  * @param override - Explicit adapter name from --adapter flag
  */
-export declare function detectAdapter(projectPath: string, override?: AdapterName): Promise<DeployAdapter>;
+export declare function detectAdapter(projectPath: string, override?: AdapterName, output?: string): Promise<DeployAdapter>;

package/dist/utils/deploy-adapter.js

@@ -1,5 +1,8 @@
 import fs from 'fs/promises';
 import path from 'path';
+import { inspectNextjsOutput } from './deploy-output/inspectNextjsOutput.js';
+import { inspectNitroOutput } from './deploy-output/inspectNitroOutput.js';
+import { resolveOutputPath } from './deploy-output/resolveOutputPath.js';
 /**
  * Auto-detect the framework adapter based on build output.
  *
@@ -9,23 +12,24 @@ import path from 'path';
  *
  * @param projectPath - Path to project root
  * @param override - Explicit adapter name from --adapter flag
- */ export async function detectAdapter(projectPath, override) {
+ */ export async function detectAdapter(projectPath, override, output) {
     if (override) {
         return loadAdapter(override);
     }
-    const hasNext = await exists(path.join(projectPath, '.next'));
-    const hasNitro = await exists(path.join(projectPath, '.output', 'nitro.json'));
-    const hasViteDist = await exists(path.join(projectPath, 'dist', 'index.html'));
-    if (hasNext) {
+    const nextOutput = resolveOutputPath(projectPath, 'nextjs', output);
+    if (await inspectNextjsOutput(nextOutput)) {
         return loadAdapter('nextjs');
     }
-    if (hasNitro) {
+    const nitroOutput = resolveOutputPath(projectPath, 'nitro', output);
+    if (await inspectNitroOutput(nitroOutput)) {
         return loadAdapter('nitro');
     }
-    if (hasViteDist) {
+    const viteOutput = resolveOutputPath(projectPath, 'vite', output);
+    if (await exists(path.join(viteOutput, 'index.html'))) {
         return loadAdapter('vite');
     }
-    throw new Error('Could not detect framework. Expected .next/ (NextJS), .output/nitro.json (Nitro), or dist/index.html (Vite). ' + 'Use --adapter to specify explicitly.');
+    const location = output ? ` in ${path.resolve(projectPath, output)}` : '';
+    throw new Error(`Could not detect framework${location}. Expected Next.js BUILD_ID + standalone server, ` + 'Nitro server entry, or Vite index.html. ' + 'Use --adapter to specify explicitly.');
 }
 async function loadAdapter(name) {
     switch(name){

package/dist/utils/deploy-output/inspectNextjsOutput/getNextRelativeAppDir.d.ts

@@ -0,0 +1 @@
+export declare function getNextRelativeAppDir(manifest: null | Record<string, unknown>): null | string;

package/dist/utils/deploy-output/inspectNextjsOutput/getNextRelativeAppDir.js

@@ -0,0 +1,15 @@
+import path from 'path';
+export function getNextRelativeAppDir(manifest) {
+    if (typeof manifest?.relativeAppDir === 'string') {
+        return manifest.relativeAppDir;
+    }
+    if (typeof manifest?.appDir !== 'string') {
+        return null;
+    }
+    const config = manifest.config;
+    if (config === null || typeof config !== 'object' || Array.isArray(config)) {
+        return null;
+    }
+    const tracingRoot = config.outputFileTracingRoot;
+    return typeof tracingRoot === 'string' ? path.relative(tracingRoot, manifest.appDir) : null;
+}

package/dist/utils/deploy-output/inspectNextjsOutput.d.ts

@@ -0,0 +1,12 @@
+interface NextjsOutputLayout {
+    buildId: string;
+    outputPath: string;
+    serverEntryPath: string;
+    standalonePath: string;
+}
+/**
+ * Inspects a resolved Next.js output directory, typically `<project>/.next`.
+ * Returns its build ID and standalone paths, or null when required files are missing.
+ */
+export declare function inspectNextjsOutput(outputPath: string): Promise<NextjsOutputLayout | null>;
+export {};

package/dist/utils/deploy-output/inspectNextjsOutput.js

@@ -0,0 +1,28 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { getNextRelativeAppDir } from './inspectNextjsOutput/getNextRelativeAppDir.js';
+import { isFile } from './isFile.js';
+import { readJson } from './readJson.js';
+import { resolveWithin } from './resolveWithin.js';
+/**
+ * Inspects a resolved Next.js output directory, typically `<project>/.next`.
+ * Returns its build ID and standalone paths, or null when required files are missing.
+ */ export async function inspectNextjsOutput(outputPath) {
+    const buildId = await fs.readFile(path.join(outputPath, 'BUILD_ID'), 'utf8').then((value)=>value.trim()).catch(()=>null);
+    if (!buildId) {
+        return null;
+    }
+    const standalonePath = path.join(outputPath, 'standalone');
+    const manifest = await readJson(path.join(outputPath, 'required-server-files.json'));
+    const relativeAppDir = getNextRelativeAppDir(manifest);
+    const serverEntryPath = relativeAppDir === null ? path.join(standalonePath, 'server.js') : resolveWithin(standalonePath, path.join(relativeAppDir, 'server.js'), 'relativeAppDir');
+    if (!await isFile(serverEntryPath)) {
+        return null;
+    }
+    return {
+        buildId,
+        outputPath,
+        serverEntryPath,
+        standalonePath
+    };
+}

package/dist/utils/deploy-output/inspectNitroOutput.d.ts

@@ -0,0 +1,9 @@
+import { resolveNitroOutputLayout } from './resolveNitroOutputLayout.js';
+type NitroOutputLayout = Awaited<ReturnType<typeof resolveNitroOutputLayout>>;
+/**
+ * Inspects a resolved Nitro output directory, typically `<project>/.output`.
+ * Returns its server and public paths, or null when the server entry is missing. The build ID is
+ * Nitro's manifest date when available; legacy outputs without a manifest omit it.
+ */
+export declare function inspectNitroOutput(outputPath: string): Promise<NitroOutputLayout | null>;
+export {};

package/dist/utils/deploy-output/inspectNitroOutput.js

@@ -0,0 +1,13 @@
+import { isFile } from './isFile.js';
+import { resolveNitroOutputLayout } from './resolveNitroOutputLayout.js';
+/**
+ * Inspects a resolved Nitro output directory, typically `<project>/.output`.
+ * Returns its server and public paths, or null when the server entry is missing. The build ID is
+ * Nitro's manifest date when available; legacy outputs without a manifest omit it.
+ */ export async function inspectNitroOutput(outputPath) {
+    const layout = await resolveNitroOutputLayout(outputPath);
+    if (!await isFile(layout.serverEntryPath)) {
+        return null;
+    }
+    return layout;
+}

package/dist/utils/deploy-output/isFile.d.ts

@@ -0,0 +1 @@
+export declare function isFile(filePath: string): Promise<boolean>;

package/dist/utils/deploy-output/isFile.js

@@ -0,0 +1,4 @@
+import fs from 'fs/promises';
+export async function isFile(filePath) {
+    return fs.stat(filePath).then((stat)=>stat.isFile()).catch(()=>false);
+}

package/dist/utils/deploy-output/readJson.d.ts

@@ -0,0 +1 @@
+export declare function readJson(filePath: string): Promise<null | Record<string, unknown>>;

package/dist/utils/deploy-output/readJson.js

@@ -0,0 +1,9 @@
+import fs from 'fs/promises';
+export async function readJson(filePath) {
+    try {
+        const value = JSON.parse(await fs.readFile(filePath, 'utf8'));
+        return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
+    } catch  {
+        return null;
+    }
+}

package/dist/utils/deploy-output/resolveNitroOutputLayout.d.ts

@@ -0,0 +1,8 @@
+interface NitroOutputLayout {
+    buildId?: string;
+    outputPath: string;
+    publicPath: string;
+    serverEntryPath: string;
+}
+export declare function resolveNitroOutputLayout(outputPath: string): Promise<NitroOutputLayout>;
+export {};

package/dist/utils/deploy-output/resolveNitroOutputLayout.js

@@ -0,0 +1,16 @@
+import path from 'path';
+import { readJson } from './readJson.js';
+import { resolveWithin } from './resolveWithin.js';
+const DEFAULT_PUBLIC_DIR = 'public';
+const DEFAULT_SERVER_ENTRY = 'server/index.mjs';
+export async function resolveNitroOutputLayout(outputPath) {
+    const manifest = await readJson(path.join(outputPath, 'nitro.json'));
+    const serverEntry = typeof manifest?.serverEntry === 'string' ? manifest.serverEntry : DEFAULT_SERVER_ENTRY;
+    const publicDir = typeof manifest?.publicDir === 'string' ? manifest.publicDir : DEFAULT_PUBLIC_DIR;
+    return {
+        buildId: typeof manifest?.date === 'string' ? manifest.date : undefined,
+        outputPath,
+        publicPath: resolveWithin(outputPath, publicDir, 'publicDir'),
+        serverEntryPath: resolveWithin(outputPath, serverEntry, 'serverEntry')
+    };
+}

package/dist/utils/deploy-output/resolveOutputPath.d.ts

@@ -0,0 +1,2 @@
+import type { AdapterName } from '../deploy-adapter.js';
+export declare function resolveOutputPath(projectPath: string, adapter: AdapterName, output?: string): string;

package/dist/utils/deploy-output/resolveOutputPath.js

@@ -0,0 +1,9 @@
+import path from 'path';
+const DEFAULT_OUTPUT_DIRS = {
+    nextjs: '.next',
+    nitro: '.output',
+    vite: 'dist'
+};
+export function resolveOutputPath(projectPath, adapter, output) {
+    return output ? path.resolve(projectPath, output) : path.join(projectPath, DEFAULT_OUTPUT_DIRS[adapter]);
+}

package/dist/utils/deploy-output/resolveWithin.d.ts

@@ -0,0 +1 @@
+export declare function resolveWithin(outputPath: string, relativePath: string, field: string): string;

package/dist/utils/deploy-output/resolveWithin.js

@@ -0,0 +1,12 @@
+import path from 'path';
+export function resolveWithin(outputPath, relativePath, field) {
+    if (path.isAbsolute(relativePath)) {
+        throw new Error(`${field} must be relative to output root`);
+    }
+    const resolved = path.resolve(outputPath, relativePath);
+    const relative = path.relative(outputPath, resolved);
+    if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw new Error(`${field} escapes output root`);
+    }
+    return resolved;
+}

package/dist/utils/lambda-config.js

@@ -1,6 +1,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { IndentationText, Node, Project, SyntaxKind } from 'ts-morph';
+import { ensurePnpmWorkspace } from './pnpm-builds.js';
 const RUN_SH_CONTENT = `#!/bin/bash -x
 
 [ ! -d '/tmp/cache' ] && mkdir -p /tmp/cache
@@ -19,21 +20,10 @@ NODE_ENV=production exec node server.js
     await fs.chmod(runShPath, 0o755);
     // 2. Modify next config to add standalone output
     await addNextConfigProperties(projectPath);
-    // 3. Create/update .npmrc
-    const npmrcPath = path.join(projectPath, '.npmrc');
-    let npmrcContent = '';
-    try {
-        npmrcContent = await fs.readFile(npmrcPath, 'utf-8');
-    } catch  {
-    // File doesn't exist, start fresh
-    }
-    if (!npmrcContent.includes('node-linker=hoisted')) {
-        npmrcContent += npmrcContent && !npmrcContent.endsWith('\n') ? '\n' : '';
-        npmrcContent += 'node-linker=hoisted\n';
-        await fs.writeFile(npmrcPath, npmrcContent, 'utf-8');
-    }
-    // 4. Add lambda:buildzip script to package.json
+    // 3. Add lambda:buildzip script to package.json
     await addLambdaBuildScript(projectPath, packageManager);
+    // 4. Write pnpm-workspace.yaml (hoisted linker + build approvals)
+    await ensurePnpmWorkspace(projectPath);
 }
 /**
  * Find the Next.js config file, checking TS extensions first

package/dist/utils/messages.js

@@ -14,6 +14,7 @@ export function helpMessage() {
       ${pc.cyan('logout')}           Clear all stored tokens
       ${pc.cyan('list-tokens')}      Show stored token information
       ${pc.cyan('init')}             Initialize a Figma CMS project
+      ${pc.cyan('setup-agent')}      Install or update the Figma deploy skill
       ${pc.cyan('bootstrap')}        Print bootstrap info (tenant IDs, OAuth creds) for a project
       ${pc.cyan('debug')}            Show debug info for troubleshooting
       ${pc.cyan('env')}              Switch active environment
@@ -31,16 +32,20 @@ export function helpMessage() {
   ${pc.bold('AUTHENTICATION')}
 
       ${pc.cyan('@payloadcms/figma login')}                Authenticate with Figma
+      ${pc.cyan('@payloadcms/figma login --headless --json')} Start resumable login for agents
+      ${pc.cyan('@payloadcms/figma login --complete <id> --callback-url <url>')} Complete resumable login
+      ${pc.dim('--json')}                                  Emit machine-readable login status
       ${pc.cyan('@payloadcms/figma logout')}               Clear tokens for current environment
       ${pc.cyan('@payloadcms/figma list-tokens')}          Display stored OAuth and project tokens
 
   ${pc.bold('INIT COMMAND')}
 
-      ${pc.cyan('@payloadcms/figma init --id <cms-resource-id>')}     Initialize project
+      ${pc.cyan('@payloadcms/figma init')}                            Create and initialize project
+      ${pc.cyan('@payloadcms/figma init --id <cms-resource-id>')}     Connect existing project
       ${pc.cyan('@payloadcms/figma init --id <id> --env staging')}    Initialize for specific environment
       ${pc.dim('--name, -n <name>')}                     Set project directory name (skips prompt)
       ${pc.dim('--force')}                               Force reconfiguration of existing project
-      ${pc.dim('--no-skill')}                            Skip installing the Payload skill into .claude/skills/payload/
+      ${pc.dim('--no-agent')}                            Skip writing AI agent config files (AGENTS.md, CLAUDE.md)
       ${pc.dim('--template, -t <spec>')}                  Override scaffold template (e.g. main:website, owner/repo#ref:path)
       ${pc.dim('--payload-version <tag|version>')}        Core Payload npm dist-tag or version (default canary; e.g. latest, 4.0.0-canary.16)
 
@@ -58,11 +63,27 @@ export function helpMessage() {
   ${pc.bold('DEPLOY COMMAND')}
 
       ${pc.cyan('@payloadcms/figma deploy')}             Deploy your project to Figma
+      ${pc.dim('                                            Creates a project when not initialized')}
       ${pc.dim('--id <project-id>')}                     Override FIGMA_PROJECT_ID
       ${pc.dim('--env <environment>')}                   Override FIGMA_ENVIRONMENT_NAME
-      ${pc.dim('--yes, -y')}                             Skip confirmation prompts
+      ${pc.dim('--yes, -y')}                             Skip prompts; use safe defaults for project creation
+      ${pc.dim('--name <name>')}                         New project name (default: package/directory name)
+      ${pc.dim('--description <description>')}           New project description (default: <name> project)
+      ${pc.dim('--subdomain <subdomain>')}               New project subdomain (default: generated from name)
+      ${pc.dim('--workspace <plan-key>')}                Workspace plan key (default workspace if omitted)
+      ${pc.dim('--region <region>')}                     New project region (default: us-east-1 non-interactively)
       ${pc.dim('--skip-build')}                          Skip building and use existing build
       ${pc.dim('--skip-size-check')}                     Skip the client-side bundle size check
+      ${pc.dim('--adapter <nextjs|nitro|vite>')}          Override framework detection
+      ${pc.dim('--output <path>')}                        Exact framework build output root
+
+  ${pc.bold('SETUP AGENT COMMAND')}
+
+      ${pc.cyan('@payloadcms/figma setup-agent')}                    Prompt for global or project installation
+      ${pc.cyan('@payloadcms/figma setup-agent --global')}           Install/update globally
+      ${pc.cyan('@payloadcms/figma setup-agent --project')}          Install/update in the current project
+      ${pc.dim('--yes, -y')}                             Skip skills installer prompts
+      ${pc.dim('Non-interactive use requires --global or --project.')}
 
   ${pc.bold('UPGRADE COMMAND')}
 

package/dist/utils/payload-generate.d.ts

@@ -0,0 +1,10 @@
+export type PayloadGenerateResult = {
+    error: string;
+    ok: false;
+} | {
+    ok: true;
+};
+/** Never throws. */
+export declare function generateImportMap(projectPath: string): Promise<PayloadGenerateResult>;
+/** Never throws. */
+export declare function generateTypes(projectPath: string): Promise<PayloadGenerateResult>;

package/dist/utils/payload-generate.js

@@ -0,0 +1,59 @@
+import spawn from 'cross-spawn';
+import path from 'path';
+// buildFigmaConfig throws without a resolvable environmentId/contentSystemId,
+// which an unauthenticated init lacks. It reads these env vars before the
+// bootstrap cache, so injecting them avoids the throw. Always inject the
+// placeholder (not the real env) for deterministic behavior; the generated
+// artifacts are ID-independent, so the value never affects output.
+const GENERATE_PLACEHOLDER = 'figma-generate-placeholder';
+/** Runs `payload <subcommand>` via the project's local binary. Never throws. */ function runPayloadGenerate(projectPath, subcommand) {
+    const bin = path.join(projectPath, 'node_modules', '.bin', 'payload');
+    return new Promise((resolve)=>{
+        const child = spawn(bin, [
+            subcommand
+        ], {
+            cwd: projectPath,
+            env: {
+                ...process.env,
+                FIGMA_CONTENT_API_CONTENT_SYSTEM_ID: GENERATE_PLACEHOLDER,
+                FIGMA_EID: GENERATE_PLACEHOLDER
+            },
+            stdio: 'pipe'
+        });
+        // Drain both pipes. An unread stdout buffer fills and blocks the child,
+        // hanging init; stdout also carries diagnostics on some failures.
+        let stderr = '';
+        let stdout = '';
+        child.stderr?.on('data', (data)=>{
+            stderr += data.toString();
+        });
+        child.stdout?.on('data', (data)=>{
+            stdout += data.toString();
+        });
+        child.on('close', (code)=>{
+            if (code === 0) {
+                resolve({
+                    ok: true
+                });
+            } else {
+                const output = stderr.trim() || stdout.trim();
+                resolve({
+                    error: output || `payload ${subcommand} exited with code ${code}`,
+                    ok: false
+                });
+            }
+        });
+        child.on('error', (error)=>{
+            resolve({
+                error: error.message,
+                ok: false
+            });
+        });
+    });
+}
+/** Never throws. */ export function generateImportMap(projectPath) {
+    return runPayloadGenerate(projectPath, 'generate:importmap');
+}
+/** Never throws. */ export function generateTypes(projectPath) {
+    return runPayloadGenerate(projectPath, 'generate:types');
+}

package/dist/utils/pnpm-builds.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Write init's pnpm-workspace.yaml: hoisted node linker (the Lambda runtime needs a
+ * flat node_modules) plus build approvals, migrating off the now-ignored package.json
+ * `pnpm.onlyBuiltDependencies`. Written for every project so an npx/npm scaffold still
+ * installs cleanly when the user later switches to pnpm.
+ */
+export declare function ensurePnpmWorkspace(projectPath: string): Promise<void>;
+/**
+ * Set each build `true` under `allowBuilds` and drop it from any `ignoredBuiltDependencies`
+ * denylist. Pure and idempotent. pnpm v11 reads approvals only from pnpm-workspace.yaml.
+ */
+export declare function upsertBuildApprovals(content: string, builds: string[]): string;
+/** Set a top-level `key: value` scalar, replacing any existing one. Pure and idempotent. */
+export declare function upsertTopLevelScalar(content: string, key: string, value: string): string;