vike 0.4.256 → 0.4.257-commit-c6e29ea

package/dist/node/vite/index.js

@@ -40,6 +40,7 @@ import { pluginStripPointerImportAttribute } from './plugins/pluginStripPointerI
 import { getVikeConfigInternalEarly, isOnlyResolvingUserConfig } from '../api/resolveViteConfigFromUser.js';
 import './assertEnvVite.js';
 import { isStorybook } from '../../utils/isStorybook.js';
+import { pluginUniversalDeploy } from './plugins/pluginUniversalDeploy.js';
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 setGetClientEntrySrcDev(getClientEntrySrcDev);
 assertIsNotProductionRuntime();
@@ -70,6 +71,7 @@ function plugin(vikeVitePluginOptions = {}) {
             ...pluginStaticReplace(vikeConfig),
             ...pluginNonRunnabeDev(),
             ...pluginStripPointerImportAttribute(),
+            ...pluginUniversalDeploy(vikeConfig),
             ...(await pluginViteConfigVikeExtensions(vikeConfig)),
         ];
         Object.assign(plugin, pluginAddendum);

package/dist/node/vite/plugins/pluginDev/optimizeDeps.d.ts

@@ -9,7 +9,7 @@ declare const optimizeDeps: {
     };
     readonly ssr: {
         readonly optimizeDeps: {
-            readonly exclude: ["@brillout/import", "@brillout/json-serializer", "@brillout/picocolors", "@brillout/vite-plugin-server-entry", "vike"];
+            readonly exclude: ["@brillout/import", "@brillout/json-serializer", "@brillout/vite-plugin-server-entry", "vike"];
         };
     };
 };

package/dist/node/vite/plugins/pluginDev/optimizeDeps.js

@@ -55,7 +55,9 @@ const optimizeDeps = {
             exclude: [
                 '@brillout/import',
                 '@brillout/json-serializer',
+                /* Adding @brillout/picocolors breaks the UD + Cloudflare test, we don't know why. TO-DO/eventually: re-add it and see if Vike's CI is green.
                 '@brillout/picocolors',
+                */
                 '@brillout/vite-plugin-server-entry',
                 'vike',
             ],

package/dist/node/vite/plugins/pluginReplaceConstantsGlobalThis.js

@@ -39,9 +39,11 @@ function pluginReplaceConstantsGlobalThis() {
                 },
             },
             configEnvironment: {
+                order: 'pre',
                 handler(name, config) {
                     const isClientSide = !isViteServerSide_configEnvironment(name, config);
                     return {
+                        consumer: isClientSide ? 'client' : 'server',
                         define: {
                             'globalThis.__VIKE__IS_CLIENT': JSON.stringify(isClientSide),
                         },

package/dist/node/vite/plugins/pluginUniversalDeploy/common.d.ts

@@ -0,0 +1,21 @@
+export { pluginCommon };
+import type { Plugin } from 'vite';
+import '../../assertEnvVite.js';
+declare const pluginCommon: {
+    applyToEnvironment(env: {
+        name: string;
+        getTopLevelConfig(): import("vite").ResolvedConfig;
+        config: import("vite").ResolvedConfig & {
+            define?: Record<string, any>;
+            resolve: Required<import("vite").ResolveOptions>;
+            consumer: "client" | "server";
+            keepProcessEnv?: boolean;
+            optimizeDeps: import("vite").DepOptimizationOptions;
+            dev: import("vite").ResolvedDevEnvironmentOptions;
+            build: import("vite").ResolvedBuildEnvironmentOptions;
+            plugins: readonly Plugin[];
+        };
+        logger: import("vite").Logger;
+    }): boolean;
+    sharedDuringBuild: true;
+};

package/dist/node/vite/plugins/pluginUniversalDeploy/common.js

@@ -0,0 +1,8 @@
+export { pluginCommon };
+import '../../assertEnvVite.js';
+const pluginCommon = {
+    applyToEnvironment(env) {
+        return env.config.consumer === 'server';
+    },
+    sharedDuringBuild: true,
+};

package/dist/node/vite/plugins/pluginUniversalDeploy/detectDeprecated.d.ts

@@ -0,0 +1,4 @@
+export { hasVikeServerOrVikePhoton };
+import type { VikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import '../../assertEnvVite.js';
+declare function hasVikeServerOrVikePhoton(vikeConfig: VikeConfigInternal): true | undefined;

package/dist/node/vite/plugins/pluginUniversalDeploy/detectDeprecated.js

@@ -0,0 +1,21 @@
+export { hasVikeServerOrVikePhoton };
+import { assert, assertWarning } from '../../../../utils/assert.js';
+import pc from '@brillout/picocolors';
+import '../../assertEnvVite.js';
+function hasVikeServerOrVikePhoton(vikeConfig) {
+    const vikeExtensionNames = vikeConfig._extensions.map((plusFile) => {
+        assert(plusFile.isConfigFile);
+        const { name } = plusFile.fileExportsByConfigName;
+        assert(typeof name === 'string');
+        return name;
+    });
+    const vikeServerOrVikePhoton = vikeExtensionNames.includes('vike-server')
+        ? 'vike-server'
+        : vikeExtensionNames.includes('vike-photon')
+            ? 'vike-photon'
+            : null;
+    if (vikeServerOrVikePhoton) {
+        assertWarning(false, `${pc.cyan(vikeServerOrVikePhoton)} is deprecated, see ${pc.underline('https://vike.dev/migration/server')}`, { onlyOnce: true });
+        return true;
+    }
+}

package/dist/node/vite/plugins/pluginUniversalDeploy/getDeployConfig.d.ts

@@ -0,0 +1,10 @@
+export { getDeployConfig };
+import { fromVike } from 'convert-route/vike';
+import type { PageConfigPublicWithRoute } from '../../../../shared-server-client/page-configs/resolveVikeConfigPublic.js';
+import '../../assertEnvVite.js';
+import type { Vercel } from '../../../../types/Config.js';
+type RouteIr = ReturnType<typeof fromVike>;
+declare function getDeployConfig(pageId: string, page: PageConfigPublicWithRoute): null | {
+    route: RouteIr[];
+    vercel: Vercel;
+};

package/dist/node/vite/plugins/pluginUniversalDeploy/getDeployConfig.js

@@ -0,0 +1,58 @@
+export { getDeployConfig };
+import { fromVike } from 'convert-route/vike';
+import { assert, assertUsage, assertWarning } from '../../../../utils/assert.js';
+import { isObject } from '../../../../utils/isObject.js';
+import '../../assertEnvVite.js';
+import { isCallable } from '../../../../utils/isCallable.js';
+import { pageContextJsonFileExtension } from '../../../../shared-server-client/getPageContextRequestUrl.js';
+function getDeployConfig(pageId, page) {
+    const { route } = page;
+    if (!route)
+        return null;
+    // Vercel setting: +edge
+    const { edge } = page.config?.vercel ?? {};
+    if (edge) {
+        assertUsage(typeof edge === 'boolean', '+edge must be a boolean');
+    }
+    // Vercel setting: +isr
+    let { isr } = page.config?.vercel ?? {};
+    if (isr) {
+        assertUsage(isObject(isr), '+isr must be an object');
+        assertUsage(typeof isr.expiration === 'number' && isr.expiration > 0, '+isr.expiration must be a positive number');
+    }
+    if (edge) {
+        assertWarning(!isr, `Page ${pageId} — ISR isn't supported for edge functions — remove +isr or +edge`, {
+            onlyOnce: true,
+        });
+        isr = undefined;
+    }
+    if (!edge && !isr)
+        return null;
+    if (isCallable(route)) {
+        const errMsg = (configName) => `The route of the page ${pageId} is defined via a Route Function — ${configName} isn't supported. Remove ${configName} or define the page's route using a Route String (or Filesystem Routing) instead of a Route Function.`;
+        assertWarning(!isr, errMsg('+isr'), { onlyOnce: true });
+        assertWarning(!edge, errMsg('+edge'), { onlyOnce: true });
+        return null;
+    }
+    const routeIr = fromVike(route);
+    return {
+        route: [routeIr, getRouteIrPageContextJson(routeIr)].filter((r) => r !== undefined),
+        // Supported by vite-plugin-vercel@11
+        vercel: { isr, edge },
+    };
+}
+function getRouteIrPageContextJson(routeIr) {
+    const lastSegment = routeIr.pathname.at(-1);
+    assert(lastSegment);
+    if (lastSegment.catchAll)
+        return;
+    return {
+        pathname: [
+            ...routeIr.pathname.slice(0, -1),
+            {
+                ...lastSegment,
+                value: lastSegment.value + pageContextJsonFileExtension,
+            },
+        ],
+    };
+}

package/dist/node/vite/plugins/pluginUniversalDeploy/getServerConfig.d.ts

@@ -0,0 +1,11 @@
+export { getServerConfig };
+export { isUniversalDeployVitePreview };
+import type { ResolvedConfig } from 'vite';
+import type { VikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import '../../assertEnvVite.js';
+declare function getServerConfig(vikeConfig: VikeConfigInternal): {
+    serverEntryId: string;
+    serverEntryVike: string;
+    serverFilePath: string | null;
+} | undefined;
+declare function isUniversalDeployVitePreview(vikeConfig: VikeConfigInternal, viteConfigResolved: ResolvedConfig): boolean;

package/dist/node/vite/plugins/pluginUniversalDeploy/getServerConfig.js

@@ -0,0 +1,49 @@
+export { getServerConfig };
+export { isUniversalDeployVitePreview };
+import { catchAllEntry } from '@universal-deploy/store';
+import { assert } from '../../../../utils/assert.js';
+import '../../assertEnvVite.js';
+function getServerConfig(vikeConfig) {
+    let serverEntryId;
+    let serverFilePath = null;
+    let serverEntryVike;
+    // universal-deploy support must be manually enabled
+    const serverConfig = 
+    // +config.js > `export default { server: true }`
+    vikeConfig.config.server ||
+        // +server.js exists
+        !!vikeConfig._pageConfigGlobal.configValueSources.server ||
+        false;
+    if (serverConfig === false)
+        return;
+    const serverPlusFile = vikeConfig._pageConfigGlobal.configValueSources.server?.[0];
+    if (serverPlusFile?.valueIsDefinedByPlusValueFile) {
+        assert('filePathAbsoluteFilesystem' in serverPlusFile.definedAt);
+        serverFilePath = serverPlusFile.definedAt.filePathAbsoluteFilesystem;
+        assert(serverFilePath);
+        serverEntryId = serverFilePath;
+        serverEntryVike = serverFilePath;
+    }
+    else {
+        serverEntryId = catchAllEntry;
+        serverEntryVike = 'vike/fetch';
+    }
+    return {
+        // Used to filter which module ID to transform.
+        // It points to a fully resolved server entry or the virtual universal-deploy catchAll entry.
+        serverEntryId,
+        // This entry will be pushed to universal-deploy via `addEntry`.
+        // It either points to the default fetchable endpoint (vike/fetch), or one defined by the user through +server.
+        serverEntryVike,
+        serverFilePath,
+    };
+}
+function isUniversalDeployVitePreview(vikeConfig, viteConfigResolved) {
+    const isServerConfig = getServerConfig(vikeConfig);
+    if (!isServerConfig)
+        return false;
+    // @universal-deploy/node -> real preview
+    // else -> vite preview
+    const udNodePlugin = viteConfigResolved.plugins.find((p) => p.name.startsWith('ud:node:emit'));
+    return !udNodePlugin;
+}

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginResolvePlusServer.d.ts

@@ -0,0 +1,7 @@
+export { pluginResolvePlusServer };
+import type { Plugin } from 'vite';
+import '../../assertEnvVite.js';
+/**
+ * If +server.js is defined, make virtual:ud:catch-all resolve to +server.js absolute path
+ */
+declare function pluginResolvePlusServer(serverFilePath: string): Plugin;

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginResolvePlusServer.js

@@ -0,0 +1,23 @@
+export { pluginResolvePlusServer };
+import { pluginCommon } from './common.js';
+import { escapeRegex } from '../../../../utils/escapeRegex.js';
+import '../../assertEnvVite.js';
+/**
+ * If +server.js is defined, make virtual:ud:catch-all resolve to +server.js absolute path
+ */
+function pluginResolvePlusServer(serverFilePath) {
+    return {
+        name: 'vike:pluginUniversalDeploy:server',
+        resolveId: {
+            order: 'pre',
+            filter: {
+                id: new RegExp(escapeRegex(serverFilePath)),
+            },
+            handler() {
+                // Will resolve the entry from the users project root
+                return this.resolve(serverFilePath);
+            },
+        },
+        ...pluginCommon,
+    };
+}

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginServerEntryAlias.d.ts

@@ -0,0 +1,5 @@
+export { pluginServerEntryAlias };
+import type { Plugin } from 'vite';
+import '../../assertEnvVite.js';
+/** Alias for virtual:ud:catch if no userland server entry */
+declare function pluginServerEntryAlias(serverFilePath?: string | null): Plugin;

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginServerEntryAlias.js

@@ -0,0 +1,42 @@
+export { pluginServerEntryAlias };
+import { catchAllEntry } from '@universal-deploy/store';
+import { pluginCommon } from './common.js';
+import { escapeRegex } from '../../../../utils/escapeRegex.js';
+import { assert } from '../../../../utils/assert.js';
+import '../../assertEnvVite.js';
+const serverEntryAlias = 'vike:server-entry';
+const virtualFileId = '\0' + serverEntryAlias;
+// === Rolldown filter
+const filterRolldown = {
+    id: {
+        include: [new RegExp(escapeRegex(serverEntryAlias)), new RegExp(escapeRegex(virtualFileId))],
+    },
+};
+// ===
+/** Alias for virtual:ud:catch if no userland server entry */
+function pluginServerEntryAlias(serverFilePath) {
+    return {
+        name: 'vike:pluginUniversalDeploy:alias',
+        resolveId: {
+            filter: filterRolldown,
+            handler() {
+                if (!serverFilePath)
+                    return catchAllEntry;
+                return virtualFileId;
+            },
+        },
+        load: {
+            filter: filterRolldown,
+            handler() {
+                assert(serverFilePath);
+                // Also re-export non-default exports, to support Durable Objects
+                return `import mod from ${JSON.stringify(catchAllEntry)};
+
+export * from ${JSON.stringify(serverFilePath)};
+export default mod;
+`;
+            },
+        },
+        ...pluginCommon,
+    };
+}

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginServerEntryInject.d.ts

@@ -0,0 +1,4 @@
+export { pluginServerEntryInject };
+import type { Plugin } from 'vite';
+import '../../assertEnvVite.js';
+declare function pluginServerEntryInject(serverEntryId: string): Plugin;

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginServerEntryInject.js

@@ -0,0 +1,25 @@
+export { pluginServerEntryInject };
+import { getMagicString } from '../../shared/getMagicString.js';
+import { serverEntryVirtualId } from '@brillout/vite-plugin-server-entry/plugin';
+import { pluginCommon } from './common.js';
+import '../../assertEnvVite.js';
+import { escapeRegex } from '../../../../utils/escapeRegex.js';
+function pluginServerEntryInject(serverEntryId) {
+    return {
+        name: 'vike:pluginUniversalDeploy:serverEntry',
+        apply: 'build',
+        transform: {
+            order: 'post',
+            filter: {
+                id: new RegExp(escapeRegex(serverEntryId)),
+            },
+            handler(code, id) {
+                const { magicString, getMagicStringResult } = getMagicString(code, id);
+                // Inject Vike virtual server entry
+                magicString.prepend(`import "${serverEntryVirtualId}";\n`);
+                return getMagicStringResult();
+            },
+        },
+        ...pluginCommon,
+    };
+}

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginUnwrapProdOptions.d.ts

@@ -0,0 +1,4 @@
+export { pluginUnwrapProdOptions };
+import type { Plugin } from 'vite';
+import '../../assertEnvVite.js';
+declare function pluginUnwrapProdOptions(serverFilePath: string): Plugin;

package/dist/node/vite/plugins/pluginUniversalDeploy/pluginUnwrapProdOptions.js

@@ -0,0 +1,22 @@
+export { pluginUnwrapProdOptions };
+import { wrapper } from 'vite-plugin-wrapper';
+import { escapeRegex } from '../../../../utils/escapeRegex.js';
+import '../../assertEnvVite.js';
+function pluginUnwrapProdOptions(serverFilePath) {
+    return wrapper({
+        resolveId: {
+            filter: {
+                id: new RegExp(escapeRegex(serverFilePath)),
+            },
+        },
+        // Unwrap all prod.* options
+        load(id) {
+            return `
+import mod from ${JSON.stringify(id)};
+
+export * from ${JSON.stringify(id)};
+export default { ...mod, ...mod?.prod };
+`;
+        },
+    });
+}

package/dist/node/vite/plugins/pluginUniversalDeploy.d.ts

@@ -0,0 +1,5 @@
+export { pluginUniversalDeploy };
+import type { Plugin } from 'vite';
+import type { VikeConfigInternal } from '../shared/resolveVikeConfigInternal.js';
+import '../assertEnvVite.js';
+declare function pluginUniversalDeploy(vikeConfig: VikeConfigInternal): Plugin[];

package/dist/node/vite/plugins/pluginUniversalDeploy.js

@@ -0,0 +1,59 @@
+export { pluginUniversalDeploy };
+import { toRou3 } from 'convert-route';
+import { addEntry } from '@universal-deploy/store';
+import universalDeploy, { resolveTargets } from '@universal-deploy/vite';
+import { pluginServerEntryInject } from './pluginUniversalDeploy/pluginServerEntryInject.js';
+import { getDeployConfig } from './pluginUniversalDeploy/getDeployConfig.js';
+import { pluginCommon } from './pluginUniversalDeploy/common.js';
+import { hasVikeServerOrVikePhoton } from './pluginUniversalDeploy/detectDeprecated.js';
+import { getServerConfig } from './pluginUniversalDeploy/getServerConfig.js';
+import { pluginServerEntryAlias } from './pluginUniversalDeploy/pluginServerEntryAlias.js';
+import { pluginUnwrapProdOptions } from './pluginUniversalDeploy/pluginUnwrapProdOptions.js';
+import { unique } from '../../../utils/unique.js';
+import { assertUsage } from '../../../utils/assert.js';
+import '../assertEnvVite.js';
+function pluginUniversalDeploy(vikeConfig) {
+    if (hasVikeServerOrVikePhoton(vikeConfig))
+        return [];
+    const serverConfig = getServerConfig(vikeConfig);
+    if (!serverConfig)
+        return [
+            resolveTargets((targets) => {
+                // Cloudflare is supported even without universal-deploy
+                const target = targets.filter((t) => t !== '@cloudflare/vite-plugin')[0];
+                assertUsage(target === undefined, `${target} requires +server — see https://vike.dev/server`);
+            }),
+        ];
+    const { serverEntryVike, serverEntryId, serverFilePath } = serverConfig;
+    return [
+        ...universalDeploy(),
+        {
+            name: 'vike:pluginUniversalDeploy:entries',
+            config() {
+                // Map each Vike route to universal-deploy
+                for (const [pageId, page] of Object.entries(vikeConfig.pages)) {
+                    const deployConfig = getDeployConfig(pageId, page);
+                    // Skip pages without a deploy configuration, as they will be handled by the catch-all route
+                    if (deployConfig) {
+                        const { route, ...config } = deployConfig;
+                        addEntry({
+                            ...config,
+                            id: serverEntryVike,
+                            // Map Vike routes to rou3 format
+                            route: unique(route.map(toRou3).flat()),
+                        });
+                    }
+                }
+                // Default catch-all route
+                addEntry({
+                    id: serverEntryVike,
+                    route: '/**',
+                });
+            },
+            ...pluginCommon,
+        },
+        pluginServerEntryInject(serverFilePath ?? serverEntryId),
+        pluginServerEntryAlias(serverFilePath),
+        !serverFilePath ? null : pluginUnwrapProdOptions(serverFilePath),
+    ].filter((p) => p !== null);
+}

package/dist/node/vite/plugins/pluginWorkaroundVite6HmrRegression.js

@@ -11,7 +11,8 @@ function pluginWorkaroundVite6HmrRegression() {
             enforce: 'post',
             hotUpdate: {
                 order: 'post',
-                handler({ modules, server, timestamp }) {
+                async handler(ctx) {
+                    const { modules, server, timestamp } = ctx;
                     if (this.environment.name !== 'ssr')
                         return;
                     let hasSsrOnlyModules = false;

package/dist/node/vite/shared/addSsrMiddleware.js

@@ -14,6 +14,7 @@ function addSsrMiddleware(middlewares, config, isPreview, isPrerenderingEnabled)
         const pageContextInit = {
             urlOriginal: url,
             headersOriginal: headers,
+            _reqDev: req,
         };
         Object.defineProperty(pageContextInit, 'userAgent', {
             get() {

package/dist/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.d.ts

@@ -34,7 +34,11 @@ type ConfigDefinition_ = {
      */
     effect?: ConfigEffect;
     /**
-     * Always load the configuration value, and as soon as possible.
+     * Load the configuration of *all* pages (regardless of what page is being rendered).
+     *
+     * WARNING: this might bloat server- and client-side KBs.
+     *
+     * By default, to save server- and client-side KBs, the configuration of a page is only loaded when rendering that page.
      *
      * @default false
      *

package/dist/node/vite/shared/resolveVikeConfigInternal/configDefinitionsBuiltIn.js

@@ -4,6 +4,7 @@ import { getConfigDefinedAt, } from '../../../../shared-server-client/page-confi
 import { getConfigValueSourceRelevantAnyEnv, getConfigValueSourcesRelevant, isConfigSourceValueNull, } from '../../plugins/pluginVirtualFiles/getConfigValueSourcesRelevant.js';
 import { getFileSuffixes } from '../../../../shared-server-node/getFileSuffixes.js';
 import '../../assertEnvVite.js';
+// TODO/after-PR-merge: rename_full configDefinitionsBuiltIn metaBuiltIn
 const configDefinitionsBuiltIn = {
     onRenderHtml: {
         env: { server: true },
@@ -225,6 +226,10 @@ const configDefinitionsBuiltIn = {
         eager: true,
         global: true,
     },
+    server: {
+        env: { server: true },
+        global: true,
+    },
     cli: {
         env: { config: true },
         global: true,
@@ -305,6 +310,9 @@ const configDefinitionsBuiltIn = {
         env: { config: true },
         global: true,
     },
+    vercel: {
+        env: { config: true },
+    },
 };
 function getConfigEnv(pageConfig, configName) {
     const source = getConfigValueSourceRelevantAnyEnv(configName, pageConfig);

package/dist/node/vite/shared/resolveVikeConfigInternal/pointerImports.d.ts

@@ -17,10 +17,13 @@ declare function transformPointerImports(code: string, filePathToShowToUser2: st
  * We discard the import name `someImport` because we don't need it.
  */
 type PointerImportData = {
+    importStringWasGenerated: boolean;
+    /** For example: `import:./some-file:someExport` */
+    importString: string;
+    /** For example: `./some-file` */
     importPath: string;
+    /** For example: `someExport` */
     exportName: string;
-    importString: string;
-    importStringWasGenerated: boolean;
 };
 declare function parsePointerImportData(importString: string): null | PointerImportData;
 declare function assertPointerImportPath(importPath: string): boolean;

package/dist/node/vite/shared/resolveVikeConfigInternal/resolvePointerImport.js

@@ -78,7 +78,15 @@ function resolveImportPathWithNode(pointerImportData, importerFilePath, userRoot
         userRootDir,
     });
     if (!filePathAbsoluteFilesystem) {
-        assert(!isImportPathRelative(pointerImportData.importPath));
+        if (isImportPathRelative(pointerImportData.importPath)) {
+            const { importPath, importStringWasGenerated, importString } = pointerImportData;
+            const { filePathToShowToUserResolved } = importerFilePath;
+            assert(filePathToShowToUserResolved);
+            const errIntro = importStringWasGenerated
+                ? `The import path ${pc.cyan(importPath)} in ${filePathToShowToUserResolved}`
+                : `The import ${pc.cyan(importString)} defined by ${filePathToShowToUserResolved}`;
+            assertUsage(false, `${errIntro} couldn't be resolved: does ${pc.cyan(importPath)} point to an existing file?`);
+        }
         /* This assertion fails if the npm package has a wrongly defined package.json#exports
         // Libraries don't use path aliases => filePathAbsoluteFilesystem should be defined
         assert(!importerFilePathAbsolute.includes('node_modules'))

package/dist/server/runtime/fetch.d.ts

@@ -0,0 +1,10 @@
+import '../assertEnvServer.js';
+declare const _default: {
+    fetch: (<T extends string>(request: Request, context: Universal.Context, runtime: import("@universal-middleware/core").RuntimeAdapterTarget<T>) => Promise<Response>) & import("@universal-middleware/core").WithUniversalSymbols<{
+        name: string;
+        method: ("GET" | "HEAD" | "POST" | "PUT" | "OPTIONS" | "PATCH")[];
+        path: string;
+        immutable: true;
+    }>;
+};
+export default _default;

package/dist/server/runtime/fetch.js

@@ -0,0 +1,5 @@
+import '../assertEnvServer.js';
+import vikeHandler from './universal-middleware.js';
+export default {
+    fetch: vikeHandler,
+};