npm - @solcreek/adapter-creek - Versions diffs - 0.1.2 → 0.1.4 - Mend

@solcreek/adapter-creek 0.1.2 → 0.1.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

package/dist/build.js CHANGED Viewed

@@ -131,7 +131,7 @@ export async function handleBuild(ctx) {
     // Step 3b: Collect prerender entries for ISR cache seeding.
     // Each prerender with a fallback file gets seeded into the cache at startup.
     const fallbackShellRoutes = await collectFallbackShellRoutes(ctx.distDir);
-    const prerenderEntries = await collectPrerenderEntries(ctx.outputs, fallbackShellRoutes);
+    const prerenderEntries = await collectPrerenderEntries(ctx.outputs, fallbackShellRoutes, ctx.distDir);
     if (prerenderEntries.length > 0) {
         console.log(`  [Creek Adapter] ${prerenderEntries.length} prerender entries for cache seeding`);
     }
@@ -140,7 +140,7 @@ export async function handleBuild(ctx) {
     // requests matching that shell — mirrors Next.js's request-scoped RDC and
     // keeps e.g. /with-suspense/* build-time values out of /without-suspense/*
     // requests that expect fresh runtime renders.
-    const composableCacheSeedsByShell = await collectComposableCacheSeeds(ctx.outputs, fallbackShellRoutes);
+    const composableCacheSeedsByShell = await collectComposableCacheSeeds(ctx.outputs, fallbackShellRoutes, ctx.distDir);
     const composableCacheSeedEntries = Array.from(composableCacheSeedsByShell.entries());
     const composableCacheSeedCount = composableCacheSeedEntries.reduce((n, [, seeds]) => n + seeds.length, 0);
     if (composableCacheSeedCount > 0) {
@@ -339,7 +339,7 @@ export async function handleBuild(ctx) {
     // handlers may read at runtime via fs.readFileSync. Next.js's adapter API
     // exposes these per-output as `output.assets` (the result of file tracing).
     // We embed them in __USER_FILES so the fs shim can serve them in workerd.
-    const userFiles = await collectUserFiles(ctx.outputs);
+    const userFiles = await collectUserFiles(ctx.outputs, ctx.distDir, ctx.projectDir);
     if (Object.keys(userFiles).length > 0) {
         console.log(`  [Creek Adapter] ${Object.keys(userFiles).length} user data files embedded`);
     }
@@ -624,6 +624,31 @@ function isStaticHtmlPage(pathname) {
         return true;
     return !path.extname(pathname);
 }
+function internalStaticPageAssetPath(pathname) {
+    const encoded = encodeURIComponent(pathname).replace(/%/g, "~");
+    return path.join("_creek", "static-pages", encoded + ".html");
+}
+const METADATA_ROUTE_NAMES = new Set([
+    "sitemap",
+    "robots",
+    "manifest",
+    "opengraph-image",
+    "twitter-image",
+    "icon",
+    "apple-icon",
+    "favicon",
+]);
+function isMetadataRoutePath(pathname) {
+    const segments = pathname.split("/").filter(Boolean);
+    if (segments.length === 0)
+        return false;
+    const last = segments[segments.length - 1] || "";
+    const lastNoExt = last.replace(/\.[a-z0-9]+$/i, "");
+    if (METADATA_ROUTE_NAMES.has(lastNoExt))
+        return true;
+    const secondLast = segments[segments.length - 2] || "";
+    return METADATA_ROUTE_NAMES.has(secondLast);
+}
 // Inject `data-dpl-id="<buildId>"` into the `<html>` tag of static HTML
 // files at build time. The Pages Router client reads this attribute on
 // page load to populate `globalThis.NEXT_DEPLOYMENT_ID`, then sends
@@ -685,6 +710,24 @@ async function safeMkdirForDest(destPath, label) {
 async function collectStaticFiles(outputs, assetsDir, projectDir, distDir, buildId) {
     let count = 0;
     const allPathnames = new Set(outputs.staticFiles.map((f) => f.pathname));
+    const appRoutePathnames = new Set(outputs.appRoutes.map((route) => route.pathname));
+    const copyStaticHtml = async (srcPath, destRelative) => {
+        const destPath = path.join(assetsDir, destRelative);
+        if (!(await safeMkdirForDest(destPath, destRelative)))
+            return false;
+        try {
+            if (buildId) {
+                await copyHtmlWithDplId(srcPath, destPath, buildId);
+            }
+            else {
+                await fs.copyFile(srcPath, destPath);
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
     for (const file of outputs.staticFiles) {
         let destRelative = file.pathname;
         const isHtml = isStaticHtmlPage(destRelative);
@@ -706,6 +749,10 @@ async function collectStaticFiles(outputs, assetsDir, projectDir, distDir, build
             count++;
         }
         catch { }
+        if (isHtml && file.pathname.includes("[")) {
+            if (await copyStaticHtml(file.filePath, internalStaticPageAssetPath(file.pathname)))
+                count++;
+        }
     }
     for (const prerender of outputs.prerenders) {
         if (prerender.fallback?.filePath) {
@@ -717,6 +764,11 @@ async function collectStaticFiles(outputs, assetsDir, projectDir, distDir, build
             // extension over the pathname — \`/opengraph-image\` has no dot but
             // maps to \`opengraph-image.body\`.
             const isBinary = prerender.fallback.filePath.endsWith(".body");
+            if (isBinary && !appRoutePathnames.has(prerender.pathname)) {
+                // Static App Page .body fallbacks are RSC artifacts; copying them
+                // extensionless would block nested paths like /(.)foo/bar.
+                continue;
+            }
             const isHtml = !isBinary && isStaticHtmlPage(prerender.pathname);
             let destRelative = prerender.pathname;
             if (isHtml) {
@@ -735,7 +787,104 @@ async function collectStaticFiles(outputs, assetsDir, projectDir, distDir, build
                 count++;
             }
             catch { }
+            if (isHtml && prerender.pathname.includes("[")) {
+                if (await copyStaticHtml(prerender.fallback.filePath, internalStaticPageAssetPath(prerender.pathname)))
+                    count++;
+            }
+        }
+    }
+    if (distDir) {
+        try {
+            const manifestPath = path.join(distDir, "prerender-manifest.json");
+            const manifest = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+            for (const routePath of Object.keys(manifest.routes || {})) {
+                if (allPathnames.has(routePath))
+                    continue;
+                if (!isMetadataRoutePath(routePath))
+                    continue;
+                const relativeRoutePath = routePath.replace(/^\/+/, "");
+                const sourceCandidates = [
+                    path.join(distDir, "server", "app", relativeRoutePath + ".body"),
+                    path.join(distDir, "server", "app", relativeRoutePath + ".html"),
+                    path.join(distDir, "server", "app", relativeRoutePath),
+                ];
+                let sourcePath = null;
+                for (const candidate of sourceCandidates) {
+                    try {
+                        await fs.access(candidate);
+                        sourcePath = candidate;
+                        break;
+                    }
+                    catch { }
+                }
+                if (!sourcePath)
+                    continue;
+                const isHtml = sourcePath.endsWith(".html") && isStaticHtmlPage(routePath);
+                const destRelative = isHtml
+                    ? path.join(routePath, "index.html")
+                    : routePath;
+                const destPath = path.join(assetsDir, destRelative);
+                if (!(await safeMkdirForDest(destPath, destRelative)))
+                    continue;
+                if (isHtml && buildId) {
+                    await copyHtmlWithDplId(sourcePath, destPath, buildId);
+                }
+                else {
+                    await fs.copyFile(sourcePath, destPath);
+                }
+                allPathnames.add(routePath);
+                count++;
+            }
         }
+        catch { }
+        try {
+            const manifestPath = path.join(distDir, "prerender-manifest.json");
+            const manifest = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+            for (const [route, dynamicRoute] of Object.entries(manifest.dynamicRoutes || {})) {
+                const fallback = dynamicRoute?.fallback;
+                if (typeof fallback !== "string" || !fallback.endsWith(".html"))
+                    continue;
+                const relativeFallback = fallback.replace(/^\/+/, "");
+                const sourceCandidates = [
+                    path.join(distDir, "server", "pages", relativeFallback),
+                    path.join(distDir, "server", "app", relativeFallback),
+                ];
+                let sourcePath = null;
+                for (const candidate of sourceCandidates) {
+                    try {
+                        await fs.access(candidate);
+                        sourcePath = candidate;
+                        break;
+                    }
+                    catch { }
+                }
+                if (!sourcePath)
+                    continue;
+                const isHtml = isStaticHtmlPage(route);
+                const destRelative = isHtml
+                    ? path.join(route, "index.html")
+                    : route;
+                const destPath = path.join(assetsDir, destRelative);
+                if (!(await safeMkdirForDest(destPath, destRelative)))
+                    continue;
+                if (buildId) {
+                    await copyHtmlWithDplId(sourcePath, destPath, buildId);
+                }
+                else {
+                    await fs.copyFile(sourcePath, destPath);
+                }
+                count++;
+                if (isHtml && relativeFallback !== destRelative) {
+                    if (await copyStaticHtml(sourcePath, relativeFallback))
+                        count++;
+                }
+                if (isHtml && route.includes("[")) {
+                    if (await copyStaticHtml(sourcePath, internalStaticPageAssetPath(route)))
+                        count++;
+                }
+            }
+        }
+        catch { }
     }
     // Edge asset bindings (\`.next/server/edge-chunks/asset_*\`). Edge routes
     // that do \`fetch(new URL('../../assets/foo', import.meta.url))\` get
@@ -913,6 +1062,26 @@ async function collectJsFilesRecursive(dir) {
     }
     return files;
 }
+async function collectFilesRecursive(dir) {
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const files = [];
+    for (const entry of entries) {
+        const absPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...await collectFilesRecursive(absPath));
+            continue;
+        }
+        if (entry.isFile())
+            files.push(absPath);
+    }
+    return files;
+}
 async function getTotalSize(dir, files) {
     let total = 0;
     for (const f of files) {
@@ -1007,7 +1176,7 @@ async function collectManifests(distDir) {
  * worker bundle when a project has large data assets — the user can hit it
  * explicitly to force a different deployment strategy.
  */
-async function collectUserFiles(outputs) {
+async function collectUserFiles(outputs, distDir, projectDir) {
     const TEXT_EXTENSIONS = new Set([
         ".json", ".txt", ".yaml", ".yml", ".md", ".csv", ".xml",
         ".html", ".htm", ".sql", ".graphql", ".gql", ".env",
@@ -1029,6 +1198,9 @@ async function collectUserFiles(outputs) {
         ...outputs.pages,
         ...outputs.pagesApi,
     ];
+    if (outputs.middleware) {
+        allOutputs.push(outputs.middleware);
+    }
     for (const output of allOutputs) {
         const assets = output.assets;
         if (!assets)
@@ -1082,6 +1254,55 @@ async function collectUserFiles(outputs) {
             }
         }
     }
+    if (distDir) {
+        const serverAssetsDir = path.join(distDir, "server", "assets");
+        const serverAssets = await collectFilesRecursive(serverAssetsDir);
+        for (const sourceFile of serverAssets) {
+            const fileOutputPath = path
+                .relative(path.join(distDir, "server"), sourceFile)
+                .replace(/\\/g, "/");
+            const embeddedPath = "server/" + fileOutputPath;
+            if (files[embeddedPath])
+                continue;
+            const ext = path.extname(sourceFile).toLowerCase();
+            const isDeclarationFile = sourceFile.endsWith(".d.ts");
+            const isText = TEXT_EXTENSIONS.has(ext) || isDeclarationFile;
+            const isBinary = BINARY_EXTENSIONS.has(ext);
+            if (!isText && !isBinary)
+                continue;
+            try {
+                if (isText) {
+                    const content = await fs.readFile(sourceFile, "utf-8");
+                    if (totalBytes + content.length > MAX_TOTAL_BYTES)
+                        continue;
+                    files[embeddedPath] = content;
+                    totalBytes += content.length;
+                }
+                else {
+                    const buffer = await fs.readFile(sourceFile);
+                    const encoded = "__CREEK_B64__" + buffer.toString("base64");
+                    if (totalBytes + encoded.length > MAX_TOTAL_BYTES)
+                        continue;
+                    files[embeddedPath] = encoded;
+                    totalBytes += encoded.length;
+                }
+            }
+            catch { }
+        }
+    }
+    if (projectDir) {
+        const packageJsonPath = path.join(projectDir, "package.json");
+        if (!files["package.json"]) {
+            try {
+                const content = await fs.readFile(packageJsonPath, "utf-8");
+                if (totalBytes + content.length <= MAX_TOTAL_BYTES) {
+                    files["package.json"] = content;
+                    totalBytes += content.length;
+                }
+            }
+            catch { }
+        }
+    }
     return files;
 }
 async function collectFallbackShellRoutes(distDir) {
@@ -1105,12 +1326,21 @@ async function collectFallbackShellRoutes(distDir) {
         return null;
     }
 }
+async function readAppRouteMeta(distDir, pathname) {
+    try {
+        const metaPath = path.join(distDir, "server", "app", pathname.replace(/^\/+/, "") + ".meta");
+        return JSON.parse(await fs.readFile(metaPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Collect prerender entries from build outputs for App Router PPR/cache seeding.
  * Pages Router prerenders are served from assets and don't need to be embedded
  * in the worker bundle.
  */
-async function collectPrerenderEntries(outputs, fallbackShellRoutes) {
+async function collectPrerenderEntries(outputs, fallbackShellRoutes, distDir) {
     const entries = [];
     // The Next adapter emits one \`prerenders\` entry per output file — including
     // \`.rsc\` sidecars and \`.segments/*.segment.rsc\` fragments. Those aren't
@@ -1121,8 +1351,18 @@ async function collectPrerenderEntries(outputs, fallbackShellRoutes) {
         const fallback = prerender.fallback;
         if (!fallback?.filePath || !fallback.filePath.endsWith(".html"))
             continue;
-        const hasPostponedState = typeof fallback.postponedState === "string" &&
-            fallback.postponedState.length > 0;
+        const metaPath = fallback.filePath.replace(/\.(html|body)$/, ".meta");
+        const meta = await fs.readFile(metaPath, "utf-8")
+            .then((raw) => JSON.parse(raw))
+            .catch(() => null);
+        const postponedState = typeof fallback.postponedState === "string" &&
+            fallback.postponedState.length > 0
+            ? fallback.postponedState
+            : typeof meta?.postponed === "string" && meta.postponed.length > 0
+                ? meta.postponed
+                : undefined;
+        const hasPostponedState = typeof postponedState === "string" &&
+            postponedState.length > 0;
         const hasPprHeaders = !!prerender.pprChain?.headers;
         const isPprChain = hasPostponedState || hasPprHeaders;
         // Skip bracket-form fallback shells — they're handled via the
@@ -1131,10 +1371,6 @@ async function collectPrerenderEntries(outputs, fallbackShellRoutes) {
             continue;
         try {
             const stat = await fs.stat(fallback.filePath).catch(() => null);
-            const metaPath = fallback.filePath.replace(/\.(html|body)$/, ".meta");
-            const meta = await fs.readFile(metaPath, "utf-8")
-                .then((raw) => JSON.parse(raw))
-                .catch(() => null);
             // Never inline HTML into the worker bundle — it can be multi-MB
             // (e.g. memory-pressure pages are ~2MB each). \`__creekSeededAppPageEntry\`
             // fetches HTML and RSC from the assets bucket at request time. The seed
@@ -1142,10 +1378,11 @@ async function collectPrerenderEntries(outputs, fallbackShellRoutes) {
             entries.push({
                 pathname: prerender.pathname,
                 html: "",
-                postponedState: fallback.postponedState,
-                allowsFallbackShellResume: fallbackShellRoutes
-                    ? fallbackShellRoutes.has(prerender.pathname)
-                    : undefined,
+                postponedState,
+                allowsFallbackShellResume: prerender.config?.partialFallback === true &&
+                    (fallbackShellRoutes
+                        ? fallbackShellRoutes.has(prerender.pathname)
+                        : true),
                 initialRevalidate: fallback.initialRevalidate,
                 initialStatus: fallback.initialStatus,
                 initialHeaders: fallback.initialHeaders,
@@ -1162,6 +1399,34 @@ async function collectPrerenderEntries(outputs, fallbackShellRoutes) {
             // Skip prerenders whose fallback file can't be read
         }
     }
+    // Some App Router fallback shells (notably cacheComponents routes without
+    // generateStaticParams) are present in prerender-manifest + .meta but are not
+    // surfaced with fallback.postponedState in the adapter outputs. Add minimal
+    // entries from .meta so the worker can still inject requestMeta.postponed.
+    if (fallbackShellRoutes) {
+        const existing = new Set(entries.map((entry) => entry.pathname));
+        for (const pathname of fallbackShellRoutes) {
+            if (existing.has(pathname))
+                continue;
+            const meta = await readAppRouteMeta(distDir, pathname);
+            if (typeof meta?.postponed !== "string" || meta.postponed.length === 0)
+                continue;
+            entries.push({
+                pathname,
+                html: "",
+                postponedState: meta.postponed,
+                allowsFallbackShellResume: true,
+                initialStatus: typeof meta.status === "number" ? meta.status : undefined,
+                initialHeaders: meta.headers && typeof meta.headers === "object"
+                    ? meta.headers
+                    : undefined,
+                segmentPaths: Array.isArray(meta.segmentPaths) ? meta.segmentPaths : undefined,
+                metaHeaders: meta.headers && typeof meta.headers === "object"
+                    ? meta.headers
+                    : undefined,
+            });
+        }
+    }
     return entries;
 }
 /**
@@ -1178,37 +1443,29 @@ async function collectPrerenderEntries(outputs, fallbackShellRoutes) {
  * naturally by Map key — the last seen wins, which is fine since they're
  * semantically identical.
  */
-async function collectComposableCacheSeeds(outputs, fallbackShellRoutes) {
+async function collectComposableCacheSeeds(outputs, fallbackShellRoutes, distDir) {
     const zlib = await import("node:zlib");
     // Map bracket-form pathname → its cache entries. Gating by shell prevents
     // seeds from one prerender's request-scoped RDC from bleeding into
     // unrelated requests (e.g. \`/with-suspense/*\`'s build-time "buildtime"
     // leaking into \`/without-suspense/*\` where the test expects "runtime").
     const byShell = new Map();
-    for (const prerender of outputs.prerenders) {
-        if (prerender.pathname.includes("[") &&
-            fallbackShellRoutes &&
-            !fallbackShellRoutes.has(prerender.pathname)) {
-            continue;
-        }
-        const postponed = prerender.fallback?.postponedState;
-        if (typeof postponed !== "string" || postponed.length === 0)
-            continue;
+    const extractSeedsFromPostponed = (postponed) => {
         const m = postponed.match(/^(\d+):/);
         if (!m)
-            continue;
+            return null;
         const prefixLen = m[0].length;
         const postponedLen = parseInt(m[1], 10);
         const cacheBlob = postponed.slice(prefixLen + postponedLen);
         if (!cacheBlob || cacheBlob === "null")
-            continue;
+            return null;
         try {
             const buf = Buffer.from(cacheBlob, "base64");
             const inflated = zlib.inflateSync(buf, { maxOutputLength: 200 * 1024 * 1024 });
             const json = JSON.parse(inflated.toString("utf-8"));
             const cacheStore = json?.store?.cache;
             if (!cacheStore || typeof cacheStore !== "object")
-                continue;
+                return null;
             const shellSeeds = [];
             for (const [key, serialized] of Object.entries(cacheStore)) {
                 if (!serialized?.entry)
@@ -1224,10 +1481,48 @@ async function collectComposableCacheSeeds(outputs, fallbackShellRoutes) {
                     revalidate: typeof e.revalidate === "number" ? e.revalidate : Number.MAX_SAFE_INTEGER,
                 });
             }
-            if (shellSeeds.length > 0)
-                byShell.set(prerender.pathname, shellSeeds);
+            return shellSeeds.length > 0 ? shellSeeds : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    for (const prerender of outputs.prerenders) {
+        const isPartialFallback = prerender.config?.partialFallback === true;
+        if (prerender.pathname.includes("[") &&
+            (!isPartialFallback ||
+                (fallbackShellRoutes && !fallbackShellRoutes.has(prerender.pathname)))) {
+            continue;
+        }
+        let postponed = prerender.fallback?.postponedState;
+        if ((typeof postponed !== "string" || postponed.length === 0) &&
+            prerender.fallback?.filePath) {
+            const metaPath = prerender.fallback.filePath.replace(/\.(html|body)$/, ".meta");
+            const metaPostponed = await fs.readFile(metaPath, "utf-8")
+                .then((raw) => JSON.parse(raw)?.postponed)
+                .catch(() => null);
+            if (typeof metaPostponed === "string" && metaPostponed.length > 0) {
+                postponed = metaPostponed;
+            }
+        }
+        if (typeof postponed !== "string" || postponed.length === 0)
+            continue;
+        const shellSeeds = extractSeedsFromPostponed(postponed);
+        if (shellSeeds)
+            byShell.set(prerender.pathname, shellSeeds);
+    }
+    if (fallbackShellRoutes) {
+        for (const pathname of fallbackShellRoutes) {
+            if (byShell.has(pathname))
+                continue;
+            const meta = await readAppRouteMeta(distDir, pathname);
+            const postponed = meta?.postponed;
+            if (typeof postponed !== "string" || postponed.length === 0)
+                continue;
+            const shellSeeds = extractSeedsFromPostponed(postponed);
+            if (shellSeeds)
+                byShell.set(pathname, shellSeeds);
         }
-        catch { }
     }
     return byShell;
 }

package/dist/bundler.d.ts CHANGED Viewed

@@ -16,5 +16,8 @@ export interface BundleOptions {
     repoRoot: string;
     standaloneDir: string;
 }
+export declare function patchUseCachePrerenderDanglingPromiseBailout(workerCode: string): string;
+export declare function patchNullFallbackPartialShellBlocking(workerCode: string): string;
+export declare function patchAppPageRevalidationPostponedState(workerCode: string): string;
 export declare function bundleForWorkers(opts: BundleOptions): Promise<string[]>;
 //# sourceMappingURL=bundler.d.ts.map