@payloadcms/figma 0.0.1-alpha.57 → 0.0.1-alpha.59

package/dist/db-content-api/utilities/data/index.js

@@ -46,17 +46,32 @@ import { transformToLocalizeStatus } from './transformPublishedLocale.js';
         }
         const current = ref;
         let value = current[field.name];
-        // Transform existing values
+        // null → [] for non-localized array-like fields. SQL adapters return null for empty join
+        // tables; Content API stores JSON null which breaks jsonb_array_elements queries.
+        if (value === null && !('localized' in field && field.localized)) {
+            const isHasManyArray = (field.type === 'relationship' || field.type === 'upload') && 'hasMany' in field && field.hasMany;
+            const isArrayLike = field.type === 'array' || field.type === 'blocks';
+            const isHasManySelect = field.type === 'select' && 'hasMany' in field && field.hasMany;
+            if (isHasManyArray || isArrayLike || isHasManySelect) {
+                current[field.name] = [];
+                return;
+            }
+        }
         if (value !== null && value !== undefined) {
-            // Step 1: Apply type casting (e.g., number -> string for text fields)
             value = castFieldValue(field, value);
             current[field.name] = value;
-            // Step 2: Apply Content API specific transformations
+            // Normalize non-localized hasMany relationship/upload: single value → array.
+            // Payload may not wrap in array before calling db.update (e.g. children: 'uuid').
+            const isNonLocalizedHasMany = !('localized' in field && field.localized) && (field.type === 'relationship' || field.type === 'upload') && 'hasMany' in field && field.hasMany;
+            if (isNonLocalizedHasMany && !Array.isArray(value)) {
+                current[field.name] = [
+                    value
+                ];
+            }
             // RichText: object -> JSON string
             if (field.type === 'richText' && typeof value !== 'string') {
                 current[field.name] = JSON.stringify(value);
             }
-        // Date fields are already handled by JSON.stringify() which converts Date -> ISO string
         }
     };
     traverseFields({
@@ -124,7 +139,7 @@ import { transformToLocalizeStatus } from './transformPublishedLocale.js';
     ];
     return Object.fromEntries(Object.entries(versionMeta).filter(([key])=>!metaKeys.includes(key)));
 }
-export function dataFromContentAPI(payload, collectionSlug, data) {
+export function dataFromContentAPI(payload, collectionSlug, data, locale) {
     if (!data || typeof data !== 'object') {
         return data;
     }
@@ -137,6 +152,7 @@ export function dataFromContentAPI(payload, collectionSlug, data) {
     if (!collectionConfig?.fields) {
         return transformed;
     }
+    const isAllLocales = locale === 'all' || locale === '*';
     // Use Payload's traverseFields to iterate over all fields
     const callback = ({ field, parentPath, ref })=>{
         if (!('name' in field) || !field.name) {
@@ -147,41 +163,50 @@ export function dataFromContentAPI(payload, collectionSlug, data) {
         }
         const current = ref;
         const value = current[field.name];
-        // Normalize undefined → null for optional fields
-        // Content API may omit fields (undefined) but Payload expects null for optional fields
+        const isLocalized = 'localized' in field && field.localized;
+        // Content API may omit fields; Payload expects null for optional fields.
+        // In all-locales mode, localized fields use {} so afterRead can safely iterate locale keys.
         if (value === undefined) {
             const isRequired = 'required' in field && field.required;
             if (!isRequired) {
-                current[field.name] = null;
+                current[field.name] = isLocalized && isAllLocales ? {} : null;
             }
             return;
         }
+        // null localized field in all-locales mode → {} (empty locale map)
+        if (value === null && isLocalized && isAllLocales) {
+            current[field.name] = {};
+            return;
+        }
         if (value !== null) {
             // hasMany relationships: normalize to array (non-localized only).
-            // Unlike Drizzle (which reconstructs arrays from join tables), we store raw JSON,
-            // so a single-item input like `{ value, relationTo }` stays as-is. Payload expects arrays.
-            // Localized fields are skipped because their value is a locale map, not a relationship value.
+            // We store raw JSON so a single value stays as-is; Payload expects arrays.
             if (field.type === 'relationship' && field.hasMany && !Array.isArray(value) && !('localized' in field && field.localized)) {
                 current[field.name] = [
                     value
                 ];
             }
-            // Localized fields: JSON string -> parsed object
-            // Content API may store localized fields as JSON strings like "{\"en\":\"value\"}"
-            // so we need to parse them back to objects.
-            // Note: We return the full locale object - Payload Core handles flattening to requested locale.
-            // When requesting a specific locale (not 'all'), values are simple strings that won't parse.
-            // In that case, we silently keep the original value.
+            // Localized array/blocks: empty per-locale arrays → null in single-locale mode.
+            // Payload's afterRead fallback triggers on null (not []), matching SQL adapter behavior.
+            if (isLocalized && !isAllLocales && (field.type === 'array' || field.type === 'blocks') && typeof value === 'object' && !Array.isArray(value)) {
+                const localeMap = value;
+                for (const localeKey of Object.keys(localeMap)){
+                    const localeValue = localeMap[localeKey];
+                    if (Array.isArray(localeValue) && localeValue.length === 0) {
+                        localeMap[localeKey] = null;
+                    }
+                }
+            }
+            // Localized fields: JSON string → parsed object (locale map).
+            // Simple strings that fail to parse as objects are kept as-is (expected for single-locale).
             if ('localized' in field && field.localized && typeof value === 'string') {
                 try {
                     const parsed = JSON.parse(value);
-                    // Only use parsed value if it's actually an object (locale -> value mapping)
-                    // Simple strings like "EN Title" would parse to themselves, which we don't want
                     if (typeof parsed === 'object' && parsed !== null) {
                         current[field.name] = parsed;
                     }
                 } catch  {
-                // Not valid JSON - keep original value (this is expected for single-locale requests)
+                // Not valid JSON - keep original value
                 }
             } else if (field.type === 'richText' && typeof value === 'string') {
                 try {

package/dist/db-content-api/utilities/joins.js

@@ -76,6 +76,8 @@ import { convertPayloadWhereToContentAPI } from './where.js';
                 if (sanitizedJoin.joinPath === joinPath) {
                     foundJoin = {
                         collectionSlug,
+                        defaultLimit: sanitizedJoin.field.defaultLimit,
+                        defaultSort: sanitizedJoin.field.defaultSort,
                         on: sanitizedJoin.field.on
                     };
                     break;
@@ -93,6 +95,7 @@ import { convertPayloadWhereToContentAPI } from './where.js';
                     const collections = sanitizedJoin.field.collection;
                     foundJoin = {
                         collectionSlug: Array.isArray(collections) ? collections[0] : collections,
+                        defaultSort: sanitizedJoin.field.defaultSort,
                         on: sanitizedJoin.field.on
                     };
                     break;
@@ -104,19 +107,22 @@ import { convertPayloadWhereToContentAPI } from './where.js';
             continue;
         }
         // Convert pagination: Payload uses page, Content API JoinClause uses offset
+        const effectiveLimit = joinQuery.limit ?? foundJoin.defaultLimit;
         let offset;
-        if (joinQuery.page && joinQuery.page > 1 && joinQuery.limit) {
-            offset = (joinQuery.page - 1) * joinQuery.limit;
+        if (joinQuery.page && joinQuery.page > 1 && effectiveLimit) {
+            offset = (joinQuery.page - 1) * effectiveLimit;
         }
         // Add fallback sort for the joined collection
-        const sortWithFallback = addFallbackSort(joinQuery.sort, payload, foundJoin.collectionSlug);
+        const sortWithFallback = addFallbackSort(joinQuery.sort, payload, foundJoin.collectionSlug, foundJoin.defaultSort);
         const contentAPIJoin = {
             collectionId: foundJoin.collectionSlug,
             count: joinQuery.count ?? false,
             on: foundJoin.on,
             path: joinPath,
-            ...joinQuery.limit !== undefined && {
+            ...joinQuery.limit !== undefined ? {
                 limit: joinQuery.limit
+            } : foundJoin.defaultLimit !== undefined && {
+                limit: foundJoin.defaultLimit
             },
             ...offset !== undefined && {
                 offset

package/dist/db-content-api/utilities/meta/buildLocalizedPaths.js

@@ -27,13 +27,21 @@
 }
 /** Recursively traverses fields to find and collect localized paths */ function traverseFields(fields, localizedPaths, parentPath = '', parentIsLocalized = false) {
     for (const field of fields){
-        // Only field types that have names can support localization
-        // See: https://payloadcms.com/docs/configuration/localization
-        //
-        // This will skip presentational fields like ui, collapsible, row, tabs (if unnamed), groups (if unnamed)
-        // which do not store data in the database and thus are not relevant for querying localized paths
-        // See: https://payloadcms.com/docs/fields/overview#presentational-fields
+        // Unnamed layout fields (row, collapsible, unnamed group, unnamed tabs) don't store data
+        // at their own level, but their child fields may be localized. Recurse into them with
+        // the same parent path so localized fields bubble up correctly.
         if (!('name' in field)) {
+            if ('fields' in field && Array.isArray(field.fields)) {
+                traverseFields(field.fields, localizedPaths, parentPath, parentIsLocalized);
+            }
+            if ('tabs' in field && Array.isArray(field.tabs)) {
+                for (const tab of field.tabs){
+                    if (tab.fields) {
+                        const tabPath = tab.name ? buildPath(parentPath, tab.name) : parentPath;
+                        traverseFields(tab.fields, localizedPaths, tabPath, parentIsLocalized);
+                    }
+                }
+            }
             continue;
         }
         const fieldPath = buildPath(parentPath, field.name);

package/dist/db-content-api/utilities/meta/buildPathTypes.js

@@ -24,7 +24,7 @@
             continue;
         }
         // Add the path
-        paths.add(key);
+        paths.add(key.replace(/__/g, '.'));
         // Check if the value is a nested where clause (for relationships)
         const value = where[key];
         if (value && typeof value === 'object' && !('equals' in value) && !('in' in value)) {
@@ -74,6 +74,14 @@
             on
         };
     }
+    // Text field with hasMany (array of strings)
+    if (field.type === 'text' && 'hasMany' in field && field.hasMany) {
+        return 'array';
+    }
+    // Number field with hasMany (array of numbers)
+    if (field.type === 'number' && 'hasMany' in field && field.hasMany) {
+        return 'array';
+    }
     // Select field with hasMany (array)
     if (field.type === 'select' && 'hasMany' in field && field.hasMany) {
         return 'array';
@@ -102,7 +110,7 @@
             for (const field of currentFields){
                 if (!('name' in field) || !field.name) {
                     // This is an unnamed field, check its contents
-                    if ('fields' in field && field.type === 'collapsible' || 'fields' in field && field.type === 'row') {
+                    if ('fields' in field && field.type === 'collapsible' || 'fields' in field && field.type === 'row' || 'fields' in field && field.type === 'group') {
                         currentField = field.fields.find((f)=>'name' in f && f.name === segment);
                         if (currentField) {
                             break;
@@ -135,6 +143,15 @@
                 // For blocks, we can't determine the exact field without knowing the block type
                 // Return the blocks field itself
                 return currentField;
+            } else if ((currentField.type === 'relationship' || currentField.type === 'upload') && typeof currentField.relationTo === 'string') {
+                // Traverse into the related collection's fields
+                const { relationTo } = currentField;
+                const relatedConfig = payload.config.collections.find((c)=>c.slug === relationTo);
+                if (relatedConfig) {
+                    currentFields = relatedConfig.fields;
+                } else {
+                    return undefined;
+                }
             } else {
                 // Field doesn't have nested fields, can't continue
                 return undefined;

package/dist/db-content-api/utilities/where.js

@@ -8,63 +8,30 @@ export function convertPayloadWhereToContentAPI(where, options = {}) {
     }
     const conditions = [];
     for (const [key, value] of Object.entries(where)){
-        if (key === 'and') {
-            // Recursively convert nested 'and' conditions, preserving options
+        if (key === 'and' || key === 'or') {
             const nestedConditions = value.map((item)=>convertPayloadWhereToContentAPI(item, {
                     ...options,
                     insideLogicalOperator: true
-                }))// TODO: A better solution would be to make the `where` schema of `zod` in `content-api`
-            // more permissive. For now I'll do it this way because I have an idea to simplify
-            // everything we're doing with `where` (Post EAP) anyway.
-            // Filter out empty conditions { and: [] } that would be invalid
-            .filter((condition)=>{
+                })).filter((condition)=>{
                 if ('and' in condition) {
                     return condition.and.length > 0;
                 }
                 if ('or' in condition) {
                     return condition.or.length > 0;
                 }
-                return true // Keep path/operator/value conditions
-                ;
+                return true;
             });
-            // If filtering resulted in no conditions, return empty and
-            if (nestedConditions.length === 0) {
-                return {
-                    and: []
-                };
-            }
-            return {
-                and: nestedConditions
-            };
-        } else if (key === 'or') {
-            // Recursively convert nested 'or' conditions, preserving options
-            const nestedConditions = value.map((item)=>convertPayloadWhereToContentAPI(item, {
-                    ...options,
-                    insideLogicalOperator: true
-                }))// Filter out empty conditions { and: [] } or { or: [] } that would be invalid
-            .filter((condition)=>{
-                if ('and' in condition) {
-                    return condition.and.length > 0;
-                }
-                if ('or' in condition) {
-                    return condition.or.length > 0;
-                }
-                return true // Keep path/operator/value conditions
-                ;
-            });
-            // If filtering resulted in no conditions, return empty and
-            if (nestedConditions.length === 0) {
-                return {
-                    and: []
-                };
+            if (key === 'and') {
+                conditions.push(...nestedConditions);
+            } else if (nestedConditions.length > 0) {
+                conditions.push({
+                    or: nestedConditions
+                });
             }
-            return {
-                or: nestedConditions
-            };
         } else {
             // TODO: fix this in content api
             // WORKAROUND: Payload uses 'parent' for version queries, but Content API expects 'documentId'
-            let fieldPath = key;
+            let fieldPath = key.replace(/__/g, '.');
             if (options.parentToDocumentId && key === 'parent') {
                 fieldPath = 'documentId';
             }
@@ -120,8 +87,11 @@ export function convertPayloadWhereToContentAPI(where, options = {}) {
             }
         }
     }
-    // If inside a logical operator (and/or), return conditions directly
-    // Otherwise, wrap in 'and' to match WhereClause type
+    if (conditions.length === 0) {
+        return {
+            and: []
+        };
+    }
     if (options.insideLogicalOperator && conditions.length === 1) {
         return conditions[0];
     }

package/dist/oauth/endpoints/getLoginEndpoint.js

@@ -170,7 +170,11 @@ export const getLoginEndpoint = ({ collection, collectionOptions, endpointSlug,
                 // Fetch Figma user info for handle and profile image
                 let figmaUserInfo = null;
                 try {
-                    figmaUserInfo = await getUserInfo(access_token);
+                    const oauthCredential = {
+                        type: 'oauth',
+                        token: access_token
+                    };
+                    figmaUserInfo = await getUserInfo(oauthCredential);
                     debugLogger.info({
                         figmaUserInfo,
                         msg: 'Fetched Figma user info'
@@ -192,7 +196,11 @@ export const getLoginEndpoint = ({ collection, collectionOptions, endpointSlug,
                     throw new APIError(errMsg);
                 }
                 // Swap for project token
-                const project_token = await getProjectToken(access_token, config.custom.figma.contentSystemId);
+                const oauthCredential = {
+                    type: 'oauth',
+                    token: access_token
+                };
+                const project_token = await getProjectToken(oauthCredential, config.custom.figma.contentSystemId);
                 const refresh_token = access_token;
                 // Store project token as access_token
                 const token = project_token.token;

package/dist/oauth/utilities/refreshTokens.js

@@ -16,7 +16,10 @@ export const refreshTokens = async ({ payload, refreshToken, strategy })=>{
     // so we will refresh both tokens
     try {
         // Get another project token
-        const { expiresAt, token } = await getProjectToken(refreshToken, payload.config.custom.figma.contentSystemId);
+        const { expiresAt, token } = await getProjectToken({
+            type: 'oauth',
+            token: refreshToken
+        }, payload.config.custom.figma.contentSystemId);
         debugLogger.info({
             expiresAt,
             msg: 'Received new tokens from Figma API',

package/dist/plugin/build-config.js

@@ -3,7 +3,7 @@ import { initClientUploads } from '@payloadcms/plugin-cloud-storage/utilities';
 import { lexicalEditor } from '@payloadcms/richtext-lexical';
 import { buildConfig as payloadBuildConfig } from 'payload';
 import { getBootstrapInfo } from '../api/control-plane.js';
-import { getValidAccessToken } from '../auth/oauth-flow.js';
+import { getValidCredential } from '../auth/oauth-flow.js';
 import { getTokenStore } from '../auth/token-store.js';
 import { getEnvConfig } from '../constants.js';
 import { contentAPIAdapter } from '../db-content-api/index.js';
@@ -50,11 +50,11 @@ function missingOAuthCredential(name) {
  * Returns the requested environment's data, or null if resolution fails.
  */ async function resolveAndCacheBootstrap(store, projectId, environmentName) {
     try {
-        const accessToken = await getValidAccessToken(store);
-        if (!accessToken) {
+        const credential = await getValidCredential(store);
+        if (!credential) {
             return null;
         }
-        const bootstrapInfo = await getBootstrapInfo(accessToken, projectId);
+        const bootstrapInfo = await getBootstrapInfo(credential, projectId);
         cacheAllEnvironments(store, projectId, bootstrapInfo);
         return store.getBootstrapData(projectId, environmentName);
     } catch (error) {

package/dist/utils/adapters/nextjs.d.ts

@@ -0,0 +1,9 @@
+import type { AssetCollection, DeployAdapter, PageCollection } from '../deploy-adapter.js';
+export declare class NextjsAdapter implements DeployAdapter {
+    name: "nextjs";
+    collectAssets(projectPath: string): Promise<AssetCollection>;
+    collectPages(projectPath: string): Promise<PageCollection>;
+    prepareLambdaBundle(projectPath: string): Promise<string>;
+}
+export declare const nextjsAdapter: NextjsAdapter;
+//# sourceMappingURL=nextjs.d.ts.map

package/dist/utils/adapters/nextjs.js

@@ -0,0 +1,59 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { collectSSGAssets, collectStaticAssets } from '../asset-collection.js';
+import { buildLambdaZip } from '../build-lambda-zip.js';
+import { collectFilesRecursive } from '../fs-utils.js';
+export class NextjsAdapter {
+    name = 'nextjs';
+    async collectAssets(projectPath) {
+        // Bundle assets: .next/static/ → _next/static/
+        const staticAssets = await collectStaticAssets(projectPath);
+        // Public assets: public/ directory
+        const publicDir = path.join(projectPath, 'public');
+        let publicAssets = [];
+        try {
+            await fs.stat(publicDir);
+            publicAssets = await collectFilesRecursive(publicDir, publicDir);
+        } catch  {
+        // No public directory
+        }
+        const allKeys = [
+            ...staticAssets,
+            ...publicAssets
+        ];
+        const pathMap = {};
+        for (const key of staticAssets){
+            pathMap[key] = key.replace(/^_next\//, '.next/');
+        }
+        for (const key of publicAssets){
+            pathMap[key] = path.join('public', key);
+        }
+        return {
+            pathMap,
+            routes: allKeys.map((k)=>`/${k}`),
+            uploadKeys: allKeys
+        };
+    }
+    async collectPages(projectPath) {
+        const ssg = await collectSSGAssets(projectPath);
+        // Extract route paths from S3 keys: "products.html" → "/products", "index.html" → "/"
+        const routes = [
+            ...new Set(ssg.keys.filter((k)=>k.endsWith('.html')).map((k)=>{
+                const stripped = k.replace(/\.html$/, '');
+                return stripped === 'index' ? '/' : `/${stripped}`;
+            }))
+        ];
+        return {
+            pathMap: ssg.pathMap,
+            routes,
+            uploadKeys: ssg.keys
+        };
+    }
+    async prepareLambdaBundle(projectPath) {
+        await buildLambdaZip(projectPath);
+        return path.join(projectPath, 'lambda.zip');
+    }
+}
+export const nextjsAdapter = new NextjsAdapter();
+
+//# sourceMappingURL=nextjs.js.map

package/dist/utils/adapters/nitro.d.ts

@@ -0,0 +1,9 @@
+import type { AssetCollection, DeployAdapter, PageCollection } from '../deploy-adapter.js';
+export declare class NitroAdapter implements DeployAdapter {
+    name: "nitro";
+    collectAssets(projectPath: string): Promise<AssetCollection>;
+    collectPages(projectPath: string): Promise<PageCollection>;
+    prepareLambdaBundle(projectPath: string): Promise<string>;
+}
+export declare const nitroAdapter: NitroAdapter;
+//# sourceMappingURL=nitro.d.ts.map

package/dist/utils/adapters/nitro.js

@@ -0,0 +1,164 @@
+import archiver from 'archiver';
+import { createWriteStream, statSync } from 'fs';
+import fs from 'fs/promises';
+import path from 'path';
+import { collectFilesRecursive } from '../fs-utils.js';
+const RUN_SCRIPT = `#!/bin/bash -x
+[ ! -d '/tmp/cache' ] && mkdir -p /tmp/cache
+NODE_ENV=production exec node server/index.mjs
+`;
+/** Directories in .output/public/ that are NOT pre-rendered pages */ const NON_PAGE_DIRS = new Set([
+    '_next',
+    'assets'
+]);
+export class NitroAdapter {
+    name = 'nitro';
+    async collectAssets(projectPath) {
+        const publicDir = path.join(projectPath, '.output', 'public');
+        const assets = [];
+        const pathMap = {};
+        // Collect flat files in .output/public/ (public dir assets)
+        try {
+            const entries = await fs.readdir(publicDir, {
+                withFileTypes: true
+            });
+            for (const entry of entries){
+                if (entry.isFile()) {
+                    assets.push(entry.name);
+                    pathMap[entry.name] = path.join('.output', 'public', entry.name);
+                }
+            }
+        } catch  {
+        // No public directory
+        }
+        // Collect bundle assets from .output/public/_next/static/
+        const bundleDir = path.join(publicDir, '_next', 'static');
+        try {
+            const bundleFiles = await collectFilesRecursive(bundleDir, bundleDir);
+            for (const file of bundleFiles){
+                const key = `_next/static/${file}`;
+                assets.push(key);
+                pathMap[key] = path.join('.output', 'public', '_next', 'static', file);
+            }
+        } catch  {
+        // No bundle directory
+        }
+        return {
+            pathMap,
+            routes: assets.map((k)=>`/${k}`),
+            uploadKeys: assets
+        };
+    }
+    async collectPages(projectPath) {
+        const publicDir = path.join(projectPath, '.output', 'public');
+        const pages = await scanForPages(publicDir, publicDir);
+        const routes = pages.map((p)=>p === 'index' ? '/' : `/${p}`);
+        const uploadKeys = pages.map((p)=>p === 'index' ? 'index.html' : `${p}/index.html`);
+        const pathMap = {};
+        for(let i = 0; i < uploadKeys.length; i++){
+            pathMap[uploadKeys[i]] = path.join('.output', 'public', uploadKeys[i]);
+        }
+        return {
+            pathMap,
+            routes,
+            uploadKeys
+        };
+    }
+    async prepareLambdaBundle(projectPath) {
+        const zipPath = path.join(projectPath, 'lambda.zip');
+        const serverDir = path.join(projectPath, '.output', 'server');
+        const publicDir = path.join(projectPath, '.output', 'public');
+        // Verify server directory exists
+        try {
+            await fs.stat(serverDir);
+        } catch  {
+            throw new Error('Nitro server build not found at .output/server. Run build first.');
+        }
+        // Write run.sh to a temp location
+        const runShPath = path.join(projectPath, '.output', 'run.sh');
+        await fs.writeFile(runShPath, RUN_SCRIPT, {
+            mode: 0o755
+        });
+        // Create zip: server/ + public/ + run.sh
+        await createZip(zipPath, [
+            {
+                prefix: 'server/',
+                source: serverDir
+            },
+            {
+                prefix: 'public/',
+                source: publicDir
+            },
+            {
+                prefix: '',
+                source: runShPath
+            }
+        ]);
+        // Clean up temp run.sh
+        await fs.rm(runShPath, {
+            force: true
+        });
+        return zipPath;
+    }
+}
+export const nitroAdapter = new NitroAdapter();
+/**
+ * Recursively scan for pre-rendered pages (directories containing index.html).
+ * Skips known non-page directories (_next/, assets/).
+ */ async function scanForPages(dir, baseDir) {
+    const pages = [];
+    // Check if this directory has an index.html (it's a page)
+    const indexPath = path.join(dir, 'index.html');
+    try {
+        await fs.stat(indexPath);
+        const relative = path.relative(baseDir, dir);
+        pages.push(relative || 'index'); // root dir -> 'index'
+    } catch  {
+    // Not a page directory
+    }
+    // Recurse into subdirectories
+    try {
+        const entries = await fs.readdir(dir, {
+            withFileTypes: true
+        });
+        for (const entry of entries){
+            if (entry.isDirectory() && !NON_PAGE_DIRS.has(entry.name)) {
+                const subPages = await scanForPages(path.join(dir, entry.name), baseDir);
+                pages.push(...subPages);
+            }
+        }
+    } catch  {
+    // Directory not readable
+    }
+    return pages;
+}
+async function createZip(zipPath, entries) {
+    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);
+        for (const entry of entries){
+            try {
+                const stat = statSync(entry.source);
+                if (stat.isDirectory()) {
+                    archive.directory(entry.source, entry.prefix.replace(/\/$/, '') || false);
+                } else {
+                    archive.file(entry.source, {
+                        name: entry.prefix + path.basename(entry.source)
+                    });
+                }
+            } catch  {
+            // Skip missing entries
+            }
+        }
+        void archive.finalize();
+    });
+}
+
+//# sourceMappingURL=nitro.js.map

package/dist/utils/adapters/vite.d.ts

@@ -0,0 +1,10 @@
+import type { AssetCollection, DeployAdapter, PageCollection } from '../deploy-adapter.js';
+export declare class ViteAdapter implements DeployAdapter {
+    fallback: string;
+    name: "vite";
+    collectAssets(projectPath: string): Promise<AssetCollection>;
+    collectPages(): Promise<PageCollection>;
+    prepareLambdaBundle(): Promise<null>;
+}
+export declare const viteAdapter: ViteAdapter;
+//# sourceMappingURL=vite.d.ts.map