@solcreek/adapter-creek 0.1.0

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@solcreek/adapter-creek",
+  "version": "0.1.0",
+  "description": "Next.js deployment adapter for Creek (Cloudflare Workers)",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./cache-handler": {
+      "default": "./dist/cache-handler.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/shims",
+    "!dist/**/*.test.*",
+    "!dist/**/*.map"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "creek",
+    "nextjs",
+    "adapter",
+    "cloudflare",
+    "workers",
+    "deployment"
+  ],
+  "author": "SolCreek",
+  "license": "Apache-2.0",
+  "homepage": "https://creek.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/solcreek/adapter-creek.git"
+  },
+  "dependencies": {
+    "@next/routing": "16.2.3",
+    "@node-rs/xxhash": "^1.7.6",
+    "sql.js": "^1.14.1",
+    "wrangler": "^4.82.2"
+  },
+  "peerDependencies": {
+    "next": ">=16.2.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "miniflare": "^4.20260410.0",
+    "next": "16.2.3",
+    "typescript": "^5.8.2",
+    "urlpattern-polyfill": "^10.1.0",
+    "vitest": "^4.1.2"
+  },
+  "packageManager": "pnpm@10.33.0"
+}

package/src/shims/als-polyfill.js

@@ -0,0 +1,7 @@
+// AsyncLocalStorage polyfill — must be imported FIRST.
+// Sets globalThis.AsyncLocalStorage before any Next.js code evaluates.
+// CF Workers has AsyncLocalStorage via node:async_hooks but not on globalThis.
+import { AsyncLocalStorage } from "node:async_hooks";
+if (!globalThis.AsyncLocalStorage) {
+  globalThis.AsyncLocalStorage = AsyncLocalStorage;
+}

package/src/shims/critters.js

@@ -0,0 +1,7 @@
+// No-op critters shim for CF Workers.
+// Next.js bundles critters for CSS inlining optimization.
+// Not needed at runtime on CF Workers — CSS is served as static assets.
+export default class Critters {
+  constructor() {}
+  process(html) { return html; }
+}

package/src/shims/empty.js

@@ -0,0 +1,2 @@
+// Empty module shim — used to stub out unused dependencies
+export default {};

package/src/shims/env.js

@@ -0,0 +1,3 @@
+// @next/env shim — env is already loaded at build time
+export function loadEnvConfig() {}
+export default { loadEnvConfig };

package/src/shims/fast-set-immediate.js

@@ -0,0 +1,285 @@
+// Shim for next/dist/server/node-environment-extensions/fast-set-immediate.
+//
+// Next's cache-components renderer relies on "fast immediates": setImmediate()
+// calls made during a runInSequentialTasks stage must flush before the next
+// setTimeout(0) stage. workerd's event loop can run the next timeout first,
+// which cuts PPR static RSC boundaries before cached content has resolved.
+//
+// Keep the behavior scoped to Next's explicit capture window. Outside
+// DANGEROUSLY_runPendingImmediatesAfterCurrentTask(), setImmediate stays native.
+const ORIGINALS_KEY = Symbol.for("creek.fast-set-immediate.originals");
+const INTERNALS = Symbol.for("creek.fast-set-immediate.internals");
+
+const originals = globalThis[ORIGINALS_KEY] || (globalThis[ORIGINALS_KEY] = {
+  setImmediate: globalThis.setImmediate,
+  clearImmediate: globalThis.clearImmediate,
+  nextTick: globalThis.process?.nextTick,
+});
+
+const originalSetImmediate =
+  typeof originals.setImmediate === "function"
+    ? originals.setImmediate.bind(globalThis)
+    : (callback, ...args) => setTimeout(callback, 0, ...args);
+const originalClearImmediate =
+  typeof originals.clearImmediate === "function"
+    ? originals.clearImmediate.bind(globalThis)
+    : clearTimeout;
+const originalNextTick =
+  typeof originals.nextTick === "function"
+    ? originals.nextTick.bind(globalThis.process)
+    : (callback, ...args) => queueMicrotask(() => callback(...args));
+
+let currentExecution = null;
+let pendingNextTicks = 0;
+let installed = false;
+
+class CreekImmediate {
+  constructor() {
+    this[INTERNALS] = {
+      hasRef: true,
+      nativeImmediate: null,
+      queueItem: null,
+    };
+  }
+
+  hasRef() {
+    const internals = this[INTERNALS];
+    if (internals.queueItem) return internals.hasRef;
+    if (internals.nativeImmediate?.hasRef) return internals.nativeImmediate.hasRef();
+    return false;
+  }
+
+  ref() {
+    const internals = this[INTERNALS];
+    if (internals.queueItem) internals.hasRef = true;
+    else internals.nativeImmediate?.ref?.();
+    return this;
+  }
+
+  unref() {
+    const internals = this[INTERNALS];
+    if (internals.queueItem) internals.hasRef = false;
+    else internals.nativeImmediate?.unref?.();
+    return this;
+  }
+
+  _onImmediate() {}
+
+  [Symbol.dispose]() {
+    const internals = this[INTERNALS];
+    if (internals.queueItem) {
+      const item = internals.queueItem;
+      internals.queueItem = null;
+      clearQueueItem(item);
+    } else if (internals.nativeImmediate) {
+      if (typeof internals.nativeImmediate[Symbol.dispose] === "function") {
+        internals.nativeImmediate[Symbol.dispose]();
+      } else {
+        originalClearImmediate(internals.nativeImmediate);
+      }
+    }
+  }
+}
+
+function install() {
+  if (installed) return;
+  installed = true;
+
+  globalThis.setImmediate = patchedSetImmediate;
+  globalThis.clearImmediate = patchedClearImmediate;
+  if (globalThis.process && typeof globalThis.process.nextTick === "function") {
+    globalThis.process.nextTick = patchedNextTick;
+  }
+
+  // Best effort for consumers that import from node:timers. Avoid touching
+  // node:timers/promises because that namespace is frozen in Workers.
+  try {
+    const nodeTimers = require("node:timers");
+    nodeTimers.setImmediate = patchedSetImmediate;
+    nodeTimers.clearImmediate = patchedClearImmediate;
+  } catch {}
+}
+
+export function DANGEROUSLY_runPendingImmediatesAfterCurrentTask() {
+  if (currentExecution !== null) {
+    expectNoPendingImmediates();
+  }
+  const execution = {
+    queuedImmediates: [],
+    abandoned: false,
+  };
+  currentExecution = execution;
+  scheduleWorkAfterNextTicksAndMicrotasks(execution);
+}
+
+export function expectNoPendingImmediates() {
+  if (currentExecution === null) return;
+
+  const execution = currentExecution;
+  drainReadyImmediatesSynchronously(execution);
+
+  if (currentExecution === execution) {
+    scheduleQueuedImmediatesAsNative(execution);
+    currentExecution = null;
+  }
+}
+
+export { install, originalSetImmediate as unpatchedSetImmediate };
+
+function scheduleWorkAfterNextTicksAndMicrotasks(execution) {
+  queueMicrotask(() => {
+    originalNextTick(() => {
+      if (currentExecution !== execution || execution.abandoned) return;
+      if (pendingNextTicks > 0) {
+        scheduleWorkAfterNextTicksAndMicrotasks(execution);
+        return;
+      }
+      performWork(execution);
+    });
+  });
+}
+
+function performWork(execution) {
+  if (currentExecution !== execution || execution.abandoned) return;
+
+  const queueItem = takeNextActiveQueueItem(execution);
+  if (!queueItem) {
+    if (currentExecution === execution) currentExecution = null;
+    return;
+  }
+
+  runQueueItem(queueItem);
+  scheduleWorkAfterNextTicksAndMicrotasks(execution);
+}
+
+function drainReadyImmediatesSynchronously(execution) {
+  for (let i = 0; i < 1000; i++) {
+    const queueItem = takeNextActiveQueueItem(execution);
+    if (!queueItem) return;
+    runQueueItem(queueItem);
+  }
+}
+
+function runQueueItem(queueItem) {
+  const { callback, args, immediateObject } = queueItem;
+  immediateObject[INTERNALS].queueItem = null;
+  clearQueueItem(queueItem);
+
+  try {
+    callback(...args);
+  } catch (err) {
+    queueMicrotask(() => {
+      throw err;
+    });
+  }
+}
+
+function bindCurrentAsyncStores(callback) {
+  const stores = [];
+  const bag = globalThis.__CREEK_ALS;
+  if (bag && typeof bag === "object") {
+    for (const als of Object.values(bag)) {
+      if (
+        als &&
+        typeof als.getStore === "function" &&
+        typeof als.run === "function"
+      ) {
+        const store = als.getStore();
+        if (store !== undefined) stores.push([als, store]);
+      }
+    }
+  }
+  if (stores.length === 0) return callback;
+
+  return (...args) => {
+    let invoke = () => callback(...args);
+    for (let i = stores.length - 1; i >= 0; i--) {
+      const [als, store] = stores[i];
+      const next = invoke;
+      invoke = () => als.run(store, next);
+    }
+    return invoke();
+  };
+}
+
+function takeNextActiveQueueItem(execution) {
+  while (execution.queuedImmediates.length > 0) {
+    const item = execution.queuedImmediates.shift();
+    if (!item.isCleared) return item;
+  }
+  return null;
+}
+
+function clearQueueItem(item) {
+  item.isCleared = true;
+  item.callback = null;
+  item.args = null;
+  item.immediateObject = null;
+}
+
+function scheduleQueuedImmediatesAsNative(execution) {
+  execution.abandoned = true;
+  for (const queueItem of execution.queuedImmediates) {
+    if (queueItem.isCleared) continue;
+    const nativeImmediate = originalSetImmediate(queueItem.callback, ...queueItem.args);
+    const internals = queueItem.immediateObject[INTERNALS];
+    internals.queueItem = null;
+    internals.nativeImmediate = nativeImmediate;
+    if (!internals.hasRef) nativeImmediate?.unref?.();
+    clearQueueItem(queueItem);
+  }
+  execution.queuedImmediates.length = 0;
+}
+
+function patchedNextTick(callback, ...args) {
+  if (currentExecution === null || typeof callback !== "function") {
+    return originalNextTick(callback, ...args);
+  }
+
+  pendingNextTicks++;
+  return originalNextTick(() => {
+    pendingNextTicks--;
+    try {
+      callback(...args);
+    } catch (err) {
+      queueMicrotask(() => {
+        throw err;
+      });
+    }
+  });
+}
+
+function patchedSetImmediate(callback, ...args) {
+  if (currentExecution === null) {
+    return originalSetImmediate(callback, ...args);
+  }
+
+  if (typeof callback !== "function") {
+    return originalSetImmediate(callback, ...args);
+  }
+
+  const immediateObject = new CreekImmediate();
+  const queueItem = {
+    isCleared: false,
+    callback: bindCurrentAsyncStores(callback),
+    args,
+    immediateObject,
+  };
+  immediateObject[INTERNALS].queueItem = queueItem;
+  currentExecution.queuedImmediates.push(queueItem);
+  return immediateObject;
+}
+
+function patchedClearImmediate(immediateObject) {
+  if (
+    immediateObject &&
+    typeof immediateObject === "object" &&
+    Object.prototype.hasOwnProperty.call(immediateObject, INTERNALS)
+  ) {
+    immediateObject[Symbol.dispose]();
+    return;
+  }
+  return originalClearImmediate(immediateObject);
+}
+
+install();

package/src/shims/fs.js

@@ -0,0 +1,225 @@
+// Minimal fs shim for CF Workers — Next.js server needs basic fs operations
+// for manifest loading and incremental cache. We provide no-ops since
+// manifests are embedded and cache uses DO (Phase 2).
+const noop = () => {};
+const noopSync = () => undefined;
+
+// Binary files in __USER_FILES are base64-encoded with a sentinel prefix
+// so readFile callers (e.g. next/og node-runtime routes reading font
+// files) receive real Uint8Array/Buffer bytes instead of a UTF-8 string.
+const BINARY_SENTINEL = "__CREEK_B64__";
+
+function decodeBase64(b64) {
+  // CF Workers and Node.js both support atob; the result is a binary
+  // string that we map to a Uint8Array byte-by-byte.
+  const binStr = atob(b64);
+  const out = new Uint8Array(binStr.length);
+  for (let i = 0; i < binStr.length; i++) out[i] = binStr.charCodeAt(i);
+  return out;
+}
+
+function maybeDecodeBinary(value, enc) {
+  if (typeof value !== "string" || !value.startsWith(BINARY_SENTINEL)) {
+    return value;
+  }
+  const bytes = decodeBase64(value.slice(BINARY_SENTINEL.length));
+  if (!enc) return bytes;
+  if (enc === "utf8" || enc === "utf-8" || enc === "UTF-8") {
+    return new TextDecoder("utf-8").decode(bytes);
+  }
+  if (enc === "base64") return value.slice(BINARY_SENTINEL.length);
+  if (typeof enc === "object" && enc.encoding) return maybeDecodeBinary(value, enc.encoding);
+  return bytes;
+}
+
+function normalizePath(filePath) {
+  return String(filePath).replace(/\\/g, "/");
+}
+
+function trimLeadingSlashes(filePath) {
+  return normalizePath(filePath).replace(/^\/+/, "");
+}
+
+function directoryCandidates(dirPath) {
+  const normalized = trimLeadingSlashes(dirPath).replace(/\/+$/, "");
+  const candidates = [normalized];
+  for (const marker of ["node_modules/", ".next/"]) {
+    const index = normalized.lastIndexOf(marker);
+    if (index > 0) candidates.push(normalized.slice(index));
+  }
+  return [...new Set(candidates.filter(Boolean))];
+}
+
+function relativeToEmbeddedDirectory(key, dirPath) {
+  const normalizedKey = trimLeadingSlashes(key);
+  for (const candidate of directoryCandidates(dirPath)) {
+    if (normalizedKey.startsWith(candidate + "/")) {
+      return normalizedKey.slice(candidate.length + 1);
+    }
+    const marker = "/" + candidate + "/";
+    const index = normalizedKey.lastIndexOf(marker);
+    if (index !== -1) {
+      return normalizedKey.slice(index + marker.length);
+    }
+  }
+  return undefined;
+}
+
+function listUserFilesInDirectory(dirPath) {
+  const files = globalThis.__USER_FILES;
+  if (!files) return [];
+  const entries = new Set();
+  for (const key in files) {
+    const relative = relativeToEmbeddedDirectory(key, dirPath);
+    if (!relative) continue;
+    const entry = relative.split("/")[0];
+    if (entry) entries.add(entry);
+  }
+  return [...entries];
+}
+
+function isUserFilesDirectory(filePath) {
+  return listUserFilesInDirectory(filePath).length > 0;
+}
+
+function joinPath(dirPath, entry) {
+  return normalizePath(dirPath).replace(/\/+$/, "") + "/" + entry;
+}
+
+// Look up a path in __USER_FILES (user-side text files like data.json that
+// route handlers read via fs.readFileSync). Embedded keys are paths relative
+// to outputFileTracingRoot; runtime requests come through process.cwd()
+// joined with a relative path. We do bidirectional suffix matching so both
+// single-app and monorepo setups resolve correctly.
+function findInUserFiles(filePath) {
+  const files = globalThis.__USER_FILES;
+  if (!files) return undefined;
+  const requestedPath = normalizePath(filePath);
+  if (files[requestedPath] !== undefined) return files[requestedPath];
+  // Normalize the requested path to a relative form for comparison.
+  const requestedTail = trimLeadingSlashes(requestedPath);
+  for (const key in files) {
+    const normalizedKey = normalizePath(key);
+    // Embedded key is a suffix of the requested path:
+    //   key  = "app/dashboard/data.json"
+    //   req  = "/app/dashboard/data.json"  (cwd "/" + relative)
+    if (requestedPath.endsWith("/" + normalizedKey) || requestedPath === normalizedKey) return files[key];
+    // Requested tail is a suffix of the embedded key (monorepo case):
+    //   key  = "apps/www/app/data.json"
+    //   req  = "/app/data.json"  (page used a project-relative path)
+    if (normalizedKey.endsWith("/" + requestedTail) || normalizedKey === requestedTail) return files[key];
+  }
+  // Last-resort: match on basename for bundled sibling assets whose
+  // request path is derived from `fileURLToPath(new URL('./X', import.meta.url))`
+  // and ends up with a chunk-relative path that shares nothing with the
+  // embedded `node_modules/...` key except the filename. Only applies to
+  // binary assets (wasm / fonts / images) and TypeScript's default lib
+  // declaration files. The latter may be requested as bare `lib.es5.d.ts`
+  // because the bundled TypeScript module has no meaningful __filename.
+  // Fixes next/og node-runtime `fs.readFileSync` of bundled wasm/ttf and
+  // twoslash loading `typescript/lib/lib.*.d.ts` in Workers.
+  const reqBase = requestedPath.split("/").pop() || "";
+  if (/\.(wasm|ttf|otf|woff2?)$/i.test(reqBase) || /^lib\..*\.d\.ts$/i.test(reqBase)) {
+    for (const key in files) {
+      if (normalizePath(key).split("/").pop() === reqBase) return files[key];
+    }
+  }
+  return undefined;
+}
+
+export const existsSync = (filePath) => {
+  if (findInUserFiles(filePath) !== undefined) return true;
+  if (isUserFilesDirectory(filePath)) return true;
+  if (typeof globalThis.__MANIFESTS === "undefined") return false;
+  for (const key of Object.keys(globalThis.__MANIFESTS)) {
+    if (key === filePath || key.endsWith(filePath)) return true;
+    if (filePath.includes(".next/")) {
+      const tail = ".next/" + filePath.split(".next/").pop();
+      const keyTail = key.includes(".next/") ? ".next/" + key.split(".next/").pop() : "";
+      if (tail === keyTail) return true;
+    }
+  }
+  return false;
+};
+export const readFileSync = (filePath, enc) => {
+  // Try reading from embedded manifests
+  if (typeof globalThis.__MANIFESTS !== "undefined") {
+    for (const [key, val] of Object.entries(globalThis.__MANIFESTS)) {
+      if (key === filePath || key.endsWith(filePath)) return val;
+      // Match by .next/ relative tail — handles different path prefixes
+      // e.g. /bundle/.next/routes-manifest.json → .next/routes-manifest.json
+      if (filePath.includes(".next/")) {
+        const tail = ".next/" + filePath.split(".next/").pop();
+        const keyTail = key.includes(".next/") ? ".next/" + key.split(".next/").pop() : "";
+        if (tail === keyTail) return val;
+      }
+      // Last resort: match by filename
+      if (filePath.split("/").pop() === key.split("/").pop()) return val;
+    }
+  }
+  // Then try user-side data files (data.json, fixtures, fonts, etc.).
+  // Binary files are stored as base64 with a sentinel prefix — decode
+  // them lazily based on the caller's requested encoding.
+  const userContent = findInUserFiles(filePath);
+  if (userContent !== undefined) return maybeDecodeBinary(userContent, enc);
+  // Throw ENOENT like real fs — Next.js loadManifest relies on this
+  // to distinguish between missing and empty files.
+  const err = new Error(`ENOENT: no such file or directory, open '${filePath}'`);
+  err.code = "ENOENT";
+  throw err;
+};
+export const writeFileSync = noop;
+export const mkdirSync = noop;
+export const unlinkSync = noop;
+export const readdirSync = (dirPath, options) => {
+  const entries = listUserFilesInDirectory(dirPath);
+  if (options && typeof options === "object" && options.withFileTypes) {
+    return entries.map((name) => ({
+      name,
+      isFile: () => findInUserFiles(joinPath(dirPath, name)) !== undefined,
+      isDirectory: () => isUserFilesDirectory(joinPath(dirPath, name)),
+      isSymbolicLink: () => false,
+    }));
+  }
+  return entries;
+};
+export const realpathSync = Object.assign((filePath) => String(filePath), {
+  native: (filePath) => String(filePath),
+});
+export const statSync = (filePath) => {
+  const userContent = findInUserFiles(filePath);
+  const fileExists = userContent !== undefined;
+  const directoryExists = !fileExists && isUserFilesDirectory(filePath);
+  const exists = fileExists || directoryExists;
+  return {
+    isFile: () => fileExists,
+    isDirectory: () => directoryExists,
+    isSymbolicLink: () => false,
+    mtime: new Date(),
+    size: fileExists ? (maybeDecodeBinary(userContent, "utf8")?.length || 0) : 0,
+  };
+};
+export const accessSync = noop;
+export const createReadStream = () => { throw new Error("fs.createReadStream not available in CF Workers"); };
+export const createWriteStream = () => { throw new Error("fs.createWriteStream not available in CF Workers"); };
+
+// readAll is used by Turbopack app-route runtime
+export const readAll = readFileSync;
+
+export const promises = {
+  readFile: async (filePath, enc) => readFileSync(filePath, enc),
+  readAll: async (filePath, enc) => readFileSync(filePath, enc),
+  writeFile: async () => {},
+  mkdir: async () => {},
+  readdir: async (dirPath, options) => readdirSync(dirPath, options),
+  stat: async (filePath) => statSync(filePath),
+  access: async () => {},
+  unlink: async () => {},
+  rm: async () => {},
+};
+
+export default {
+  existsSync, readFileSync, readAll, writeFileSync, mkdirSync, unlinkSync,
+  readdirSync, realpathSync, statSync, accessSync, createReadStream, createWriteStream,
+  promises,
+};