@opennextjs/aws 3.1.4

package/dist/adapters/config/util.js

@@ -0,0 +1,84 @@
+import fs from "fs";
+import path from "path";
+export function loadConfig(nextDir) {
+    const filePath = path.join(nextDir, "required-server-files.json");
+    const json = fs.readFileSync(filePath, "utf-8");
+    const { config } = JSON.parse(json);
+    return config;
+}
+export function loadBuildId(nextDir) {
+    const filePath = path.join(nextDir, "BUILD_ID");
+    return fs.readFileSync(filePath, "utf-8").trim();
+}
+export function loadHtmlPages(nextDir) {
+    const filePath = path.join(nextDir, "server", "pages-manifest.json");
+    const json = fs.readFileSync(filePath, "utf-8");
+    return Object.entries(JSON.parse(json))
+        .filter(([_, value]) => value.endsWith(".html"))
+        .map(([key]) => key);
+}
+export function loadPublicAssets(openNextDir) {
+    const filePath = path.join(openNextDir, "public-files.json");
+    const json = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(json);
+}
+export function loadRoutesManifest(nextDir) {
+    const filePath = path.join(nextDir, "routes-manifest.json");
+    const json = fs.readFileSync(filePath, "utf-8");
+    const routesManifest = JSON.parse(json);
+    const _dataRoutes = routesManifest.dataRoutes ?? [];
+    const dataRoutes = {
+        static: _dataRoutes.filter((r) => r.routeKeys === undefined),
+        dynamic: _dataRoutes.filter((r) => r.routeKeys !== undefined),
+    };
+    return {
+        basePath: routesManifest.basePath,
+        rewrites: Array.isArray(routesManifest.rewrites)
+            ? { beforeFiles: [], afterFiles: routesManifest.rewrites, fallback: [] }
+            : {
+                beforeFiles: routesManifest.rewrites.beforeFiles ?? [],
+                afterFiles: routesManifest.rewrites.afterFiles ?? [],
+                fallback: routesManifest.rewrites.fallback ?? [],
+            },
+        redirects: routesManifest.redirects ?? [],
+        routes: {
+            static: routesManifest.staticRoutes ?? [],
+            dynamic: routesManifest.dynamicRoutes ?? [],
+            data: dataRoutes,
+        },
+        locales: routesManifest.i18n?.locales ?? [],
+    };
+}
+export function loadConfigHeaders(nextDir) {
+    const filePath = path.join(nextDir, "routes-manifest.json");
+    const json = fs.readFileSync(filePath, "utf-8");
+    const routesManifest = JSON.parse(json);
+    return routesManifest.headers;
+}
+export function loadPrerenderManifest(nextDir) {
+    const filePath = path.join(nextDir, "prerender-manifest.json");
+    const json = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(json);
+}
+export function loadAppPathsManifestKeys(nextDir) {
+    const appPathsManifestPath = path.join(nextDir, "server", "app-paths-manifest.json");
+    const appPathsManifestJson = fs.existsSync(appPathsManifestPath)
+        ? fs.readFileSync(appPathsManifestPath, "utf-8")
+        : "{}";
+    const appPathsManifest = JSON.parse(appPathsManifestJson);
+    return Object.keys(appPathsManifest).map((key) => {
+        // Remove parallel route
+        let cleanedKey = key.replace(/\/@[^\/]+/g, "");
+        // Remove group routes
+        cleanedKey = cleanedKey.replace(/\/\((?!\.)[^\)]*\)/g, "");
+        // Remove /page suffix
+        cleanedKey = cleanedKey.replace(/\/page$/g, "");
+        // We need to check if the cleaned key is empty because it means it's the root path
+        return cleanedKey === "" ? "/" : cleanedKey;
+    });
+}
+export function loadMiddlewareManifest(nextDir) {
+    const filePath = path.join(nextDir, "server", "middleware-manifest.json");
+    const json = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(json);
+}

package/dist/adapters/dynamo-provider.d.ts

@@ -0,0 +1,8 @@
+declare const PHYSICAL_RESOURCE_ID: "dynamodb-cache";
+export interface InitializationFunctionEvent {
+    type: "initializationFunction";
+    requestType: "create" | "update" | "delete";
+    resourceId: typeof PHYSICAL_RESOURCE_ID;
+}
+export declare const handler: (...args: any[]) => any;
+export {};

package/dist/adapters/dynamo-provider.js

@@ -0,0 +1,42 @@
+import { readFileSync } from "fs";
+import { createGenericHandler } from "../core/createGenericHandler.js";
+import { resolveTagCache } from "../core/resolve.js";
+const PHYSICAL_RESOURCE_ID = "dynamodb-cache";
+const tagCache = await resolveTagCache(globalThis.openNextConfig?.initializationFunction?.tagCache);
+export const handler = await createGenericHandler({
+    handler: defaultHandler,
+    type: "initializationFunction",
+});
+async function defaultHandler(event) {
+    switch (event.requestType) {
+        case "delete":
+            return remove();
+        case "create":
+        case "update":
+        default:
+            return insert(event.requestType);
+    }
+}
+async function insert(requestType) {
+    const file = readFileSync(`dynamodb-cache.json`, "utf8");
+    const data = JSON.parse(file);
+    const parsedData = data.map((item) => ({
+        tag: item.tag.S,
+        path: item.path.S,
+        revalidatedAt: parseInt(item.revalidatedAt.N),
+    }));
+    await tagCache.writeTags(parsedData);
+    return {
+        type: "initializationFunction",
+        requestType,
+        resourceId: PHYSICAL_RESOURCE_ID,
+    };
+}
+async function remove() {
+    // Do we want to actually delete anything here?
+    return {
+        type: "initializationFunction",
+        requestType: "delete",
+        resourceId: PHYSICAL_RESOURCE_ID,
+    };
+}

package/dist/adapters/edge-adapter.d.ts

@@ -0,0 +1,8 @@
+declare global {
+    var isEdgeRuntime: true;
+}
+export declare const handler: (...args: any[]) => any;
+declare const _default: {
+    fetch: (...args: any[]) => any;
+};
+export default _default;

package/dist/adapters/edge-adapter.js

@@ -0,0 +1,54 @@
+import { emptyReadableStream } from "../utils/stream";
+// We import it like that so that the edge plugin can replace it
+import { NextConfig } from "../adapters/config";
+import { createGenericHandler } from "../core/createGenericHandler";
+import { convertBodyToReadableStream, convertToQueryString, } from "../core/routing/util";
+const defaultHandler = async (internalEvent) => {
+    globalThis.isEdgeRuntime = true;
+    const host = internalEvent.headers.host
+        ? `https://${internalEvent.headers.host}`
+        : "http://localhost:3000";
+    const initialUrl = new URL(internalEvent.rawPath, host);
+    initialUrl.search = convertToQueryString(internalEvent.query);
+    const url = initialUrl.toString();
+    // @ts-expect-error - This is bundled
+    const handler = await import(`./middleware.mjs`);
+    const response = await handler.default({
+        headers: internalEvent.headers,
+        method: internalEvent.method || "GET",
+        nextConfig: {
+            basePath: NextConfig.basePath,
+            i18n: NextConfig.i18n,
+            trailingSlash: NextConfig.trailingSlash,
+        },
+        url,
+        body: convertBodyToReadableStream(internalEvent.method, internalEvent.body),
+    });
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+        if (key.toLowerCase() === "set-cookie") {
+            responseHeaders[key] = responseHeaders[key]
+                ? [...responseHeaders[key], value]
+                : [value];
+        }
+        else {
+            responseHeaders[key] = value;
+        }
+    });
+    const body = response.body ?? emptyReadableStream();
+    return {
+        type: "core",
+        statusCode: response.status,
+        headers: responseHeaders,
+        body: body,
+        // Do we need to handle base64 encoded response?
+        isBase64Encoded: false,
+    };
+};
+export const handler = await createGenericHandler({
+    handler: defaultHandler,
+    type: "middleware",
+});
+export default {
+    fetch: handler,
+};

package/dist/adapters/image-optimization-adapter.d.ts

@@ -0,0 +1,4 @@
+import { StreamCreator } from "../http/openNextResponse.js";
+import { InternalEvent, InternalResult } from "../types/open-next.js";
+export declare const handler: (...args: any[]) => any;
+export declare function defaultHandler(event: InternalEvent, streamCreator?: StreamCreator): Promise<InternalResult>;

package/dist/adapters/image-optimization-adapter.js

@@ -0,0 +1,193 @@
+import { createHash } from "node:crypto";
+import https from "node:https";
+import path from "node:path";
+import { loadBuildId, loadConfig } from "./config/util.js";
+import { OpenNextNodeResponse } from "../http/openNextResponse.js";
+// @ts-ignore
+import { defaultConfig } from "next/dist/server/config-shared";
+import { ImageOptimizerCache,
+// @ts-ignore
+ } from "next/dist/server/image-optimizer";
+import { emptyReadableStream, toReadableStream } from "../utils/stream.js";
+import { createGenericHandler } from "../core/createGenericHandler.js";
+import { resolveImageLoader } from "../core/resolve.js";
+import { debug, error } from "./logger.js";
+import { optimizeImage } from "./plugins/image-optimization/image-optimization.js";
+import { setNodeEnv } from "./util.js";
+setNodeEnv();
+const nextDir = path.join(__dirname, ".next");
+const config = loadConfig(nextDir);
+const buildId = loadBuildId(nextDir);
+const nextConfig = {
+    ...defaultConfig,
+    images: {
+        ...defaultConfig.images,
+        ...config.images,
+    },
+};
+debug("Init config", {
+    nextDir,
+    nextConfig,
+});
+/////////////
+// Handler //
+/////////////
+export const handler = await createGenericHandler({
+    handler: defaultHandler,
+    type: "imageOptimization",
+});
+export async function defaultHandler(event, streamCreator) {
+    // Images are handled via header and query param information.
+    debug("handler event", event);
+    const { headers, query: queryString } = event;
+    try {
+        // Set the HOST environment variable to the host header if it is not set
+        // If it is set it is assumed to be set by the user and should be used instead
+        // It might be useful for cases where the user wants to use a different host than the one in the request
+        // It could even allow to have multiple hosts for the image optimization by setting the HOST environment variable in the wrapper for example
+        if (!process.env.HOST) {
+            const headersHost = headers["x-forwarded-host"] || headers["host"];
+            process.env.HOST = headersHost;
+        }
+        const imageParams = validateImageParams(headers, queryString === null ? undefined : queryString);
+        let etag;
+        // We don't cache any images, so in order to be able to return 304 responses, we compute an ETag from what is assumed to be static
+        if (process.env.OPENNEXT_STATIC_ETAG) {
+            etag = computeEtag(imageParams);
+        }
+        if (etag && headers["if-none-match"] === etag) {
+            return {
+                statusCode: 304,
+                headers: {},
+                body: emptyReadableStream(),
+                isBase64Encoded: false,
+                type: "core",
+            };
+        }
+        const result = await optimizeImage(headers, imageParams, nextConfig, downloadHandler);
+        return buildSuccessResponse(result, streamCreator, etag);
+    }
+    catch (e) {
+        return buildFailureResponse(e, streamCreator);
+    }
+}
+//////////////////////
+// Helper functions //
+//////////////////////
+function validateImageParams(headers, query) {
+    // Next.js checks if external image URL matches the
+    // `images.remotePatterns`
+    const imageParams = ImageOptimizerCache.validateParams(
+    // @ts-ignore
+    { headers }, query, nextConfig, false);
+    debug("image params", imageParams);
+    if ("errorMessage" in imageParams) {
+        throw new Error(imageParams.errorMessage);
+    }
+    return imageParams;
+}
+function computeEtag(imageParams) {
+    return createHash("sha1")
+        .update(JSON.stringify({
+        href: imageParams.href,
+        width: imageParams.width,
+        quality: imageParams.quality,
+        buildId,
+    }))
+        .digest("base64");
+}
+function buildSuccessResponse(result, streamCreator, etag) {
+    const headers = {
+        Vary: "Accept",
+        "Content-Type": result.contentType,
+        "Cache-Control": `public,max-age=${result.maxAge},immutable`,
+    };
+    debug("result", result);
+    if (etag) {
+        headers["ETag"] = etag;
+    }
+    if (streamCreator) {
+        const response = new OpenNextNodeResponse(() => void 0, async () => void 0, streamCreator);
+        response.writeHead(200, headers);
+        response.end(result.buffer);
+    }
+    return {
+        type: "core",
+        statusCode: 200,
+        body: toReadableStream(result.buffer, true),
+        isBase64Encoded: true,
+        headers,
+    };
+}
+function buildFailureResponse(e, streamCreator) {
+    debug(e);
+    if (streamCreator) {
+        const response = new OpenNextNodeResponse(() => void 0, async () => void 0, streamCreator);
+        response.writeHead(500, {
+            Vary: "Accept",
+            "Cache-Control": `public,max-age=60,immutable`,
+            "Content-Type": "application/json",
+        });
+        response.end(e?.message || e?.toString() || "An error occurred");
+    }
+    return {
+        type: "core",
+        isBase64Encoded: false,
+        statusCode: 500,
+        headers: {
+            Vary: "Accept",
+            // For failed images, allow client to retry after 1 minute.
+            "Cache-Control": `public,max-age=60,immutable`,
+            "Content-Type": "application/json",
+        },
+        body: toReadableStream(e?.message || e?.toString() || "An error occurred"),
+    };
+}
+const loader = await resolveImageLoader(globalThis.openNextConfig.imageOptimization?.loader ?? "s3");
+async function downloadHandler(_req, res, url) {
+    // downloadHandler is called by Next.js. We don't call this function
+    // directly.
+    debug("downloadHandler url", url);
+    // Reads the output from the Writable and writes to the response
+    const pipeRes = (w, res) => {
+        w.pipe(res)
+            .once("close", () => {
+            res.statusCode = 200;
+            res.end();
+        })
+            .once("error", (err) => {
+            error("Failed to get image", err);
+            res.statusCode = 400;
+            res.end();
+        });
+    };
+    try {
+        // Case 1: remote image URL => download the image from the URL
+        if (url.href.toLowerCase().match(/^https?:\/\//)) {
+            pipeRes(https.get(url), res);
+        }
+        // Case 2: local image => download the image from S3
+        else {
+            // Download image from S3
+            // note: S3 expects keys without leading `/`
+            const response = await loader.load(url.href);
+            if (!response.body) {
+                throw new Error("Empty response body from the S3 request.");
+            }
+            // @ts-ignore
+            pipeRes(response.body, res);
+            // Respect the bucket file's content-type and cache-control
+            // imageOptimizer will use this to set the results.maxAge
+            if (response.contentType) {
+                res.setHeader("Content-Type", response.contentType);
+            }
+            if (response.cacheControl) {
+                res.setHeader("Cache-Control", response.cacheControl);
+            }
+        }
+    }
+    catch (e) {
+        error("Failed to download image", e);
+        throw e;
+    }
+}

package/dist/adapters/logger.d.ts

@@ -0,0 +1,13 @@
+declare global {
+    var openNextDebug: boolean;
+}
+export declare function debug(...args: any[]): void;
+export declare function warn(...args: any[]): void;
+export declare function error(...args: any[]): void;
+export declare const awsLogger: {
+    trace: () => void;
+    debug: () => void;
+    info: typeof debug;
+    warn: typeof warn;
+    error: typeof error;
+};

package/dist/adapters/logger.js

@@ -0,0 +1,51 @@
+export function debug(...args) {
+    if (globalThis.openNextDebug) {
+        console.log(...args);
+    }
+}
+export function warn(...args) {
+    console.warn(...args);
+}
+const DOWNPLAYED_ERROR_LOGS = [
+    {
+        clientName: "S3Client",
+        commandName: "GetObjectCommand",
+        errorName: "NoSuchKey",
+    },
+];
+const isDownplayedErrorLog = (errorLog) => DOWNPLAYED_ERROR_LOGS.some((downplayedInput) => downplayedInput.clientName === errorLog?.clientName &&
+    downplayedInput.commandName === errorLog?.commandName &&
+    (downplayedInput.errorName === errorLog?.error?.name ||
+        downplayedInput.errorName === errorLog?.error?.Code));
+export function error(...args) {
+    // we try to catch errors from the aws-sdk client and downplay some of them
+    if (args.some((arg) => isDownplayedErrorLog(arg))) {
+        debug(...args);
+    }
+    else if (args.some((arg) => arg.__openNextInternal)) {
+        // In case of an internal error, we log it with the appropriate log level
+        const error = args.find((arg) => arg.__openNextInternal);
+        if (error.logLevel === 0) {
+            debug(...args);
+            return;
+        }
+        else if (error.logLevel === 1) {
+            warn(...args);
+            return;
+        }
+        else {
+            console.error(...args);
+            return;
+        }
+    }
+    else {
+        console.error(...args);
+    }
+}
+export const awsLogger = {
+    trace: () => { },
+    debug: () => { },
+    info: debug,
+    warn,
+    error,
+};

package/dist/adapters/middleware.d.ts

@@ -0,0 +1,5 @@
+export declare const handler: (...args: any[]) => any;
+declare const _default: {
+    fetch: (...args: any[]) => any;
+};
+export default _default;

package/dist/adapters/middleware.js

@@ -0,0 +1,84 @@
+import { debug, error } from "../adapters/logger";
+import { createGenericHandler } from "../core/createGenericHandler";
+import { resolveIncrementalCache, resolveQueue, resolveTagCache, } from "../core/resolve";
+import routingHandler from "../core/routingHandler";
+const resolveOriginResolver = () => {
+    const openNextParams = globalThis.openNextConfig.middleware;
+    if (typeof openNextParams?.originResolver === "function") {
+        return openNextParams.originResolver();
+    }
+    else {
+        return Promise.resolve({
+            name: "env",
+            resolve: async (_path) => {
+                try {
+                    const origin = JSON.parse(process.env.OPEN_NEXT_ORIGIN ?? "{}");
+                    for (const [key, value] of Object.entries(globalThis.openNextConfig.functions ?? {}).filter(([key]) => key !== "default")) {
+                        if (value.patterns.some((pattern) => {
+                            // Convert cloudfront pattern to regex
+                            return new RegExp(
+                            // transform glob pattern to regex
+                            "/" +
+                                pattern
+                                    .replace(/\*\*/g, "(.*)")
+                                    .replace(/\*/g, "([^/]*)")
+                                    .replace(/\//g, "\\/")
+                                    .replace(/\?/g, ".")).test(_path);
+                        })) {
+                            debug("Using origin", key, value.patterns);
+                            return origin[key];
+                        }
+                    }
+                    if (_path.startsWith("/_next/image") && origin["imageOptimizer"]) {
+                        debug("Using origin", "imageOptimizer", _path);
+                        return origin["imageOptimizer"];
+                    }
+                    if (origin["default"]) {
+                        debug("Using default origin", origin["default"], _path);
+                        return origin["default"];
+                    }
+                    return false;
+                }
+                catch (e) {
+                    error("Error while resolving origin", e);
+                    return false;
+                }
+            },
+        });
+    }
+};
+globalThis.internalFetch = fetch;
+const defaultHandler = async (internalEvent) => {
+    const originResolver = await resolveOriginResolver();
+    //#override includeCacheInMiddleware
+    globalThis.tagCache = await resolveTagCache(globalThis.openNextConfig.middleware?.override?.tagCache);
+    globalThis.queue = await resolveQueue(globalThis.openNextConfig.middleware?.override?.queue);
+    globalThis.incrementalCache = await resolveIncrementalCache(globalThis.openNextConfig.middleware?.override?.incrementalCache);
+    //#endOverride
+    const result = await routingHandler(internalEvent);
+    if ("internalEvent" in result) {
+        debug("Middleware intercepted event", internalEvent);
+        let origin = false;
+        if (!result.isExternalRewrite) {
+            origin = await originResolver.resolve(result.internalEvent.rawPath);
+        }
+        return {
+            type: "middleware",
+            internalEvent: result.internalEvent,
+            isExternalRewrite: result.isExternalRewrite,
+            origin,
+            isISR: result.isISR,
+        };
+    }
+    else {
+        debug("Middleware response", result);
+        return result;
+    }
+};
+export const handler = await createGenericHandler({
+    handler: defaultHandler,
+    type: "middleware",
+});
+export default {
+    fetch: handler,
+};

package/dist/adapters/plugins/14.1/util.d.ts

@@ -0,0 +1 @@
+export declare const requestHandler: any;

package/dist/adapters/plugins/14.1/util.js

@@ -0,0 +1,29 @@
+import { NextConfig } from "../../config";
+import { debug } from "../../logger.js";
+//#override requestHandler
+// @ts-ignore
+export const requestHandler = new NextServer.default({
+    conf: {
+        ...NextConfig,
+        // Next.js compression should be disabled because of a bug in the bundled
+        // `compression` package — https://github.com/vercel/next.js/issues/11669
+        compress: false,
+        // By default, Next.js uses local disk to store ISR cache. We will use
+        // our own cache handler to store the cache on S3.
+        cacheHandler: `${process.env.LAMBDA_TASK_ROOT}/cache.cjs`,
+        cacheMaxMemorySize: 0,
+        experimental: {
+            ...NextConfig.experimental,
+            // This uses the request.headers.host as the URL
+            // https://github.com/vercel/next.js/blob/canary/packages/next/src/server/next-server.ts#L1749-L1754
+            trustHostHeader: true,
+        },
+    },
+    customServer: false,
+    dev: false,
+    dir: __dirname,
+}).getRequestHandler();
+//#endOverride
+//#override requireHooks
+debug("No need to override require hooks with next 13.4.20+");
+//#endOverride

package/dist/adapters/plugins/image-optimization/image-optimization.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from "node:http";
+import { APIGatewayProxyEventHeaders } from "aws-lambda";
+import { NextConfig } from "next/dist/server/config-shared";
+import { NextUrlWithParsedQuery } from "next/dist/server/request-meta";
+export declare function optimizeImage(headers: APIGatewayProxyEventHeaders, imageParams: any, nextConfig: NextConfig, handleRequest: (newReq: IncomingMessage, newRes: ServerResponse, newParsedUrl: NextUrlWithParsedQuery) => Promise<void>): Promise<{
+    buffer: Buffer;
+    contentType: string;
+    maxAge: number;
+}>;

package/dist/adapters/plugins/image-optimization/image-optimization.js

@@ -0,0 +1,14 @@
+//#override imports
+import { imageOptimizer } from "next/dist/server/image-optimizer";
+import { debug } from "../../logger.js";
+//#override optimizeImage
+export async function optimizeImage(headers, imageParams, nextConfig, handleRequest) {
+    const result = await imageOptimizer(
+    // @ts-ignore
+    { headers }, {}, // res object is not necessary as it's not actually used.
+    imageParams, nextConfig, false, // not in dev mode
+    handleRequest);
+    debug("optimized result", result);
+    return result;
+}
+//#endOverride

package/dist/adapters/plugins/image-optimization/image-optimization.replacement.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { APIGatewayProxyEventHeaders } from "aws-lambda";
+import type { NextConfig } from "next/dist/server/config-shared";
+import type { NextUrlWithParsedQuery } from "next/dist/server/request-meta";
+export declare function optimizeImage(headers: APIGatewayProxyEventHeaders, imageParams: any, nextConfig: NextConfig, handleRequest: (newReq: IncomingMessage, newRes: ServerResponse, newParsedUrl?: NextUrlWithParsedQuery) => Promise<void>): Promise<{
+    buffer: Buffer;
+    contentType: string;
+    maxAge: number;
+}>;

package/dist/adapters/plugins/image-optimization/image-optimization.replacement.js

@@ -0,0 +1,22 @@
+//#override imports
+import { 
+// @ts-ignore
+fetchExternalImage, 
+// @ts-ignore
+fetchInternalImage, imageOptimizer, } from "next/dist/server/image-optimizer";
+import { debug } from "../../logger.js";
+//#override optimizeImage
+export async function optimizeImage(headers, imageParams, nextConfig, handleRequest) {
+    const { isAbsolute, href } = imageParams;
+    const imageUpstream = isAbsolute
+        ? await fetchExternalImage(href)
+        : await fetchInternalImage(href, 
+        // @ts-ignore
+        { headers }, {}, // res object is not necessary as it's not actually used.
+        handleRequest);
+    // @ts-ignore
+    const result = await imageOptimizer(imageUpstream, imageParams, nextConfig, false);
+    debug("optimized result", result);
+    return result;
+}
+//#endOverride

package/dist/adapters/plugins/without-routing/requestHandler.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/adapters/plugins/without-routing/requestHandler.js

@@ -0,0 +1,10 @@
+//#override withRouting
+const preprocessResult = {
+    internalEvent: internalEvent,
+    isExternalRewrite: false,
+    origin: false,
+    isISR: false,
+};
+//#endOverride
+// We need to export something otherwise when compiled in js it creates an empty export {} inside the override
+export default {};