@opennextjs/aws 3.4.1 → 3.5.0

package/dist/overrides/converters/utils.d.ts

@@ -1 +1,8 @@
 export declare function removeUndefinedFromQuery(query: Record<string, string | string[] | undefined>): Record<string, string | string[]>;
+/**
+ * Extract the host from the headers (default to "on")
+ *
+ * @param headers
+ * @returns The host
+ */
+export declare function extractHostFromHeaders(headers: Record<string, string>): string;

package/dist/overrides/converters/utils.js

@@ -7,3 +7,12 @@ export function removeUndefinedFromQuery(query) {
     }
     return newQuery;
 }
+/**
+ * Extract the host from the headers (default to "on")
+ *
+ * @param headers
+ * @returns The host
+ */
+export function extractHostFromHeaders(headers) {
+    return headers["x-forwarded-host"] ?? headers.host ?? "on";
+}

package/dist/overrides/imageLoader/s3-lite.d.ts

@@ -0,0 +1,3 @@
+import type { ImageLoader } from "../../types/overrides";
+declare const s3Loader: ImageLoader;
+export default s3Loader;

package/dist/overrides/imageLoader/s3-lite.js

@@ -0,0 +1,61 @@
+import { Readable } from "node:stream";
+import { AwsClient } from "aws4fetch";
+import { FatalError } from "../../utils/error";
+let awsClient = null;
+const { BUCKET_NAME, BUCKET_KEY_PREFIX } = process.env;
+// https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html#configuration-envvars-runtime
+// If AWS_REGION is defined it will override AWS_DEFAULT_REGION
+const BUCKET_REGION = process.env.BUCKET_REGION ??
+    process.env.AWS_REGION ??
+    process.env.AWS_DEFAULT_REGION;
+const getAwsClient = () => {
+    if (awsClient) {
+        return awsClient;
+    }
+    awsClient = new AwsClient({
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+        sessionToken: process.env.AWS_SESSION_TOKEN,
+        region: BUCKET_REGION,
+    });
+    return awsClient;
+};
+function ensureEnvExists() {
+    if (!(BUCKET_NAME || BUCKET_KEY_PREFIX || BUCKET_REGION)) {
+        throw new FatalError("Bucket name, region and key prefix must be defined!");
+    }
+}
+const awsFetch = async (key, options) => {
+    const client = getAwsClient();
+    const url = `https://${BUCKET_NAME}.s3.${BUCKET_REGION}.amazonaws.com/${key}`;
+    return client.fetch(url, options);
+};
+const s3Loader = {
+    name: "s3-lite",
+    load: async (key) => {
+        ensureEnvExists();
+        const keyPrefix = BUCKET_KEY_PREFIX?.replace(/^\/|\/$/g, "");
+        const response = await awsFetch(keyPrefix
+            ? `${keyPrefix}/${key.replace(/^\//, "")}`
+            : key.replace(/^\//, ""), {
+            method: "GET",
+        });
+        if (response.status === 404) {
+            throw new FatalError("The specified key does not exist.");
+        }
+        if (response.status !== 200) {
+            throw new FatalError(`Failed to get image. Status code: ${response.status}`);
+        }
+        if (!response.body) {
+            throw new FatalError("No body in aws4fetch s3 response");
+        }
+        // We need to cast it else there will be a TypeError: o.pipe is not a function
+        const body = Readable.fromWeb(response.body);
+        return {
+            body: body,
+            contentType: response.headers.get("content-type") ?? undefined,
+            cacheControl: response.headers.get("cache-control") ?? undefined,
+        };
+    },
+};
+export default s3Loader;

package/dist/overrides/incrementalCache/multi-tier-ddb-s3.js

@@ -77,7 +77,7 @@ const multiTierCache = {
             }
         }
         const result = await S3Cache.get(key, isFetch);
-        if (result.value) {
+        if (result?.value) {
             localCache.set(key, {
                 value: result.value,
                 lastModified: result.lastModified ?? Date.now(),

package/dist/overrides/proxyExternalRequest/fetch.js

@@ -3,7 +3,8 @@ const fetchProxy = {
     name: "fetch-proxy",
     // @ts-ignore
     proxy: async (internalEvent) => {
-        const { url, headers, method, body } = internalEvent;
+        const { url, headers: eventHeaders, method, body } = internalEvent;
+        const headers = Object.fromEntries(Object.entries(eventHeaders).filter(([key]) => key.toLowerCase() !== "cf-connecting-ip"));
         const response = await fetch(url, {
             method,
             headers,

package/dist/overrides/tagCache/dummy.js

@@ -1,6 +1,7 @@
 // We don't want to throw error on this one because we might use it when we don't need tag cache
 const dummyTagCache = {
     name: "dummy",
+    mode: "original",
     getByPath: async () => {
         return [];
     },

package/dist/overrides/tagCache/dynamodb-lite.js

@@ -47,6 +47,7 @@ function buildDynamoObject(path, tags, revalidatedAt) {
     };
 }
 const tagCache = {
+    mode: "original",
     async getByPath(path) {
         try {
             if (globalThis.openNextConfig.dangerous?.disableTagCache) {

package/dist/overrides/tagCache/dynamodb-nextMode.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    name: string;
+    mode: "nextMode";
+    hasBeenRevalidated: (tags: string[], lastModified?: number) => Promise<boolean>;
+    writeTags: (tags: string[]) => Promise<void>;
+};
+export default _default;

package/dist/overrides/tagCache/dynamodb-nextMode.js

@@ -0,0 +1,119 @@
+import { AwsClient } from "aws4fetch";
+import { RecoverableError } from "../../utils/error";
+import { customFetchClient } from "../../utils/fetch";
+import path from "node:path";
+import { debug, error } from "../../adapters/logger";
+import { chunk, parseNumberFromEnv } from "../../adapters/util";
+import { MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT, getDynamoBatchWriteCommandConcurrency, } from "./constants";
+let awsClient = null;
+const getAwsClient = () => {
+    const { CACHE_BUCKET_REGION } = process.env;
+    if (awsClient) {
+        return awsClient;
+    }
+    awsClient = new AwsClient({
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+        sessionToken: process.env.AWS_SESSION_TOKEN,
+        region: CACHE_BUCKET_REGION,
+        retries: parseNumberFromEnv(process.env.AWS_SDK_S3_MAX_ATTEMPTS),
+    });
+    return awsClient;
+};
+const awsFetch = (body, type = "query") => {
+    const { CACHE_BUCKET_REGION } = process.env;
+    const client = getAwsClient();
+    return customFetchClient(client)(`https://dynamodb.${CACHE_BUCKET_REGION}.amazonaws.com`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/x-amz-json-1.0",
+            "X-Amz-Target": `DynamoDB_20120810.${type === "query" ? "BatchGetItem" : "BatchWriteItem"}`,
+        },
+        body,
+    });
+};
+function buildDynamoKey(key) {
+    const { NEXT_BUILD_ID } = process.env;
+    // FIXME: We should probably use something else than path.join here
+    // this could transform some fetch cache key into a valid path
+    return path.posix.join(NEXT_BUILD_ID ?? "", "_tag", key);
+}
+// We use the same key for both path and tag
+// That's mostly for compatibility reason so that it's easier to use this with existing infra
+// FIXME: Allow a simpler object without an unnecessary path key
+function buildDynamoObject(tag, revalidatedAt) {
+    return {
+        path: { S: buildDynamoKey(tag) },
+        tag: { S: buildDynamoKey(tag) },
+        revalidatedAt: { N: `${revalidatedAt ?? Date.now()}` },
+    };
+}
+// This implementation does not support automatic invalidation of paths by the cdn
+export default {
+    name: "ddb-nextMode",
+    mode: "nextMode",
+    hasBeenRevalidated: async (tags, lastModified) => {
+        if (globalThis.openNextConfig.dangerous?.disableTagCache) {
+            return false;
+        }
+        if (tags.length > 100) {
+            throw new RecoverableError("Cannot query more than 100 tags at once. You should not be using this tagCache implementation for this amount of tags");
+        }
+        const { CACHE_DYNAMO_TABLE } = process.env;
+        // It's unlikely that we will have more than 100 items to query
+        // If that's the case, you should not use this tagCache implementation
+        const response = await awsFetch(JSON.stringify({
+            RequestItems: {
+                [CACHE_DYNAMO_TABLE ?? ""]: {
+                    Keys: tags.map((tag) => ({
+                        path: { S: buildDynamoKey(tag) },
+                        tag: { S: buildDynamoKey(tag) },
+                    })),
+                },
+            },
+        }), "query");
+        if (response.status !== 200) {
+            throw new RecoverableError(`Failed to query dynamo item: ${response.status}`);
+        }
+        // Now we need to check for every item if lastModified is greater than the revalidatedAt
+        const { Responses } = await response.json();
+        if (!Responses) {
+            return false;
+        }
+        const revalidatedTags = Responses[CACHE_DYNAMO_TABLE ?? ""].filter((item) => Number.parseInt(item.revalidatedAt.N) > (lastModified ?? 0));
+        debug("retrieved tags", revalidatedTags);
+        return revalidatedTags.length > 0;
+    },
+    writeTags: async (tags) => {
+        try {
+            const { CACHE_DYNAMO_TABLE } = process.env;
+            if (globalThis.openNextConfig.dangerous?.disableTagCache) {
+                return;
+            }
+            const dataChunks = chunk(tags, MAX_DYNAMO_BATCH_WRITE_ITEM_COUNT).map((Items) => ({
+                RequestItems: {
+                    [CACHE_DYNAMO_TABLE ?? ""]: Items.map((tag) => ({
+                        PutRequest: {
+                            Item: {
+                                ...buildDynamoObject(tag),
+                            },
+                        },
+                    })),
+                },
+            }));
+            const toInsert = chunk(dataChunks, getDynamoBatchWriteCommandConcurrency());
+            for (const paramsChunk of toInsert) {
+                await Promise.all(paramsChunk.map(async (params) => {
+                    const response = await awsFetch(JSON.stringify(params), "batchWrite");
+                    if (response.status !== 200) {
+                        throw new RecoverableError(`Failed to batch write dynamo item: ${response.status}`);
+                    }
+                    return response;
+                }));
+            }
+        }
+        catch (e) {
+            error("Failed to batch write dynamo item", e);
+        }
+    },
+};

package/dist/overrides/tagCache/dynamodb.js

@@ -25,6 +25,7 @@ function buildDynamoObject(path, tags, revalidatedAt) {
     };
 }
 const tagCache = {
+    mode: "original",
     async getByPath(path) {
         try {
             if (globalThis.openNextConfig.dangerous?.disableTagCache) {

package/dist/overrides/tagCache/fs-dev.js

@@ -4,6 +4,7 @@ const tagContent = fs.readFileSync(tagFile, "utf-8");
 let tags = JSON.parse(tagContent);
 const tagCache = {
     name: "fs-dev",
+    mode: "original",
     getByPath: async (path) => {
         return tags
             .filter((tagPathMapping) => tagPathMapping.path.S === path)

package/dist/overrides/wrappers/aws-lambda-streaming.js

@@ -63,7 +63,7 @@ const handler = async (handler, converter) => awslambda.streamifyResponse(async
             return compressedStream ?? responseStream;
         },
     };
-    const response = await handler(internalEvent, streamCreator);
+    const response = await handler(internalEvent, { streamCreator });
     const isUsingEdge = globalThis.isEdgeRuntime ?? false;
     if (isUsingEdge) {
         debug("Headers has not been set, we must be in the edge runtime");

package/dist/overrides/wrappers/aws-lambda.js

@@ -26,7 +26,9 @@ const handler = async (handler, converter) => async (event) => {
             });
         },
     };
-    const response = await handler(internalEvent, fakeStream);
+    const response = await handler(internalEvent, {
+        streamCreator: fakeStream,
+    });
     return converter.convertTo(response, event);
 };
 export default {

package/dist/overrides/wrappers/cloudflare-edge.js

@@ -9,7 +9,6 @@ const cfPropNameMapping = {
 };
 const handler = async (handler, converter) => async (request, env, ctx) => {
     globalThis.process = process;
-    globalThis.openNextWaitUntil = ctx.waitUntil.bind(ctx);
     // Set the environment variables
     // Cloudflare suggests to not override the process.env object but instead apply the values to it
     for (const [key, value] of Object.entries(env)) {
@@ -33,7 +32,9 @@ const handler = async (handler, converter) => async (request, env, ctx) => {
                 : propValue;
         }
     }
-    const response = await handler(internalEvent);
+    const response = await handler(internalEvent, {
+        waitUntil: ctx.waitUntil.bind(ctx),
+    });
     const result = await converter.convertTo(response);
     return result;
 };

package/dist/overrides/wrappers/cloudflare-node.js

@@ -3,7 +3,6 @@ import { Writable } from "node:stream";
 const NULL_BODY_STATUSES = new Set([101, 204, 205, 304]);
 const handler = async (handler, converter) => async (request, env, ctx) => {
     globalThis.process = process;
-    globalThis.openNextWaitUntil = ctx.waitUntil.bind(ctx);
     // Set the environment variables
     // Cloudflare suggests to not override the process.env object but instead apply the values to it
     for (const [key, value] of Object.entries(env)) {
@@ -12,12 +11,7 @@ const handler = async (handler, converter) => async (request, env, ctx) => {
         }
     }
     const internalEvent = await converter.convertFrom(request);
-    // TODO:
-    // The edge converter populate event.url with the url including the origin.
-    // This is required for middleware to keep track of the protocol (i.e. http with wrangler dev).
-    // However the server expects that the origin is not included.
-    const url = new URL(internalEvent.url);
-    internalEvent.url = url.href.slice(url.origin.length);
+    const url = new URL(request.url);
     const { promise: promiseResponse, resolve: resolveResponse } = Promise.withResolvers();
     const streamCreator = {
         writeHeaders(prelude) {
@@ -26,6 +20,11 @@ const handler = async (handler, converter) => async (request, env, ctx) => {
             for (const cookie of cookies) {
                 responseHeaders.append("Set-Cookie", cookie);
             }
+            // TODO(vicb): this is a workaround to make PPR work with `wrangler dev`
+            // See https://github.com/cloudflare/workers-sdk/issues/8004
+            if (url.hostname === "localhost") {
+                responseHeaders.set("Content-Encoding", "identity");
+            }
             const { readable, writable } = new TransformStream({
                 transform(chunk, controller) {
                     controller.enqueue(Uint8Array.from(chunk.chunk ?? chunk));
@@ -40,7 +39,10 @@ const handler = async (handler, converter) => async (request, env, ctx) => {
             return Writable.fromWeb(writable);
         },
     };
-    ctx.waitUntil(handler(internalEvent, streamCreator));
+    ctx.waitUntil(handler(internalEvent, {
+        streamCreator,
+        waitUntil: ctx.waitUntil.bind(ctx),
+    }));
     return promiseResponse;
 };
 export default {

package/dist/overrides/wrappers/dummy.js

@@ -1,6 +1,6 @@
 const dummyWrapper = async (handler, converter) => {
-    return async (event, responseStream) => {
-        return await handler(event, responseStream);
+    return async (event, options) => {
+        return await handler(event, options);
     };
 };
 export default {

package/dist/overrides/wrappers/express-dev.js

@@ -7,24 +7,24 @@ const wrapper = async (handler, converter) => {
     const imageHandler = await import(imageHandlerPath).then((m) => m.handler);
     app.all("/_next/image", async (req, res) => {
         const internalEvent = await converter.convertFrom(req);
-        const _res = {
+        const streamCreator = {
             writeHeaders: (prelude) => {
                 res.writeHead(prelude.statusCode, prelude.headers);
                 return res;
             },
         };
-        await imageHandler(internalEvent, _res);
+        await imageHandler(internalEvent, { streamCreator });
     });
     app.all("*paths", async (req, res) => {
         const internalEvent = await converter.convertFrom(req);
-        const _res = {
+        const streamCreator = {
             writeHeaders: (prelude) => {
                 res.writeHead(prelude.statusCode, prelude.headers);
                 return res;
             },
             onFinish: () => { },
         };
-        await handler(internalEvent, _res);
+        await handler(internalEvent, { streamCreator });
     });
     const server = app.listen(Number.parseInt(process.env.PORT ?? "3000", 10), () => {
         console.log(`Server running on port ${process.env.PORT ?? 3000}`);

package/dist/overrides/wrappers/node.js

@@ -3,7 +3,7 @@ import { debug, error } from "../../adapters/logger";
 const wrapper = async (handler, converter) => {
     const server = createServer(async (req, res) => {
         const internalEvent = await converter.convertFrom(req);
-        const _res = {
+        const streamCreator = {
             writeHeaders: (prelude) => {
                 res.setHeader("Set-Cookie", prelude.cookies);
                 res.writeHead(prelude.statusCode, prelude.headers);
@@ -19,7 +19,7 @@ const wrapper = async (handler, converter) => {
             res.end("OK");
         }
         else {
-            await handler(internalEvent, _res);
+            await handler(internalEvent, { streamCreator });
         }
     });
     await new Promise((resolve) => {

package/dist/plugins/edge.d.ts

@@ -2,15 +2,13 @@ import type { Plugin } from "esbuild";
 import type { MiddlewareInfo } from "../types/next-types.js";
 export interface IPluginSettings {
     nextDir: string;
-    edgeFunctionHandlerPath?: string;
     middlewareInfo?: MiddlewareInfo;
     isInCloudfare?: boolean;
 }
 /**
  * @param opts.nextDir - The path to the .next directory
- * @param opts.edgeFunctionHandlerPath - The path to the edgeFunctionHandler.js file that we'll use to bundle the routing
  * @param opts.middlewareInfo - Information about the middleware
  * @param opts.isInCloudfare - Whether the code runs on the cloudflare runtime
  * @returns
  */
-export declare function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewareInfo, isInCloudfare, }: IPluginSettings): Plugin;
+export declare function openNextEdgePlugins({ nextDir, middlewareInfo, isInCloudfare, }: IPluginSettings): Plugin;

package/dist/plugins/edge.js

@@ -1,17 +1,16 @@
 import { readFileSync } from "node:fs";
 import path from "node:path";
 import chalk from "chalk";
-import { loadAppPathRoutesManifest, loadAppPathsManifest, loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "../adapters/config/util.js";
+import { loadAppPathRoutesManifest, loadAppPathsManifest, loadAppPathsManifestKeys, loadBuildId, loadConfig, loadConfigHeaders, loadFunctionsConfigManifest, loadHtmlPages, loadMiddlewareManifest, loadPrerenderManifest, loadRoutesManifest, } from "../adapters/config/util.js";
 import logger from "../logger.js";
 import { getCrossPlatformPathRegex } from "../utils/regex.js";
 /**
  * @param opts.nextDir - The path to the .next directory
- * @param opts.edgeFunctionHandlerPath - The path to the edgeFunctionHandler.js file that we'll use to bundle the routing
  * @param opts.middlewareInfo - Information about the middleware
  * @param opts.isInCloudfare - Whether the code runs on the cloudflare runtime
  * @returns
  */
-export function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewareInfo, isInCloudfare, }) {
+export function openNextEdgePlugins({ nextDir, middlewareInfo, isInCloudfare, }) {
     const entryFiles = middlewareInfo?.files.map((file) => path.join(nextDir, file)) ?? [];
     const routes = middlewareInfo
         ? [
@@ -27,14 +26,6 @@ export function openNextEdgePlugins({ nextDir, edgeFunctionHandlerPath, middlewa
         name: "opennext-edge",
         setup(build) {
             logger.debug(chalk.blue("OpenNext Edge plugin"));
-            if (edgeFunctionHandlerPath) {
-                // If we bundle the routing, we need to resolve the middleware
-                build.onResolve({ filter: getCrossPlatformPathRegex("./middleware.mjs") }, () => {
-                    return {
-                        path: edgeFunctionHandlerPath,
-                    };
-                });
-            }
             build.onResolve({ filter: /\.(mjs|wasm)$/g }, () => {
                 return {
                     external: true,
@@ -129,6 +120,7 @@ ${contents}
                 const MiddlewareManifest = loadMiddlewareManifest(nextDir);
                 const AppPathsManifest = loadAppPathsManifest(nextDir);
                 const AppPathRoutesManifest = loadAppPathRoutesManifest(nextDir);
+                const FunctionsConfigManifest = loadFunctionsConfigManifest(nextDir);
                 const contents = `
   import path from "node:path";
 
@@ -151,6 +143,7 @@ ${contents}
   export const MiddlewareManifest = ${JSON.stringify(MiddlewareManifest)};
   export const AppPathsManifest = ${JSON.stringify(AppPathsManifest)};
   export const AppPathRoutesManifest = ${JSON.stringify(AppPathRoutesManifest)};
+  export const FunctionsConfigManifest = ${JSON.stringify(FunctionsConfigManifest)};
 
 
   process.env.NEXT_BUILD_ID = BuildId;

package/dist/plugins/externalMiddleware.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "esbuild";
+export declare function openNextExternalMiddlewarePlugin(functionPath: string): Plugin;

package/dist/plugins/externalMiddleware.js

@@ -0,0 +1,10 @@
+import { getCrossPlatformPathRegex } from "../utils/regex.js";
+export function openNextExternalMiddlewarePlugin(functionPath) {
+    return {
+        name: "open-next-external-node-middleware",
+        setup(build) {
+            // If we bundle the routing, we need to resolve the middleware
+            build.onResolve({ filter: getCrossPlatformPathRegex("./middleware.mjs") }, () => ({ path: functionPath }));
+        },
+    };
+}

package/dist/plugins/resolve.js

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import chalk from "chalk";
 import logger from "../logger.js";
 import { getCrossPlatformPathRegex } from "../utils/regex.js";
@@ -44,7 +44,7 @@ export function openNextResolvePlugin({ overrides, fnName, }) {
         setup(build) {
             logger.debug(chalk.blue("OpenNext Resolve plugin"), fnName ? `for ${fnName}` : "");
             build.onLoad({ filter: getCrossPlatformPathRegex("core/resolve.js") }, async (args) => {
-                let contents = readFileSync(args.path, "utf-8");
+                let contents = await readFile(args.path, "utf-8");
                 const overridesEntries = Object.entries(overrides ?? {});
                 for (let [overrideName, overrideValue] of overridesEntries) {
                     if (!overrideValue) {

package/dist/types/cache.d.ts

@@ -16,7 +16,7 @@ interface CachedRedirectValue {
     props: Object;
 }
 interface CachedRouteValue {
-    kind: "ROUTE";
+    kind: "ROUTE" | "APP_ROUTE";
     body: Buffer;
     status: number;
     headers: Record<string, undefined | string | string[]>;
@@ -30,13 +30,21 @@ interface CachedImageValue {
     isStale?: boolean;
 }
 interface IncrementalCachedPageValue {
-    kind: "PAGE";
+    kind: "PAGE" | "PAGES";
     html: string;
     pageData: Object;
     status?: number;
     headers?: Record<string, undefined | string>;
 }
-type IncrementalCacheValue = CachedRedirectValue | IncrementalCachedPageValue | CachedImageValue | CachedFetchValue | CachedRouteValue;
+interface IncrementalCachedAppPageValue {
+    kind: "APP_PAGE";
+    html: string;
+    rscData: Buffer;
+    headers?: Record<string, undefined | string | string[]>;
+    postponed?: string;
+    status?: number;
+}
+export type IncrementalCacheValue = CachedRedirectValue | IncrementalCachedPageValue | IncrementalCachedAppPageValue | CachedImageValue | CachedFetchValue | CachedRouteValue;
 export interface CacheHandlerContext {
     fs?: never;
     dev?: boolean;
@@ -54,9 +62,31 @@ export interface CacheHandlerValue {
     value: IncrementalCacheValue | null;
 }
 export type Extension = "cache" | "fetch";
+type MetaHeaders = {
+    "x-next-cache-tags"?: string;
+    [k: string]: string | string[] | undefined;
+};
 export interface Meta {
     status?: number;
-    headers?: Record<string, undefined | string | string[]>;
+    headers?: MetaHeaders;
     postponed?: string;
 }
+export type TagCacheMetaFile = {
+    tag: {
+        S: string;
+    };
+    path: {
+        S: string;
+    };
+    revalidatedAt: {
+        N: string;
+    };
+};
+export type IncrementalCacheContext = {
+    revalidate?: number | false | undefined;
+    fetchCache?: boolean | undefined;
+    fetchUrl?: string | undefined;
+    fetchIdx?: number | undefined;
+    tags?: string[] | undefined;
+};
 export {};