@payloadcms/figma 0.1.0-alpha.7 → 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/oauth/components/LoginButton/index.js

@@ -6,6 +6,17 @@ import { getSearchParam } from '../../utils/getSearchParam.js';
 import { resolveParentTargetOrigin, setupIframeAutoLogin } from './iframeAutoLogin.js';
 import './index.scss';
 const baseClass = 'oauth-login';
+const COLLECTION_SKELETON_KEYS = [
+    'collection-1',
+    'collection-2',
+    'collection-3',
+    'collection-4'
+];
+const GLOBAL_SKELETON_KEYS = [
+    'global-1',
+    'global-2',
+    'global-3'
+];
 // Max time we wait for the parent (figma.com) to respond with a code after
 // posting `mint-cms-oauth-code`. If we hit this without a reply, we assume
 // the parent isn't going to respond and fall back to the manual login button.
@@ -49,6 +60,57 @@ const FigmaIcon = ()=>/*#__PURE__*/ _jsx("svg", {
             fillRule: "evenodd"
         })
     });
+const PayloadAdminLoadingShimmer = ()=>/*#__PURE__*/ _jsx("div", {
+        "aria-label": "Signing in",
+        "aria-live": "polite",
+        className: `${baseClass}__admin-shimmer`,
+        role: "status",
+        children: /*#__PURE__*/ _jsxs("div", {
+            "aria-hidden": "true",
+            className: `${baseClass}__admin-shimmer-main`,
+            children: [
+                /*#__PURE__*/ _jsxs("div", {
+                    className: `${baseClass}__shimmer-heading-row`,
+                    children: [
+                        /*#__PURE__*/ _jsx("div", {
+                            className: `${baseClass}__shimmer-block ${baseClass}__shimmer-heading-icon`
+                        }),
+                        /*#__PURE__*/ _jsx("div", {
+                            className: `${baseClass}__shimmer-block ${baseClass}__shimmer-heading-label`
+                        })
+                    ]
+                }),
+                /*#__PURE__*/ _jsxs("div", {
+                    className: `${baseClass}__shimmer-section`,
+                    children: [
+                        /*#__PURE__*/ _jsx("div", {
+                            className: `${baseClass}__shimmer-block ${baseClass}__shimmer-section-label`
+                        }),
+                        /*#__PURE__*/ _jsx("div", {
+                            className: `${baseClass}__shimmer-card-grid`,
+                            children: COLLECTION_SKELETON_KEYS.map((key)=>/*#__PURE__*/ _jsx("div", {
+                                    className: `${baseClass}__shimmer-block ${baseClass}__shimmer-card`
+                                }, key))
+                        })
+                    ]
+                }),
+                /*#__PURE__*/ _jsxs("div", {
+                    className: `${baseClass}__shimmer-section`,
+                    children: [
+                        /*#__PURE__*/ _jsx("div", {
+                            className: `${baseClass}__shimmer-block ${baseClass}__shimmer-section-label`
+                        }),
+                        /*#__PURE__*/ _jsx("div", {
+                            className: `${baseClass}__shimmer-card-grid`,
+                            children: GLOBAL_SKELETON_KEYS.map((key)=>/*#__PURE__*/ _jsx("div", {
+                                    className: `${baseClass}__shimmer-block ${baseClass}__shimmer-card`
+                                }, key))
+                        })
+                    ]
+                })
+            ]
+        })
+    });
 export const DefaultLoginButton = ({ disabled, endpointSlug })=>{
     const { config: { admin: { user: userSlug }, routes: { api }, serverURL } } = useConfig();
     const [authorizeURL, setAuthorizeURL] = useState('');
@@ -150,26 +212,11 @@ export const DefaultLoginButton = ({ disabled, endpointSlug })=>{
         endpointSlug
     ]);
     if (!shouldRenderButton) {
-        // In the iframe auto-login window, show a "Signing in…" hint so the
-        // user sees something is happening instead of a blank slot until the
-        // flow either navigates them away or times out into the manual button.
+        // In the iframe auto-login window, show a Payload admin-shaped shimmer
+        // until the flow either navigates them away or times out into the manual
+        // button.
         if (isInIframe === true && !disabled) {
-            return /*#__PURE__*/ _jsx("div", {
-                className: baseClass,
-                children: /*#__PURE__*/ _jsxs("div", {
-                    className: `${baseClass}__signing-in`,
-                    role: "status",
-                    children: [
-                        /*#__PURE__*/ _jsx("span", {
-                            children: "Signing in"
-                        }),
-                        /*#__PURE__*/ _jsx("div", {
-                            "aria-hidden": "true",
-                            className: `${baseClass}__spinner`
-                        })
-                    ]
-                })
-            });
+            return /*#__PURE__*/ _jsx(PayloadAdminLoadingShimmer, {});
         }
         return null;
     }

package/dist/oauth/components/LoginButton/index.scss

@@ -1,3 +1,10 @@
+.oauth-login,
+.oauth-login__admin-shimmer {
+  --oauth-login-shimmer-bg: var(--theme-bg, var(--theme-elevation-0, #ffffff));
+  --oauth-login-shimmer-block: var(--theme-elevation-100, #efefef);
+  --oauth-login-shimmer-highlight: var(--theme-elevation-200, #f7f7f7);
+}
+
 .oauth-login {
   display: flex;
   justify-content: center;
@@ -55,28 +62,127 @@
       Oxygen, Ubuntu, Cantarell, sans-serif;
   }
 
-  &__signing-in {
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    gap: 0.75rem;
-    font-size: 1rem;
+  &__admin-shimmer {
+    position: fixed;
+    inset: 0;
+    z-index: 1000;
+    overflow: hidden;
+    background: var(--oauth-login-shimmer-bg);
     font-family: Inter, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto,
       Oxygen, Ubuntu, Cantarell, sans-serif;
   }
 
-  &__spinner {
-    width: 24px;
-    height: 24px;
-    border: 2px solid var(--theme-elevation-200, #e5e5e5);
-    border-top-color: currentColor;
-    border-radius: 50%;
-    animation: oauth-login-spin 0.8s linear infinite;
+  &__admin-shimmer-main {
+    padding: 2rem 2.5rem;
+  }
+
+  &__shimmer-block {
+    position: relative;
+    overflow: hidden;
+    border-radius: 0.25rem;
+    background-color: var(--oauth-login-shimmer-block);
+  }
+
+  &__shimmer-block::after {
+    content: '';
+    position: absolute;
+    inset: 0;
+    border-radius: inherit;
+    background-image: linear-gradient(
+      100deg,
+      transparent 0%,
+      transparent 35%,
+      var(--oauth-login-shimmer-highlight) 50%,
+      transparent 65%,
+      transparent 100%
+    );
+    pointer-events: none;
+    transform: translateX(-100%);
+    animation: oauth-login-shimmer 1.45s linear infinite;
+  }
+
+  &__shimmer-heading-row {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    height: 1.75rem;
+    margin-bottom: 1rem;
+  }
+
+  &__shimmer-heading-icon {
+    width: 1.5rem;
+    height: 1.5rem;
+  }
+
+  &__shimmer-heading-label {
+    width: 7.5rem;
+    height: 1.25rem;
+  }
+
+  &__shimmer-section {
+    margin-bottom: 1.5rem;
+  }
+
+  &__shimmer-section-label {
+    width: 7.5rem;
+    height: 1.25rem;
+    margin-bottom: 0.5rem;
+  }
+
+  &__shimmer-card-grid {
+    display: grid;
+    grid-template-columns: repeat(4, minmax(0, 1fr));
+    gap: 1rem;
+    max-width: 51.625rem;
+  }
+
+  &__shimmer-card {
+    height: 4rem;
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  .oauth-login,
+  .oauth-login__admin-shimmer {
+    --oauth-login-shimmer-bg: var(--theme-bg, var(--theme-elevation-0, #2b2b2b));
+    --oauth-login-shimmer-block: var(--theme-elevation-100, #383838);
+    --oauth-login-shimmer-highlight: var(--theme-elevation-200, #444444);
+  }
+}
+
+@media (max-width: 48rem) {
+  .oauth-login {
+    &__shimmer-card-grid {
+      grid-template-columns: repeat(2, minmax(0, 1fr));
+    }
   }
 }
 
-@keyframes oauth-login-spin {
+@media (max-width: 30rem) {
+  .oauth-login {
+    &__admin-shimmer-main {
+      padding-right: 0.75rem;
+      padding-left: 0.75rem;
+    }
+
+    &__shimmer-card-grid {
+      grid-template-columns: 1fr;
+    }
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .oauth-login__shimmer-block::after {
+    animation: none;
+  }
+}
+
+@keyframes oauth-login-shimmer {
+  from {
+    transform: translateX(-100%);
+  }
+
   to {
-    transform: rotate(360deg);
+    transform: translateX(100%);
   }
 }

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

@@ -1,10 +1,11 @@
 import archiver from 'archiver';
-import { createWriteStream, statSync } from 'fs';
+import { createWriteStream } 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';
+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 = {};
@@ -57,8 +58,8 @@ export class NitroAdapter {
             throw new Error(`Nitro server build not found at ${layout.outputPath}`);
         }
         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 serverPrefix = zipPrefix(path.relative(layout.outputPath, serverDir).split(path.sep).join('/'));
+        const publicPrefix = zipPrefix(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), {
@@ -66,22 +67,33 @@ export class NitroAdapter {
         });
         const zipPath = path.join(projectPath, 'lambda.zip');
         try {
+            const runShStat = await fs.stat(runShPath);
+            const [allServerFiles, publicFiles] = await Promise.all([
+                walkBundleFiles(serverDir),
+                walkPublicBundleFiles(layout.publicPath)
+            ]);
+            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, [
                 {
-                    prefix: `${serverPrefix}/`,
-                    source: serverDir
+                    files: bundlableServerFiles,
+                    prefix: serverPrefix
                 },
                 {
-                    prefix: `${publicPrefix}/`,
-                    source: layout.publicPath
+                    files: publicFiles,
+                    prefix: publicPrefix
                 },
                 {
-                    prefix: '',
-                    source: runShPath
+                    files: [
+                        {
+                            relativePath: 'run.sh',
+                            size: runShStat.size,
+                            sourcePath: runShPath
+                        }
+                    ],
+                    prefix: ''
                 }
             ]);
-            const runShStat = await fs.stat(runShPath);
-            const unzippedBytes = await getDirectorySize(serverDir) + await getDirectorySize(layout.publicPath) + runShStat.size;
             return {
                 unzippedBytes,
                 zipPath
@@ -135,9 +147,25 @@ NODE_ENV=production exec node '${escapedEntry}'
     }
     return pages;
 }
+function zipPrefix(relativeDir) {
+    return relativeDir ? `${relativeDir}/` : '';
+}
 function toPageUploadKey(page) {
     return page === 'index' ? 'index.html' : `${page}/index.html`;
 }
+async function walkPublicBundleFiles(publicPath) {
+    try {
+        // 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;
+        }
+        return [];
+    }
+}
 async function createZip(zipPath, entries) {
     return new Promise((resolve, reject)=>{
         const output = createWriteStream(zipPath);
@@ -150,17 +178,10 @@ async function createZip(zipPath, entries) {
         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
+            for (const file of entry.files){
+                archive.file(file.sourcePath, {
+                    name: entry.prefix + file.relativePath
+                });
             }
         }
         void archive.finalize();

package/dist/utils/adapters/vite.js

@@ -1,12 +1,13 @@
 import path from 'path';
 import { resolveOutputPath } from '../deploy-output/resolveOutputPath.js';
 import { collectFilesRecursive } from '../fs-utils.js';
+import { isPublishableAsset } from '../secret-files.js';
 export class ViteAdapter {
     fallback = '/index.html';
     name = 'vite';
     async collectAssets(projectPath, output) {
         const outputPath = resolveOutputPath(projectPath, 'vite', output);
-        const files = await collectFilesRecursive(outputPath, outputPath);
+        const files = (await collectFilesRecursive(outputPath, outputPath)).filter(isPublishableAsset);
         const pathMap = Object.fromEntries(files.map((file)=>[
                 file,
                 path.relative(projectPath, path.join(outputPath, file))

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 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 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)
@@ -112,11 +112,6 @@ const MAX_ASSET_SIZE = 50 * 1024 * 1024 // 50MB
     const keys = [];
     const pathMap = {};
     const routeAssetMap = {};
-    const extensions = [
-        '.html',
-        '.rsc',
-        '.meta'
-    ];
     const appDir = path.join(outputPath, 'server', 'app');
     for (const [routeKey, route] of Object.entries(manifest.routes)){
         // Current manifests classify app pages explicitly. Older App Router manifests
@@ -125,9 +120,34 @@ const MAX_ASSET_SIZE = 50 * 1024 * 1024 // 50MB
         if (!isPageRoute) {
             continue;
         }
+        // ISR prerenders are seeds for the Next.js runtime, not permanent S3 pages.
+        // Keep legacy manifests without this field; only false explicitly disables revalidation.
+        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 = [];
+        // For partially static routes, dataRoute can name a runtime endpoint even
+        // when the build has no full RSC file. Next.js sets prefetchDataRoute only
+        // when it emits that static payload.
+        const hasFullRSC = route.renderingMode !== 'PARTIALLY_STATIC' || typeof route.prefetchDataRoute === 'string';
+        const extensions = hasFullRSC ? [
+            '.html',
+            '.rsc',
+            '.meta'
+        ] : [
+            '.html',
+            '.meta'
+        ];
         for (const ext of extensions){
             const s3Key = `${stripped}${ext}`;
             keys.push(s3Key);