@solcreek/adapter-creek 0.1.0

package/src/shims/http.js

@@ -0,0 +1,240 @@
+// Minimal node:http shim for CF Workers.
+// Plain objects with the minimum API surface that Next.js handler needs.
+// Does NOT extend from node:stream (CF Workers stream compat may be incomplete).
+
+import { EventEmitter } from "node:events";
+
+export class IncomingMessage extends EventEmitter {
+  constructor(socket) {
+    super();
+    this.socket = socket || { encrypted: true, remoteAddress: "127.0.0.1", address: () => ({ port: 443 }), end() {}, destroy() {} };
+    this.connection = this.socket;
+    this.httpVersion = "1.1";
+    this.httpVersionMajor = 1;
+    this.httpVersionMinor = 1;
+    this.complete = true;
+    this.headers = {};
+    this.rawHeaders = [];
+    this.trailers = {};
+    this.rawTrailers = [];
+    this.method = "GET";
+    this.url = "/";
+    this.statusCode = null;
+    this.statusMessage = null;
+    this.aborted = false;
+    this.upgrade = false;
+    this.readable = true;
+    this._body = null;
+    this._bodyConsumed = false;
+    // Node.js Readable state — some Next.js code checks this directly.
+    this._readableState = { ended: false, endEmitted: false, flowing: null };
+    // Buffer chunks until a listener is attached.
+    // push() may be called before the handler adds "data" listeners.
+    this._bufferedChunks = [];
+    this._ended = false;
+    this._flowing = false;
+  }
+  // Readable stream interface (minimal)
+  read() {
+    if (this._bufferedChunks.length > 0) return this._bufferedChunks.shift();
+    return null;
+  }
+  push(chunk) {
+    if (chunk === null) {
+      this._ended = true;
+      this.complete = true;
+      this._readableState.ended = true;
+      if (this._flowing) {
+        this._readableState.endEmitted = true;
+        this.emit("end");
+      }
+      return;
+    }
+    if (this._flowing) {
+      this.emit("data", chunk);
+    } else {
+      this._bufferedChunks.push(chunk);
+    }
+  }
+  // Flush buffered data when listeners are ready
+  _startFlowing() {
+    if (this._flowing) return;
+    this._flowing = true;
+    this._readableState.flowing = true;
+    while (this._bufferedChunks.length > 0) {
+      this.emit("data", this._bufferedChunks.shift());
+    }
+    if (this._ended) {
+      this._readableState.endEmitted = true;
+      this.emit("end");
+    }
+  }
+  on(event, fn) {
+    super.on(event, fn);
+    // When a "data" listener is attached, start flowing
+    if (event === "data" && !this._flowing) {
+      queueMicrotask(() => this._startFlowing());
+    }
+    return this;
+  }
+  addListener(event, fn) { return this.on(event, fn); }
+  pipe(dest) {
+    this.on("data", (chunk) => dest.write(chunk));
+    this.on("end", () => { if (dest.end) dest.end(); });
+    return dest;
+  }
+  unpipe() {}
+  resume() { this._startFlowing(); return this; }
+  pause() { return this; }
+  setEncoding() { return this; }
+  setTimeout() { return this; }
+  destroy() { this.emit("close"); return this; }
+  [Symbol.asyncIterator]() {
+    const self = this;
+    // Drain both currently-buffered chunks AND any chunks that arrive
+    // via subsequent push() calls. Use a pull-based queue with a
+    // resolver so we wake up the awaiting consumer exactly when new
+    // data arrives or end is reached. This replaces an older
+    // implementation that went through on("data"/"end") events with a
+    // queueMicrotask + _startFlowing dance — on workerd the microtask
+    // timing was unreliable for bodyParser:false handlers that iterate
+    // the request body directly (they would hang forever).
+    const queue = [];
+    let ended = false;
+    let resolver = null;
+    const notify = () => {
+      if (resolver) {
+        const r = resolver;
+        resolver = null;
+        r();
+      }
+    };
+    // Seed the queue with any pre-buffered chunks. Clear the shim's
+    // buffer so a later push() goes straight into our queue.
+    for (const chunk of self._bufferedChunks) queue.push(chunk);
+    self._bufferedChunks = [];
+    self._flowing = true;
+    self._readableState.flowing = true;
+    if (self._ended) {
+      ended = true;
+      self._readableState.endEmitted = true;
+    }
+    // Replace push() so later chunks land in our queue. Keep the null
+    // sentinel semantics for end-of-stream.
+    const origPush = self.push.bind(self);
+    self.push = (chunk) => {
+      if (chunk === null) {
+        ended = true;
+        self._ended = true;
+        self.complete = true;
+        self._readableState.ended = true;
+        self._readableState.endEmitted = true;
+        notify();
+        return;
+      }
+      queue.push(chunk);
+      notify();
+    };
+    return {
+      async next() {
+        if (queue.length === 0 && !ended) {
+          await new Promise((r) => { resolver = r; });
+        }
+        if (queue.length > 0) return { done: false, value: queue.shift() };
+        return { done: true, value: undefined };
+      }
+    };
+  }
+}
+
+export class ServerResponse extends EventEmitter {
+  constructor(req) {
+    super();
+    this.req = req;
+    this.statusCode = 200;
+    this.statusMessage = "";
+    this.headersSent = false;
+    this.finished = false;
+    this.writable = true;
+    this.sendDate = true;
+    this._headers = {};
+    this._headerNames = {};
+    this.socket = req?.socket || { encrypted: true, remoteAddress: "127.0.0.1" };
+    this.connection = this.socket;
+  }
+  setHeader(name, value) { this._headers[name.toLowerCase()] = value; this._headerNames[name.toLowerCase()] = name; }
+  appendHeader(name, value) {
+    const key = name.toLowerCase();
+    const existing = this._headers[key];
+    if (existing === undefined) {
+      this._headers[key] = value;
+    } else if (Array.isArray(existing)) {
+      existing.push(value);
+    } else {
+      this._headers[key] = [existing, value];
+    }
+    this._headerNames[key] = name;
+  }
+  getHeader(name) { return this._headers[name.toLowerCase()]; }
+  getHeaders() { return { ...this._headers }; }
+  getHeaderNames() { return Object.keys(this._headers); }
+  hasHeader(name) { return name.toLowerCase() in this._headers; }
+  removeHeader(name) { delete this._headers[name.toLowerCase()]; delete this._headerNames[name.toLowerCase()]; }
+  writeHead(code, msg, hdrs) {
+    this.statusCode = code;
+    if (typeof msg === "string") this.statusMessage = msg;
+    else if (typeof msg === "object") hdrs = msg;
+    if (hdrs) {
+      for (const [k, v] of Object.entries(hdrs)) {
+        // Array values (e.g., Set-Cookie) should be stored as-is
+        if (Array.isArray(v)) {
+          this._headers[k.toLowerCase()] = v;
+          this._headerNames[k.toLowerCase()] = k;
+        } else {
+          this.setHeader(k, v);
+        }
+      }
+    }
+    this.headersSent = true;
+    return this;
+  }
+  write(chunk, encoding, cb) {
+    if (typeof encoding === "function") { cb = encoding; encoding = undefined; }
+    this.emit("data", chunk);
+    if (cb) cb();
+    return true;
+  }
+  end(chunk, encoding, cb) {
+    if (typeof chunk === "function") { cb = chunk; chunk = null; }
+    if (typeof encoding === "function") { cb = encoding; encoding = null; }
+    if (chunk) this.emit("data", chunk);
+    this.finished = true;
+    this.writable = false;
+    this.emit("finish");
+    this.emit("close");
+    if (cb) cb();
+    return this;
+  }
+  get writableEnded() { return this.finished; }
+  get writableFinished() { return this.finished; }
+  flushHeaders() { this.headersSent = true; }
+  assignSocket() {}
+  detachSocket() {}
+  writeContinue() {}
+  writeProcessing() {}
+  setTimeout() { return this; }
+  addTrailers() {}
+  cork() {}
+  uncork() {}
+  // Writable interface stubs
+  destroy() { return this; }
+}
+
+export function createServer() { throw new Error("http.createServer not available in CF Workers"); }
+export function request() { throw new Error("http.request not available in CF Workers"); }
+export function get() { throw new Error("http.get not available in CF Workers"); }
+
+export const METHODS = ["GET","POST","PUT","DELETE","PATCH","HEAD","OPTIONS"];
+export const STATUS_CODES = { 200:"OK",201:"Created",204:"No Content",301:"Moved Permanently",302:"Found",304:"Not Modified",400:"Bad Request",401:"Unauthorized",403:"Forbidden",404:"Not Found",500:"Internal Server Error" };
+
+export default { IncomingMessage, ServerResponse, createServer, request, get, METHODS, STATUS_CODES };

package/src/shims/image-optimizer.js

@@ -0,0 +1,18 @@
+// Image optimization shim for CF Workers.
+// Delegates to Cloudflare Image Resizing instead of sharp.
+// See: https://developers.cloudflare.com/images/transform-images/
+
+export async function optimizeImage(buffer, { width, height, quality, contentType }) {
+  // CF Image Resizing is handled at the edge via cf.image options
+  // on fetch requests. For the adapter, we return the original image
+  // since optimization happens at the CDN layer, not in the worker.
+  //
+  // In production, the dispatch worker or CDN rules apply:
+  //   fetch(imageUrl, { cf: { image: { width, height, quality, format } } })
+  return {
+    buffer,
+    contentType: contentType || "image/webp",
+  };
+}
+
+export default { optimizeImage };

package/src/shims/load-manifest.js

@@ -0,0 +1,123 @@
+// Shim for next/dist/server/load-manifest.external.js
+// Reads manifests from globalThis.__MANIFESTS (embedded at build time by the adapter).
+
+const cache = new Map();
+
+// Manifests that Next.js loads with `handleMissing: true` or that are
+// conditionally generated and may not exist in every build. Returning {} for
+// these matches the upstream Node fs behavior — without this, dynamic routes
+// 500 when the build-time glob scan didn't pick them up.
+//
+// Source: next/dist/server/route-modules/route-module.ts
+// Aligned with opennextjs-cloudflare#1151 + #1160.
+const KNOWN_OPTIONAL_MANIFESTS = new Set([
+  "react-loadable-manifest",          // Turbopack: only routes with dynamic imports
+  "subresource-integrity-manifest",   // only when experimental.sri configured
+  "server-reference-manifest",        // App Router only
+  "dynamic-css-manifest",             // Pages Router + Webpack only
+  "fallback-build-manifest",          // only for /_error
+  "prefetch-hints",                   // Next 16.2+
+  "_client-reference-manifest",       // optional for static metadata routes (evalManifest)
+]);
+
+function isKnownOptional(manifestPath) {
+  // Compare against the basename without trailing extension. Some Next.js
+  // constants omit the extension (e.g. SUBRESOURCE_INTEGRITY_MANIFEST), so we
+  // strip .json / .js before matching.
+  const base = manifestPath.split("/").pop() || manifestPath;
+  const stripped = base.replace(/\.(json|js)$/, "");
+  return KNOWN_OPTIONAL_MANIFESTS.has(stripped);
+}
+
+function findInManifests(path) {
+  const manifests = globalThis.__MANIFESTS;
+  if (!manifests) return undefined;
+
+  // Direct match
+  if (manifests[path]) return manifests[path];
+
+  // Match by .next/ relative tail — handles path prefix differences
+  // Requested: //.next/routes-manifest.json
+  // Available: /Users/.../apps/www/.next/routes-manifest.json
+  const tail = path.includes(".next/")
+    ? ".next/" + path.split(".next/").pop()
+    : path.split("/").pop();
+
+  for (const [key, val] of Object.entries(manifests)) {
+    const keyTail = key.includes(".next/")
+      ? ".next/" + key.split(".next/").pop()
+      : key.split("/").pop();
+    if (tail === keyTail) return val;
+  }
+
+  return undefined;
+}
+
+function loadManifest(path, shouldCache = true, _cache = cache, skipParse = false, handleMissing) {
+  const cached = shouldCache && cache.get(path);
+  if (cached) return cached;
+
+  const content = findInManifests(path);
+
+  if (content === undefined) {
+    if (handleMissing || isKnownOptional(path)) {
+      const result = {};
+      if (shouldCache) cache.set(path, result);
+      return result;
+    }
+    throw new Error(`[Creek] Manifest not found: ${path}`);
+  }
+
+  let manifest = skipParse ? content : JSON.parse(content);
+  if (shouldCache) cache.set(path, manifest);
+  return manifest;
+}
+
+function evalManifest(path, shouldCache = true, _cache = cache, handleMissing) {
+  const cached = shouldCache && cache.get(path);
+  if (cached) return cached;
+
+  const content = findInManifests(path);
+
+  if (content === undefined) {
+    if (handleMissing || isKnownOptional(path)) {
+      const result = {};
+      if (shouldCache) cache.set(path, result);
+      return result;
+    }
+    throw new Error(`[Creek] Manifest not found for eval: ${path}`);
+  }
+
+  let contextObject = {};
+  try {
+    contextObject = JSON.parse(content);
+  } catch {
+    // JS manifests (e.g., _buildManifest.js) — extract JSON via regex.
+    // CF Workers blocks new Function() (CSP), so we parse the assignment
+    // pattern: self.__BUILD_MANIFEST = {...}
+    try {
+      const jsonMatch = content.match(/=\s*(\{[\s\S]*\})\s*[;\n]/);
+      if (jsonMatch) {
+        const data = JSON.parse(jsonMatch[1]);
+        for (const [key, val] of Object.entries(data)) {
+          contextObject[key] = val;
+        }
+      }
+    } catch {}
+  }
+
+  if (shouldCache) cache.set(path, contextObject);
+  return contextObject;
+}
+
+function loadManifestFromRelativePath({ projectDir, distDir, manifest, shouldCache, cache: c, skipParse, handleMissing, useEval }) {
+  const manifestPath = (projectDir || "") + "/" + (distDir || ".next") + "/" + manifest;
+  if (useEval) return evalManifest(manifestPath, shouldCache, c, handleMissing);
+  return loadManifest(manifestPath, shouldCache, c, skipParse, handleMissing);
+}
+
+function clearManifestCache(path) {
+  return cache.delete(path);
+}
+
+module.exports = { loadManifest, evalManifest, loadManifestFromRelativePath, clearManifestCache };

package/src/shims/opentelemetry.js

@@ -0,0 +1,229 @@
+// Minimal @opentelemetry/api shim for CF Workers
+// Next.js uses it for tracing but it's not required for functionality.
+
+const NOOP = () => {};
+// NOOP_SPAN must be usable by Next.js (has methods like isRecording/end)
+// but must NOT be serializable by React RSC. React only serializes
+// enumerable own properties — so we use non-enumerable properties.
+const NOOP_SPAN = Object.create(null);
+Object.defineProperties(NOOP_SPAN, {
+  setAttribute: { value: () => NOOP_SPAN },
+  setAttributes: { value: () => NOOP_SPAN },
+  addEvent: { value: () => NOOP_SPAN },
+  setStatus: { value: () => NOOP_SPAN },
+  updateName: { value: () => NOOP_SPAN },
+  end: { value: NOOP },
+  isRecording: { value: () => false },
+  recordException: { value: NOOP },
+  spanContext: { value: () => ({ traceId: "", spanId: "", traceFlags: 0 }) },
+});
+const NOOP_TRACER = {
+  startSpan: () => NOOP_SPAN,
+  startActiveSpan: (name, ...args) => {
+    const fn = args[args.length - 1];
+    if (typeof fn === "function") return fn(NOOP_SPAN);
+    return NOOP_SPAN;
+  },
+};
+const NOOP_TRACER_PROVIDER = { getTracer: () => NOOP_TRACER };
+const NOOP_CONTEXT_MANAGER = {
+  active: () => ROOT_CONTEXT,
+  with: (ctx, fn) => fn(),
+  bind: (ctx, target) => target,
+  enable: NOOP, disable: NOOP,
+};
+
+// Context objects need getValue/setValue/deleteValue per OpenTelemetry API.
+// setValue + deleteValue must return a NEW context with the key's value
+// set/removed — not mutate in place, and not return the same empty ROOT_CONTEXT
+// (or the tracer code calling \`trace.setSpan(ctx, span)\` would get a
+// context that still doesn't contain the span).
+function _makeContext(store) {
+  return {
+    getValue: (key) => store.get(key),
+    setValue: (key, value) => {
+      const next = new Map(store);
+      next.set(key, value);
+      return _makeContext(next);
+    },
+    deleteValue: (key) => {
+      const next = new Map(store);
+      next.delete(key);
+      return _makeContext(next);
+    },
+  };
+}
+export const ROOT_CONTEXT = _makeContext(new Map());
+export const defaultTextMapGetter = { get: () => undefined, keys: () => [] };
+export const defaultTextMapSetter = { set: NOOP };
+export const INVALID_SPANID = "";
+export const INVALID_TRACEID = "";
+export const INVALID_SPAN_CONTEXT = { traceId: "", spanId: "", traceFlags: 0 };
+
+// \`trace\` and \`context\` also have to cooperate across @opentelemetry/api
+// copies via the same globalThis symbol that \`propagation\` uses below.
+// Next.js's tracer.js imports the trace API through our shim; when the
+// user's instrumentation runs \`NodeTracerProvider.register()\`, it writes
+// the real tracer provider and context manager into
+// \`globalThis[Symbol.for("opentelemetry.js.api.1")]\` via its own api
+// copy. Without delegating here, Next.js's render path keeps calling
+// NOOP_TRACER.startSpan + context.active()=ROOT_CONTEXT, so no real span
+// is ever present in the context passed to \`propagation.inject\`. Result:
+// the user's propagator sees no span and falls back to
+// \`"invariant"\` for \`my-parent-span-id\`, failing the regex assertion
+// \`/<meta name="my-parent-span-id" content="[a-f0-9]{16}">/\`. Reading
+// from the shared global recovers the real tracer + context manager and
+// gives the propagator a real span to read.
+const CONTEXT_API_KEY = Symbol.for("opentelemetry.context");
+const SPAN_KEY = Symbol.for("OpenTelemetry Context Key SPAN");
+function _getGlobalTracerProvider() {
+  return _otelGlobal().trace ?? null;
+}
+function _getGlobalContextManager() {
+  return _otelGlobal().context ?? null;
+}
+export const trace = {
+  getTracer: (...args) => {
+    const g = _getGlobalTracerProvider();
+    if (g && typeof g.getTracer === "function") {
+      try { return g.getTracer(...args); } catch {}
+    }
+    return NOOP_TRACER;
+  },
+  getTracerProvider: () => _getGlobalTracerProvider() ?? NOOP_TRACER_PROVIDER,
+  setGlobalTracerProvider: (p) => { _otelGlobal().trace = p; return p; },
+  // getSpan(ctx): read the SPAN key from the context object — the same
+  // pattern sdk-trace-base uses. Falls back to undefined when the context
+  // is our empty ROOT_CONTEXT.
+  getSpan: (ctx) => {
+    if (ctx && typeof ctx.getValue === "function") {
+      const s = ctx.getValue(SPAN_KEY);
+      if (s) return s;
+    }
+    return undefined;
+  },
+  getActiveSpan: () => {
+    const ctx = _callActiveContext();
+    if (ctx && typeof ctx.getValue === "function") return ctx.getValue(SPAN_KEY);
+    return undefined;
+  },
+  setSpan: (ctx, span) => (ctx || ROOT_CONTEXT).setValue(SPAN_KEY, span),
+  deleteSpan: (ctx) => (ctx || ROOT_CONTEXT).deleteValue(SPAN_KEY),
+  setSpanContext: (ctx) => ctx || ROOT_CONTEXT,
+  // getSpanContext: read span from context, return its spanContext() result.
+  // User propagators rely on \`trace.getSpanContext(ctx)?.spanId\` to fill
+  // their my-parent-span-id meta tag — without this, they fall back to
+  // the literal string "invariant".
+  getSpanContext: (ctx) => {
+    const span = trace.getSpan(ctx);
+    if (span && typeof span.spanContext === "function") {
+      try { return span.spanContext(); } catch {}
+    }
+    return undefined;
+  },
+  isSpanContextValid: (sc) => !!sc && typeof sc.traceId === "string" && sc.traceId.length > 0,
+};
+
+function _callActiveContext() {
+  const mgr = _getGlobalContextManager();
+  if (mgr && typeof mgr.active === "function") {
+    try { return mgr.active(); } catch {}
+  }
+  return ROOT_CONTEXT;
+}
+export const context = {
+  active: () => _callActiveContext(),
+  with: (ctx, fn, thisArg, ...args) => {
+    const mgr = _getGlobalContextManager();
+    if (mgr && typeof mgr.with === "function") {
+      try { return mgr.with(ctx, fn, thisArg, ...args); } catch {}
+    }
+    return fn.call(thisArg, ...args);
+  },
+  bind: (ctx, target) => {
+    const mgr = _getGlobalContextManager();
+    if (mgr && typeof mgr.bind === "function") {
+      try { return mgr.bind(ctx, target); } catch {}
+    }
+    return target;
+  },
+  setGlobalContextManager: (mgr) => { _otelGlobal().context = mgr; return mgr; },
+  disable: () => { delete _otelGlobal().context; },
+};
+
+// Propagation must be functional (not NOOP) for user instrumentation to
+// work — Next.js's server render calls \`propagation.inject(ctx, carrier,
+// setter)\` when \`experimental.clientTraceMetadata\` is configured, and
+// expects the user's propagator (set by \`NodeTracerProvider.register({
+// propagator })\`) to emit the \`<meta name="...">\` tags.
+//
+// Delicate: \`@opentelemetry/api\` is loaded as multiple copies in the
+// bundle — one compiled into \`next/\`, one Turbopack-bundled from the
+// user's \`node_modules\`, and this shim (aliased for bare-specifier
+// imports at wrangler time). Their code agrees on a shared singleton by
+// writing propagator/context/tracer onto
+// \`globalThis[Symbol.for("opentelemetry.js.api.<major>")].propagation\`.
+// If this shim's propagation used a module-local variable, the user's
+// \`setGlobalPropagator\` call on their bundled api would never reach
+// this shim's \`inject\` — which is the codepath Next.js actually calls
+// through. Writing/reading via the same global symbol keeps every copy
+// in sync.
+// Fixes e2e/opentelemetry/client-trace-metadata (5 tests).
+const OTEL_GLOBAL_KEY = Symbol.for("opentelemetry.js.api.1");
+function _otelGlobal() {
+  let g = globalThis[OTEL_GLOBAL_KEY];
+  if (!g) {
+    g = { version: "1.9.0" };
+    globalThis[OTEL_GLOBAL_KEY] = g;
+  }
+  return g;
+}
+function _getPropagator() {
+  return _otelGlobal().propagation ?? null;
+}
+export const propagation = {
+  inject: (ctx, carrier, setter) => {
+    const p = _getPropagator();
+    if (p && typeof p.inject === "function") {
+      try { p.inject(ctx, carrier, setter); } catch {}
+    }
+  },
+  extract: (ctx, carrier, getter) => {
+    const p = _getPropagator();
+    if (p && typeof p.extract === "function") {
+      try { return p.extract(ctx, carrier, getter); } catch {}
+    }
+    return ctx;
+  },
+  fields: () => {
+    const p = _getPropagator();
+    if (p && typeof p.fields === "function") {
+      try { return p.fields(); } catch {}
+    }
+    return [];
+  },
+  setGlobalPropagator: (p) => {
+    _otelGlobal().propagation = p;
+    return propagation;
+  },
+  disable: () => { delete _otelGlobal().propagation; },
+};
+
+export const diag = {
+  setLogger: NOOP, disable: NOOP,
+  createComponentLogger: () => diag,
+  verbose: NOOP, debug: NOOP, info: NOOP, warn: NOOP, error: NOOP,
+};
+
+export function createContextKey(name) { return Symbol(name); }
+
+export const SpanKind = { INTERNAL: 0, SERVER: 1, CLIENT: 2, PRODUCER: 3, CONSUMER: 4 };
+export const SpanStatusCode = { UNSET: 0, OK: 1, ERROR: 2 };
+export const TraceFlags = { NONE: 0, SAMPLED: 1 };
+
+export default {
+  trace, context, propagation, diag, createContextKey,
+  ROOT_CONTEXT, SpanKind, SpanStatusCode, TraceFlags,
+  defaultTextMapGetter, defaultTextMapSetter,
+  INVALID_SPANID, INVALID_TRACEID, INVALID_SPAN_CONTEXT,
+};

package/src/shims/sharp.js

@@ -0,0 +1,12 @@
+// sharp shim for Cloudflare Workers.
+//
+// `@vercel/og/index.node.js` tries `(await import("sharp")).default` and,
+// if truthy, uses sharp to rasterize satori's SVG output to PNG. sharp
+// relies on native `.node` bindings (libvips) that workerd cannot load,
+// so the real module half-loads and ends up non-callable — the caller
+// then throws `TypeError: sharp is not a function`.
+//
+// Returning `default: undefined` makes getSharp() return undefined and
+// @vercel/og falls back to its built-in resvg.wasm path, which is already
+// bundled as a CompiledWasm module and works natively on workerd.
+export default undefined;