@solcreek/adapter-creek 0.1.0

package/dist/cache-handler.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Cache handler for Next.js ISR on Cloudflare Workers.
+ *
+ * Implements the cacheHandler interface (get/set/revalidateTag/resetRequestCache).
+ * Uses in-memory Map for single-instance caching.
+ *
+ * TODO: Phase 2 — migrate to Durable Objects for persistent, multi-instance cache
+ * with tag-based invalidation via DOShardedTagCache.
+ */
+export default class CacheHandler {
+    constructor(_ctx?: unknown);
+    get(key: string, _ctx?: {
+        kind?: string;
+    }): Promise<{
+        value: unknown;
+        lastModified: number;
+        age: number;
+        cacheState: "stale";
+    } | {
+        value: unknown;
+        lastModified: number;
+        age: number;
+        cacheState: "fresh";
+    } | null>;
+    set(key: string, data: unknown | null, ctx?: {
+        tags?: string[];
+        revalidate?: number | false;
+    }): Promise<void>;
+    revalidateTag(tag: string | string[]): Promise<void>;
+    resetRequestCache(): void;
+}
+//# sourceMappingURL=cache-handler.d.ts.map

package/dist/cache-handler.js

@@ -0,0 +1,100 @@
+/**
+ * Cache handler for Next.js ISR on Cloudflare Workers.
+ *
+ * Implements the cacheHandler interface (get/set/revalidateTag/resetRequestCache).
+ * Uses in-memory Map for single-instance caching.
+ *
+ * TODO: Phase 2 — migrate to Durable Objects for persistent, multi-instance cache
+ * with tag-based invalidation via DOShardedTagCache.
+ */
+const cache = new Map();
+const tagToKeys = new Map();
+// When a tag is invalidated via revalidateTag(), we record the wall-clock
+// timestamp here. Subsequent get() calls compare this against the entry's
+// lastModified — if the tag was invalidated AFTER the entry was written,
+// the entry is treated as stale (cacheState: "stale") rather than missing.
+//
+// This implements stale-while-revalidate semantics: Next.js receives the
+// old value plus the stale signal and decides to serve it while triggering
+// a background re-render. Aligned with opennextjs-cloudflare#1168.
+const tagInvalidatedAt = new Map();
+function isStaleByTags(entry) {
+    for (const tag of entry.tags) {
+        const invalidatedAt = tagInvalidatedAt.get(tag);
+        if (invalidatedAt !== undefined && invalidatedAt > entry.lastModified) {
+            return true;
+        }
+    }
+    return false;
+}
+export default class CacheHandler {
+    constructor(_ctx) {
+        // Context includes serverDistDir, dev, etc.
+        // Not needed for in-memory implementation.
+    }
+    async get(key, _ctx) {
+        const entry = cache.get(key);
+        if (!entry)
+            return null;
+        const age = (Date.now() - entry.lastModified) / 1000;
+        // Stale if either (a) any of its tags was invalidated since write, or
+        // (b) time-based revalidate has elapsed.
+        const staleByTag = isStaleByTags(entry);
+        const staleByTime = entry.revalidate !== undefined &&
+            entry.revalidate !== false &&
+            (entry.revalidate === 0 || age > entry.revalidate);
+        if (staleByTag || staleByTime) {
+            return {
+                value: entry.value,
+                lastModified: entry.lastModified,
+                age: Math.floor(age),
+                cacheState: "stale",
+            };
+        }
+        return {
+            value: entry.value,
+            lastModified: entry.lastModified,
+            age: Math.floor(age),
+            cacheState: "fresh",
+        };
+    }
+    async set(key, data, ctx) {
+        if (data === null) {
+            cache.delete(key);
+            return;
+        }
+        const tags = ctx?.tags ?? [];
+        const revalidate = typeof ctx?.revalidate === "number" ? ctx.revalidate : undefined;
+        cache.set(key, {
+            value: data,
+            lastModified: Date.now(),
+            tags,
+            revalidate,
+        });
+        // Index by tags for revalidateTag()
+        for (const tag of tags) {
+            let keys = tagToKeys.get(tag);
+            if (!keys) {
+                keys = new Set();
+                tagToKeys.set(tag, keys);
+            }
+            keys.add(key);
+        }
+    }
+    async revalidateTag(tag) {
+        const tags = Array.isArray(tag) ? tag : [tag];
+        const now = Date.now();
+        // Mark each tag as invalidated NOW. Existing entries become stale on
+        // the next get(); fresh writes (lastModified > now) are unaffected.
+        // We do NOT delete entries — Next.js wants to serve them as stale
+        // while it re-renders in the background.
+        for (const t of tags) {
+            tagInvalidatedAt.set(t, now);
+        }
+    }
+    resetRequestCache() {
+        // No per-request cache to reset in this implementation.
+    }
+}
+;
+//# sourceMappingURL=cache-handler.js.map

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { NextAdapter } from "next";
+declare const adapter: NextAdapter;
+export default adapter;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,247 @@
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { handleBuild } from "./build.js";
+/**
+ * Detect the monorepo root by walking up looking for workspace markers.
+ */
+function findRepoRoot(startDir) {
+    let dir = startDir;
+    while (true) {
+        if (existsSync(path.join(dir, "pnpm-workspace.yaml")) ||
+            existsSync(path.join(dir, "turbo.json"))) {
+            return dir;
+        }
+        const pkgPath = path.join(dir, "package.json");
+        if (existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+                if (pkg.workspaces)
+                    return dir;
+            }
+            catch { }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return startDir;
+}
+/**
+ * Detect direct dependencies whose `.js` entry files contain JSX.
+ *
+ * Turbopack at the pinned Next.js canary has a regression where it fails
+ * to parse JSX inside `.js` files shipped by a workspace-linked / third-
+ * party package (exit message: `Expected ';', got 'ident'`). The
+ * documented fix is to add the package to `transpilePackages` so Next.js
+ * runs SWC over it. Vanilla `next build` fails identically on these
+ * fixtures without our adapter — but user apps don't get to edit their
+ * own `next.config.js` just because we say so, so we auto-inject.
+ *
+ * Scope: only DIRECT deps. Transitive deps are either already transpiled
+ * by their publisher (the common case) or reachable through the direct
+ * dep we pick up. Walking all of node_modules would be slow and catch
+ * unrelated packages.
+ *
+ * Detection: we resolve each dep's entry file (`package.json#exports["."]`
+ * or `main`) and heuristically look for JSX with strong React hints.
+ * False positives cost a little build time (Next.js transpiles an
+ * already-ES-code package); false negatives are the status quo. The
+ * heuristic is conservative — we require BOTH a JSX construct AND a
+ * React signal ('use client' / react import / createElement) to claim
+ * a package needs transpile.
+ */
+function detectPackagesNeedingTranspile(projectDir) {
+    let projectPkg;
+    try {
+        projectPkg = JSON.parse(readFileSync(path.join(projectDir, "package.json"), "utf-8"));
+    }
+    catch {
+        return [];
+    }
+    const directDeps = new Set();
+    for (const field of ["dependencies", "devDependencies", "peerDependencies"]) {
+        const map = projectPkg[field];
+        if (map && typeof map === "object") {
+            for (const name of Object.keys(map))
+                directDeps.add(name);
+        }
+    }
+    if (directDeps.size === 0)
+        return [];
+    // Don't ever try to transpile Next.js itself or the React runtimes —
+    // they're pre-bundled and transpilePackages on them would be an
+    // expensive no-op at best, a breakage at worst.
+    const SKIP = new Set([
+        "next", "react", "react-dom", "react-server-dom-webpack",
+        "react-dom/server", "scheduler", "@next/routing", "@next/swc",
+        "@solcreek/adapter-creek",
+    ]);
+    const needsTranspile = [];
+    for (const dep of directDeps) {
+        if (SKIP.has(dep))
+            continue;
+        // Ignore subpath-qualified entries that aren't real packages (shouldn't
+        // show up in dependencies, but be defensive).
+        if (dep.includes("/") && !dep.startsWith("@"))
+            continue;
+        // Locate the package root via direct node_modules path. Can't use
+        // `require.resolve(dep + '/package.json')` — Node's resolver honors
+        // the `exports` field and most packages don't expose `./package.json`.
+        // pnpm's flat node_modules layout hoists a symlink at
+        // `node_modules/<dep>` for every direct + hoisted dep, so this works
+        // across npm, yarn, pnpm.
+        const pkgRoot = path.join(projectDir, "node_modules", dep);
+        const pkgJsonPath = path.join(pkgRoot, "package.json");
+        let pkgJson;
+        try {
+            pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+        }
+        catch {
+            continue;
+        }
+        // Skip packages that declare themselves ES (module field points at
+        // .mjs) AND ship no .js siblings — transpile wouldn't kick in for
+        // them anyway. We still process packages whose `main` is a .js.
+        const entryCandidates = collectEntryFiles(pkgJson, pkgRoot);
+        if (entryCandidates.length === 0)
+            continue;
+        for (const entry of entryCandidates) {
+            try {
+                const content = readFileSync(entry, "utf-8");
+                if (looksLikeJsxInJs(content, entry)) {
+                    needsTranspile.push(dep);
+                    break; // one hit is enough; move to next package
+                }
+            }
+            catch { }
+        }
+    }
+    return needsTranspile;
+}
+/**
+ * Pick the `.js` entry file(s) for a package. Only files that end in `.js`
+ * (and not `.mjs` / `.cjs`) are eligible — the others are either module-
+ * specific formats (where Turbopack's JSX-in-JS bug doesn't apply) or
+ * already indicate transpilation happened upstream.
+ */
+function collectEntryFiles(pkgJson, pkgRoot) {
+    const candidates = [];
+    const tryAdd = (rel) => {
+        if (typeof rel !== "string")
+            return;
+        if (!rel.endsWith(".js"))
+            return;
+        const abs = path.join(pkgRoot, rel.startsWith("./") ? rel.slice(2) : rel);
+        try {
+            if (statSync(abs).isFile())
+                candidates.push(abs);
+        }
+        catch { }
+    };
+    tryAdd(pkgJson.main);
+    // `exports` can be a string, or a nested conditional object. We walk
+    // the "." entry's import/require/default branches.
+    const exports_ = pkgJson.exports;
+    if (typeof exports_ === "string") {
+        tryAdd(exports_);
+    }
+    else if (exports_ && typeof exports_ === "object") {
+        const rootExport = exports_["."] ?? exports_;
+        if (typeof rootExport === "string") {
+            tryAdd(rootExport);
+        }
+        else if (rootExport && typeof rootExport === "object") {
+            for (const cond of ["default", "import", "require", "node", "browser"]) {
+                tryAdd(rootExport[cond]);
+            }
+        }
+    }
+    return [...new Set(candidates)];
+}
+/**
+ * Heuristic: a `.js` file looks like it contains JSX if it has at least
+ * one JSX-ish token AND at least one React signal. Both conditions keeps
+ * false positives low (e.g. plain TS generics `function f<T>()` without
+ * React imports won't trigger).
+ */
+function looksLikeJsxInJs(content, filePath) {
+    if (!filePath.endsWith(".js"))
+        return false;
+    const head = content.slice(0, 20_000); // cap scan cost
+    const JSX_HINTS = [
+        /return\s*\(\s*</, // return (<...
+        /return\s+<[A-Za-z]/, // return <Tag or <Component
+        /=>\s*<[A-Za-z]/, // arrow => <...
+        /\bcreateElement\s*\(/, // raw createElement
+    ];
+    const hasJsxHint = JSX_HINTS.some((re) => re.test(head));
+    if (!hasJsxHint)
+        return false;
+    const REACT_HINTS = [
+        /['"]use client['"]/,
+        /from\s+['"]react['"]/,
+        /require\s*\(\s*['"]react['"]\s*\)/,
+        /\bReact\.createElement\b/,
+    ];
+    return REACT_HINTS.some((re) => re.test(head));
+}
+const cacheHandlerPath = fileURLToPath(new URL("./cache-handler.js", import.meta.url));
+const adapter = {
+    name: "adapter-creek",
+    modifyConfig(config, { phase }) {
+        if (phase !== "phase-production-build")
+            return config;
+        const projectDir = process.cwd();
+        const repoRoot = findRepoRoot(projectDir);
+        const isMonorepo = repoRoot !== projectDir;
+        const installedCacheHandlerPath = path.join(projectDir, "node_modules", "@solcreek", "adapter-creek", "dist", "cache-handler.js");
+        const resolvedCacheHandlerPath = existsSync(installedCacheHandlerPath)
+            ? installedCacheHandlerPath
+            : cacheHandlerPath;
+        // Auto-add any direct dep that ships JSX in `.js` to transpilePackages.
+        // Works around a Turbopack regression where JSX inside `.js` files from
+        // a workspace-linked / third-party package fails to parse with
+        // `Expected ';', got 'ident'`. The documented upstream fix is exactly
+        // `transpilePackages: [pkg]`; doing this here means user apps don't
+        // have to know about it.
+        const detected = detectPackagesNeedingTranspile(projectDir);
+        const existing = Array.isArray(config.transpilePackages) ? config.transpilePackages : [];
+        const transpilePackages = detected.length > 0
+            ? [...new Set([...existing, ...detected])]
+            : existing;
+        if (detected.length > 0) {
+            console.log(`  [Creek Adapter] auto-transpile: ${JSON.stringify(detected)} (JSX in .js entry)`);
+        }
+        return {
+            ...config,
+            // Disable memory cache — CF Workers doesn't have persistent fs.
+            // The runtime cache handler is inlined in the worker entry (CreekCacheHandler).
+            cacheMaxMemorySize: 0,
+            // Cap maxPostponedStateSize so Next.js's zlib inflate (5x this) stays
+            // under workerd's 128MB max output length. Default is 100MB → 500MB
+            // decompressed → workerd RangeError. 20MB compressed → 100MB decompressed
+            // → safely under limit. Real PPR fallback shells are typically ≤ a few
+            // KB anyway, so this cap is purely defensive.
+            experimental: {
+                ...(config.experimental ?? {}),
+                maxPostponedStateSize: "20mb",
+            },
+            // Skip TypeScript type checking during build — CF Workers adapter
+            // builds run `next build` where TS errors block the build. Type
+            // checking should happen before deployment, not during bundling.
+            typescript: { ...config.typescript, ignoreBuildErrors: true },
+            ...(transpilePackages.length > 0 && { transpilePackages }),
+            // Monorepo: set tracing root so Next.js traces deps from repo root
+            ...(isMonorepo && {
+                outputFileTracingRoot: repoRoot,
+            }),
+        };
+    },
+    async onBuildComplete(ctx) {
+        await handleBuild(ctx);
+    },
+};
+export default adapter;
+//# sourceMappingURL=index.js.map

package/dist/manifest.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Deploy manifest for Creek CLI.
+ *
+ * Written to .creek/adapter-output/manifest.json after build.
+ * Creek CLI reads this to know how to upload and deploy.
+ */
+export interface DeployManifest {
+    /** Manifest schema version */
+    version: 1;
+    /** Next.js build ID */
+    buildId: string;
+    /** Next.js version used */
+    nextVersion: string;
+    /** Framework identifier */
+    framework: "nextjs";
+    /** Main worker entry file name (relative to server/) */
+    entrypoint: string;
+    /** All files in server/ directory */
+    serverFiles: string[];
+    /** Asset directory name (relative to adapter-output/) */
+    assetDir: "assets";
+    /** CF Workers compatibility settings */
+    compatibilityDate: string;
+    compatibilityFlags: string[];
+    /** Whether middleware is present */
+    hasMiddleware: boolean;
+    /** Whether prerenders exist (signals ISR support needed) */
+    hasPrerender: boolean;
+    /** Signals control-plane to inject DO bindings for ISR cache */
+    doBindings: boolean;
+}
+export declare function writeManifest(outputDir: string, opts: {
+    buildId: string;
+    nextVersion: string;
+    entrypoint: string;
+    serverFiles: string[];
+    hasMiddleware: boolean;
+    hasPrerender: boolean;
+}): Promise<void>;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/manifest.js

@@ -0,0 +1,27 @@
+/**
+ * Deploy manifest for Creek CLI.
+ *
+ * Written to .creek/adapter-output/manifest.json after build.
+ * Creek CLI reads this to know how to upload and deploy.
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+export async function writeManifest(outputDir, opts) {
+    const manifest = {
+        version: 1,
+        buildId: opts.buildId,
+        nextVersion: opts.nextVersion,
+        framework: "nextjs",
+        entrypoint: opts.entrypoint,
+        serverFiles: opts.serverFiles,
+        assetDir: "assets",
+        compatibilityDate: "2026-03-28",
+        compatibilityFlags: ["nodejs_compat_v2"],
+        hasMiddleware: opts.hasMiddleware,
+        hasPrerender: opts.hasPrerender,
+        // Always inject DO bindings for Next.js SSR (ISR cache support)
+        doBindings: true,
+    };
+    await fs.writeFile(path.join(outputDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+}
+//# sourceMappingURL=manifest.js.map

package/dist/worker-entry.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Worker entry source code generator.
+ *
+ * Generates a CF Workers entry that statically imports all Next.js
+ * page/route handlers. With --webpack, .next/server/app/*.js are
+ * standard CJS modules that esbuild can bundle.
+ */
+import type { NextAdapter } from "next";
+type BuildContext = Parameters<NonNullable<NextAdapter["onBuildComplete"]>>[0];
+export interface WorkerEntryOptions {
+    buildId: string;
+    routing: BuildContext["routing"];
+    outputs: BuildContext["outputs"];
+    basePath: string;
+    assetPrefix: string;
+    i18n: unknown;
+    /**
+     * Subset of \`next.config\` that the worker runtime needs — \`ROUTING\`
+     * doesn't expose these fields directly (trailingSlash is implemented
+     * as regex rules in \`beforeMiddleware\`). Carry them separately so
+     * code that needs the boolean flag can consult it without reverse-
+     * engineering the routing table.
+     */
+    config: {
+        trailingSlash?: boolean;
+    };
+    /** Embedded manifests: absolute path → file content */
+    manifests: Record<string, string>;
+    /**
+     * User-side text files (data.json, fixtures, i18n messages, etc.) keyed by
+     * path relative to outputFileTracingRoot. Read by the fs shim at runtime when
+     * route handlers call fs.readFileSync. See build.ts:collectUserFiles().
+     */
+    userFiles: Record<string, string>;
+    /** Path to Turbopack runtime file (for static import to trigger chunk bundling) */
+    turbopackRuntimePath?: string;
+    /** Prerender entries for ISR cache seeding */
+    prerenderEntries: Array<{
+        pathname: string;
+        html: string;
+        postponedState?: string;
+        allowsFallbackShellResume?: boolean;
+        initialRevalidate?: number | false;
+        initialStatus?: number;
+        initialHeaders?: Record<string, string | string[]>;
+        pprHeaders?: Record<string, string>;
+        lastModified?: number;
+        segmentPaths?: string[];
+        metaHeaders?: Record<string, string | string[]>;
+    }>;
+    /**
+     * Composable cache (`'use cache'`) entries extracted from build-time
+     * prerenders, keyed by bracket-form shell pathname. Applied request-scoped
+     * at runtime so only requests matching a shell see its seeds.
+     */
+    composableCacheSeedsByShell?: Array<[
+        string,
+        Array<{
+            key: string;
+            value: string;
+            tags: string[];
+            stale: number;
+            timestamp: number;
+            expire: number;
+            revalidate: number;
+        }>
+    ]>;
+    /** Path to edge registration chunk (contains _ENTRIES setup) */
+    edgeRegistrationChunkPath?: string;
+    /** Turbopack runtime module IDs for edge middleware evaluation */
+    edgeRuntimeModuleIds?: number[];
+    /** Paths to edge otherChunks that need explicit import */
+    edgeOtherChunkPaths?: string[];
+    /**
+     * Path to `.next/server/edge-runtime-webpack.js` when the user built with
+     * `next build --webpack`. This tiny IIFE installs the chunk-push hook on
+     * `self.webpackChunk_N_E`; it must evaluate BEFORE `middleware.js` so the
+     * push that registers chunk 149 triggers entry evaluation and populates
+     * `_ENTRIES["middleware_middleware"]`. Turbopack builds don't emit this
+     * file — its absence is the signal to fall through to the Turbopack path.
+     */
+    webpackEdgeRuntimePath?: string;
+    /**
+     * Path to a tiny generated bootstrap file that predeclares
+     * `globalThis._ENTRIES`. Imported BEFORE the webpack runtime so that
+     * middleware.js's strict-mode bare `_ENTRIES = {}` has a global to resolve
+     * against (otherwise: ReferenceError at module evaluation).
+     */
+    webpackEdgeBootstrapPath?: string;
+    /**
+     * [xxh3_128_hex, wasm_filename_with_ext] pairs. Turbopack edge bundles
+     * access the compiled WebAssembly.Module via \`globalThis.wasm_<hex>\`.
+     * Import each wasm (wrangler declares \`.wasm\` as CompiledWasm) and
+     * assign onto globalThis before edge modules evaluate.
+     */
+    wasmHashToFilename?: Array<[string, string]>;
+    /**
+     * [byteLength, wasm_filename] pairs. Registered in
+     * \`globalThis.__CREEK_WASM_BY_LENGTH\` so the runtime
+     * \`WebAssembly.instantiate\` patch can swap byte-based calls for the
+     * pre-compiled Module workerd already has in memory.
+     */
+    wasmLengthToFilename?: Array<[number, string]>;
+    /**
+     * Module specifiers that Turbopack marked as externals but that the
+     * user's code references at runtime via dynamic import. \`id\` is the
+     * exact runtime specifier passed to Turbopack's externalImport helper;
+     * \`importSpecifier\` is the concrete module path we ask wrangler to
+     * bundle for that id.
+     */
+    externalModules?: Array<{
+        id: string;
+        importSpecifier: string;
+    }>;
+    /**
+     * Absolute path to the user's \`.next/server/instrumentation.js\` when the
+     * project actually provides one (not our \`module.exports = {}\` placeholder).
+     * We static-import it from the worker entry so wrangler bundles the full
+     * module graph, then hand it to Next.js's \`getInstrumentationModule\`
+     * lookup — otherwise the dynamic \`__require\` falls back to undefined on
+     * workerd and \`instrumentation.register()\` is never called.
+     * Fixes e2e/opentelemetry/client-trace-metadata (5 tests) and any other
+     * test that depends on user instrumentation side effects.
+     */
+    userInstrumentationPath?: string;
+}
+/**
+ * Generate the worker entry source code.
+ * All handler modules are statically imported so esbuild bundles them.
+ */
+export declare function generateWorkerEntry(opts: WorkerEntryOptions): string;
+export {};
+//# sourceMappingURL=worker-entry.d.ts.map