vike 0.4.254 → 0.4.255-commit-05a7b95

package/dist/node/vite/plugins/pluginCommon/assertResolveAlias.js

@@ -1,7 +1,7 @@
 export { assertResolveAlias };
 import { assert, assertUsage, assertWarning } from '../../../../utils/assert.js';
 import { isArray } from '../../../../utils/isArray.js';
-import { isPathAliasRecommended } from '../../../../utils/parseNpmPackage.js';
+import { isPathAliasRecommendation } from '../../../../utils/parseNpmPackage.js';
 import pc from '@brillout/picocolors';
 import '../../assertEnvVite.js';
 // Recommend users to avoid un-distinguishable path aliases.
@@ -62,7 +62,7 @@ function assertResolveAlias(config) {
             //  - resolveOptimizeDeps()
             //  - extractAssets
             //  - in general: using un-distinguishable path aliases is asking for trouble
-            if (!isPathAliasRecommended(find)) {
+            if (!isPathAliasRecommendation(find)) {
                 if (find.startsWith('@')) {
                     const msg = `${errPrefix} defines an invalid resolve.alias ${deprecation}: a path alias cannot start with ${pc.cyan('@')}, ${errSuffix1}`;
                     assertWarning(false, msg, { onlyOnce: true });

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

@@ -5,7 +5,7 @@ import { assert } from '../../../../utils/assert.js';
 import { createDebug } from '../../../../utils/debug.js';
 import { isArray } from '../../../../utils/isArray.js';
 import { isFilePathAbsoluteFilesystem } from '../../../../utils/isFilePathAbsoluteFilesystem.js';
-import { assertIsImportPathNpmPackage, getNpmPackageName } from '../../../../utils/parseNpmPackage.js';
+import { assertImportIsNpmPackage, getNpmPackageName } from '../../../../utils/parseNpmPackage.js';
 import { requireResolveOptional } from '../../../../utils/requireResolve.js';
 import { isVirtualFileId } from '../../../../utils/virtualFileId.js';
 import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
@@ -146,7 +146,7 @@ async function getPageDeps(config, pageConfigs) {
         // optimizeDeps.include expects npm packages
         assert(!e.startsWith('/'));
         // Shouldn't be a path alias, as path aliases would need to be added to optimizeDeps.entries instead of optimizeDeps.include
-        assertIsImportPathNpmPackage(e);
+        assertImportIsNpmPackage(e);
         if (isExcluded(e, isForClientSide, definedAt))
             return;
         if (isForClientSide) {

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/pluginStripPointerImportAttribute.js

@@ -1,8 +1,8 @@
 export { pluginStripPointerImportAttribute };
 import { getMagicString } from '../shared/getMagicString.js';
 import '../assertEnvVite.js';
-// Match `with { type: 'vike-pointer' }` (with optional whitespace variations)
-const runtimeAttrRE = /\bwith\s*\{\s*type\s*:\s*['"]vike-pointer['"]\s*\}/g;
+// Match `with { type: 'vike:pointer' }` (with optional whitespace variations)
+const runtimeAttrRE = /\bwith\s*\{\s*type\s*:\s*['"]vike:pointer['"]\s*\}/g;
 function pluginStripPointerImportAttribute() {
     return [
         {
@@ -10,7 +10,7 @@ function pluginStripPointerImportAttribute() {
             transform: {
                 filter: {
                     code: {
-                        include: 'vike-pointer',
+                        include: 'vike:pointer',
                     },
                 },
                 handler(code, id) {

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

@@ -0,0 +1,12 @@
+export { getDeployConfigs };
+import type { PageConfigPublicWithRoute } from '../../../../shared-server-client/page-configs/resolveVikeConfigPublic.js';
+import '../../assertEnvVite.js';
+declare function getDeployConfigs(pageId: string, page: PageConfigPublicWithRoute): {
+    route: string[];
+    vercel: {
+        isr: {
+            expiration: number;
+        } | undefined;
+        edge: boolean;
+    };
+} | null;

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

@@ -0,0 +1,73 @@
+import pc from '@brillout/picocolors';
+export { getDeployConfigs };
+import { fromVike, toRou3 } from 'convert-route';
+import { assert, assertUsage, assertWarning } from '../../../../utils/assert.js';
+import '../../assertEnvVite.js';
+function getDeployConfigs(pageId, page) {
+    // Convert Vike's routes to rou3 format
+    const routeIr = typeof page.route === 'string' ? fromVike(page.route) : null;
+    // Vercel specific configs
+    const rawIsr = extractIsr(page.config);
+    let isr = assertIsr(rawIsr);
+    const edge = extractEdge(page.config);
+    const isrOrEdge = isr ? 'isr' : edge ? 'edge' : null;
+    if (typeof page.route === 'function' && isrOrEdge) {
+        assertWarning(false, `Page ${pageId}: ${pc.cyan(isrOrEdge)} is not supported when using route function. Remove ${pc.cyan(isrOrEdge)} config or use a route string if possible.`, { onlyOnce: true });
+        isr = null;
+    }
+    if (edge && rawIsr !== null && typeof rawIsr === 'object') {
+        assertUsage(false, `Page ${pageId}: ISR cannot be enabled for edge functions. Remove ${pc.cyan('isr')} config or set \`{ edge: false }\`.`);
+    }
+    if (isrOrEdge && routeIr) {
+        return {
+            route: [...new Set([...toRou3(routeIr), ...getPageContextRoute(routeIr)])],
+            vercel: {
+                isr: isr ? { expiration: isr } : undefined,
+                edge: Boolean(edge),
+            },
+        };
+    }
+    return null;
+}
+function extractIsr(exports) {
+    if (exports === null || typeof exports !== 'object')
+        return null;
+    if (!('isr' in exports))
+        return null;
+    const isr = exports.isr;
+    assertUsage(typeof isr === 'object' &&
+        typeof isr.expiration === 'number' &&
+        isr.expiration > 0, ' `{ expiration }` must be a positive number');
+    return isr;
+}
+function assertIsr(isr) {
+    if (isr === null || isr === undefined)
+        return null;
+    return isr.expiration;
+}
+function extractEdge(exports) {
+    if (exports === null || typeof exports !== 'object')
+        return null;
+    if (!('edge' in exports))
+        return null;
+    const edge = exports.edge;
+    assertUsage(typeof edge === 'boolean', ' `{ edge }` must be a boolean');
+    return edge;
+}
+function getPageContextRoute(routeIr) {
+    const lastSegment = routeIr.pathname.at(-1);
+    assert(lastSegment);
+    if (!lastSegment.catchAll) {
+        const pageContextIr = {
+            pathname: [
+                ...routeIr.pathname.slice(0, -1),
+                {
+                    ...lastSegment,
+                    value: `${lastSegment.value}.pageContext.json`,
+                },
+            ],
+        };
+        return toRou3(pageContextIr);
+    }
+    return [];
+}

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,155 @@
+export { pluginUniversalDeploy };
+import { addEntry } from '@universal-deploy/store';
+import { node } from '@universal-deploy/node/vite';
+import { catchAll, devServer } from '@universal-deploy/store/vite';
+import { serverEntryVirtualId as vikeEntryId } from '@brillout/vite-plugin-server-entry/plugin';
+import { getMagicString } from '../shared/getMagicString.js';
+import { escapeRegex } from '../../../utils/escapeRegex.js';
+import { getDeployConfigs } from './pluginUniversalDeploy/getDeployConfigs.js';
+import { assert, assertUsage, assertWarning } from '../../../utils/assert.js';
+import { asyncFlatten } from '../../../utils/asyncFlatten.js';
+import '../assertEnvVite.js';
+import pc from '@brillout/picocolors';
+const virtualFileIdCatchAll = /^virtual:ud:catch-all$/;
+function pluginUniversalDeploy(vikeConfig) {
+    if (hasVikeServerOrVikePhoton(vikeConfig))
+        return [];
+    let serverEntryId = virtualFileIdCatchAll;
+    let serverFilePath = null;
+    const serverConfig = vikeConfig.config.server;
+    if (serverConfig === false)
+        return [];
+    const serverPlusFile = vikeConfig._pageConfigGlobal.configValueSources.server?.[0];
+    if (serverPlusFile) {
+        assert('filePathAbsoluteFilesystem' in serverPlusFile.definedAt);
+        serverFilePath = serverPlusFile.definedAt.filePathAbsoluteFilesystem;
+        assert(serverFilePath);
+        serverEntryId = new RegExp(escapeRegex(serverFilePath));
+    }
+    if (serverConfig !== true && !serverFilePath)
+        return [];
+    const plugins = [
+        catchAll(),
+        devServer(),
+        // Enable node adapter only if +server is defined and no other deployment target has been found
+        ...node({ importer: 'vike' }).map((p) => 
+        // Disable node() plugin later when Vite's config() hook runs, because noDeploymentTargetFound() requires `config`
+        enablePluginIf((config) => noDeploymentTargetFound(config), p)),
+        {
+            name: 'vike:pluginUniversalDeploy:entries',
+            config() {
+                for (const [pageId, page] of Object.entries(vikeConfig.pages)) {
+                    const deployConfigs = getDeployConfigs(pageId, page);
+                    if (deployConfigs !== null) {
+                        addEntry({
+                            id: serverFilePath ?? 'vike/fetch',
+                            ...deployConfigs,
+                        });
+                    }
+                }
+                // Default catch-all route
+                addEntry({
+                    id: serverFilePath ?? 'vike/fetch',
+                    route: '/**',
+                });
+            },
+            ...pluginOptions,
+        },
+        {
+            name: 'vike:pluginUniversalDeploy:serverEntry',
+            apply: 'build',
+            transform: {
+                order: 'post',
+                filter: {
+                    id: {
+                        include: [serverEntryId],
+                    },
+                },
+                handler(code, id) {
+                    const { magicString, getMagicStringResult } = getMagicString(code, id);
+                    // Inject Vike virtual server entry
+                    magicString.prepend(`import "${vikeEntryId}";\n`);
+                    return getMagicStringResult();
+                },
+            },
+            ...pluginOptions,
+        },
+    ];
+    if (serverFilePath) {
+        plugins.push(
+        // If +server.js is defined, make virtual:ud:catch-all resolve to +server.js absolute path
+        {
+            name: 'vike:pluginUniversalDeploy:server',
+            resolveId: {
+                order: 'pre',
+                filter: {
+                    id: virtualFileIdCatchAll,
+                },
+                handler() {
+                    // Will resolve the entry from the users project root
+                    return this.resolve(serverFilePath);
+                },
+            },
+            ...pluginOptions,
+        });
+    }
+    return plugins;
+}
+const pluginOptions = {
+    applyToEnvironment(env) {
+        return env.config.consumer === 'server';
+    },
+    sharedDuringBuild: true,
+};
+/**
+ * Enables a plugin based on a specified condition callback which will be executed in the `config` hook.
+ */
+function enablePluginIf(condition, originalPlugin) {
+    const originalConfig = originalPlugin.config;
+    originalPlugin.config = {
+        order: originalConfig && 'order' in originalConfig ? originalConfig.order : 'pre',
+        async handler(c, e) {
+            const enabled = await condition.call(this, c, e);
+            if (!enabled) {
+                const keysToDelete = Object.keys(originalPlugin).filter((k) => k !== 'name');
+                originalPlugin.name += ':disabled';
+                for (const key of keysToDelete) {
+                    // @ts-expect-error
+                    delete originalPlugin[key];
+                }
+            }
+            else if (originalConfig) {
+                if (typeof originalConfig === 'function') {
+                    return originalConfig.call(this, c, e);
+                }
+                return originalConfig.handler.call(this, c, e);
+            }
+        },
+    };
+    return originalPlugin;
+}
+// Disable a plugin if one of the following plugin is present
+//  - vite-plugin-vercel
+//  - @cloudflare/vite-plugin
+async function noDeploymentTargetFound(c) {
+    const plugins = (await asyncFlatten((c.plugins ?? []))).filter((p) => Boolean(p));
+    assertUsage(!plugins.some((p) => p.name.startsWith('photon:target-loader:vercel')), 'Replace `@photonjs/vercel` by `vite-plugin-vercel@11`, see https://vike.dev/migration/universal-deploy');
+    assertUsage(!plugins.some((p) => p.name.startsWith('photon:target-loader:cloudflare')), 'Replace `@photonjs/cloudflare` by `@cloudflare/vite-plugin`, see https://vike.dev/migration/universal-deploy');
+    // vite-plugin-vercel
+    const vitePluginVercel = plugins.some((p) => p.name.match(/^vite-plugin-vercel:(?!.*:disabled$)/));
+    // @cloudflare/vite-plugin
+    const cloudflareVitePlugin = plugins.some((p) => p.name.match(/^vite-plugin-cloudflare:(?!.*:disabled$)/));
+    return !vitePluginVercel && !cloudflareVitePlugin;
+}
+function hasVikeServerOrVikePhoton(vikeConfig) {
+    const vikeExtendsNames = new Set(vikeConfig._extensions.map((plusFile) => ('fileExportsByConfigName' in plusFile ? plusFile.fileExportsByConfigName : {}).name));
+    const vikeServerOrVikePhoton = vikeExtendsNames.has('vike-server')
+        ? 'vike-server'
+        : vikeExtendsNames.has('vike-photon')
+            ? 'vike-photon'
+            : null;
+    if (vikeServerOrVikePhoton) {
+        assertWarning(false, `${pc.cyan(vikeServerOrVikePhoton)} is deprecated, see ${pc.underline('https://vike.dev/migration/universal-deploy')}`, { onlyOnce: true });
+        return true;
+    }
+}

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/getClientEntrySrcDev.js

@@ -1,6 +1,6 @@
 export { getClientEntrySrcDev };
 import { assertIsNotProductionRuntime } from '../../../utils/assertSetup.js';
-import { assertIsImportPathNpmPackage } from '../../../utils/parseNpmPackage.js';
+import { assertImportIsNpmPackage } from '../../../utils/parseNpmPackage.js';
 import { toPosixPath, pathJoin } from '../../../utils/path.js';
 import { requireResolveNpmPackage, requireResolveDistFile } from '../../../utils/requireResolve.js';
 import { assert } from '../../../utils/assert.js';
@@ -32,7 +32,7 @@ function getClientEntrySrcDev(clientEntry, viteDevServer) {
             filePath = requireResolveDistFile(`dist/${clientEntry.replace('@@vike/dist/', '')}`);
         }
         else {
-            assertIsImportPathNpmPackage(clientEntry);
+            assertImportIsNpmPackage(clientEntry);
             filePath = requireResolveNpmPackage({ importPathNpmPackage: clientEntry, userRootDir });
         }
     }

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

@@ -7,7 +7,7 @@ export { cleanFilePathUnknown };
 export { assertModuleId };
 import path from 'node:path';
 import { assertFilePathAbsoluteFilesystem } from '../../../utils/isFilePathAbsoluteFilesystem.js';
-import { assertIsImportPathNpmPackage } from '../../../utils/parseNpmPackage.js';
+import { assertImportIsNpmPackage } from '../../../utils/parseNpmPackage.js';
 import { toPosixPath } from '../../../utils/path.js';
 import { assert } from '../../../utils/assert.js';
 import { assertPosixPath } from '../../../utils/path.js';
@@ -43,7 +43,7 @@ function getComputedProps(args) {
         const importPathAbsolute = args.importPathAbsolute ?? null;
         const { filePathAbsoluteUserRootDir } = args;
         if (importPathAbsolute)
-            assertIsImportPathNpmPackage(importPathAbsolute);
+            assertImportIsNpmPackage(importPathAbsolute);
         return {
             importPathAbsolute,
             filePathAbsoluteUserRootDir,
@@ -57,7 +57,7 @@ function getComputedProps(args) {
 }
 function getComputedPropsImportPathAbsolute(args) {
     const { importPathAbsolute } = args;
-    assertIsImportPathNpmPackage(importPathAbsolute);
+    assertImportIsNpmPackage(importPathAbsolute);
     return {
         filePathAbsoluteUserRootDir: null,
         importPathAbsolute,

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,
@@ -301,6 +306,19 @@ const configDefinitionsBuiltIn = {
         global: true,
         vite: true,
     },
+    license: {
+        env: { config: true },
+        global: true,
+    },
+    // -- Vercel --
+    isr: {
+        env: { server: true, config: true },
+        eager: true,
+    },
+    edge: {
+        env: { server: true, config: true },
+        eager: true,
+    },
 };
 function getConfigEnv(pageConfig, configName) {
     const source = getConfigValueSourceRelevantAnyEnv(configName, pageConfig);

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

@@ -1,6 +1,5 @@
 export { transformPointerImports };
 export { parsePointerImportData };
-export { isPointerImportData };
 export { assertPointerImportPath };
 export type { PointerImportData };
 import '../../assertEnvVite.js';
@@ -23,7 +22,6 @@ type PointerImportData = {
     importString: string;
     importStringWasGenerated: boolean;
 };
-declare function isPointerImportData(str: string): boolean;
 declare function parsePointerImportData(importString: string): null | PointerImportData;
 declare function assertPointerImportPath(importPath: string): boolean;
 declare module 'estree' {

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

@@ -1,6 +1,5 @@
 export { transformPointerImports };
 export { parsePointerImportData };
-export { isPointerImportData };
 export { assertPointerImportPath };
 // Playground: https://github.com/brillout/acorn-playground
 // Notes about `with { type: 'pointer' }`
@@ -30,6 +29,10 @@ function transformPointerImports(code, filePathToShowToUser2, pointerImports,
 // For ./transformPointerImports.spec.ts
 skipWarnings) {
     const spliceOperations = [];
+    // Collect all const declarations to prepend at the top, so that they are
+    // available before any code runs (import declarations are hoisted but const
+    // is not, so we must place them at the top to avoid TDZ errors).
+    const constDeclarations = [];
     // Performance trick
     if (!code.includes('import'))
         return null;
@@ -78,7 +81,7 @@ skipWarnings) {
                 assertWarning(false, errMsg, { onlyOnce: true });
             }
         }
-        let replacement = '';
+        let constDeclaration = '';
         node.specifiers.forEach((specifier) => {
             assert(specifier.type === 'ImportSpecifier' ||
                 specifier.type === 'ImportDefaultSpecifier' ||
@@ -97,16 +100,23 @@ skipWarnings) {
                 return importLocalName;
             })();
             const importString = serializePointerImportData({ importPath, exportName, importStringWasGenerated: true });
-            replacement += `const ${importLocalName} = '${importString}';`;
+            constDeclaration += `const ${importLocalName} = '${importString}';`;
         });
+        if (constDeclaration)
+            constDeclarations.push(constDeclaration);
+        // Replace the import with blank lines to preserve source map line numbers.
         spliceOperations.push({
             start,
             end,
-            replacement,
+            replacement: '\n'.repeat(importStatementCode.split('\n').length - 1),
         });
     });
-    const codeMod = spliceMany(code, spliceOperations);
-    return codeMod;
+    if (constDeclarations.length === 0 && spliceOperations.length === 0)
+        return null;
+    const codeWithImportsRemoved = spliceMany(code, spliceOperations);
+    if (constDeclarations.length === 0)
+        return codeWithImportsRemoved;
+    return constDeclarations.join('') + '\n' + codeWithImportsRemoved;
 }
 function getImports(code) {
     const result = parseSync(code, {

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

@@ -4,7 +4,7 @@ import pc from '@brillout/picocolors';
 import { assert, assertUsage } from '../../../../utils/assert.js';
 import { isFilePathAbsolute } from '../../../../utils/isFilePathAbsoluteFilesystem.js';
 import { isImportPathRelative } from '../../../../utils/isImportPath.js';
-import { isImportPathNpmPackageOrPathAlias } from '../../../../utils/parseNpmPackage.js';
+import { isImportNpmPackageOrPathAlias } from '../../../../utils/parseNpmPackage.js';
 import { assertPosixPath } from '../../../../utils/path.js';
 import { requireResolveOptional } from '../../../../utils/requireResolve.js';
 import { assertPointerImportPath, parsePointerImportData } from './pointerImports.js';
@@ -50,7 +50,7 @@ function resolvePointerImportData(pointerImportData, importerFilePath, userRootD
         filePath = getFilePathResolved({ filePathAbsoluteUserRootDir, userRootDir });
     }
     else {
-        assert(isImportPathNpmPackageOrPathAlias(importPath));
+        assert(isImportNpmPackageOrPathAlias(importPath));
         const importPathAbsolute = importPath;
         if (filePathAbsoluteFilesystem) {
             filePath = getFilePathResolved({

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

@@ -15,9 +15,9 @@ import { genPromise } from '../../../../utils/genPromise.js';
 import { assertFilePathAbsoluteFilesystem } from '../../../../utils/isFilePathAbsoluteFilesystem.js';
 import { isImportPathRelative } from '../../../../utils/isImportPath.js';
 import { isObject } from '../../../../utils/isObject.js';
-import { isPlainScriptFile } from '../../../../utils/isScriptFile.js';
+import { isPlainJavaScriptFile, isPlainScriptFile } from '../../../../utils/isScriptFile.js';
 import { isVitest } from '../../../../utils/isVitest.js';
-import { assertIsImportPathNpmPackage, isImportPathNpmPackageOrPathAlias } from '../../../../utils/parseNpmPackage.js';
+import { assertImportIsNpmPackage, isImportNpmPackageOrPathAlias } from '../../../../utils/parseNpmPackage.js';
 import { assertPosixPath, toPosixPath } from '../../../../utils/path.js';
 import { requireResolveOptionalDir } from '../../../../utils/requireResolve.js';
 import { transformPointerImports } from './pointerImports.js';
@@ -179,10 +179,10 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                     const importPathOriginal = args.path;
                     // Esbuild resolves path aliases.
                     // - Enabling us to use:
-                    //   - assertIsImportPathNpmPackage()
-                    //   - isImportPathNpmPackage(str, { cannotBePathAlias: true })
+                    //   - assertImportIsNpmPackage()
+                    //   - isImportNpmPackage(str, { cannotBePathAlias: true })
                     assertFilePathAbsoluteFilesystem(importPathResolved);
-                    //  Should be remove this? See comment below.
+                    //  Should we remove this? See comment below.
                     const isVikeExtensionImport = (path.startsWith('vike-') && path.endsWith('/config')) || importPathResolved.endsWith('+config.js');
                     const isPointerImport = transformImports === 'all' ||
                         // .jsx, .vue, .svg, ... => obviously not config code => pointer import
@@ -193,32 +193,20 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                         //      - vike@0.4.162 started soft-requiring Vike extensions to set the name config.
                         //    - In practice, it seems like it requires some (non-trivial?) refactoring.
                         isVikeExtensionImport ||
-                        args.with?.['type'] === 'vike-pointer';
+                        args.with?.['type'] === 'vike:pointer';
                     assertPosixPath(importPathResolved);
-                    // `isNpmPkgImport` => `importPathOriginal` is most likely an npm package import, but it can also be a path alias that a) looks like an npm package import and b) resolves outside of `userRootDir`.
-                    const isNpmPkgImport = (() => {
-                        if (importPathResolved.includes('/node_modules/')) {
-                            // So far I can't think of a use case where this assertion would fail, but let's eventually remove it to avoid artificially restricting the user.
-                            assert(isImportPathNpmPackageOrPathAlias(importPathOriginal));
-                            return true;
-                        }
-                        // Linked npm packages
-                        if (
-                        // Assuming path aliases usually resolve inside `userRootDir`.
-                        // - This isn't always the case: https://github.com/vikejs/vike/issues/2326
-                        !importPathResolved.startsWith(userRootDir) &&
-                            // False positive if `importPathOriginal` is a path alias that a) looks like an npm package import and b) resolves outside of `userRootDir` => we then we wrongfully assume that `importPathOriginal` is an npm package import.
-                            isImportPathNpmPackageOrPathAlias(importPathOriginal)) {
-                            return true;
-                        }
-                        return false;
-                    })();
+                    // False positive if `importPathOriginal` is a path alias that a) looks like an npm package import and b) resolves outside of `userRootDir` => we then we wrongfully assume that `importPathOriginal` is an npm package import.
+                    // - For example: https://github.com/vikejs/vike/issues/2326
+                    const isMostLikelyNpmPkgImport = isImportNpmPackageOrPathAlias(importPathOriginal) &&
+                        (importPathResolved.includes('/node_modules/') ||
+                            // Linked npm package
+                            !importPathResolved.startsWith(userRootDir));
                     const isExternal = isPointerImport ||
                         // Performance: npm package imports can be externalized. (We could as well let esbuild transpile /node_modules/ code but it's useless as /node_modules/ code is already built. It would unnecessarily slow down transpilation.)
-                        isNpmPkgImport;
+                        (isMostLikelyNpmPkgImport && isPlainJavaScriptFile(importPathResolved));
                     if (!isExternal) {
                         // User-land config code (i.e. not runtime code) => let esbuild transpile it
-                        assert(!isPointerImport && !isNpmPkgImport);
+                        assert(!isPointerImport);
                         if (debug.isActivated)
                             debug('onResolve() [non-external]', { args, resolved, isPointerImport, isExternal });
                         return resolved;
@@ -236,7 +224,7 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                             filePathAbsoluteFilesystem: importPathResolved,
                             userRootDir,
                         });
-                        if (filePathAbsoluteUserRootDir && !isNpmPkgImport) {
+                        if (filePathAbsoluteUserRootDir && !isMostLikelyNpmPkgImport) {
                             // `importPathOriginal` is most likely a path alias.
                             // - We have to use esbuild's path alias resolution, because:
                             //   - Vike doesn't resolve path aliases at all.
@@ -246,19 +234,13 @@ async function transpileWithEsbuild(filePath, userRootDir, transformImports, esb
                         }
                         else {
                             // `importPathOriginal` is most likely an npm package import.
-                            assertIsImportPathNpmPackage(importPathOriginal);
+                            assertImportIsNpmPackage(importPathOriginal);
                             // For improved error messages, let the resolution be handled by Vike or Node.js.
                             importPathTranspiled = importPathOriginal;
                         }
                     }
                     if (debug.isActivated)
                         debug('onResolve() [external]', { args, resolved, importPathTranspiled, isPointerImport, isExternal });
-                    assert(isExternal);
-                    assert(
-                    // Import of runtime code => handled by Vike
-                    isPointerImport ||
-                        // Import of config code => loaded by Node.js at build-time
-                        isNpmPkgImport);
                     pointerImports[importPathTranspiled] = isPointerImport;
                     return { external: true, path: importPathTranspiled };
                 });

package/dist/server/assertEnvServer.js

@@ -20,7 +20,7 @@ function onLoad() {
     addEcosystemStamp();
 }
 // Used by:
-// - Telefunc (to detect the user's stack https://github.com/brillout/telefunc/blob/8288310e88e06a42b710d39c39fb502364ca6d30/telefunc/utils/isVikeApp.ts#L4)
+// - Telefunc (to detect the user's stack https://github.com/telefunc/telefunc/blob/8288310e88e06a42b710d39c39fb502364ca6d30/telefunc/utils/isVikeApp.ts#L4)
 function addEcosystemStamp() {
     const g = globalThis;
     g._isVikeApp =

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,
+};