@payloadcms/figma 0.0.1-alpha.6 → 0.0.1-alpha.61

package/dist/utils/build-detection.js

@@ -1,23 +1,34 @@
 import fs from 'fs/promises';
 import path from 'path';
 /**
- * Detect if a valid Lambda-ready build exists
- *
- * Checks for:
- * - .next/standalone/server.js (required for Lambda)
- * - .next/BUILD_ID (Next.js build identifier)
- *
- * @param projectPath - Path to project root
- * @returns Build info if valid build found, null otherwise
+ * Detect a valid build across supported frameworks.
+ * Tries NextJS, then Nitro, then Vite. Returns the first match.
  */ export async function detectBuild(projectPath) {
+    // Try NextJS first
+    const nextjsBuild = await detectNextjsBuild(projectPath);
+    if (nextjsBuild) {
+        return nextjsBuild;
+    }
+    // Try Nitro
+    const nitroBuild = await detectNitroBuild(projectPath);
+    if (nitroBuild) {
+        return nitroBuild;
+    }
+    // Try Vite
+    const viteBuild = await detectViteBuild(projectPath);
+    if (viteBuild) {
+        return viteBuild;
+    }
+    return null;
+}
+/**
+ * Detect NextJS standalone build (.next/standalone/server.js + .next/BUILD_ID)
+ */ async function detectNextjsBuild(projectPath) {
     try {
-        // Check for .next/standalone/server.js
         const serverPath = path.join(projectPath, '.next', 'standalone', 'server.js');
         const serverStat = await fs.stat(serverPath);
-        // Check for .next/BUILD_ID
         const buildIdPath = path.join(projectPath, '.next', 'BUILD_ID');
         const buildId = (await fs.readFile(buildIdPath, 'utf-8')).trim();
-        // Check for lambda.zip
         const lambdaZipPath = path.join(projectPath, 'lambda.zip');
         let hasLambdaZip = false;
         try {
@@ -36,6 +47,58 @@ import path from 'path';
         return null;
     }
 }
+/**
+ * Detect Nitro build (.output/server/index.mjs)
+ * Build ID parsed from .output/nitro.json date field, or mtime of index.mjs
+ */ async function detectNitroBuild(projectPath) {
+    try {
+        const indexPath = path.join(projectPath, '.output', 'server', 'index.mjs');
+        const indexStat = await fs.stat(indexPath);
+        let buildId = indexStat.mtime.toISOString();
+        try {
+            const nitroJsonPath = path.join(projectPath, '.output', 'nitro.json');
+            const nitroJson = JSON.parse(await fs.readFile(nitroJsonPath, 'utf-8'));
+            if (nitroJson.date) {
+                buildId = nitroJson.date;
+            }
+        } catch  {
+        // nitro.json missing or unparseable — fall back to mtime
+        }
+        const lambdaZipPath = path.join(projectPath, 'lambda.zip');
+        let hasLambdaZip = false;
+        try {
+            await fs.stat(lambdaZipPath);
+            hasLambdaZip = true;
+        } catch  {
+            hasLambdaZip = false;
+        }
+        return {
+            buildId,
+            hasLambdaZip,
+            path: '.output',
+            timestamp: indexStat.mtime
+        };
+    } catch  {
+        return null;
+    }
+}
+/**
+ * Detect Vite build (dist/index.html)
+ * Build ID is mtime of index.html as ISO string. No server, so hasLambdaZip is always false.
+ */ async function detectViteBuild(projectPath) {
+    try {
+        const indexPath = path.join(projectPath, 'dist', 'index.html');
+        const indexStat = await fs.stat(indexPath);
+        return {
+            buildId: indexStat.mtime.toISOString(),
+            hasLambdaZip: false,
+            path: 'dist',
+            timestamp: indexStat.mtime
+        };
+    } catch  {
+        return null;
+    }
+}
 /**
  * Get the build command from package.json
  *

package/dist/utils/build-lambda-zip.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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. Copies public/ to .next/standalone/public/ (if exists)
+ * 4. Creates lambda.zip from .next/standalone/
+ *
+ * @param projectPath - Path to project root
+ * @throws Error if standalone directory missing or zip creation fails
+ */
+export declare function buildLambdaZip(projectPath: string): Promise<void>;
+//# sourceMappingURL=build-lambda-zip.d.ts.map

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

@@ -0,0 +1,81 @@
+import archiver from 'archiver';
+import { createWriteStream } from 'fs';
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * 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. Copies public/ to .next/standalone/public/ (if exists)
+ * 4. Creates lambda.zip from .next/standalone/
+ *
+ * @param projectPath - Path to project root
+ * @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 publicPath = path.join(projectPath, 'public');
+    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
+    }
+    if (await isDirectory(publicPath)) {
+        const destPublic = path.join(standalonePath, 'public');
+        await copyDirectory(publicPath, destPublic);
+    }
+    await createZip(standalonePath, zipPath);
+}
+async function isDirectory(dirPath) {
+    try {
+        const stats = await fs.stat(dirPath);
+        return stats.isDirectory();
+    } catch  {
+        return false;
+    }
+}
+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);
+        }
+    }
+}
+function createZip(sourceDir, zipPath) {
+    return new Promise((resolve, reject)=>{
+        const output = createWriteStream(zipPath);
+        const archive = archiver('zip', {
+            zlib: {
+                level: 9
+            }
+        });
+        output.on('close', ()=>resolve());
+        archive.on('error', (err)=>reject(err));
+        archive.pipe(output);
+        archive.directory(sourceDir, false);
+        void archive.finalize();
+    });
+}
+
+//# sourceMappingURL=build-lambda-zip.js.map

package/dist/utils/cache-bootstrap.d.ts

@@ -0,0 +1,8 @@
+import type { BootstrapInfo } from '../api/control-plane.js';
+import type { TokenStore } from '../auth/token-store.js';
+/**
+ * Cache bootstrap data for all environments in the local encrypted store.
+ * Called from init, env, and build-config to keep the store populated.
+ */
+export declare function cacheAllEnvironments(tokenStore: TokenStore, projectId: string, bootstrapInfo: BootstrapInfo): void;
+//# sourceMappingURL=cache-bootstrap.d.ts.map

package/dist/utils/cache-bootstrap.js

@@ -0,0 +1,18 @@
+import * as log from './log.js';
+/**
+ * Cache bootstrap data for all environments in the local encrypted store.
+ * Called from init, env, and build-config to keep the store populated.
+ */ export function cacheAllEnvironments(tokenStore, projectId, bootstrapInfo) {
+    const { oauthCredentials } = bootstrapInfo;
+    for (const env of bootstrapInfo.environments){
+        tokenStore.setBootstrapData(projectId, env.name, {
+            contentSystemId: env.contentSystemId,
+            oauthClientId: oauthCredentials.oauthClientId,
+            oauthClientSecret: oauthCredentials.oauthClientSecret,
+            tenantInstanceId: env.tenantInstanceId
+        });
+    }
+    log.debug(`Cached bootstrap data for environments: ${bootstrapInfo.environments.map((e)=>e.name).join(', ')}`);
+}
+
+//# sourceMappingURL=cache-bootstrap.js.map

package/dist/utils/config.js

@@ -19,7 +19,7 @@ const GITIGNORE_FILENAME = '.gitignore';
         }
     }
     // Parse existing entries
-    const existingLines = existingContent.split('\n').filter((line)=>line.trim());
+    const existingLines = existingContent.split(/\r?\n/).filter((line)=>line.trim());
     const existingSet = new Set(existingLines);
     // Add new entries that don't exist
     const newEntries = entries.filter((entry)=>!existingSet.has(entry));

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

@@ -0,0 +1,40 @@
+export interface PageCollection {
+    /** S3 key → relative filesystem path from project root */
+    pathMap: Record<string, string>;
+    /** Route → S3 upload keys for that route (e.g., { "/products": ["products.html", "products.rsc"] }) */
+    routeAssetMap: Record<string, string[]>;
+    /** Route paths for the manifest pages array (e.g., ["/products", "/blog"]) */
+    routes: string[];
+    /** S3 keys to upload (e.g., ["products.html", "products.rsc", "products.meta"]) */
+    uploadKeys: string[];
+}
+export interface AssetCollection {
+    /** S3 key → relative filesystem path from project root */
+    pathMap: Record<string, string>;
+    /** Route paths for the manifest assets array (e.g., ["/favicon.ico"]) */
+    routes: string[];
+    /** S3 keys to upload (same as routes for assets, without leading slash) */
+    uploadKeys: string[];
+}
+export type AdapterName = 'nextjs' | 'nitro' | 'vite';
+export interface DeployAdapter {
+    collectAssets(projectPath: string): Promise<AssetCollection>;
+    collectPages(projectPath: 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 path to zip, or null if no server (e.g., Vite SPA). */
+    prepareLambdaBundle(projectPath: string): Promise<null | string>;
+}
+/**
+ * Auto-detect the framework adapter based on build output.
+ *
+ * - .next/ exists → nextjs
+ * - .output/nitro.json exists → nitro
+ * - dist/index.html exists (no .next/, no .output/) → vite
+ *
+ * @param projectPath - Path to project root
+ * @param override - Explicit adapter name from --adapter flag
+ */
+export declare function detectAdapter(projectPath: string, override?: AdapterName): Promise<DeployAdapter>;
+//# sourceMappingURL=deploy-adapter.d.ts.map

package/dist/utils/deploy-adapter.js

@@ -0,0 +1,58 @@
+import fs from 'fs/promises';
+import path from 'path';
+/**
+ * Auto-detect the framework adapter based on build output.
+ *
+ * - .next/ exists → nextjs
+ * - .output/nitro.json exists → nitro
+ * - dist/index.html exists (no .next/, no .output/) → vite
+ *
+ * @param projectPath - Path to project root
+ * @param override - Explicit adapter name from --adapter flag
+ */ export async function detectAdapter(projectPath, override) {
+    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) {
+        return loadAdapter('nextjs');
+    }
+    if (hasNitro) {
+        return loadAdapter('nitro');
+    }
+    if (hasViteDist) {
+        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.');
+}
+async function loadAdapter(name) {
+    switch(name){
+        case 'nextjs':
+            {
+                const mod = await import('./adapters/nextjs.js');
+                return mod.nextjsAdapter;
+            }
+        case 'nitro':
+            {
+                const mod = await import('./adapters/nitro.js');
+                return mod.nitroAdapter;
+            }
+        case 'vite':
+            {
+                const mod = await import('./adapters/vite.js');
+                return mod.viteAdapter;
+            }
+    }
+}
+async function exists(filePath) {
+    try {
+        await fs.stat(filePath);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+
+//# sourceMappingURL=deploy-adapter.js.map

package/dist/utils/download-template.js

@@ -11,7 +11,8 @@ import { x } from 'tar';
         this.name = 'TemplateDownloadError';
     }
 }
-const BRANCH_OR_TAG = 'main';
+const BRANCH_OR_TAG = 'v3.79.1';
+/** GitHub strips the 'v' prefix in tarball directory names */ const TARBALL_PREFIX = `payload-${BRANCH_OR_TAG.replace(/^v/, '')}`;
 const TEMPLATE_NAME = 'blank';
 const MAX_RETRIES = 3;
 const INITIAL_RETRY_DELAY = 1000 // 1 second
@@ -43,7 +44,7 @@ const INITIAL_RETRY_DELAY = 1000 // 1 second
  * Single attempt to download template (extracted for retry logic)
  */ async function downloadTemplateAttempt(projectDir) {
     const url = `https://codeload.github.com/payloadcms/payload/tar.gz/${BRANCH_OR_TAG}`;
-    const filter = `payload-${BRANCH_OR_TAG}/templates/${TEMPLATE_NAME}/`;
+    const filter = `${TARBALL_PREFIX}/templates/${TEMPLATE_NAME}/`;
     try {
         // Ensure target directory exists
         await fs.mkdir(projectDir, {

package/dist/utils/env-management.d.ts

@@ -1,16 +1,33 @@
 /**
- * Generate a cryptographically secure secret for PAYLOAD_SECRET
+ * Get an environment variable value from .env file (async)
  *
- * @returns 24-character hexadecimal string
+ * @param projectPath - Path to project directory
+ * @param key - Environment variable name to retrieve
+ * @returns The value if found, null otherwise
+ */
+export declare function getEnvVar(projectPath: string, key: string): Promise<null | string>;
+/**
+ * Get an environment variable value from .env file (sync)
+ *
+ * @param projectPath - Path to project directory
+ * @param key - Environment variable name to retrieve
+ * @returns The value if found, null otherwise
  */
-export declare function generateSecret(): string;
+export declare function getEnvVarSync(projectPath: string, key: string): null | string;
 /**
- * Manage environment files for a new project
+ * Add or update an environment variable in .env file
  *
- * Creates .env from .env.example (if exists) and populates PAYLOAD_SECRET
+ * @param projectPath - Path to project directory
+ * @param key - Environment variable name
+ * @param value - Environment variable value
+ */
+export declare function addOrUpdateEnvVar(projectPath: string, key: string, value: string): Promise<void>;
+/**
+ * Remove an environment variable from .env file
  *
  * @param projectPath - Path to project directory
- * @returns The generated payload secret
+ * @param key - Environment variable name to remove
+ * @returns true if key was found and removed, false otherwise
  */
-export declare function manageEnvFiles(projectPath: string): Promise<string>;
+export declare function removeEnvVar(projectPath: string, key: string): Promise<boolean>;
 //# sourceMappingURL=env-management.d.ts.map

package/dist/utils/env-management.js

@@ -1,97 +1,152 @@
-import { randomBytes } from 'crypto';
 import fs from 'fs/promises';
+import fsSync from 'node:fs';
 import path from 'path';
 /**
- * Generate a cryptographically secure secret for PAYLOAD_SECRET
- *
- * @returns 24-character hexadecimal string
- */ export function generateSecret() {
-    return randomBytes(32).toString('hex').slice(0, 24);
-}
-/**
- * Sanitize and process environment file contents
- *
- * @param contents - Raw .env file contents
- * @param payloadSecret - Secret to use for PAYLOAD_SECRET
- * @returns Processed .env contents
- */ function sanitizeEnv(contents, payloadSecret) {
-    const lines = contents.split('\n');
-    const seenKeys = new Set();
-    const processedLines = [];
+ * Parse .env file contents and extract value for a key
+ */ function parseEnvValue(contents, key) {
+    const lines = contents.split(/\r?\n/);
     for (const line of lines){
         // Skip empty lines and comments
         if (!line.trim() || line.trim().startsWith('#')) {
-            processedLines.push(line);
             continue;
         }
         // Skip lines without =
         if (!line.includes('=')) {
-            processedLines.push(line);
             continue;
         }
-        const [key] = line.split('=');
-        const trimmedKey = key.trim();
-        // Skip duplicate keys
-        if (seenKeys.has(trimmedKey)) {
-            continue;
-        }
-        seenKeys.add(trimmedKey);
-        // Replace PAYLOAD_SECRET with actual value
-        if (trimmedKey === 'PAYLOAD_SECRET' || trimmedKey === 'PAYLOAD_SECRET_KEY') {
-            processedLines.push(`PAYLOAD_SECRET=${payloadSecret}`);
-        } else {
-            processedLines.push(line);
+        const equalsIndex = line.indexOf('=');
+        const lineKey = line.substring(0, equalsIndex).trim();
+        if (lineKey === key) {
+            return line.substring(equalsIndex + 1);
         }
     }
-    // Add PAYLOAD_SECRET if not present
-    if (!seenKeys.has('PAYLOAD_SECRET') && !seenKeys.has('PAYLOAD_SECRET_KEY')) {
-        processedLines.push(`PAYLOAD_SECRET=${payloadSecret}`);
+    return null;
+}
+/**
+ * Get an environment variable value from .env file (async)
+ *
+ * @param projectPath - Path to project directory
+ * @param key - Environment variable name to retrieve
+ * @returns The value if found, null otherwise
+ */ export async function getEnvVar(projectPath, key) {
+    const envPath = path.join(projectPath, '.env');
+    try {
+        const contents = await fs.readFile(envPath, 'utf-8');
+        return parseEnvValue(contents, key);
+    } catch  {
+        // File doesn't exist or can't be read
+        return null;
     }
-    return processedLines.join('\n');
 }
 /**
- * Manage environment files for a new project
+ * Get an environment variable value from .env file (sync)
  *
- * Creates .env from .env.example (if exists) and populates PAYLOAD_SECRET
+ * @param projectPath - Path to project directory
+ * @param key - Environment variable name to retrieve
+ * @returns The value if found, null otherwise
+ */ export function getEnvVarSync(projectPath, key) {
+    const envPath = path.join(projectPath, '.env');
+    try {
+        const contents = fsSync.readFileSync(envPath, 'utf-8');
+        return parseEnvValue(contents, key);
+    } catch  {
+        // File doesn't exist or can't be read
+        return null;
+    }
+}
+/**
+ * Add or update an environment variable in .env file
  *
  * @param projectPath - Path to project directory
- * @returns The generated payload secret
- */ export async function manageEnvFiles(projectPath) {
-    const payloadSecret = generateSecret();
-    const envExamplePath = path.join(projectPath, '.env.example');
+ * @param key - Environment variable name
+ * @param value - Environment variable value
+ */ export async function addOrUpdateEnvVar(projectPath, key, value) {
     const envPath = path.join(projectPath, '.env');
     try {
-        // Check if .env.example exists
-        let envExampleContents = '';
-        try {
-            envExampleContents = await fs.readFile(envExamplePath, 'utf-8');
-        } catch  {
-            // No .env.example, create minimal .env
-            envExampleContents = '';
-        }
-        // Check if .env already exists
+        let contents = '';
         let envExists = false;
+        // Try to read existing .env file
         try {
-            await fs.access(envPath);
+            contents = await fs.readFile(envPath, 'utf-8');
             envExists = true;
         } catch  {
-        // .env doesn't exist
+        // .env doesn't exist, will create it
         }
-        if (!envExists) {
-            // Create .env from .env.example
-            const sanitized = sanitizeEnv(envExampleContents, payloadSecret);
-            await fs.writeFile(envPath, sanitized, 'utf-8');
-        } else {
-            // Update existing .env if it doesn't have PAYLOAD_SECRET
-            const existingContents = await fs.readFile(envPath, 'utf-8');
-            if (!existingContents.includes('PAYLOAD_SECRET=') && !existingContents.includes('PAYLOAD_SECRET_KEY=')) {
-                const sanitized = sanitizeEnv(existingContents, payloadSecret);
-                await fs.writeFile(envPath, sanitized, 'utf-8');
+        const lines = contents.split(/\r?\n/);
+        const seenKeys = new Set();
+        const processedLines = [];
+        let keyUpdated = false;
+        for (const line of lines){
+            // Skip empty lines at start if file didn't exist
+            if (!envExists && !line.trim()) {
+                continue;
+            }
+            // Preserve empty lines and comments
+            if (!line.trim() || line.trim().startsWith('#')) {
+                processedLines.push(line);
+                continue;
+            }
+            // Skip lines without =
+            if (!line.includes('=')) {
+                processedLines.push(line);
+                continue;
+            }
+            const [lineKey] = line.split('=');
+            const trimmedKey = lineKey.trim();
+            // Skip duplicate keys (keep first occurrence)
+            if (seenKeys.has(trimmedKey)) {
+                continue;
+            }
+            seenKeys.add(trimmedKey);
+            // Update or keep the line
+            if (trimmedKey === key) {
+                processedLines.push(`${key}=${value}`);
+                keyUpdated = true;
+            } else {
+                processedLines.push(line);
             }
         }
-        return payloadSecret;
+        // Add key if not present
+        if (!keyUpdated) {
+            processedLines.push(`${key}=${value}`);
+        }
+        await fs.writeFile(envPath, processedLines.join('\n'), 'utf-8');
     } catch (error) {
-        throw new Error(`Failed to manage environment files: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        throw new Error(`Failed to update .env file: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Remove an environment variable from .env file
+ *
+ * @param projectPath - Path to project directory
+ * @param key - Environment variable name to remove
+ * @returns true if key was found and removed, false otherwise
+ */ export async function removeEnvVar(projectPath, key) {
+    const envPath = path.join(projectPath, '.env');
+    try {
+        const contents = await fs.readFile(envPath, 'utf-8');
+        const lines = contents.split(/\r?\n/);
+        const filteredLines = [];
+        let found = false;
+        for (const line of lines){
+            if (line.trim() && !line.trim().startsWith('#') && line.includes('=')) {
+                const equalsIndex = line.indexOf('=');
+                const lineKey = line.substring(0, equalsIndex).trim();
+                if (lineKey === key) {
+                    found = true;
+                    continue;
+                }
+            }
+            filteredLines.push(line);
+        }
+        if (found) {
+            // Collapse consecutive blank lines and trim leading/trailing blank lines
+            const collapsed = filteredLines.join('\n').replace(/\n{3,}/g, '\n\n').replace(/^\n+/, '');
+            await fs.writeFile(envPath, collapsed, 'utf-8');
+        }
+        return found;
+    } catch  {
+        return false;
     }
 }
 

package/dist/utils/format-env-suffix.d.ts

@@ -0,0 +1,12 @@
+import type { Environment } from '../constants.js';
+/**
+ * Format environment suffix for user-facing messages.
+ * Returns empty string for production (default), suffix for other environments.
+ *
+ * @param env - The environment
+ * @param prefix - Prefix before environment name (default: ' to ')
+ * @param suffix - Suffix after environment name (default: '')
+ * @returns Formatted string or empty string for production
+ */
+export declare function formatEnvSuffix(env: Environment, prefix?: string, suffix?: string): string;
+//# sourceMappingURL=format-env-suffix.d.ts.map

package/dist/utils/format-env-suffix.js

@@ -0,0 +1,13 @@
+/**
+ * Format environment suffix for user-facing messages.
+ * Returns empty string for production (default), suffix for other environments.
+ *
+ * @param env - The environment
+ * @param prefix - Prefix before environment name (default: ' to ')
+ * @param suffix - Suffix after environment name (default: '')
+ * @returns Formatted string or empty string for production
+ */ export function formatEnvSuffix(env, prefix = ' to ', suffix = '') {
+    return env !== 'production' ? `${prefix}${env}${suffix}` : '';
+}
+
+//# sourceMappingURL=format-env-suffix.js.map