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

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

@@ -1,8 +1,8 @@
 import type { AssetCollection, DeployAdapter, LambdaBundle, 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<LambdaBundle>;
+    collectAssets(projectPath: string, output?: string): Promise<AssetCollection>;
+    collectPages(projectPath: string, output?: string): Promise<PageCollection>;
+    prepareLambdaBundle(projectPath: string, output?: string): Promise<LambdaBundle>;
 }
 export declare const nextjsAdapter: NextjsAdapter;

package/dist/utils/adapters/nextjs.js

@@ -2,12 +2,14 @@ import fs from 'fs/promises';
 import path from 'path';
 import { collectSSGAssets, collectStaticAssets } from '../asset-collection.js';
 import { buildLambdaZip } from '../build-lambda-zip.js';
+import { resolveOutputPath } from '../deploy-output/resolveOutputPath.js';
 import { collectFilesRecursive } from '../fs-utils.js';
 export class NextjsAdapter {
     name = 'nextjs';
-    async collectAssets(projectPath) {
+    async collectAssets(projectPath, output) {
         // Bundle assets: .next/static/ → _next/static/
-        const staticAssets = await collectStaticAssets(projectPath);
+        const staticAssets = await collectStaticAssets(projectPath, output);
+        const outputPath = resolveOutputPath(projectPath, 'nextjs', output);
         // Public assets: public/ directory
         const publicDir = path.join(projectPath, 'public');
         let publicAssets = [];
@@ -23,7 +25,7 @@ export class NextjsAdapter {
         ];
         const pathMap = {};
         for (const key of staticAssets){
-            pathMap[key] = key.replace(/^_next\//, '.next/');
+            pathMap[key] = path.relative(projectPath, path.join(outputPath, key.replace(/^_next\//, '')));
         }
         for (const key of publicAssets){
             pathMap[key] = path.join('public', key);
@@ -34,8 +36,8 @@ export class NextjsAdapter {
             uploadKeys: allKeys
         };
     }
-    async collectPages(projectPath) {
-        const ssg = await collectSSGAssets(projectPath);
+    async collectPages(projectPath, output) {
+        const ssg = await collectSSGAssets(projectPath, output);
         // Build route → asset keys mapping and extract unique routes
         const routeAssetMap = {};
         for (const key of ssg.keys){
@@ -54,8 +56,8 @@ export class NextjsAdapter {
             uploadKeys: ssg.keys
         };
     }
-    async prepareLambdaBundle(projectPath) {
-        return buildLambdaZip(projectPath);
+    async prepareLambdaBundle(projectPath, output) {
+        return buildLambdaZip(projectPath, output);
     }
 }
 export const nextjsAdapter = new NextjsAdapter();

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

@@ -1,8 +1,8 @@
 import type { AssetCollection, DeployAdapter, LambdaBundle, 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<LambdaBundle>;
+    collectAssets(projectPath: string, output?: string): Promise<AssetCollection>;
+    collectPages(projectPath: string, output?: string): Promise<PageCollection>;
+    prepareLambdaBundle(projectPath: string, output?: string): Promise<LambdaBundle>;
 }
 export declare const nitroAdapter: NitroAdapter;

package/dist/utils/adapters/nitro.js

@@ -2,62 +2,39 @@ import archiver from 'archiver';
 import { createWriteStream, statSync } from 'fs';
 import fs from 'fs/promises';
 import path from 'path';
+import { resolveNitroOutputLayout } from '../deploy-output/resolveNitroOutputLayout.js';
+import { resolveOutputPath } from '../deploy-output/resolveOutputPath.js';
 import { collectFilesRecursive, getDirectorySize } 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',
+/** Framework asset directories that are not pre-rendered pages. */ const NON_PAGE_DIRS = new Set([
+    '_build',
+    '_nuxt',
     '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
-        }
+    async collectAssets(projectPath, output) {
+        const { publicPath } = await getLayout(projectPath, output);
+        const pageKeys = new Set((await scanForPages(publicPath, publicPath)).map(toPageUploadKey));
+        const assets = (await collectFilesRecursive(publicPath, publicPath)).filter((file)=>!pageKeys.has(file));
+        const pathMap = Object.fromEntries(assets.map((file)=>[
+                file,
+                path.relative(projectPath, path.join(publicPath, file))
+            ]));
         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);
+    async collectPages(projectPath, output) {
+        const { publicPath } = await getLayout(projectPath, output);
+        const pages = await scanForPages(publicPath, publicPath);
         const routes = pages.map((p)=>p === 'index' ? '/' : `/${p}`);
-        const uploadKeys = pages.map((p)=>p === 'index' ? 'index.html' : `${p}/index.html`);
+        const uploadKeys = pages.map(toPageUploadKey);
         const pathMap = {};
         const routeAssetMap = {};
         for(let i = 0; i < uploadKeys.length; i++){
-            pathMap[uploadKeys[i]] = path.join('.output', 'public', uploadKeys[i]);
+            pathMap[uploadKeys[i]] = path.relative(projectPath, path.join(publicPath, uploadKeys[i]));
             routeAssetMap[routes[i]] = [
                 uploadKeys[i]
             ];
@@ -69,52 +46,68 @@ export class NitroAdapter {
             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
+    async prepareLambdaBundle(projectPath, output) {
+        const layout = await getLayout(projectPath, output);
         try {
-            await fs.stat(serverDir);
+            const stat = await fs.stat(layout.serverEntryPath);
+            if (!stat.isFile()) {
+                throw new Error('not a file');
+            }
         } catch  {
-            throw new Error('Nitro server build not found at .output/server. Run build first.');
+            throw new Error(`Nitro server build not found at ${layout.outputPath}`);
         }
-        // Write run.sh to a temp location
-        const runShPath = path.join(projectPath, '.output', 'run.sh');
-        await fs.writeFile(runShPath, RUN_SCRIPT, {
+        const serverDir = path.dirname(layout.serverEntryPath);
+        const serverPrefix = path.relative(layout.outputPath, serverDir).split(path.sep).join('/');
+        const publicPrefix = path.relative(layout.outputPath, layout.publicPath).split(path.sep).join('/');
+        const serverEntry = path.relative(layout.outputPath, layout.serverEntryPath).split(path.sep).join('/');
+        const runShPath = path.join(layout.outputPath, 'run.sh');
+        await fs.writeFile(runShPath, createRunScript(serverEntry), {
             mode: 0o755
         });
-        // Create zip: server/ + public/ + run.sh
-        await createZip(zipPath, [
-            {
-                prefix: 'server/',
-                source: serverDir
-            },
-            {
-                prefix: 'public/',
-                source: publicDir
-            },
-            {
-                prefix: '',
-                source: runShPath
-            }
-        ]);
-        const runShStat = await fs.stat(runShPath);
-        const unzippedBytes = await getDirectorySize(serverDir) + await getDirectorySize(publicDir) + runShStat.size;
-        // Clean up temp run.sh
-        await fs.rm(runShPath, {
-            force: true
-        });
-        return {
-            unzippedBytes,
-            zipPath
-        };
+        const zipPath = path.join(projectPath, 'lambda.zip');
+        try {
+            await createZip(zipPath, [
+                {
+                    prefix: `${serverPrefix}/`,
+                    source: serverDir
+                },
+                {
+                    prefix: `${publicPrefix}/`,
+                    source: layout.publicPath
+                },
+                {
+                    prefix: '',
+                    source: runShPath
+                }
+            ]);
+            const runShStat = await fs.stat(runShPath);
+            const unzippedBytes = await getDirectorySize(serverDir) + await getDirectorySize(layout.publicPath) + runShStat.size;
+            return {
+                unzippedBytes,
+                zipPath
+            };
+        } finally{
+            await fs.rm(runShPath, {
+                force: true
+            });
+        }
     }
 }
 export const nitroAdapter = new NitroAdapter();
+function getLayout(projectPath, output) {
+    const outputPath = resolveOutputPath(projectPath, 'nitro', output);
+    return resolveNitroOutputLayout(outputPath);
+}
+function createRunScript(serverEntry) {
+    const escapedEntry = serverEntry.replaceAll("'", "'\\''");
+    return `#!/bin/bash -x
+[ ! -d '/tmp/cache' ] && mkdir -p /tmp/cache
+NODE_ENV=production exec node '${escapedEntry}'
+`;
+}
 /**
  * Recursively scan for pre-rendered pages (directories containing index.html).
- * Skips known non-page directories (_next/, assets/).
+ * Skips known framework asset directories.
  */ async function scanForPages(dir, baseDir) {
     const pages = [];
     // Check if this directory has an index.html (it's a page)
@@ -142,6 +135,9 @@ export const nitroAdapter = new NitroAdapter();
     }
     return pages;
 }
+function toPageUploadKey(page) {
+    return page === 'index' ? 'index.html' : `${page}/index.html`;
+}
 async function createZip(zipPath, entries) {
     return new Promise((resolve, reject)=>{
         const output = createWriteStream(zipPath);

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

@@ -2,7 +2,7 @@ import type { AssetCollection, DeployAdapter, LambdaBundle, PageCollection } fro
 export declare class ViteAdapter implements DeployAdapter {
     fallback: string;
     name: "vite";
-    collectAssets(projectPath: string): Promise<AssetCollection>;
+    collectAssets(projectPath: string, output?: string): Promise<AssetCollection>;
     collectPages(): Promise<PageCollection>;
     prepareLambdaBundle(): Promise<LambdaBundle | null>;
 }

package/dist/utils/adapters/vite.js

@@ -1,15 +1,16 @@
 import path from 'path';
+import { resolveOutputPath } from '../deploy-output/resolveOutputPath.js';
 import { collectFilesRecursive } from '../fs-utils.js';
 export class ViteAdapter {
     fallback = '/index.html';
     name = 'vite';
-    async collectAssets(projectPath) {
-        const distDir = path.join(projectPath, 'dist');
-        const files = await collectFilesRecursive(distDir, distDir);
-        const pathMap = {};
-        for (const file of files){
-            pathMap[file] = path.join('dist', file);
-        }
+    async collectAssets(projectPath, output) {
+        const outputPath = resolveOutputPath(projectPath, 'vite', output);
+        const files = await collectFilesRecursive(outputPath, outputPath);
+        const pathMap = Object.fromEntries(files.map((file)=>[
+                file,
+                path.relative(projectPath, path.join(outputPath, file))
+            ]));
         return {
             pathMap,
             routes: files.map((k)=>`/${k}`),

package/dist/utils/assert-never.d.ts

@@ -0,0 +1 @@
+export declare function assertNever(x: never): never;

package/dist/utils/assert-never.js

@@ -0,0 +1,3 @@
+export function assertNever(x) {
+    throw new Error('Unhandled case: ' + JSON.stringify(x));
+}

package/dist/utils/asset-collection.d.ts

@@ -14,7 +14,7 @@ export declare function getFileSize(filePath: string): Promise<number>;
  * @param projectPath - Path to project root
  * @returns Array of static asset paths (using _next prefix)
  */
-export declare function collectStaticAssets(projectPath: string): Promise<string[]>;
+export declare function collectStaticAssets(projectPath: string, output?: string): Promise<string[]>;
 /**
  * Result from collecting SSG assets
  */
@@ -38,7 +38,7 @@ export type SSGAssets = {
  * @param projectPath - Path to project root
  * @returns SSG asset keys and a pathMap for filesystem resolution
  */
-export declare function collectSSGAssets(projectPath: string): Promise<SSGAssets>;
+export declare function collectSSGAssets(projectPath: string, output?: string): Promise<SSGAssets>;
 /**
  * Create Lambda deployment zip
  *

package/dist/utils/asset-collection.js

@@ -1,6 +1,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { buildLambdaZip } from './build-lambda-zip.js';
+import { resolveOutputPath } from './deploy-output/resolveOutputPath.js';
 import * as log from './log.js';
 // Maximum file size for static assets (S3 limitation)
 const MAX_ASSET_SIZE = 50 * 1024 * 1024 // 50MB
@@ -64,19 +65,13 @@ const MAX_ASSET_SIZE = 50 * 1024 * 1024 // 50MB
  *
  * @param projectPath - Path to project root
  * @returns Array of static asset paths (using _next prefix)
- */ export async function collectStaticAssets(projectPath) {
-    const staticDir = path.join(projectPath, '.next', 'static');
-    try {
-        await fs.stat(staticDir);
-    } catch  {
-        // No static directory
-        return [];
-    }
+ */ export async function collectStaticAssets(projectPath, output) {
+    const outputPath = resolveOutputPath(projectPath, 'nextjs', output);
+    const staticDir = path.join(outputPath, 'static');
     const files = await collectFiles(staticDir, projectPath);
-    // Normalize paths to forward slashes (cross-platform) and convert prefix
     return files.map((file)=>{
-        const normalized = file.split(path.sep).join('/');
-        return normalized.replace(/^\.next\//, '_next/');
+        const relativeToStatic = path.relative(staticDir, path.resolve(projectPath, file));
+        return `_next/static/${relativeToStatic.split(path.sep).join('/')}`;
     });
 }
 /**
@@ -92,8 +87,9 @@ const MAX_ASSET_SIZE = 50 * 1024 * 1024 // 50MB
  *
  * @param projectPath - Path to project root
  * @returns SSG asset keys and a pathMap for filesystem resolution
- */ export async function collectSSGAssets(projectPath) {
-    const manifestPath = path.join(projectPath, '.next', 'prerender-manifest.json');
+ */ export async function collectSSGAssets(projectPath, output) {
+    const outputPath = resolveOutputPath(projectPath, 'nextjs', output);
+    const manifestPath = path.join(outputPath, 'prerender-manifest.json');
     let manifest;
     try {
         const raw = await fs.readFile(manifestPath, 'utf-8');
@@ -122,9 +118,8 @@ const MAX_ASSET_SIZE = 50 * 1024 * 1024 // 50MB
         const stripped = routeKey === '/' ? 'index' : routeKey.replace(/^\//, '');
         for (const ext of extensions){
             const s3Key = `${stripped}${ext}`;
-            const fsPath = path.join('.next', 'server', 'app', `${stripped}${ext}`);
             keys.push(s3Key);
-            pathMap[s3Key] = fsPath;
+            pathMap[s3Key] = path.relative(projectPath, path.join(outputPath, 'server', 'app', `${stripped}${ext}`));
         }
     }
     return {

package/dist/utils/build-detection.d.ts

@@ -1,3 +1,4 @@
+import type { AdapterName } from './deploy-adapter.js';
 /**
  * Information about a detected build
  */
@@ -11,11 +12,15 @@ export interface BuildInfo {
     /** Build timestamp */
     timestamp: Date;
 }
+export interface DetectBuildOptions {
+    adapter?: AdapterName;
+    output?: string;
+}
 /**
  * Detect a valid build across supported frameworks.
  * Tries NextJS, then Nitro, then Vite. Returns the first match.
  */
-export declare function detectBuild(projectPath: string): Promise<BuildInfo | null>;
+export declare function detectBuild(projectPath: string, options: DetectBuildOptions): Promise<BuildInfo | null>;
 /**
  * Get the build command from package.json
  *

package/dist/utils/build-detection.js

@@ -1,103 +1,82 @@
 import fs from 'fs/promises';
 import path from 'path';
+import { assertNever } from './assert-never.js';
+import { inspectNextjsOutput } from './deploy-output/inspectNextjsOutput.js';
+import { inspectNitroOutput } from './deploy-output/inspectNitroOutput.js';
+import { resolveOutputPath } from './deploy-output/resolveOutputPath.js';
 /**
  * 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 {
-        const serverPath = path.join(projectPath, '.next', 'standalone', 'server.js');
-        const serverStat = await fs.stat(serverPath);
-        const buildIdPath = path.join(projectPath, '.next', 'BUILD_ID');
-        const buildId = (await fs.readFile(buildIdPath, 'utf-8')).trim();
-        const lambdaZipPath = path.join(projectPath, 'lambda.zip');
-        let hasLambdaZip = false;
-        try {
-            await fs.stat(lambdaZipPath);
-            hasLambdaZip = true;
-        } catch  {
-            hasLambdaZip = false;
+ */ export async function detectBuild(projectPath, options) {
+    const adapters = options.adapter ? [
+        options.adapter
+    ] : [
+        'nextjs',
+        'nitro',
+        'vite'
+    ];
+    for (const adapter of adapters){
+        const outputPath = resolveOutputPath(projectPath, adapter, options.output);
+        const build = await detectAdapterBuild(projectPath, adapter, outputPath);
+        if (build) {
+            return build;
         }
-        return {
-            buildId,
-            hasLambdaZip,
-            path: '.next/standalone',
-            timestamp: serverStat.mtime
-        };
-    } catch  {
-        return null;
     }
+    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;
+async function detectAdapterBuild(projectPath, adapter, outputPath) {
+    switch(adapter){
+        case 'nextjs':
+            {
+                const layout = await inspectNextjsOutput(outputPath);
+                if (!layout) {
+                    return null;
+                }
+                const stat = await fs.stat(layout.serverEntryPath);
+                return {
+                    buildId: layout.buildId,
+                    hasLambdaZip: await hasLambdaZip(projectPath),
+                    path: path.relative(projectPath, layout.standalonePath),
+                    timestamp: stat.mtime
+                };
             }
-        } 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;
+        case 'nitro':
+            {
+                const layout = await inspectNitroOutput(outputPath);
+                if (!layout) {
+                    return null;
+                }
+                const stat = await fs.stat(layout.serverEntryPath);
+                return {
+                    buildId: layout.buildId ?? stat.mtime.toISOString(),
+                    hasLambdaZip: await hasLambdaZip(projectPath),
+                    path: path.relative(projectPath, outputPath),
+                    timestamp: stat.mtime
+                };
+            }
+        case 'vite':
+            {
+                try {
+                    const stat = await fs.stat(path.join(outputPath, 'index.html'));
+                    if (!stat.isFile()) {
+                        return null;
+                    }
+                    return {
+                        buildId: stat.mtime.toISOString(),
+                        hasLambdaZip: false,
+                        path: path.relative(projectPath, outputPath),
+                        timestamp: stat.mtime
+                    };
+                } catch  {
+                    return null;
+                }
+            }
+        default:
+            assertNever(adapter);
     }
 }
-/**
- * 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;
-    }
+async function hasLambdaZip(projectPath) {
+    return fs.stat(path.join(projectPath, 'lambda.zip')).then(()=>true).catch(()=>false);
 }
 /**
  * Get the build command from package.json

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

@@ -11,15 +11,14 @@ export declare const LAMBDA_MAX_UNZIPPED_BYTES: number;
  * 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 declare function buildLambdaZip(projectPath: string): Promise<LambdaBundle>;
+export declare function buildLambdaZip(projectPath: string, output?: string): Promise<LambdaBundle>;