@payloadcms/figma 0.1.0-alpha.8 → 0.1.0-alpha.9

package/dist/commands/init.js

@@ -391,7 +391,7 @@ async function maybeWriteAgentConfigFiles(args) {
             log.error(error instanceof Error ? error.message : 'Unknown error');
             process.exit(1);
         }
-        // Apply Lambda modifications (run.sh, standalone output, lambda:buildzip script)
+        // Apply Lambda modifications (run.sh, Next.js config, lambda:buildzip script)
         await applyLambdaModifications(process.cwd(), packageManager);
         // Ensure .gitignore has required entries
         await ensureGitignore(process.cwd(), [

package/dist/next/image-loader.d.ts

@@ -0,0 +1,6 @@
+export type FigmaNextImageLoaderProps = {
+    quality?: number;
+    src: string;
+    width: number;
+};
+export declare function figmaNextImageLoader({ quality, src, width }: FigmaNextImageLoaderProps): string;

package/dist/next/image-loader.js

@@ -0,0 +1,14 @@
+'use client';
+const PAYLOAD_FILE_PATH_PATTERN = /^\/(?!\/)(?:.+\/)?api\/[^/]+\/file\/.+$/;
+export function figmaNextImageLoader({ quality, src, width }) {
+    const [pathname, search = ''] = src.split('?');
+    if (!PAYLOAD_FILE_PATH_PATTERN.test(pathname)) {
+        return src;
+    }
+    const searchParams = new URLSearchParams(search);
+    searchParams.set('w', String(width));
+    if (quality !== undefined) {
+        searchParams.set('q', String(quality));
+    }
+    return `${pathname}?${searchParams}`;
+}

package/dist/plugin/build-config.js

@@ -20,6 +20,7 @@ import { getEnvVarSync } from '../utils/env-management.js';
 import * as log from '../utils/log.js';
 import { logMissingCliAuth } from './auth-preflight.js';
 import { logMissingContentSystemId } from './bootstrap-preflight.js';
+import { createCacheRevalidationHooksPlugin } from './cache-revalidation-hooks.js';
 import { LIMIT_REACHED_VIEW_KEY, LIMIT_REACHED_VIEW_PATH } from './cloud-limits/routes.js';
 import { getDevCookieNames } from './dev-cookie-names.js';
 import { passesMakeViewerWriteGate, withMakeViewerWriteBaseAccessDefaults } from './make-permission-access/make-permission-access.js';
@@ -427,7 +428,10 @@ export async function buildFigmaConfig(config) {
             // figma.storage is false and would break remote uploads for those apps.
             createSandboxUploadFetchPlugin({
                 userCollections: config.collections
-            })
+            }),
+            // Keep last so hooks added by app plugins also get the missing Next cache
+            // context guard used by Payload CLI operations in the Make sandbox.
+            createCacheRevalidationHooksPlugin()
         ]
     };
     // Inject Figma-managed identity fields only into the Payload Admin collection.

package/dist/plugin/cache-revalidation-hooks.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from 'payload';
+/**
+ * Prevent Next cache invalidation from turning a successful Payload mutation
+ * into an apparent failure when the mutation runs outside a Next request.
+ */
+export declare function createCacheRevalidationHooksPlugin(): Plugin;

package/dist/plugin/cache-revalidation-hooks.js

@@ -0,0 +1,69 @@
+const missingNextCacheContext = /^Invariant: static generation store missing in (?:revalidateTag|revalidatePath|updateTag)\b/;
+const unsupportedUpdateTagContext = /^updateTag can only be called from within a Server Action\./;
+/**
+ * Next cache invalidation requires request-scoped state. Payload's Local API has
+ * no Next request when it runs from the CLI in a Make sandbox, so Next throws
+ * after the database write has already committed. Treat only that missing-
+ * context error as a no-op; cache invalidation still runs normally in a Next
+ * request, and all other hook failures retain their existing behavior.
+ */ function isUnsupportedNextCacheContextError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const errorCode = error.__NEXT_ERROR_CODE;
+    if (missingNextCacheContext.test(error.message)) {
+        return errorCode === undefined || errorCode === 'E263';
+    }
+    if (unsupportedUpdateTagContext.test(error.message)) {
+        return errorCode === undefined || errorCode === 'E872';
+    }
+    return false;
+}
+function reportIgnoredRevalidation(args, hookName) {
+    const hookArgs = args[0];
+    hookArgs?.req?.payload?.logger?.warn({
+        hook: hookName,
+        msg: 'Ignored Next cache invalidation outside a supported request context'
+    });
+}
+function wrapHook(hook, hookName) {
+    return async (...args)=>{
+        try {
+            return await hook(...args);
+        } catch (error) {
+            if (isUnsupportedNextCacheContextError(error)) {
+                reportIgnoredRevalidation(args, hookName);
+                return undefined;
+            }
+            throw error;
+        }
+    };
+}
+function wrapHooks(hooks) {
+    if (!hooks) {
+        return hooks;
+    }
+    return Object.fromEntries(Object.entries(hooks).map(([name, value])=>[
+            name,
+            Array.isArray(value) ? value.map((hook)=>typeof hook === 'function' ? wrapHook(hook, name) : hook) : value
+        ]));
+}
+/**
+ * Prevent Next cache invalidation from turning a successful Payload mutation
+ * into an apparent failure when the mutation runs outside a Next request.
+ */ export function createCacheRevalidationHooksPlugin() {
+    const plugin = (config)=>({
+            ...config,
+            collections: config.collections?.map((collection)=>({
+                    ...collection,
+                    hooks: wrapHooks(collection.hooks)
+                })),
+            globals: config.globals?.map((global)=>({
+                    ...global,
+                    hooks: wrapHooks(global.hooks)
+                }))
+        });
+    // Run after tenant plugins so hooks they add receive the same guard.
+    plugin.order = Number.POSITIVE_INFINITY;
+    return plugin;
+}

package/dist/utils/adapters/nextjs.js

@@ -4,18 +4,19 @@ import { collectSSGAssets, collectStaticAssets, collectStaticMetadataAssets } fr
 import { buildLambdaZip } from '../build-lambda-zip.js';
 import { resolveOutputPath } from '../deploy-output/resolveOutputPath.js';
 import { collectFilesRecursive } from '../fs-utils.js';
+import { isPublishableAsset } from '../secret-files.js';
 export class NextjsAdapter {
     name = 'nextjs';
     async collectAssets(projectPath, output) {
         // Bundle assets: .next/static/ → _next/static/
-        const staticAssets = await collectStaticAssets(projectPath, output);
+        const staticAssets = (await collectStaticAssets(projectPath, output)).filter(isPublishableAsset);
         const outputPath = resolveOutputPath(projectPath, 'nextjs', output);
         // Public assets: public/ directory
         const publicDir = path.join(projectPath, 'public');
         let publicAssets = [];
         try {
             await fs.stat(publicDir);
-            publicAssets = await collectFilesRecursive(publicDir, publicDir);
+            publicAssets = (await collectFilesRecursive(publicDir, publicDir)).filter(isPublishableAsset);
         } catch  {
         // No public directory
         }
@@ -27,7 +28,7 @@ export class NextjsAdapter {
         for (const key of publicAssets){
             pathMap[key] = path.join('public', key);
         }
-        for (const key of metadataAssets.keys){
+        for (const key of metadataAssets.keys.filter(isPublishableAsset)){
             pathMap[key] = metadataAssets.pathMap[key];
         }
         const uploadKeys = Object.keys(pathMap);

package/dist/utils/adapters/nitro.js

@@ -5,6 +5,7 @@ import path from 'path';
 import { resolveNitroOutputLayout } from '../deploy-output/resolveNitroOutputLayout.js';
 import { resolveOutputPath } from '../deploy-output/resolveOutputPath.js';
 import { collectFilesRecursive, EscapingSymlinkError, walkBundleFiles } from '../fs-utils.js';
+import { isBundlableFile, isPublishableAsset } from '../secret-files.js';
 /** Framework asset directories that are not pre-rendered pages. */ const NON_PAGE_DIRS = new Set([
     '_build',
     '_nuxt',
@@ -15,7 +16,7 @@ export class NitroAdapter {
     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 assets = (await collectFilesRecursive(publicPath, publicPath)).filter((file)=>!pageKeys.has(file) && isPublishableAsset(file));
         const pathMap = Object.fromEntries(assets.map((file)=>[
                 file,
                 path.relative(projectPath, path.join(publicPath, file))
@@ -28,7 +29,7 @@ export class NitroAdapter {
     }
     async collectPages(projectPath, output) {
         const { publicPath } = await getLayout(projectPath, output);
-        const pages = await scanForPages(publicPath, publicPath);
+        const pages = (await scanForPages(publicPath, publicPath)).filter((page)=>isPublishableAsset(toPageUploadKey(page)));
         const routes = pages.map((p)=>p === 'index' ? '/' : `/${p}`);
         const uploadKeys = pages.map(toPageUploadKey);
         const pathMap = {};
@@ -67,14 +68,15 @@ export class NitroAdapter {
         const zipPath = path.join(projectPath, 'lambda.zip');
         try {
             const runShStat = await fs.stat(runShPath);
-            const [serverFiles, publicFiles] = await Promise.all([
+            const [allServerFiles, publicFiles] = await Promise.all([
                 walkBundleFiles(serverDir),
                 walkPublicBundleFiles(layout.publicPath)
             ]);
-            const unzippedBytes = serverFiles.reduce((total, file)=>total + file.size, 0) + publicFiles.reduce((total, file)=>total + file.size, 0) + runShStat.size;
+            const bundlableServerFiles = allServerFiles.filter((file)=>isBundlableFile(file.relativePath));
+            const unzippedBytes = bundlableServerFiles.reduce((total, file)=>total + file.size, 0) + publicFiles.reduce((total, file)=>total + file.size, 0) + runShStat.size;
             await createZip(zipPath, [
                 {
-                    files: serverFiles,
+                    files: bundlableServerFiles,
                     prefix: serverPrefix
                 },
                 {
@@ -153,7 +155,10 @@ function toPageUploadKey(page) {
 }
 async function walkPublicBundleFiles(publicPath) {
     try {
-        return await walkBundleFiles(publicPath);
+        // The Nitro server serves this tree statically, so secrets copied into the
+        // public directory must not reach the Lambda bundle either.
+        const files = await walkBundleFiles(publicPath);
+        return files.filter((file)=>isPublishableAsset(file.relativePath));
     } catch (error) {
         if (error instanceof EscapingSymlinkError) {
             throw error;

package/dist/utils/adapters/vite.js

@@ -1,20 +1,7 @@
 import path from 'path';
 import { resolveOutputPath } from '../deploy-output/resolveOutputPath.js';
 import { collectFilesRecursive } from '../fs-utils.js';
-/**
- * A buildless static deploy points `--output` at the project root, so local
- * secrets and private history sit beside the intended web assets. Every
- * collected file becomes a publicly reachable route, so never publish these.
- */ const EXCLUDED_ASSET_NAMES = new Set([
-    '.git',
-    '.netrc',
-    '.npmrc',
-    '.ssh',
-    'node_modules'
-]);
-function isPublishableAsset(key) {
-    return key.split('/').every((segment)=>!EXCLUDED_ASSET_NAMES.has(segment) && !segment.startsWith('.env'));
-}
+import { isPublishableAsset } from '../secret-files.js';
 export class ViteAdapter {
     fallback = '/index.html';
     name = 'vite';

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

@@ -30,7 +30,7 @@ type StaticMetadataAssets = Omit<SSGAssets, 'routeAssetMap'>;
 /**
  * Collect SSG asset paths by parsing .next/prerender-manifest.json
  *
- * For each page route without revalidation in the manifest's `routes` object, collects:
+ * For each static page route without revalidation in the manifest's `routes` object, collects:
  * - {route}.html  (full HTML)
  * - {route}.rsc   (React Server Components payload)
  * - {route}.meta  (response headers JSON)

package/dist/utils/asset-collection.js

@@ -77,7 +77,7 @@ const MAX_ASSET_SIZE = 50 * 1024 * 1024 // 50MB
 /**
  * Collect SSG asset paths by parsing .next/prerender-manifest.json
  *
- * For each page route without revalidation in the manifest's `routes` object, collects:
+ * For each static page route without revalidation in the manifest's `routes` object, collects:
  * - {route}.html  (full HTML)
  * - {route}.rsc   (React Server Components payload)
  * - {route}.meta  (response headers JSON)
@@ -125,6 +125,14 @@ const MAX_ASSET_SIZE = 50 * 1024 * 1024 // 50MB
         if (route.initialRevalidateSeconds !== undefined && route.initialRevalidateSeconds !== false) {
             continue;
         }
+        // SSR and PPR can also disable revalidation. Only static computation can be
+        // served from S3; an initial response is safe for a static CSR shell.
+        const hasStaticRendering = route.compute === 'static' && (route.response === 'complete' || route.response === 'initial');
+        // Older SSG entries omit these fields. Ambiguous PPR entries must use Lambda.
+        const hasLegacyStaticRendering = route.compute === undefined && route.response === undefined && (route.renderingMode === undefined || route.renderingMode === 'STATIC');
+        if (!hasStaticRendering && !hasLegacyStaticRendering) {
+            continue;
+        }
         // Strip leading slash for S3 key; handle root "/" → "index"
         const stripped = routeKey === '/' ? 'index' : routeKey.replace(/^\//, '');
         const routeAssets = [];

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

@@ -5,6 +5,7 @@ import { configureNextjsCache } from './configureNextjsCache.js';
 import { inspectNextjsOutput } from './deploy-output/inspectNextjsOutput.js';
 import { resolveOutputPath } from './deploy-output/resolveOutputPath.js';
 import { walkBundleFiles } from './fs-utils.js';
+import { isBundlableFile } from './secret-files.js';
 /**
  * AWS Lambda's hard limit on unzipped deployment code size (250 MB). The unzipped
  * total must be strictly less than this value, so a bundle exactly equal to it is
@@ -31,7 +32,7 @@ import { walkBundleFiles } from './fs-utils.js';
     if (!layout) {
         throw new Error(`Standalone build not found at ${outputPath}`);
     }
-    const files = await walkBundleFiles(layout.standalonePath);
+    const files = (await walkBundleFiles(layout.standalonePath)).filter((file)=>isBundlableFile(file.relativePath));
     // Override archive entries in memory without changing Next's standalone output.
     const bundleFileOverrides = await createBundleFileOverrides(layout.standalonePath, layout.serverEntryPath);
     const zipPath = path.join(projectPath, 'lambda.zip');

package/dist/utils/lambda-config.js

@@ -1,6 +1,8 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { IndentationText, Node, Project, SyntaxKind } from 'ts-morph';
+import { addFigmaImageLoaderConfig } from './next-image-loader-config.js';
+import { writeFigmaImageLoaderFile } from './next-image-loader-file.js';
 import { ensurePnpmWorkspace } from './pnpm-builds.js';
 const RUN_SH_CONTENT = `#!/bin/bash -x
 
@@ -18,8 +20,9 @@ NODE_ENV=production exec node server.js
     const runShPath = path.join(projectPath, 'run.sh');
     await fs.writeFile(runShPath, RUN_SH_CONTENT, 'utf-8');
     await fs.chmod(runShPath, 0o755);
-    // 2. Modify next config to add standalone output
+    // 2. Add Next.js-specific configuration.
     await addNextConfigProperties(projectPath);
+    await writeFigmaImageLoaderFile(projectPath);
     // 3. Add lambda:buildzip script to package.json
     await addLambdaBuildScript(projectPath, packageManager);
     // 4. Write pnpm-workspace.yaml (hoisted linker + build approvals)
@@ -48,6 +51,7 @@ NODE_ENV=production exec node server.js
 /**
  * Add required Next.js config properties using ts-morph AST parsing
  * - output: 'standalone' (for Lambda deployment)
+ * - images.loader: 'custom' and images.loaderFile for Payload media
  */ async function addNextConfigProperties(projectPath) {
     const nextConfigPath = await findNextConfigPath(projectPath);
     const project = new Project({
@@ -65,15 +69,16 @@ NODE_ENV=production exec node server.js
     if (!configObject) {
         throw new Error(`Could not find Next.js config object in ${path.basename(nextConfigPath)}. ` + `Expected either 'export default { ... }' or 'export default wrapper(configVar, ...)'`);
     }
-    const hasOutput = configObject.getProperty('output') !== undefined;
-    if (hasOutput) {
-        return;
+    if (configObject.getProperty('output') === undefined) {
+        configObject.addPropertyAssignment({
+            name: 'output',
+            initializer: "'standalone'"
+        });
+    }
+    addFigmaImageLoaderConfig(configObject);
+    if (!sourceFile.isSaved()) {
+        await sourceFile.save();
     }
-    configObject.addPropertyAssignment({
-        name: 'output',
-        initializer: "'standalone'"
-    });
-    await sourceFile.save();
 }
 /**
  * Find the config object literal from either:

package/dist/utils/next-image-loader-config.d.ts

@@ -0,0 +1,2 @@
+import type { ObjectLiteralExpression } from 'ts-morph';
+export declare function addFigmaImageLoaderConfig(configObject: ObjectLiteralExpression): void;

package/dist/utils/next-image-loader-config.js

@@ -0,0 +1,63 @@
+import { Node, SyntaxKind } from 'ts-morph';
+import { FIGMA_IMAGE_LOADER_PATH } from './next-image-loader-file.js';
+export function addFigmaImageLoaderConfig(configObject) {
+    const imagesProperty = configObject.getProperty('images');
+    if (!imagesProperty) {
+        configObject.addPropertyAssignment({
+            name: 'images',
+            initializer: `{
+        loader: 'custom',
+        loaderFile: '${FIGMA_IMAGE_LOADER_PATH}',
+      }`
+        });
+        return;
+    }
+    let imagesValue;
+    if (Node.isPropertyAssignment(imagesProperty)) {
+        imagesValue = imagesProperty.getInitializer();
+    } else if (Node.isShorthandPropertyAssignment(imagesProperty)) {
+        imagesValue = imagesProperty.getNameNode();
+    }
+    const imagesObject = resolveLocalObjectLiteral(imagesValue);
+    if (!imagesObject) {
+        throw new Error('Figma could not add the image loader because it could not inspect the `images` configuration. ' + 'Define `images` as an object in this Next.js config file and rerun ' + '`npx @payloadcms/figma init`.');
+    }
+    const loaderProperty = imagesObject.getProperty('loader');
+    const loaderFileProperty = imagesObject.getProperty('loaderFile');
+    if (loaderProperty || loaderFileProperty) {
+        const isFigmaLoader = getStringPropertyValue(loaderProperty) === 'custom' && getStringPropertyValue(loaderFileProperty) === FIGMA_IMAGE_LOADER_PATH;
+        if (!isFigmaLoader) {
+            throw new Error('A custom Next.js image loader is already configured, so Figma left it unchanged. ' + 'Remove the existing images.loader and images.loaderFile settings and rerun ' + '`npx @payloadcms/figma init`.');
+        }
+        return;
+    }
+    imagesObject.addPropertyAssignment({
+        name: 'loader',
+        initializer: "'custom'"
+    });
+    imagesObject.addPropertyAssignment({
+        name: 'loaderFile',
+        initializer: `'${FIGMA_IMAGE_LOADER_PATH}'`
+    });
+}
+function resolveLocalObjectLiteral(node) {
+    if (Node.isObjectLiteralExpression(node)) {
+        return node;
+    }
+    if (!Node.isIdentifier(node)) {
+        return undefined;
+    }
+    const sourceFile = node.getSourceFile();
+    for (const definition of node.getDefinitionNodes()){
+        if (Node.isVariableDeclaration(definition) && definition.getSourceFile() === sourceFile) {
+            return definition.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
+        }
+    }
+    return undefined;
+}
+function getStringPropertyValue(property) {
+    if (!property || !Node.isPropertyAssignment(property)) {
+        return undefined;
+    }
+    return property.getInitializerIfKind(SyntaxKind.StringLiteral)?.getLiteralValue();
+}

package/dist/utils/next-image-loader-file.d.ts

@@ -0,0 +1,2 @@
+export declare const FIGMA_IMAGE_LOADER_PATH = "./figma-image-loader.ts";
+export declare function writeFigmaImageLoaderFile(projectPath: string): Promise<void>;

package/dist/utils/next-image-loader-file.js

@@ -0,0 +1,11 @@
+import fs from 'fs/promises';
+import path from 'path';
+export const FIGMA_IMAGE_LOADER_PATH = './figma-image-loader.ts';
+const FIGMA_IMAGE_LOADER_CONTENT = `'use client'
+
+// Generated by @payloadcms/figma. Do not edit.
+export { figmaNextImageLoader as default } from '@payloadcms/figma/next-image-loader'
+`;
+export async function writeFigmaImageLoaderFile(projectPath) {
+    await fs.writeFile(path.join(projectPath, FIGMA_IMAGE_LOADER_PATH), FIGMA_IMAGE_LOADER_CONTENT);
+}

package/dist/utils/secret-files.d.ts

@@ -0,0 +1,25 @@
+/**
+ * True when a forward-slash asset key holds no secret or private-history path
+ * segment.
+ *
+ * A deploy can point `--output` at a directory that also holds those files (a
+ * buildless static root, or a framework output folder that copied them in).
+ * Every collected asset becomes a publicly reachable route, so `node_modules`
+ * is excluded here too.
+ */
+export declare function isPublishableAsset(key: string): boolean;
+/**
+ * True when a forward-slash bundle path belongs in a Lambda zip.
+ *
+ * A server bundle needs its `node_modules`, but never the project's `.env`
+ * files or credentials: a deployed function reads its configuration from
+ * deploy environment variables, and a packed secret only widens the blast
+ * radius of any later path that serves bundle files. `.env.production` is the
+ * deliberate exception, an escape hatch for configuration too large for the
+ * Lambda environment-variable limit.
+ *
+ * Paths inside `node_modules` are kept as-is. A dependency's own dotfiles are
+ * not the developer's secrets, and removing files a package may read at
+ * runtime would break the bundle.
+ */
+export declare function isBundlableFile(relativePath: string): boolean;

package/dist/utils/secret-files.js

@@ -0,0 +1,50 @@
+/**
+ * Local secrets and private history that must never leave the developer's
+ * machine: environment files, git history, and credential files.
+ */ const SECRET_NAMES = new Set([
+    '.git',
+    '.netrc',
+    '.npmrc',
+    '.ssh'
+]);
+/** Installed dependencies: private for static hosting, required by a server bundle. */ const DEPENDENCY_DIR = 'node_modules';
+/**
+ * The one environment file a Lambda zip may carry. AWS caps a function's
+ * environment variables at 4 KB total, so a project with more configuration
+ * than that has no way to pass it except inside the bundle. It is still never
+ * publishable: `isPublishableAsset` rejects it like any other `.env` file.
+ */ const BUNDLABLE_ENV_FILE = '.env.production';
+/**
+ * True when a forward-slash asset key holds no secret or private-history path
+ * segment.
+ *
+ * A deploy can point `--output` at a directory that also holds those files (a
+ * buildless static root, or a framework output folder that copied them in).
+ * Every collected asset becomes a publicly reachable route, so `node_modules`
+ * is excluded here too.
+ */ export function isPublishableAsset(key) {
+    return key.split('/').every((segment)=>segment !== DEPENDENCY_DIR && !isSecretName(segment));
+}
+/**
+ * True when a forward-slash bundle path belongs in a Lambda zip.
+ *
+ * A server bundle needs its `node_modules`, but never the project's `.env`
+ * files or credentials: a deployed function reads its configuration from
+ * deploy environment variables, and a packed secret only widens the blast
+ * radius of any later path that serves bundle files. `.env.production` is the
+ * deliberate exception, an escape hatch for configuration too large for the
+ * Lambda environment-variable limit.
+ *
+ * Paths inside `node_modules` are kept as-is. A dependency's own dotfiles are
+ * not the developer's secrets, and removing files a package may read at
+ * runtime would break the bundle.
+ */ export function isBundlableFile(relativePath) {
+    const segments = relativePath.split('/');
+    if (segments.includes(DEPENDENCY_DIR)) {
+        return true;
+    }
+    return segments.every((segment)=>segment === BUNDLABLE_ENV_FILE || !isSecretName(segment));
+}
+function isSecretName(segment) {
+    return SECRET_NAMES.has(segment) || segment.startsWith('.env');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payloadcms/figma",
-  "version": "0.1.0-alpha.8",
+  "version": "0.1.0-alpha.9",
   "license": "SEE LICENSE IN LICENSE.md",
   "type": "module",
   "exports": {
@@ -14,6 +14,11 @@
       "types": "./dist/exports/client.d.ts",
       "default": "./dist/exports/client.js"
     },
+    "./next-image-loader": {
+      "import": "./dist/next/image-loader.js",
+      "types": "./dist/next/image-loader.d.ts",
+      "default": "./dist/next/image-loader.js"
+    },
     "./views": {
       "import": "./dist/exports/views.js",
       "types": "./dist/exports/views.d.ts",