@opennextjs/cloudflare 0.6.5 → 1.0.0-beta.0

package/dist/api/cloudflare-context.d.ts

@@ -1,4 +1,5 @@
-import type { DurableObjectQueueHandler } from "./durable-objects/queue";
+import type { GetPlatformProxyOptions } from "wrangler";
+import type { DOQueueHandler } from "./durable-objects/queue";
 import { DOShardedTagCache } from "./durable-objects/sharded-tag-cache";
 declare global {
     interface CloudflareEnv {
@@ -11,11 +12,11 @@ declare global {
         NEXT_TAG_CACHE_D1?: D1Database;
         NEXT_TAG_CACHE_DO_SHARDED?: DurableObjectNamespace<DOShardedTagCache>;
         NEXT_TAG_CACHE_DO_SHARDED_DLQ?: Queue;
-        NEXT_CACHE_DO_QUEUE?: DurableObjectNamespace<DurableObjectQueueHandler>;
+        NEXT_CACHE_DO_QUEUE?: DurableObjectNamespace<DOQueueHandler>;
         NEXT_CACHE_DO_QUEUE_MAX_REVALIDATION?: string;
         NEXT_CACHE_DO_QUEUE_REVALIDATION_TIMEOUT_MS?: string;
         NEXT_CACHE_DO_QUEUE_RETRY_INTERVAL_MS?: string;
-        NEXT_CACHE_DO_QUEUE_MAX_NUM_REVALIDATIONS?: string;
+        NEXT_CACHE_DO_QUEUE_MAX_RETRIES?: string;
         NEXT_CACHE_DO_QUEUE_DISABLE_SQLITE?: string;
     }
 }
@@ -49,5 +50,6 @@ export declare function getCloudflareContext<CfProperties extends Record<string,
  * with the open-next Cloudflare adapter
  *
  * Note: this function should only be called inside the Next.js config file, and although async it doesn't need to be `await`ed
+ * @param options options on how the function should operate and if/where to persist the platform data
  */
-export declare function initOpenNextCloudflareForDev(): Promise<void>;
+export declare function initOpenNextCloudflareForDev(options?: GetPlatformProxyOptions): Promise<void>;

package/dist/api/cloudflare-context.js

@@ -71,12 +71,17 @@ async function getCloudflareContextAsync() {
  * with the open-next Cloudflare adapter
  *
  * Note: this function should only be called inside the Next.js config file, and although async it doesn't need to be `await`ed
+ * @param options options on how the function should operate and if/where to persist the platform data
  */
-export async function initOpenNextCloudflareForDev() {
+export async function initOpenNextCloudflareForDev(options) {
     const shouldInitializationRun = shouldContextInitializationRun();
     if (!shouldInitializationRun)
         return;
-    const context = await getCloudflareContextFromWrangler();
+    if (options?.environment && process.env.NEXT_DEV_WRANGLER_ENV) {
+        console.warn(`'initOpenNextCloudflareForDev' has been called with an environment option while NEXT_DEV_WRANGLER_ENV is set.` +
+            ` NEXT_DEV_WRANGLER_ENV will be ignored and the environment will be set to: '${options.environment}'`);
+    }
+    const context = await getCloudflareContextFromWrangler(options);
     addCloudflareContextToNodejsGlobal(context);
     await monkeyPatchVmModuleEdgeContext(context);
 }
@@ -131,12 +136,14 @@ async function monkeyPatchVmModuleEdgeContext(cloudflareContext) {
  *
  * @returns the cloudflare context ready for use
  */
-async function getCloudflareContextFromWrangler() {
+async function getCloudflareContextFromWrangler(options) {
     // Note: we never want wrangler to be bundled in the Next.js app, that's why the import below looks like it does
     const { getPlatformProxy } = await import(/* webpackIgnore: true */ `${"__wrangler".replaceAll("_", "")}`);
+    // This allows the selection of a wrangler environment while running in next dev mode
+    const environment = options?.environment ?? process.env.NEXT_DEV_WRANGLER_ENV;
     const { env, cf, ctx } = await getPlatformProxy({
-        // This allows the selection of a wrangler environment while running in next dev mode
-        environment: process.env.NEXT_DEV_WRANGLER_ENV,
+        ...options,
+        environment,
     });
     return {
         env,

package/dist/api/durable-objects/queue.d.ts

@@ -5,7 +5,7 @@ interface FailedState {
     retryCount: number;
     nextAlarmMs: number;
 }
-export declare class DurableObjectQueueHandler extends DurableObject<CloudflareEnv> {
+export declare class DOQueueHandler extends DurableObject<CloudflareEnv> {
     ongoingRevalidations: Map<string, Promise<void>>;
     sql: SqlStorage;
     routeInFailedState: Map<string, FailedState>;
@@ -13,7 +13,7 @@ export declare class DurableObjectQueueHandler extends DurableObject<CloudflareE
     readonly maxRevalidations: number;
     readonly revalidationTimeout: number;
     readonly revalidationRetryInterval: number;
-    readonly maxRevalidationAttempts: number;
+    readonly maxRetries: number;
     readonly disableSQLite: boolean;
     constructor(ctx: DurableObjectState, env: CloudflareEnv);
     revalidate(msg: QueueMessage): Promise<void>;

package/dist/api/durable-objects/queue.js

@@ -4,8 +4,8 @@ import { DurableObject } from "cloudflare:workers";
 const DEFAULT_MAX_REVALIDATION = 5;
 const DEFAULT_REVALIDATION_TIMEOUT_MS = 10_000;
 const DEFAULT_RETRY_INTERVAL_MS = 2_000;
-const DEFAULT_MAX_NUM_REVALIDATIONS = 6;
-export class DurableObjectQueueHandler extends DurableObject {
+const DEFAULT_MAX_RETRIES = 6;
+export class DOQueueHandler extends DurableObject {
     // Ongoing revalidations are deduped by the deduplication id
     // Since this is running in waitUntil, we expect the durable object state to persist this during the duration of the revalidation
     // TODO: handle incremental cache with only eventual consistency (i.e. KV or R2/D1 with the optional cache layer on top)
@@ -17,7 +17,7 @@ export class DurableObjectQueueHandler extends DurableObject {
     maxRevalidations;
     revalidationTimeout;
     revalidationRetryInterval;
-    maxRevalidationAttempts;
+    maxRetries;
     disableSQLite;
     constructor(ctx, env) {
         super(ctx, env);
@@ -35,9 +35,9 @@ export class DurableObjectQueueHandler extends DurableObject {
         this.revalidationRetryInterval = env.NEXT_CACHE_DO_QUEUE_RETRY_INTERVAL_MS
             ? parseInt(env.NEXT_CACHE_DO_QUEUE_RETRY_INTERVAL_MS)
             : DEFAULT_RETRY_INTERVAL_MS;
-        this.maxRevalidationAttempts = env.NEXT_CACHE_DO_QUEUE_MAX_NUM_REVALIDATIONS
-            ? parseInt(env.NEXT_CACHE_DO_QUEUE_MAX_NUM_REVALIDATIONS)
-            : DEFAULT_MAX_NUM_REVALIDATIONS;
+        this.maxRetries = env.NEXT_CACHE_DO_QUEUE_MAX_RETRIES
+            ? parseInt(env.NEXT_CACHE_DO_QUEUE_MAX_RETRIES)
+            : DEFAULT_MAX_RETRIES;
         this.disableSQLite = env.NEXT_CACHE_DO_QUEUE_DISABLE_SQLITE === "true";
         // We restore the state
         ctx.blockConcurrencyWhile(async () => {
@@ -152,9 +152,8 @@ export class DurableObjectQueueHandler extends DurableObject {
         const existingFailedState = this.routeInFailedState.get(msg.MessageDeduplicationId);
         let updatedFailedState;
         if (existingFailedState) {
-            if (existingFailedState.retryCount >= this.maxRevalidationAttempts) {
-                // We give up after 6 retries and log the error
-                error(`The revalidation for ${msg.MessageBody.host}${msg.MessageBody.url} has failed after 6 retries. It will not be tried again, but subsequent ISR requests will retry.`);
+            if (existingFailedState.retryCount >= this.maxRetries) {
+                error(`The revalidation for ${msg.MessageBody.host}${msg.MessageBody.url} has failed after ${this.maxRetries} retries. It will not be tried again, but subsequent ISR requests will retry.`);
                 this.routeInFailedState.delete(msg.MessageDeduplicationId);
                 return;
             }

package/dist/api/durable-objects/queue.spec.js

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from "vitest";
-import { DurableObjectQueueHandler } from "./queue";
+import { DOQueueHandler } from "./queue";
 vi.mock("cloudflare:workers", () => ({
     DurableObject: class {
         ctx;
@@ -25,7 +25,7 @@ const createDurableObjectQueue = ({ fetchDuration, statusCode, headers, disableS
         },
     };
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return new DurableObjectQueueHandler(mockState, {
+    return new DOQueueHandler(mockState, {
         WORKER_SELF_REFERENCE: {
             fetch: vi.fn().mockReturnValue(new Promise((res) => setTimeout(() => res(new Response(null, {
                 status: statusCode,

package/dist/api/overrides/incremental-cache/kv-incremental-cache.d.ts

@@ -1,6 +1,7 @@
 import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides";
 export declare const CACHE_ASSET_DIR = "cdn-cgi/_next_cache";
 export declare const STATUS_DELETED = 1;
+export declare const NAME = "cf-kv-incremental-cache";
 /**
  * Open Next cache based on cloudflare KV and Assets.
  *
@@ -8,8 +9,8 @@ export declare const STATUS_DELETED = 1;
  * The cloudflare context and process.env are not initialized yet
  * when the constructor is called.
  */
-declare class Cache implements IncrementalCache {
-    readonly name = "cloudflare-kv";
+declare class KVIncrementalCache implements IncrementalCache {
+    readonly name = "cf-kv-incremental-cache";
     get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>> | null>;
     set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
     delete(key: string): Promise<void>;
@@ -18,5 +19,5 @@ declare class Cache implements IncrementalCache {
     protected debug(...args: unknown[]): void;
     protected getBuildId(): string;
 }
-declare const _default: Cache;
+declare const _default: KVIncrementalCache;
 export default _default;

package/dist/api/overrides/incremental-cache/kv-incremental-cache.js

@@ -2,6 +2,7 @@ import { IgnorableError, RecoverableError } from "@opennextjs/aws/utils/error.js
 import { getCloudflareContext } from "../../cloudflare-context.js";
 export const CACHE_ASSET_DIR = "cdn-cgi/_next_cache";
 export const STATUS_DELETED = 1;
+export const NAME = "cf-kv-incremental-cache";
 /**
  * Open Next cache based on cloudflare KV and Assets.
  *
@@ -9,8 +10,8 @@ export const STATUS_DELETED = 1;
  * The cloudflare context and process.env are not initialized yet
  * when the constructor is called.
  */
-class Cache {
-    name = "cloudflare-kv";
+class KVIncrementalCache {
+    name = NAME;
     async get(key, isFetch) {
         const cfEnv = getCloudflareContext().env;
         const kv = cfEnv.NEXT_INC_CACHE_KV;
@@ -120,4 +121,4 @@ class Cache {
         return process.env.NEXT_BUILD_ID ?? "no-build-id";
     }
 }
-export default new Cache();
+export default new KVIncrementalCache();

package/dist/api/overrides/incremental-cache/r2-incremental-cache.d.ts

@@ -1,4 +1,5 @@
 import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides.js";
+export declare const NAME = "cf-r2-incremental-cache";
 /**
  * An instance of the Incremental Cache that uses an R2 bucket (`NEXT_INC_CACHE_R2_BUCKET`) as it's
  * underlying data store.
@@ -7,7 +8,7 @@ import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs
  * environment variable, and defaults to `incremental-cache`.
  */
 declare class R2IncrementalCache implements IncrementalCache {
-    readonly name = "r2-incremental-cache";
+    readonly name = "cf-r2-incremental-cache";
     get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>> | null>;
     set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
     delete(key: string): Promise<void>;

package/dist/api/overrides/incremental-cache/r2-incremental-cache.js

@@ -1,6 +1,7 @@
 import { debug, error } from "@opennextjs/aws/adapters/logger.js";
 import { IgnorableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context.js";
+export const NAME = "cf-r2-incremental-cache";
 /**
  * An instance of the Incremental Cache that uses an R2 bucket (`NEXT_INC_CACHE_R2_BUCKET`) as it's
  * underlying data store.
@@ -9,7 +10,7 @@ import { getCloudflareContext } from "../../cloudflare-context.js";
  * environment variable, and defaults to `incremental-cache`.
  */
 class R2IncrementalCache {
-    name = "r2-incremental-cache";
+    name = NAME;
     async get(key, isFetch) {
         const r2 = getCloudflareContext().env.NEXT_INC_CACHE_R2_BUCKET;
         if (!r2)

package/dist/api/overrides/incremental-cache/regional-cache.d.ts

@@ -5,17 +5,21 @@ type Options = {
      * The mode to use for the regional cache.
      *
      * - `short-lived`: Re-use a cache entry for up to a minute after it has been retrieved.
-     * - `long-lived`: Re-use a fetch cache entry until it is revalidated (per-region), or an ISR/SSG entry for up to 30 minutes.
+     * - `long-lived`: Re-use a fetch cache entry until it is revalidated (per-region),
+     *                 or an ISR/SSG entry for up to 30 minutes.
      */
     mode: "short-lived" | "long-lived";
     /**
      * Whether the regional cache entry should be updated in the background or not when it experiences
      * a cache hit.
      *
-     * Defaults to `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
+     * @default `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
      */
     shouldLazilyUpdateOnCacheHit?: boolean;
 };
+/**
+ * Wrapper adding a regional cache on an `IncrementalCache` implementation
+ */
 declare class RegionalCache implements IncrementalCache {
     private store;
     private opts;
@@ -35,17 +39,19 @@ declare class RegionalCache implements IncrementalCache {
  *
  * The regional cache uses the Cache API.
  *
- * **WARNING:** If an entry is revalidated in one region, it will trigger an additional revalidation if
+ * **WARNING:**
+ * If an entry is revalidated on demand in one region (using either `revalidateTag`, `revalidatePath` or `res.revalidate` ), it will trigger an additional revalidation if
  * a request is made to another region that has an entry stored in its regional cache.
  *
- * @param cache - Incremental cache instance.
- * @param opts.mode - The mode to use for the regional cache.
- * - `short-lived`: Re-use a cache entry for up to a minute after it has been retrieved.
- * - `long-lived`: Re-use a fetch cache entry until it is revalidated (per-region), or an ISR/SSG entry for up to 30 minutes.
- * @param opts.shouldLazilyUpdateOnCacheHit - Whether the regional cache entry should be updated in
- * the background or not when it experiences a cache hit.
+ * @param cache Incremental cache instance.
+ * @param opts.mode The mode to use for the regional cache.
+ *                  - `short-lived`: Re-use a cache entry for up to a minute after it has been retrieved.
+ *                  - `long-lived`: Re-use a fetch cache entry until it is revalidated (per-region),
+ *                                  or an ISR/SSG entry for up to 30 minutes.
+ * @param opts.shouldLazilyUpdateOnCacheHit Whether the regional cache entry should be updated in
+ *                                          the background or not when it experiences a cache hit.
  *
- * Defaults to `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
+ * @default `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
  */
 export declare function withRegionalCache(cache: IncrementalCache, opts: Options): RegionalCache;
 export {};

package/dist/api/overrides/incremental-cache/regional-cache.js

@@ -1,7 +1,11 @@
 import { debug, error } from "@opennextjs/aws/adapters/logger.js";
 import { getCloudflareContext } from "../../cloudflare-context.js";
+import { NAME as KV_CACHE_NAME } from "./kv-incremental-cache.js";
 const ONE_MINUTE_IN_SECONDS = 60;
 const THIRTY_MINUTES_IN_SECONDS = ONE_MINUTE_IN_SECONDS * 30;
+/**
+ * Wrapper adding a regional cache on an `IncrementalCache` implementation
+ */
 class RegionalCache {
     store;
     opts;
@@ -10,6 +14,9 @@ class RegionalCache {
     constructor(store, opts) {
         this.store = store;
         this.opts = opts;
+        if (this.store.name === KV_CACHE_NAME) {
+            throw new Error("The KV incremental cache does not need a regional cache.");
+        }
         this.name = this.store.name;
         this.opts.shouldLazilyUpdateOnCacheHit ??= this.opts.mode === "long-lived";
     }
@@ -94,17 +101,19 @@ class RegionalCache {
  *
  * The regional cache uses the Cache API.
  *
- * **WARNING:** If an entry is revalidated in one region, it will trigger an additional revalidation if
+ * **WARNING:**
+ * If an entry is revalidated on demand in one region (using either `revalidateTag`, `revalidatePath` or `res.revalidate` ), it will trigger an additional revalidation if
  * a request is made to another region that has an entry stored in its regional cache.
  *
- * @param cache - Incremental cache instance.
- * @param opts.mode - The mode to use for the regional cache.
- * - `short-lived`: Re-use a cache entry for up to a minute after it has been retrieved.
- * - `long-lived`: Re-use a fetch cache entry until it is revalidated (per-region), or an ISR/SSG entry for up to 30 minutes.
- * @param opts.shouldLazilyUpdateOnCacheHit - Whether the regional cache entry should be updated in
- * the background or not when it experiences a cache hit.
+ * @param cache Incremental cache instance.
+ * @param opts.mode The mode to use for the regional cache.
+ *                  - `short-lived`: Re-use a cache entry for up to a minute after it has been retrieved.
+ *                  - `long-lived`: Re-use a fetch cache entry until it is revalidated (per-region),
+ *                                  or an ISR/SSG entry for up to 30 minutes.
+ * @param opts.shouldLazilyUpdateOnCacheHit Whether the regional cache entry should be updated in
+ *                                          the background or not when it experiences a cache hit.
  *
- * Defaults to `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
+ * @default `false` for the `short-lived` mode, and `true` for the `long-lived` mode.
  */
 export function withRegionalCache(cache, opts) {
     return new RegionalCache(cache, opts);

package/dist/api/overrides/tag-cache/d1-next-tag-cache.d.ts

@@ -1,4 +1,5 @@
 import type { NextModeTagCache } from "@opennextjs/aws/types/overrides.js";
+export declare const NAME = "d1-next-mode-tag-cache";
 export declare class D1NextModeTagCache implements NextModeTagCache {
     readonly mode: "nextMode";
     readonly name = "d1-next-mode-tag-cache";

package/dist/api/overrides/tag-cache/d1-next-tag-cache.js

@@ -1,9 +1,10 @@
 import { debug, error } from "@opennextjs/aws/adapters/logger.js";
 import { RecoverableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context.js";
+export const NAME = "d1-next-mode-tag-cache";
 export class D1NextModeTagCache {
     mode = "nextMode";
-    name = "d1-next-mode-tag-cache";
+    name = NAME;
     async hasBeenRevalidated(tags, lastModified) {
         const { isDisabled, db } = this.getConfig();
         if (isDisabled)

package/dist/api/overrides/tag-cache/do-sharded-tag-cache.d.ts

@@ -1,67 +1,73 @@
 import type { NextModeTagCache } from "@opennextjs/aws/types/overrides.js";
-export declare const DEFAULT_SOFT_REPLICAS = 4;
-export declare const DEFAULT_HARD_REPLICAS = 2;
 export declare const DEFAULT_WRITE_RETRIES = 3;
 export declare const DEFAULT_NUM_SHARDS = 4;
+export declare const NAME = "do-sharded-tag-cache";
 interface ShardedDOTagCacheOptions {
     /**
      * The number of shards that will be used.
+     *
      * 1 shards means 1 durable object instance.
-     * Soft (internal next tags used for `revalidatePath`) and hard tags (the one you define in your app) will be split in different shards.
+     * Soft (internal next tags used for `revalidatePath`) and hard tags (the one you define in your app)
+     * will be split in different shards.
+     *
      * The number of requests made to Durable Objects will scale linearly with the number of shards.
-     * For example, a request involving 5 tags may access between 1 and 5 shards, with the upper limit being the lesser of the number of tags or the number of shards
+     * For example, a request involving 5 tags may access between 1 and 5 shards, with the upper limit being
+     * the lesser of the number of tags or the number of shards
+     *
      * @default 4
      */
     baseShardSize: number;
     /**
      * Whether to enable a regional cache on a per-shard basis
      * Because of the way tags are implemented in Next.js, some shards will have more requests than others. For these cases, it is recommended to enable the regional cache.
+     *
      * @default false
      */
     regionalCache?: boolean;
     /**
      * The TTL for the regional cache in seconds
      * Increasing this value will reduce the number of requests to the Durable Object, but it could make `revalidateTags`/`revalidatePath` call being longer to take effect
+     *
      * @default 5
      */
     regionalCacheTtlSec?: number;
     /**
-     * Whether to enable shard replication
-     * Shard replication will duplicate each shards into N replicas to spread the load even more
-     * All replicas of the a shard contain the same value - write are sent to all of the replicas.
-     * This allows most frequent read operations to be sent to only one replica to spread the load.
-     * For example with N being 2, tag `tag1` could be read from 2 different durable object instance
-     * On read you only need to read from one of the shards, but on write you need to write to all shards
-     * @default false
-     */
-    enableShardReplication?: boolean;
-    /**
-     * The number of replicas that will be used for shard replication
-     * Soft shard replicas are more often accessed than hard shard replicas, so it is recommended to have more soft replicas than hard replicas
-     * Soft replicas are for internal next tags used for `revalidatePath` (i.e. `_N_T_/layout`, `_N_T_/page1`), hard replicas are the tags defined in your app
-     * @default { numberOfSoftReplicas: 4, numberOfHardReplicas: 2 }
+     * Enable shard replication to handle higher load.
+     *
+     * By default shards are not replicated (`numberOfSoftReplicas = 1` or `numberOfHardReplicas = 1`).
+     *
+     * Setting the number of replicas to a number greater than 1 will replicate the shards.
+     * Write operations always apply to all of the shards.
+     * However read operations read from a single shard to spread the load.
+     *
+     * Soft replicas are for internal next tags used for `revalidatePath` (i.e. `_N_T_/layout`, `_N_T_/page1`).
+     * Hard replicas are the tags defined in your app.
+     *
+     * Soft replicas are accessed more often  than hard replicas, so it is recommended to have more soft replicas
+     * than hard replicas (2x is a good rule of thumb)
      */
-    shardReplicationOptions?: {
+    shardReplication?: {
         numberOfSoftReplicas: number;
         numberOfHardReplicas: number;
     };
     /**
      * The number of retries to perform when writing tags
+     *
      * @default 3
      */
     maxWriteRetries?: number;
 }
-interface TagCacheDOIdOptions {
+interface DOIdOptions {
     baseShardId: string;
     numberOfReplicas: number;
     shardType: "soft" | "hard";
     replicaId?: number;
 }
-export declare class TagCacheDOId {
-    options: TagCacheDOIdOptions;
+export declare class DOId {
+    options: DOIdOptions;
     shardId: string;
     replicaId: number;
-    constructor(options: TagCacheDOIdOptions);
+    constructor(options: DOIdOptions);
     private generateRandomNumberBetween;
     get key(): string;
 }
@@ -92,7 +98,7 @@ declare class ShardedDOTagCache implements NextModeTagCache {
         tags: string[];
         generateAllReplicas?: boolean;
     }): {
-        doId: TagCacheDOId;
+        doId: DOId;
         tags: string[];
     }[];
     private getConfig;
@@ -111,12 +117,12 @@ declare class ShardedDOTagCache implements NextModeTagCache {
      * @returns
      */
     writeTags(tags: string[]): Promise<void>;
-    performWriteTagsWithRetry(doId: TagCacheDOId, tags: string[], lastModified: number, retryNumber?: number): Promise<void>;
+    performWriteTagsWithRetry(doId: DOId, tags: string[], lastModified: number, retryNumber?: number): Promise<void>;
     getCacheInstance(): Promise<Cache | undefined>;
-    getCacheKey(doId: TagCacheDOId, tags: string[]): Promise<Request<unknown, CfProperties<unknown>>>;
-    getFromRegionalCache(doId: TagCacheDOId, tags: string[]): Promise<Response | undefined>;
-    putToRegionalCache(doId: TagCacheDOId, tags: string[], hasBeenRevalidated: boolean): Promise<void>;
-    deleteRegionalCache(doId: TagCacheDOId, tags: string[]): Promise<void>;
+    getCacheKey(doId: DOId, tags: string[]): Promise<Request<unknown, CfProperties<unknown>>>;
+    getFromRegionalCache(doId: DOId, tags: string[]): Promise<Response | undefined>;
+    putToRegionalCache(doId: DOId, tags: string[], hasBeenRevalidated: boolean): Promise<void>;
+    deleteRegionalCache(doId: DOId, tags: string[]): Promise<void>;
 }
 declare const _default: (opts?: ShardedDOTagCacheOptions) => ShardedDOTagCache;
 export default _default;

package/dist/api/overrides/tag-cache/do-sharded-tag-cache.js

@@ -2,12 +2,11 @@ import { debug, error } from "@opennextjs/aws/adapters/logger.js";
 import { generateShardId } from "@opennextjs/aws/core/routing/queue.js";
 import { IgnorableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context";
-const SOFT_TAG_PREFIX = "_N_T_/";
-export const DEFAULT_SOFT_REPLICAS = 4;
-export const DEFAULT_HARD_REPLICAS = 2;
 export const DEFAULT_WRITE_RETRIES = 3;
 export const DEFAULT_NUM_SHARDS = 4;
-export class TagCacheDOId {
+export const NAME = "do-sharded-tag-cache";
+const SOFT_TAG_PREFIX = "_N_T_/";
+export class DOId {
     options;
     shardId;
     replicaId;
@@ -27,15 +26,15 @@ export class TagCacheDOId {
 class ShardedDOTagCache {
     opts;
     mode = "nextMode";
-    name = "do-sharded-tag-cache";
+    name = NAME;
     numSoftReplicas;
     numHardReplicas;
     maxWriteRetries;
     localCache;
     constructor(opts = { baseShardSize: DEFAULT_NUM_SHARDS }) {
         this.opts = opts;
-        this.numSoftReplicas = opts.shardReplicationOptions?.numberOfSoftReplicas ?? DEFAULT_SOFT_REPLICAS;
-        this.numHardReplicas = opts.shardReplicationOptions?.numberOfHardReplicas ?? DEFAULT_HARD_REPLICAS;
+        this.numSoftReplicas = opts.shardReplication?.numberOfSoftReplicas ?? 1;
+        this.numHardReplicas = opts.shardReplication?.numberOfHardReplicas ?? 1;
         this.maxWriteRetries = opts.maxWriteRetries ?? DEFAULT_WRITE_RETRIES;
     }
     getDurableObjectStub(doId) {
@@ -55,19 +54,14 @@ class ShardedDOTagCache {
     generateDOIdArray({ tags, shardType, generateAllReplicas = false, }) {
         let replicaIndexes = [1];
         const isSoft = shardType === "soft";
-        let numReplicas = 1;
-        if (this.opts.enableShardReplication) {
-            numReplicas = isSoft ? this.numSoftReplicas : this.numHardReplicas;
-            replicaIndexes = generateAllReplicas
-                ? Array.from({ length: numReplicas }, (_, i) => i + 1)
-                : [undefined];
-        }
+        const numReplicas = isSoft ? this.numSoftReplicas : this.numHardReplicas;
+        replicaIndexes = generateAllReplicas ? Array.from({ length: numReplicas }, (_, i) => i + 1) : [undefined];
         return replicaIndexes.flatMap((replicaId) => {
             return tags
                 .filter((tag) => (isSoft ? tag.startsWith(SOFT_TAG_PREFIX) : !tag.startsWith(SOFT_TAG_PREFIX)))
                 .map((tag) => {
                 return {
-                    doId: new TagCacheDOId({
+                    doId: new DOId({
                         baseShardId: generateShardId(tag, this.opts.baseShardSize, "shard"),
                         numberOfReplicas: numReplicas,
                         shardType,

package/dist/api/overrides/tag-cache/do-sharded-tag-cache.spec.js

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import doShardedTagCache, { DEFAULT_HARD_REPLICAS, DEFAULT_SOFT_REPLICAS, TagCacheDOId, } from "./do-sharded-tag-cache";
+import shardedDOTagCache, { DOId } from "./do-sharded-tag-cache";
 const hasBeenRevalidatedMock = vi.fn();
 const writeTagsMock = vi.fn();
 const idFromNameMock = vi.fn();
@@ -23,7 +23,7 @@ describe("DOShardedTagCache", () => {
     afterEach(() => vi.clearAllMocks());
     describe("generateShardId", () => {
         it("should generate a shardId", () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             const expectedResult = [
                 { doId: expect.objectContaining({ shardId: "tag-hard;shard-1" }), tags: ["tag1"] },
                 { doId: expect.objectContaining({ shardId: "tag-hard;shard-2" }), tags: ["tag2"] },
@@ -34,7 +34,7 @@ describe("DOShardedTagCache", () => {
             expect(result[1]?.doId.key).toBe("tag-hard;shard-2;replica-1");
         });
         it("should group tags by shard", () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             const expectedResult = [
                 { doId: expect.objectContaining({ shardId: "tag-hard;shard-1" }), tags: ["tag1", "tag6"] },
             ];
@@ -43,13 +43,13 @@ describe("DOShardedTagCache", () => {
             expect(result[0]?.doId.key).toBe("tag-hard;shard-1;replica-1");
         });
         it("should generate the same shardId for the same tag", () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             const firstResult = cache.groupTagsByDO({ tags: ["tag1"] });
             const secondResult = cache.groupTagsByDO({ tags: ["tag1", "tag3", "tag4"] });
             expect(firstResult[0]).toEqual(secondResult[0]);
         });
         it("should split hard and soft tags", () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             const expectedResult = [
                 { doId: expect.objectContaining({ shardId: "tag-soft;shard-3" }), tags: ["_N_T_/tag1"] },
                 { doId: expect.objectContaining({ shardId: "tag-hard;shard-1", replicaId: 1 }), tags: ["tag1"] },
@@ -61,7 +61,10 @@ describe("DOShardedTagCache", () => {
         });
         describe("with shard replication", () => {
             it("should generate all doIds if generateAllReplicas is true", () => {
-                const cache = doShardedTagCache({ baseShardSize: 4, enableShardReplication: true });
+                const cache = shardedDOTagCache({
+                    baseShardSize: 4,
+                    shardReplication: { numberOfSoftReplicas: 4, numberOfHardReplicas: 2 },
+                });
                 const expectedResult = [
                     { doId: expect.objectContaining({ shardId: "tag-soft;shard-3" }), tags: ["_N_T_/tag1"] },
                     { doId: expect.objectContaining({ shardId: "tag-soft;shard-3" }), tags: ["_N_T_/tag1"] },
@@ -74,7 +77,10 @@ describe("DOShardedTagCache", () => {
                 expect(result).toEqual(expectedResult);
             });
             it("should generate only one doIds by tag type if generateAllReplicas is false", () => {
-                const cache = doShardedTagCache({ baseShardSize: 4, enableShardReplication: true });
+                const cache = shardedDOTagCache({
+                    baseShardSize: 4,
+                    shardReplication: { numberOfSoftReplicas: 4, numberOfHardReplicas: 2 },
+                });
                 const shardedTagCollection = cache.groupTagsByDO({
                     tags: ["tag1", "_N_T_/tag1"],
                     generateAllReplicas: false,
@@ -86,9 +92,9 @@ describe("DOShardedTagCache", () => {
                 expect(secondDOId?.shardId).toBe("tag-hard;shard-1");
                 // We still need to check if the last part is between the correct boundaries
                 expect(firstDOId?.replicaId).toBeGreaterThanOrEqual(1);
-                expect(firstDOId?.replicaId).toBeLessThanOrEqual(DEFAULT_SOFT_REPLICAS);
+                expect(firstDOId?.replicaId).toBeLessThanOrEqual(4);
                 expect(secondDOId?.replicaId).toBeGreaterThanOrEqual(1);
-                expect(secondDOId?.replicaId).toBeLessThanOrEqual(DEFAULT_HARD_REPLICAS);
+                expect(secondDOId?.replicaId).toBeLessThanOrEqual(2);
             });
         });
     });
@@ -102,13 +108,13 @@ describe("DOShardedTagCache", () => {
             globalThis.openNextConfig = {
                 dangerous: { disableTagCache: true },
             };
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             const result = await cache.hasBeenRevalidated(["tag1"]);
             expect(result).toBe(false);
             expect(idFromNameMock).not.toHaveBeenCalled();
         });
         it("should return false if stub return false", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             cache.getFromRegionalCache = vi.fn();
             hasBeenRevalidatedMock.mockImplementationOnce(() => false);
             const result = await cache.hasBeenRevalidated(["tag1"], 123456);
@@ -118,7 +124,7 @@ describe("DOShardedTagCache", () => {
             expect(result).toBe(false);
         });
         it("should return true if stub return true", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             cache.getFromRegionalCache = vi.fn();
             hasBeenRevalidatedMock.mockImplementationOnce(() => true);
             const result = await cache.hasBeenRevalidated(["tag1"], 123456);
@@ -128,7 +134,7 @@ describe("DOShardedTagCache", () => {
             expect(result).toBe(true);
         });
         it("should return false if it throws", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             cache.getFromRegionalCache = vi.fn();
             hasBeenRevalidatedMock.mockImplementationOnce(() => {
                 throw new Error("error");
@@ -140,7 +146,7 @@ describe("DOShardedTagCache", () => {
             expect(result).toBe(false);
         });
         it("Should return from the cache if it was found there", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             cache.getFromRegionalCache = vi.fn().mockReturnValueOnce(new Response("true"));
             const result = await cache.hasBeenRevalidated(["tag1"], 123456);
             expect(result).toBe(true);
@@ -148,7 +154,7 @@ describe("DOShardedTagCache", () => {
             expect(hasBeenRevalidatedMock).not.toHaveBeenCalled();
         });
         it("should try to put the result in the cache if it was not revalidated", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             cache.getFromRegionalCache = vi.fn();
             cache.putToRegionalCache = vi.fn();
             hasBeenRevalidatedMock.mockImplementationOnce(() => false);
@@ -158,7 +164,7 @@ describe("DOShardedTagCache", () => {
             expect(cache.putToRegionalCache).toHaveBeenCalled();
         });
         it("should call all the durable object instance", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             cache.getFromRegionalCache = vi.fn();
             const result = await cache.hasBeenRevalidated(["tag1", "tag2"], 123456);
             expect(result).toBe(false);
@@ -181,20 +187,20 @@ describe("DOShardedTagCache", () => {
             globalThis.openNextConfig = {
                 dangerous: { disableTagCache: true },
             };
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             await cache.writeTags(["tag1"]);
             expect(idFromNameMock).not.toHaveBeenCalled();
             expect(writeTagsMock).not.toHaveBeenCalled();
         });
         it("should write the tags to the cache", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             await cache.writeTags(["tag1"]);
             expect(idFromNameMock).toHaveBeenCalled();
             expect(writeTagsMock).toHaveBeenCalled();
             expect(writeTagsMock).toHaveBeenCalledWith(["tag1"], 1000);
         });
         it("should write the tags to the cache for multiple shards", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             await cache.writeTags(["tag1", "tag2"]);
             expect(idFromNameMock).toHaveBeenCalledTimes(2);
             expect(writeTagsMock).toHaveBeenCalledTimes(2);
@@ -202,7 +208,10 @@ describe("DOShardedTagCache", () => {
             expect(writeTagsMock).toHaveBeenCalledWith(["tag2"], 1000);
         });
         it('should write to all the replicated shards if "generateAllReplicas" is true', async () => {
-            const cache = doShardedTagCache({ baseShardSize: 4, enableShardReplication: true });
+            const cache = shardedDOTagCache({
+                baseShardSize: 4,
+                shardReplication: { numberOfSoftReplicas: 4, numberOfHardReplicas: 2 },
+            });
             await cache.writeTags(["tag1", "_N_T_/tag1"]);
             expect(idFromNameMock).toHaveBeenCalledTimes(6);
             expect(writeTagsMock).toHaveBeenCalledTimes(6);
@@ -210,7 +219,7 @@ describe("DOShardedTagCache", () => {
             expect(writeTagsMock).toHaveBeenCalledWith(["_N_T_/tag1"], 1000);
         });
         it("should call deleteRegionalCache", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             cache.deleteRegionalCache = vi.fn();
             await cache.writeTags(["tag1"]);
             expect(cache.deleteRegionalCache).toHaveBeenCalled();
@@ -220,7 +229,7 @@ describe("DOShardedTagCache", () => {
     });
     describe("getCacheInstance", () => {
         it("should return undefined by default", async () => {
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             expect(await cache.getCacheInstance()).toBeUndefined();
         });
         it("should try to return the cache instance if regional cache is enabled", async () => {
@@ -228,7 +237,7 @@ describe("DOShardedTagCache", () => {
             globalThis.caches = {
                 open: vi.fn().mockResolvedValue("cache"),
             };
-            const cache = doShardedTagCache({ baseShardSize: 4, regionalCache: true });
+            const cache = shardedDOTagCache({ baseShardSize: 4, regionalCache: true });
             expect(cache.localCache).toBeUndefined();
             expect(await cache.getCacheInstance()).toBe("cache");
             expect(cache.localCache).toBe("cache");
@@ -238,8 +247,8 @@ describe("DOShardedTagCache", () => {
     });
     describe("getFromRegionalCache", () => {
         it("should return undefined if regional cache is disabled", async () => {
-            const cache = doShardedTagCache();
-            const doId = new TagCacheDOId({
+            const cache = shardedDOTagCache();
+            const doId = new DOId({
                 baseShardId: "shard-1",
                 numberOfReplicas: 1,
                 shardType: "hard",
@@ -253,8 +262,8 @@ describe("DOShardedTagCache", () => {
                     match: vi.fn().mockResolvedValue("response"),
                 }),
             };
-            const cache = doShardedTagCache({ baseShardSize: 4, regionalCache: true });
-            const doId = new TagCacheDOId({
+            const cache = shardedDOTagCache({ baseShardSize: 4, regionalCache: true });
+            const doId = new DOId({
                 baseShardId: "shard-1",
                 numberOfReplicas: 1,
                 shardType: "hard",
@@ -266,11 +275,11 @@ describe("DOShardedTagCache", () => {
     });
     describe("getCacheKey", () => {
         it("should return the cache key without the random part", async () => {
-            const cache = doShardedTagCache();
-            const doId1 = new TagCacheDOId({ baseShardId: "shard-0", numberOfReplicas: 1, shardType: "hard" });
+            const cache = shardedDOTagCache();
+            const doId1 = new DOId({ baseShardId: "shard-0", numberOfReplicas: 1, shardType: "hard" });
             const reqKey = await cache.getCacheKey(doId1, ["_N_T_/tag1"]);
             expect(reqKey.url).toBe("http://local.cache/shard/tag-hard;shard-0?tags=_N_T_%2Ftag1");
-            const doId2 = new TagCacheDOId({
+            const doId2 = new DOId({
                 baseShardId: "shard-1",
                 numberOfReplicas: 1,
                 shardType: "hard",
@@ -283,12 +292,12 @@ describe("DOShardedTagCache", () => {
         it("should retry if it fails", async () => {
             vi.useFakeTimers();
             vi.setSystemTime(1000);
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             writeTagsMock.mockImplementationOnce(() => {
                 throw new Error("error");
             });
             const spiedFn = vi.spyOn(cache, "performWriteTagsWithRetry");
-            const doId = new TagCacheDOId({
+            const doId = new DOId({
                 baseShardId: "shard-1",
                 numberOfReplicas: 1,
                 shardType: "hard",
@@ -303,12 +312,12 @@ describe("DOShardedTagCache", () => {
         it("should stop retrying after 3 times", async () => {
             vi.useFakeTimers();
             vi.setSystemTime(1000);
-            const cache = doShardedTagCache();
+            const cache = shardedDOTagCache();
             writeTagsMock.mockImplementationOnce(() => {
                 throw new Error("error");
             });
             const spiedFn = vi.spyOn(cache, "performWriteTagsWithRetry");
-            await cache.performWriteTagsWithRetry(new TagCacheDOId({ baseShardId: "shard-1", numberOfReplicas: 1, shardType: "hard" }), ["tag1"], Date.now(), 3);
+            await cache.performWriteTagsWithRetry(new DOId({ baseShardId: "shard-1", numberOfReplicas: 1, shardType: "hard" }), ["tag1"], Date.now(), 3);
             expect(writeTagsMock).toHaveBeenCalledTimes(1);
             expect(spiedFn).toHaveBeenCalledTimes(1);
             expect(sendDLQMock).toHaveBeenCalledWith({

package/dist/cli/build/patches/plugins/dynamic-requires.js

@@ -82,7 +82,14 @@ rule:
       regex: ^NodeModuleLoader$
 fix: |
   async load($ID) {
-    ${getRequires("$ID", files, serverDir)}
+    ${buildOpts.debug
+        ? `   try {
+      ${getRequires("$ID", files, serverDir)}
+    } catch (e) {
+      console.error('Exception in NodeModuleLoader', e);
+      throw e;
+    }`
+        : getRequires("$ID", files, serverDir)}
   }`;
 }
 async function getRequirePageRule(buildOpts) {
@@ -112,7 +119,14 @@ function requirePage($PAGE, $DIST_DIR, $IS_APP_PATH) {
     process.env.__NEXT_PRIVATE_RUNTIME_TYPE = $IS_APP_PATH ? 'app' : 'pages';
   try {
     ${getRequires("pagePath", jsFiles, serverDir)}
-  } finally {
+  } ${buildOpts.debug
+            ? `
+  catch (e) {
+    console.error("Exception in requirePage", e);
+    throw e;
+  }`
+            : ``}
+  finally {
     process.env.__NEXT_PRIVATE_RUNTIME_TYPE = '';
   }
 }`,

package/dist/cli/build/patches/plugins/next-minimal.js

@@ -1,8 +1,15 @@
 import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
+// Remove an instantiation of `AbortController` from the runtime.
+//
+//  Solves https://github.com/cloudflare/workerd/issues/3657:
+// - The `AbortController` is meant for the client side, but ends in the server code somehow.
+//   That's why we can get ride of it. See https://github.com/vercel/next.js/pull/73975/files.
+// - Top level instantiation of `AbortController` are not supported by workerd as of March, 2025.
+//   See https://github.com/cloudflare/workerd/issues/3657
+// - As Next code is not more executed at top level, we do not need to apply this patch
+//   See https://github.com/opennextjs/opennextjs-cloudflare/pull/497
+//
 // We try to be as specific as possible to avoid patching the wrong thing here
-// It seems that there is a bug in the worker runtime. When the AbortController is created outside of the request context it throws an error (not sure if it's expected or not) except in this case. https://github.com/cloudflare/workerd/issues/3657
-// It fails while requiring the `app-page.runtime.prod.js` file, but instead of throwing an error, it just return an empty object for the `require('app-page.runtime.prod.js')` call which makes every request to an app router page fail.
-// If it's a bug in workerd and it's not expected to throw an error, we can remove this patch.
 export const abortControllerRule = `
 rule:
   all:
@@ -65,18 +72,7 @@ fix:
   'true'
 `;
 export function patchNextMinimal(updater) {
-    updater.updateContent("patch-abortController-next15.2", [
-        {
-            field: {
-                filter: /app-page(-experimental)?\.runtime\.prod\.js$/,
-                contentFilter: /new AbortController/,
-                callback: ({ contents }) => {
-                    return patchCode(contents, abortControllerRule);
-                },
-            },
-        },
-    ]);
-    updater.updateContent("patch-next-minimal", [
+    return updater.updateContent("patch-next-minimal", [
         {
             field: {
                 filter: /next-server\.(js)$/,
@@ -87,8 +83,4 @@ export function patchNextMinimal(updater) {
             },
         },
     ]);
-    return {
-        name: "patch-abortController",
-        setup() { },
-    };
 }

package/dist/cli/commands/populate-cache.js

@@ -2,6 +2,8 @@ import { existsSync } from "node:fs";
 import path from "node:path";
 import logger from "@opennextjs/aws/logger.js";
 import { globSync } from "glob";
+import { NAME as R2_CACHE_NAME } from "../../api/overrides/incremental-cache/r2-incremental-cache.js";
+import { NAME as D1_TAG_NAME } from "../../api/overrides/tag-cache/d1-next-tag-cache.js";
 import { runWrangler } from "../utils/run-wrangler.js";
 async function resolveCacheName(value) {
     return typeof value === "function" ? (await value()).name : value;
@@ -31,7 +33,7 @@ export async function populateCache(options, config, populateCacheOptions) {
     if (!config.dangerous?.disableIncrementalCache && incrementalCache) {
         const name = await resolveCacheName(incrementalCache);
         switch (name) {
-            case "r2-incremental-cache": {
+            case R2_CACHE_NAME: {
                 logger.info("\nPopulating R2 incremental cache...");
                 const assets = getCacheAssetPaths(options);
                 assets.forEach(({ fsPath, destPath }) => {
@@ -51,7 +53,7 @@ export async function populateCache(options, config, populateCacheOptions) {
     if (!config.dangerous?.disableTagCache && !config.dangerous?.disableIncrementalCache && tagCache) {
         const name = await resolveCacheName(tagCache);
         switch (name) {
-            case "d1-next-mode-tag-cache": {
+            case D1_TAG_NAME: {
                 logger.info("\nCreating D1 table if necessary...");
                 runWrangler(options, [
                     "d1 execute",
@@ -61,16 +63,6 @@ export async function populateCache(options, config, populateCacheOptions) {
                 logger.info("\nSuccessfully created D1 table");
                 break;
             }
-            case "d1-tag-cache": {
-                logger.info("\nPopulating D1 tag cache...");
-                runWrangler(options, [
-                    "d1 execute",
-                    "NEXT_TAG_CACHE_D1",
-                    `--file ${JSON.stringify(path.join(options.outputDir, "cloudflare/cache-assets-manifest.sql"))}`,
-                ], { ...populateCacheOptions, logging: "error" });
-                logger.info("Successfully populated cache");
-                break;
-            }
             default:
                 logger.info("Tag cache does not need populating");
         }

package/dist/cli/templates/worker.d.ts

@@ -1,4 +1,4 @@
-export { DurableObjectQueueHandler } from "./.build/durable-objects/queue.js";
+export { DOQueueHandler } from "./.build/durable-objects/queue.js";
 export { DOShardedTagCache } from "./.build/durable-objects/sharded-tag-cache.js";
 declare const _default: ExportedHandler<CloudflareEnv>;
 export default _default;

package/dist/cli/templates/worker.js

@@ -1,4 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
+import process from "node:process";
 // @ts-expect-error: resolved by wrangler build
 import * as nextEnvVars from "./env/next-env.mjs";
 const cloudflareContextALS = new AsyncLocalStorage();
@@ -9,7 +10,7 @@ Object.defineProperty(globalThis, Symbol.for("__cloudflare-context__"), {
     },
 });
 //@ts-expect-error: Will be resolved by wrangler build
-export { DurableObjectQueueHandler } from "./.build/durable-objects/queue.js";
+export { DOQueueHandler } from "./.build/durable-objects/queue.js";
 //@ts-expect-error: Will be resolved by wrangler build
 export { DOShardedTagCache } from "./.build/durable-objects/sharded-tag-cache.js";
 // Populate process.env on the first request
@@ -54,6 +55,11 @@ function populateProcessEnv(url, env) {
     if (processEnvPopulated) {
         return;
     }
+    // Some packages rely on `process.version` and `process.versions.node` (i.e. Jose@4)
+    // TODO: Remove when https://github.com/unjs/unenv/pull/493 is merged
+    Object.assign(process, { version: process.version || "v22.14.0" });
+    // @ts-expect-error Node type does not match workerd
+    Object.assign(process.versions, { node: "22.14.0", ...process.versions });
     processEnvPopulated = true;
     for (const [key, value] of Object.entries(env)) {
         if (typeof value === "string") {
@@ -63,7 +69,7 @@ function populateProcessEnv(url, env) {
     const mode = env.NEXTJS_ENV ?? "production";
     if (nextEnvVars[mode]) {
         for (const key in nextEnvVars[mode]) {
-            process.env[key] = nextEnvVars[mode][key];
+            process.env[key] ??= nextEnvVars[mode][key];
         }
     }
     // Set the default Origin for the origin resolver.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "0.6.5",
+  "version": "1.0.0-beta.0",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"
@@ -27,7 +27,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/opennextjs/opennextjs-cloudflare.git",
+    "url": "git+https://github.com/opennextjs/opennextjs-cloudflare.git",
     "directory": "packages/cloudflare"
   },
   "keywords": [
@@ -43,7 +43,7 @@
   "homepage": "https://github.com/opennextjs/opennextjs-cloudflare",
   "dependencies": {
     "@dotenvx/dotenvx": "1.31.0",
-    "@opennextjs/aws": "https://pkg.pr.new/@opennextjs/aws@802",
+    "@opennextjs/aws": "3.5.4",
     "enquirer": "^2.4.1",
     "glob": "^11.0.0"
   },
@@ -67,7 +67,7 @@
     "vitest": "^2.1.1"
   },
   "peerDependencies": {
-    "wrangler": "^3.114.1 || ^4.6.0"
+    "wrangler": "^3.114.3 || ^4.7.0"
   },
   "scripts": {
     "clean": "rimraf dist",

package/dist/api/overrides/tag-cache/d1-tag-cache.d.ts

@@ -1,33 +0,0 @@
-import type { OriginalTagCache } from "@opennextjs/aws/types/overrides.js";
-/**
- * An instance of the Tag Cache that uses a D1 binding (`NEXT_TAG_CACHE_D1`) as it's underlying data store.
- *
- * **Tag/path mappings table**
- *
- * Information about the relation between tags and paths is stored in a `tags` table that contains
- * two columns; `tag`, and `path`.
- *
- * This table should be populated using an SQL file that is generated during the build process.
- *
- * **Tag revalidations table**
- *
- * Revalidation times for tags are stored in a `revalidations` table that contains two columns; `tags`,
- * and `revalidatedAt`.
- */
-declare class D1TagCache implements OriginalTagCache {
-    readonly name = "d1-tag-cache";
-    getByPath(rawPath: string): Promise<string[]>;
-    getByTag(rawTag: string): Promise<string[]>;
-    getLastModified(path: string, lastModified?: number): Promise<number>;
-    writeTags(tags: {
-        tag: string;
-        path: string;
-        revalidatedAt?: number;
-    }[]): Promise<void>;
-    private getConfig;
-    protected removeBuildId(key: string): string;
-    protected getCacheKey(key: string): string;
-    protected getBuildId(): string;
-}
-declare const _default: D1TagCache;
-export default _default;

package/dist/api/overrides/tag-cache/d1-tag-cache.js

@@ -1,140 +0,0 @@
-import { debug, error } from "@opennextjs/aws/adapters/logger.js";
-import { RecoverableError } from "@opennextjs/aws/utils/error.js";
-import { getCloudflareContext } from "../../cloudflare-context.js";
-/**
- * An instance of the Tag Cache that uses a D1 binding (`NEXT_TAG_CACHE_D1`) as it's underlying data store.
- *
- * **Tag/path mappings table**
- *
- * Information about the relation between tags and paths is stored in a `tags` table that contains
- * two columns; `tag`, and `path`.
- *
- * This table should be populated using an SQL file that is generated during the build process.
- *
- * **Tag revalidations table**
- *
- * Revalidation times for tags are stored in a `revalidations` table that contains two columns; `tags`,
- * and `revalidatedAt`.
- */
-class D1TagCache {
-    name = "d1-tag-cache";
-    async getByPath(rawPath) {
-        const { isDisabled, db } = this.getConfig();
-        if (isDisabled)
-            return [];
-        const path = this.getCacheKey(rawPath);
-        try {
-            const { success, results } = await db
-                .prepare(`SELECT tag FROM tags WHERE path = ?`)
-                .bind(path)
-                .all();
-            if (!success)
-                throw new RecoverableError(`D1 select failed for ${path}`);
-            const tags = results?.map((item) => this.removeBuildId(item.tag));
-            debug("tags for path", path, tags);
-            return tags;
-        }
-        catch (e) {
-            error("Failed to get tags by path", e);
-            return [];
-        }
-    }
-    async getByTag(rawTag) {
-        const { isDisabled, db } = this.getConfig();
-        if (isDisabled)
-            return [];
-        const tag = this.getCacheKey(rawTag);
-        try {
-            const { success, results } = await db
-                .prepare(`SELECT path FROM tags WHERE tag = ?`)
-                .bind(tag)
-                .all();
-            if (!success)
-                throw new RecoverableError(`D1 select failed for ${tag}`);
-            const paths = results?.map((item) => this.removeBuildId(item.path));
-            debug("paths for tag", tag, paths);
-            return paths;
-        }
-        catch (e) {
-            error("Failed to get by tag", e);
-            return [];
-        }
-    }
-    async getLastModified(path, lastModified) {
-        const { isDisabled, db } = this.getConfig();
-        if (isDisabled)
-            return lastModified ?? Date.now();
-        try {
-            const { success, results } = await db
-                .prepare(`SELECT revalidations.tag FROM revalidations
-            INNER JOIN tags ON revalidations.tag = tags.tag
-            WHERE tags.path = ? AND revalidations.revalidatedAt > ?;`)
-                .bind(this.getCacheKey(path), lastModified ?? 0)
-                .all();
-            if (!success)
-                throw new RecoverableError(`D1 select failed for ${path} - ${lastModified ?? 0}`);
-            debug("revalidatedTags", results);
-            return results?.length > 0 ? -1 : (lastModified ?? Date.now());
-        }
-        catch (e) {
-            error("Failed to get revalidated tags", e);
-            return lastModified ?? Date.now();
-        }
-    }
-    async writeTags(tags) {
-        const { isDisabled, db } = this.getConfig();
-        if (isDisabled || tags.length === 0)
-            return;
-        try {
-            const uniqueTags = new Set();
-            const results = await db.batch(tags
-                .map(({ tag, path, revalidatedAt }) => {
-                if (revalidatedAt === 1) {
-                    // new tag/path mapping from set
-                    return db
-                        .prepare(`INSERT INTO tags (tag, path) VALUES (?, ?)`)
-                        .bind(this.getCacheKey(tag), this.getCacheKey(path));
-                }
-                if (!uniqueTags.has(tag) && revalidatedAt !== -1) {
-                    // tag was revalidated
-                    uniqueTags.add(tag);
-                    return db
-                        .prepare(`INSERT INTO revalidations (tag, revalidatedAt) VALUES (?, ?)`)
-                        .bind(this.getCacheKey(tag), revalidatedAt ?? Date.now());
-                }
-            })
-                .filter((stmt) => !!stmt));
-            const failedResults = results.filter((res) => !res.success);
-            if (failedResults.length > 0) {
-                throw new RecoverableError(`${failedResults.length} tags failed to write`);
-            }
-        }
-        catch (e) {
-            error("Failed to batch write tags", e);
-        }
-    }
-    getConfig() {
-        const cfEnv = getCloudflareContext().env;
-        const db = cfEnv.NEXT_TAG_CACHE_D1;
-        if (!db)
-            debug("No D1 database found");
-        const isDisabled = !!globalThis.openNextConfig
-            .dangerous?.disableTagCache;
-        return !db || isDisabled
-            ? { isDisabled: true }
-            : {
-                isDisabled: false,
-                db,
-            };
-    }
-    removeBuildId(key) {
-        return key.replace(`${this.getBuildId()}/`, "");
-    }
-    getCacheKey(key) {
-        return `${this.getBuildId()}/${key}`.replaceAll("//", "/");
-    }
-    getBuildId() {
-        return process.env.NEXT_BUILD_ID ?? "no-build-id";
-    }
-}
-export default new D1TagCache();