@opennextjs/cloudflare 0.5.11 → 0.6.0

package/dist/api/overrides/queue/do-queue.js

@@ -0,0 +1,15 @@
+import { IgnorableError } from "@opennextjs/aws/utils/error.js";
+import { getCloudflareContext } from "../../cloudflare-context";
+export default {
+    name: "do-queue",
+    send: async (msg) => {
+        const durableObject = getCloudflareContext().env.NEXT_CACHE_DO_QUEUE;
+        if (!durableObject)
+            throw new IgnorableError("No durable object binding for cache revalidation");
+        const id = durableObject.idFromName(msg.MessageGroupId);
+        const stub = durableObject.get(id);
+        await stub.revalidate({
+            ...msg,
+        });
+    },
+};

package/dist/api/{memory-queue.d.ts → overrides/queue/memory-queue.d.ts}

@@ -5,16 +5,16 @@ export declare const DEFAULT_REVALIDATION_TIMEOUT_MS = 10000;
  *
  * It offers basic support for in-memory de-duping per isolate.
  *
- * A service binding called `NEXT_CACHE_REVALIDATION_WORKER` that points to your worker is required.
+ * A service binding called `WORKER_SELF_REFERENCE` that points to your worker is required.
  */
 export declare class MemoryQueue implements Queue {
     private opts;
     readonly name = "memory-queue";
-    revalidatedPaths: Map<string, NodeJS.Timeout>;
+    revalidatedPaths: Set<string>;
     constructor(opts?: {
         revalidationTimeoutMs: number;
     });
-    send({ MessageBody: { host, url }, MessageGroupId }: QueueMessage): Promise<void>;
+    send({ MessageBody: { host, url }, MessageDeduplicationId }: QueueMessage): Promise<void>;
 }
 declare const _default: MemoryQueue;
 export default _default;

package/dist/api/{memory-queue.js → overrides/queue/memory-queue.js}

@@ -1,49 +1,53 @@
-import logger from "@opennextjs/aws/logger.js";
+import { debug, error } from "@opennextjs/aws/adapters/logger.js";
 import { IgnorableError } from "@opennextjs/aws/utils/error.js";
-import { getCloudflareContext } from "./cloudflare-context";
+import { getCloudflareContext } from "../../cloudflare-context";
 export const DEFAULT_REVALIDATION_TIMEOUT_MS = 10_000;
 /**
  * The Memory Queue offers basic ISR revalidation by directly requesting a revalidation of a route.
  *
  * It offers basic support for in-memory de-duping per isolate.
  *
- * A service binding called `NEXT_CACHE_REVALIDATION_WORKER` that points to your worker is required.
+ * A service binding called `WORKER_SELF_REFERENCE` that points to your worker is required.
  */
 export class MemoryQueue {
     opts;
     name = "memory-queue";
-    revalidatedPaths = new Map();
+    revalidatedPaths = new Set();
     constructor(opts = { revalidationTimeoutMs: DEFAULT_REVALIDATION_TIMEOUT_MS }) {
         this.opts = opts;
     }
-    async send({ MessageBody: { host, url }, MessageGroupId }) {
-        const service = getCloudflareContext().env.NEXT_CACHE_REVALIDATION_WORKER;
+    async send({ MessageBody: { host, url }, MessageDeduplicationId }) {
+        const service = getCloudflareContext().env.WORKER_SELF_REFERENCE;
         if (!service)
             throw new IgnorableError("No service binding for cache revalidation worker");
-        if (this.revalidatedPaths.has(MessageGroupId))
+        if (this.revalidatedPaths.has(MessageDeduplicationId))
             return;
-        this.revalidatedPaths.set(MessageGroupId, 
-        // force remove to allow new revalidations incase something went wrong
-        setTimeout(() => this.revalidatedPaths.delete(MessageGroupId), this.opts.revalidationTimeoutMs));
+        this.revalidatedPaths.add(MessageDeduplicationId);
         try {
             const protocol = host.includes("localhost") ? "http" : "https";
             // TODO: Drop the import - https://github.com/opennextjs/opennextjs-cloudflare/issues/361
             // @ts-ignore
             const manifest = await import("./.next/prerender-manifest.json");
-            await service.fetch(`${protocol}://${host}${url}`, {
+            const response = await service.fetch(`${protocol}://${host}${url}`, {
                 method: "HEAD",
                 headers: {
                     "x-prerender-revalidate": manifest.preview.previewModeId,
                     "x-isr": "1",
                 },
+                // We want to timeout the revalidation to avoid hanging the queue
+                signal: AbortSignal.timeout(this.opts.revalidationTimeoutMs),
             });
+            // Here we want at least to log when the revalidation was not successful
+            if (response.status !== 200 || response.headers.get("x-nextjs-cache") !== "REVALIDATED") {
+                error(`Revalidation failed for ${url} with status ${response.status}`);
+            }
+            debug(`Revalidation successful for ${url}`);
         }
         catch (e) {
-            logger.error(e);
+            error(e);
         }
         finally {
-            clearTimeout(this.revalidatedPaths.get(MessageGroupId));
-            this.revalidatedPaths.delete(MessageGroupId);
+            this.revalidatedPaths.delete(MessageDeduplicationId);
         }
     }
 }

package/dist/api/overrides/queue/memory-queue.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/api/{memory-queue.spec.js → overrides/queue/memory-queue.spec.js}

@@ -3,11 +3,17 @@ import { afterEach, beforeAll, describe, expect, it, vi } from "vitest";
 import cache, { DEFAULT_REVALIDATION_TIMEOUT_MS } from "./memory-queue.js";
 vi.mock("./.next/prerender-manifest.json", () => Promise.resolve({ preview: { previewModeId: "id" } }));
 const mockServiceWorkerFetch = vi.fn();
-vi.mock("./cloudflare-context", () => ({
+vi.mock("../../cloudflare-context", () => ({
     getCloudflareContext: () => ({
-        env: { NEXT_CACHE_REVALIDATION_WORKER: { fetch: mockServiceWorkerFetch } },
+        env: { WORKER_SELF_REFERENCE: { fetch: mockServiceWorkerFetch } },
     }),
 }));
+const generateMessageBody = ({ host, url }) => ({
+    host,
+    url,
+    eTag: "etag",
+    lastModified: Date.now(),
+});
 describe("MemoryQueue", () => {
     beforeAll(() => {
         vi.useFakeTimers();
@@ -16,17 +22,17 @@ describe("MemoryQueue", () => {
     afterEach(() => vi.clearAllMocks());
     it("should process revalidations for a path", async () => {
         const firstRequest = cache.send({
-            MessageBody: { host: "test.local", url: "/test" },
+            MessageBody: generateMessageBody({ host: "test.local", url: "/test" }),
             MessageGroupId: generateMessageGroupId("/test"),
-            MessageDeduplicationId: "",
+            MessageDeduplicationId: "/test",
         });
         vi.advanceTimersByTime(DEFAULT_REVALIDATION_TIMEOUT_MS);
         await firstRequest;
         expect(mockServiceWorkerFetch).toHaveBeenCalledTimes(1);
         const secondRequest = cache.send({
-            MessageBody: { host: "test.local", url: "/test" },
+            MessageBody: generateMessageBody({ host: "test.local", url: "/test" }),
             MessageGroupId: generateMessageGroupId("/test"),
-            MessageDeduplicationId: "",
+            MessageDeduplicationId: "/test",
         });
         vi.advanceTimersByTime(1);
         await secondRequest;
@@ -34,17 +40,17 @@ describe("MemoryQueue", () => {
     });
     it("should process revalidations for multiple paths", async () => {
         const firstRequest = cache.send({
-            MessageBody: { host: "test.local", url: "/test" },
+            MessageBody: generateMessageBody({ host: "test.local", url: "/test" }),
             MessageGroupId: generateMessageGroupId("/test"),
-            MessageDeduplicationId: "",
+            MessageDeduplicationId: "/test",
         });
         vi.advanceTimersByTime(1);
         await firstRequest;
         expect(mockServiceWorkerFetch).toHaveBeenCalledTimes(1);
         const secondRequest = cache.send({
-            MessageBody: { host: "test.local", url: "/test" },
+            MessageBody: generateMessageBody({ host: "test.local", url: "/test" }),
             MessageGroupId: generateMessageGroupId("/other"),
-            MessageDeduplicationId: "",
+            MessageDeduplicationId: "/other",
         });
         vi.advanceTimersByTime(1);
         await secondRequest;
@@ -53,14 +59,14 @@ describe("MemoryQueue", () => {
     it("should de-dupe revalidations", async () => {
         const requests = [
             cache.send({
-                MessageBody: { host: "test.local", url: "/test" },
+                MessageBody: generateMessageBody({ host: "test.local", url: "/test" }),
                 MessageGroupId: generateMessageGroupId("/test"),
-                MessageDeduplicationId: "",
+                MessageDeduplicationId: "/test",
             }),
             cache.send({
-                MessageBody: { host: "test.local", url: "/test" },
+                MessageBody: generateMessageBody({ host: "test.local", url: "/test" }),
                 MessageGroupId: generateMessageGroupId("/test"),
-                MessageDeduplicationId: "",
+                MessageDeduplicationId: "/test",
             }),
         ];
         vi.advanceTimersByTime(1);

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

@@ -0,0 +1,13 @@
+import type { NextModeTagCache } from "@opennextjs/aws/types/overrides.js";
+export declare class D1NextModeTagCache implements NextModeTagCache {
+    readonly mode: "nextMode";
+    readonly name = "d1-next-mode-tag-cache";
+    hasBeenRevalidated(tags: string[], lastModified?: number): Promise<boolean>;
+    writeTags(tags: string[]): Promise<void>;
+    private getConfig;
+    protected removeBuildId(key: string): string;
+    protected getCacheKey(key: string): string;
+    protected getBuildId(): string;
+}
+declare const _default: D1NextModeTagCache;
+export default _default;

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

@@ -0,0 +1,61 @@
+import { debug, error } from "@opennextjs/aws/adapters/logger.js";
+import { RecoverableError } from "@opennextjs/aws/utils/error.js";
+import { getCloudflareContext } from "../../cloudflare-context.js";
+export class D1NextModeTagCache {
+    mode = "nextMode";
+    name = "d1-next-mode-tag-cache";
+    async hasBeenRevalidated(tags, lastModified) {
+        const { isDisabled, db } = this.getConfig();
+        if (isDisabled)
+            return false;
+        try {
+            const result = await db
+                .prepare(`SELECT COUNT(*) as cnt FROM revalidations WHERE tag IN (${tags.map(() => "?").join(", ")}) AND revalidatedAt > ? LIMIT 1`)
+                .bind(...tags.map((tag) => this.getCacheKey(tag)), lastModified ?? Date.now())
+                .first();
+            if (!result)
+                throw new RecoverableError(`D1 select failed for ${tags}`);
+            return result.cnt > 0;
+        }
+        catch (e) {
+            error(e);
+            // By default we don't want to crash here, so we return false
+            // We still log the error though so we can debug it
+            return false;
+        }
+    }
+    async writeTags(tags) {
+        const { isDisabled, db } = this.getConfig();
+        if (isDisabled)
+            return Promise.resolve();
+        const result = await db.batch(tags.map((tag) => db
+            .prepare(`INSERT INTO revalidations (tag, revalidatedAt) VALUES (?, ?)`)
+            .bind(this.getCacheKey(tag), Date.now())));
+        if (!result)
+            throw new RecoverableError(`D1 insert failed for ${tags}`);
+    }
+    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 D1NextModeTagCache();

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

@@ -1,20 +1,18 @@
 import type { OriginalTagCache } from "@opennextjs/aws/types/overrides.js";
 /**
- * An instance of the Tag Cache that uses a D1 binding (`NEXT_CACHE_D1`) as it's underlying data store.
+ * 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`. The table name can be configured with `NEXT_CACHE_D1_TAGS_TABLE`
- * environment variable.
+ * 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`. The table name can be configured with `NEXT_CACHE_D1_REVALIDATIONS_TABLE`
- * environment variable.
+ * and `revalidatedAt`.
  */
 declare class D1TagCache implements OriginalTagCache {
     readonly name = "d1-tag-cache";

package/dist/api/{d1-tag-cache.js → overrides/tag-cache/d1-tag-cache.js}

@@ -1,33 +1,31 @@
 import { debug, error } from "@opennextjs/aws/adapters/logger.js";
 import { RecoverableError } from "@opennextjs/aws/utils/error.js";
-import { getCloudflareContext } from "./cloudflare-context.js";
+import { getCloudflareContext } from "../../cloudflare-context.js";
 /**
- * An instance of the Tag Cache that uses a D1 binding (`NEXT_CACHE_D1`) as it's underlying data store.
+ * 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`. The table name can be configured with `NEXT_CACHE_D1_TAGS_TABLE`
- * environment variable.
+ * 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`. The table name can be configured with `NEXT_CACHE_D1_REVALIDATIONS_TABLE`
- * environment variable.
+ * and `revalidatedAt`.
  */
 class D1TagCache {
     name = "d1-tag-cache";
     async getByPath(rawPath) {
-        const { isDisabled, db, tables } = this.getConfig();
+        const { isDisabled, db } = this.getConfig();
         if (isDisabled)
             return [];
         const path = this.getCacheKey(rawPath);
         try {
             const { success, results } = await db
-                .prepare(`SELECT tag FROM ${JSON.stringify(tables.tags)} WHERE path = ?`)
+                .prepare(`SELECT tag FROM tags WHERE path = ?`)
                 .bind(path)
                 .all();
             if (!success)
@@ -42,13 +40,13 @@ class D1TagCache {
         }
     }
     async getByTag(rawTag) {
-        const { isDisabled, db, tables } = this.getConfig();
+        const { isDisabled, db } = this.getConfig();
         if (isDisabled)
             return [];
         const tag = this.getCacheKey(rawTag);
         try {
             const { success, results } = await db
-                .prepare(`SELECT path FROM ${JSON.stringify(tables.tags)} WHERE tag = ?`)
+                .prepare(`SELECT path FROM tags WHERE tag = ?`)
                 .bind(tag)
                 .all();
             if (!success)
@@ -63,14 +61,14 @@ class D1TagCache {
         }
     }
     async getLastModified(path, lastModified) {
-        const { isDisabled, db, tables } = this.getConfig();
+        const { isDisabled, db } = this.getConfig();
         if (isDisabled)
             return lastModified ?? Date.now();
         try {
             const { success, results } = await db
-                .prepare(`SELECT ${JSON.stringify(tables.revalidations)}.tag FROM ${JSON.stringify(tables.revalidations)}
-            INNER JOIN ${JSON.stringify(tables.tags)} ON ${JSON.stringify(tables.revalidations)}.tag = ${JSON.stringify(tables.tags)}.tag
-            WHERE ${JSON.stringify(tables.tags)}.path = ? AND ${JSON.stringify(tables.revalidations)}.revalidatedAt > ?;`)
+                .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)
@@ -84,7 +82,7 @@ class D1TagCache {
         }
     }
     async writeTags(tags) {
-        const { isDisabled, db, tables } = this.getConfig();
+        const { isDisabled, db } = this.getConfig();
         if (isDisabled || tags.length === 0)
             return;
         try {
@@ -94,14 +92,14 @@ class D1TagCache {
                 if (revalidatedAt === 1) {
                     // new tag/path mapping from set
                     return db
-                        .prepare(`INSERT INTO ${JSON.stringify(tables.tags)} (tag, path) VALUES (?, ?)`)
+                        .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 ${JSON.stringify(tables.revalidations)} (tag, revalidatedAt) VALUES (?, ?)`)
+                        .prepare(`INSERT INTO revalidations (tag, revalidatedAt) VALUES (?, ?)`)
                         .bind(this.getCacheKey(tag), revalidatedAt ?? Date.now());
                 }
             })
@@ -117,22 +115,17 @@ class D1TagCache {
     }
     getConfig() {
         const cfEnv = getCloudflareContext().env;
-        const db = cfEnv.NEXT_CACHE_D1;
+        const db = cfEnv.NEXT_TAG_CACHE_D1;
         if (!db)
             debug("No D1 database found");
         const isDisabled = !!globalThis.openNextConfig
             .dangerous?.disableTagCache;
-        if (!db || isDisabled) {
-            return { isDisabled: true };
-        }
-        return {
-            isDisabled: false,
-            db,
-            tables: {
-                tags: cfEnv.NEXT_CACHE_D1_TAGS_TABLE ?? "tags",
-                revalidations: cfEnv.NEXT_CACHE_D1_REVALIDATIONS_TABLE ?? "revalidations",
-            },
-        };
+        return !db || isDisabled
+            ? { isDisabled: true }
+            : {
+                isDisabled: false,
+                db,
+            };
     }
     removeBuildId(key) {
         return key.replace(`${this.getBuildId()}/`, "");

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

@@ -0,0 +1,122 @@
+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;
+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.
+     * 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
+     * @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 }
+     */
+    shardReplicationOptions?: {
+        numberOfSoftReplicas: number;
+        numberOfHardReplicas: number;
+    };
+    /**
+     * The number of retries to perform when writing tags
+     * @default 3
+     */
+    maxWriteRetries?: number;
+}
+interface TagCacheDOIdOptions {
+    baseShardId: string;
+    numberOfReplicas: number;
+    shardType: "soft" | "hard";
+    replicaId?: number;
+}
+export declare class TagCacheDOId {
+    options: TagCacheDOIdOptions;
+    shardId: string;
+    replicaId: number;
+    constructor(options: TagCacheDOIdOptions);
+    private generateRandomNumberBetween;
+    get key(): string;
+}
+declare class ShardedDOTagCache implements NextModeTagCache {
+    private opts;
+    readonly mode: "nextMode";
+    readonly name = "do-sharded-tag-cache";
+    readonly numSoftReplicas: number;
+    readonly numHardReplicas: number;
+    readonly maxWriteRetries: number;
+    localCache?: Cache;
+    constructor(opts?: ShardedDOTagCacheOptions);
+    private getDurableObjectStub;
+    /**
+     * Generates a list of DO ids for the shards and replicas
+     * @param tags The tags to generate shards for
+     * @param shardType Whether to generate shards for soft or hard tags
+     * @param generateAllShards Whether to generate all shards or only one
+     * @returns An array of TagCacheDOId and tag
+     */
+    private generateDOIdArray;
+    /**
+     * Same tags are guaranteed to be in the same shard
+     * @param tags
+     * @returns An array of DO ids and tags
+     */
+    groupTagsByDO({ tags, generateAllReplicas }: {
+        tags: string[];
+        generateAllReplicas?: boolean;
+    }): {
+        doId: TagCacheDOId;
+        tags: string[];
+    }[];
+    private getConfig;
+    /**
+     * This function checks if the tags have been revalidated
+     * It is never supposed to throw and in case of error, it will return false
+     * @param tags
+     * @param lastModified default to `Date.now()`
+     * @returns
+     */
+    hasBeenRevalidated(tags: string[], lastModified?: number): Promise<boolean>;
+    /**
+     * This function writes the tags to the cache
+     * Due to the way shards and regional cache are implemented, the regional cache may not be properly invalidated
+     * @param tags
+     * @returns
+     */
+    writeTags(tags: string[]): Promise<void>;
+    performWriteTagsWithRetry(doId: TagCacheDOId, 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>;
+}
+declare const _default: (opts?: ShardedDOTagCacheOptions) => ShardedDOTagCache;
+export default _default;