vike 0.4.249 → 0.4.250-commit-193dea3

package/dist/client/runtime-server-routing/createPageContextClientSide.d.ts

@@ -1,4 +1,5 @@
 export { createPageContextClientSide };
+export type PageContextCreatedClient_ServerRouting = Awaited<ReturnType<typeof createPageContextClientSide>>;
 declare function createPageContextClientSide(): Promise<{
     _isOriginalObject: true;
     isPageContext: true;
@@ -59,9 +60,4 @@ declare function createPageContextClientSide(): Promise<{
     isBackwardNavigation: null;
     isHistoryNavigation: null;
     _hasPageContextFromServer: true;
-} & {
-    pageId: string;
-    routeParams: Record<string, string>;
-} & import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").GlobalConfigPublic & import("../../shared-server-client/getPageFiles.js").PageContextConfig & {
-    _pageFilesLoaded: import("../../shared-server-client/getPageFiles.js").PageFile[];
-}>;
+} & import("../../shared-server-client/page-configs/resolveVikeConfigPublic.js").GlobalConfigPublic>;

package/dist/client/runtime-server-routing/createPageContextClientSide.js

@@ -1,13 +1,7 @@
 export { createPageContextClientSide };
-import { assertUsage, updateType, objectAssign } from './utils.js';
-import { getPageContextSerializedInHtml } from '../shared/getJsonSerializedInHtml.js';
-import { loadPageConfigsLazyClientSide, } from '../shared/loadPageConfigsLazyClientSide.js';
-import { getCurrentUrl } from '../shared/getCurrentUrl.js';
+import { updateType, objectAssign } from './utils.js';
 import { createPageContextObject, createPageContextShared } from '../../shared-server-client/createPageContextShared.js';
 import { getGlobalContextClientInternal } from './getGlobalContextClientInternal.js';
-import { preparePageContextForPublicUsageClient, } from './preparePageContextForPublicUsageClient.js';
-import { execHook } from '../../shared-server-client/hooks/execHook.js';
-const urlFirst = getCurrentUrl({ withoutHash: true });
 async function createPageContextClientSide() {
     const globalContext = await getGlobalContextClientInternal();
     const pageContextCreated = createPageContextObject();
@@ -21,21 +15,7 @@ async function createPageContextClientSide() {
         isHistoryNavigation: null,
         _hasPageContextFromServer: true,
     });
-    objectAssign(pageContextCreated, getPageContextSerializedInHtml());
     // Sets pageContext.config to global configs
     updateType(pageContextCreated, createPageContextShared(pageContextCreated, globalContext._globalConfigPublic));
-    // Sets pageContext.config to local configs (overrides the pageContext.config set above)
-    updateType(pageContextCreated, await loadPageConfigsLazyClientSideAndExecHook(pageContextCreated));
-    assertPristineUrl();
     return pageContextCreated;
 }
-function assertPristineUrl() {
-    const urlCurrent = getCurrentUrl({ withoutHash: true });
-    assertUsage(urlFirst === urlCurrent, `The URL was manipulated before the hydration finished ('${urlFirst}' to '${urlCurrent}'). Ensure the hydration has finished before manipulating the URL. Consider using the onHydrationEnd() hook.`);
-}
-async function loadPageConfigsLazyClientSideAndExecHook(pageContext) {
-    const pageContextAddendum = await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal);
-    objectAssign(pageContext, pageContextAddendum);
-    await execHook('onCreatePageContext', pageContext, preparePageContextForPublicUsageClient);
-    return pageContext;
-}

package/dist/client/runtime-server-routing/entry.js

@@ -2,13 +2,17 @@ import { assertServerRouting } from '../../utils/assertRoutingType.js';
 assertServerRouting();
 import { createPageContextClientSide } from './createPageContextClientSide.js';
 import { execHookOnRenderClient } from '../shared/execHookOnRenderClient.js';
-import { assertSingleInstance_onClientEntryServerRouting } from './utils.js';
+import { assertSingleInstance_onClientEntryServerRouting, assertUsage, objectAssign } from './utils.js';
 import { removeFoucBuster } from '../shared/removeFoucBuster.js';
 import { execHook } from '../../shared-server-client/hooks/execHook.js';
 import { preparePageContextForPublicUsageClient } from './preparePageContextForPublicUsageClient.js';
 import { setVirtualFileExportsGlobalEntry } from '../shared/getGlobalContextClientInternalShared.js';
 // @ts-expect-error
 import * as virtualFileExportsGlobalEntry from 'virtual:vike:global-entry:client:server-routing';
+import { loadPageConfigsLazyClientSide } from '../shared/loadPageConfigsLazyClientSide.js';
+import { getPageContextSerializedInHtml } from '../shared/getJsonSerializedInHtml.js';
+import { getCurrentUrl } from '../shared/getCurrentUrl.js';
+const urlFirst = getCurrentUrl({ withoutHash: true });
 assertSingleInstance_onClientEntryServerRouting(import.meta.env.PROD);
 setVirtualFileExportsGlobalEntry(virtualFileExportsGlobalEntry);
 if (import.meta.env.DEV)
@@ -16,6 +20,16 @@ if (import.meta.env.DEV)
 hydrate();
 async function hydrate() {
     const pageContext = await createPageContextClientSide();
+    objectAssign(pageContext, getPageContextSerializedInHtml());
+    // Sets pageContext.config using local configs — overrides the pageContext.config set using global configs at createPageContextClientSide()
+    const pageContextAddendum = await loadPageConfigsLazyClientSide(pageContext.pageId, pageContext._pageFilesAll, pageContext._globalContext._pageConfigs, pageContext._globalContext._pageConfigGlobal);
+    objectAssign(pageContext, pageContextAddendum);
+    await execHook('onCreatePageContext', pageContext, preparePageContextForPublicUsageClient);
+    assertPristineUrl();
     await execHookOnRenderClient(pageContext, preparePageContextForPublicUsageClient);
     await execHook('onHydrationEnd', pageContext, preparePageContextForPublicUsageClient);
 }
+function assertPristineUrl() {
+    const urlCurrent = getCurrentUrl({ withoutHash: true });
+    assertUsage(urlFirst === urlCurrent, `The URL was manipulated before the hydration finished ('${urlFirst}' to '${urlCurrent}'). Ensure the hydration has finished before manipulating the URL. Consider using the onHydrationEnd() hook.`);
+}

package/dist/client/shared/execHookOnRenderClient.d.ts

@@ -3,11 +3,14 @@ export type { PageContextBeforeRenderClient };
 import type { PageFile, PageContextConfig } from '../../shared-server-client/getPageFiles.js';
 import type { PageContextForPublicUsageClientShared } from './preparePageContextForPublicUsageClientShared.js';
 import type { GlobalContextClientInternalShared } from './getGlobalContextClientInternalShared.js';
+import type { PageContextCreatedClient } from '../runtime-client-routing/createPageContextClientSide.js';
+import type { PageContextCreatedClient_ServerRouting } from '../runtime-server-routing/createPageContextClientSide.js';
+type PageContextCreatedClientShared = PageContextCreatedClient | PageContextCreatedClient_ServerRouting;
 type PageContextBeforeRenderClient = {
     _pageFilesLoaded: PageFile[];
     urlOriginal?: string;
     urlPathname?: string;
     pageId: string;
     _globalContext: GlobalContextClientInternalShared;
-} & PageContextConfig & PageContextForPublicUsageClientShared;
+} & PageContextCreatedClientShared & PageContextConfig & PageContextForPublicUsageClientShared;
 declare function execHookOnRenderClient<PageContext extends PageContextBeforeRenderClient>(pageContext: PageContext, prepareForPublicUsage: (pageConfig: PageContext) => PageContext): Promise<void>;

package/dist/node/vite/index.js

@@ -22,6 +22,7 @@ import { pluginWorkaroundCssModuleHmr } from './plugins/pluginWorkaroundCssModul
 import { pluginWorkaroundVite6HmrRegression } from './plugins/pluginWorkaroundVite6HmrRegression.js';
 import { pluginReplaceConstantsPageContext } from './plugins/pluginReplaceConstantsPageContext.js';
 import { pluginReplaceConstantsGlobalThis } from './plugins/pluginReplaceConstantsGlobalThis.js';
+import { pluginStaticReplace } from './plugins/pluginStaticReplace.js';
 import { pluginViteRPC } from './plugins/non-runnable-dev/pluginViteRPC.js';
 import { pluginBuildApp } from './plugins/build/pluginBuildApp.js';
 import { pluginDistPackageJsonFile } from './plugins/build/pluginDistPackageJsonFile.js';
@@ -33,7 +34,7 @@ import { pluginModuleBanner } from './plugins/build/pluginModuleBanner.js';
 import { pluginReplaceConstantsNonRunnableDev } from './plugins/non-runnable-dev/pluginReplaceConstantsNonRunnableDev.js';
 import { isVikeCliOrApi } from '../../shared-server-node/api-context.js';
 import { pluginViteConfigVikeExtensions } from './plugins/pluginViteConfigVikeExtensions.js';
-import { isOnlyResolvingUserConfig } from '../api/resolveViteConfigFromUser.js';
+import { getVikeConfigInternalEarly, isOnlyResolvingUserConfig } from '../api/resolveViteConfigFromUser.js';
 // We don't call this in ./onLoad.ts to avoid a cyclic dependency with utils.ts
 setGetClientEntrySrcDev(getClientEntrySrcDev);
 assertIsNotProductionRuntime();
@@ -42,6 +43,7 @@ function plugin(vikeVitePluginOptions = {}) {
     const promise = (async () => {
         if (skip())
             return [];
+        const vikeConfig = await getVikeConfigInternalEarly();
         const plugins = [
             ...pluginCommon(vikeVitePluginOptions),
             ...pluginVirtualFiles(),
@@ -58,8 +60,9 @@ function plugin(vikeVitePluginOptions = {}) {
             ...pluginWorkaroundVite6HmrRegression(),
             ...pluginReplaceConstantsPageContext(),
             ...pluginReplaceConstantsGlobalThis(),
+            ...pluginStaticReplace(vikeConfig),
             ...pluginNonRunnabeDev(),
-            ...(await pluginViteConfigVikeExtensions()),
+            ...(await pluginViteConfigVikeExtensions(vikeConfig)),
         ];
         return plugins;
     })();

package/dist/node/vite/plugins/non-runnable-dev/pluginReplaceConstantsNonRunnableDev.js

@@ -1,22 +1,50 @@
 export { pluginReplaceConstantsNonRunnableDev };
-import { isRunnableDevEnvironment, isDevCheck } from '../../utils.js';
+// We cannot use [`define`](https://vite.dev/config/shared-options.html#define) because we don't have access to `this.environment` and therefore we cannot call `isRunnableDevEnvironment(this.environment)` inside a configEnvironment() hook.
+import { isRunnableDevEnvironment, isDevCheck, assert } from '../../utils.js';
 import { getMagicString } from '../../shared/getMagicString.js';
-// - We cannot use [`define`](https://vite.dev/config/shared-options.html#define) because we don't have access to `this.environment` and therefore we cannot call `isRunnableDevEnvironment(this.environment)` inside a configEnvironment() hook.
-// - We cannot use [`filter.id`](https://rolldown.rs/plugins/hook-filters) because Vite's optimizeDeps bundles packages (e.g. `vike` or `telefunc`) into node_modules/.vite/deps_ssr/chunk-WBC5FHD7.js
 const IS_NON_RUNNABLE_DEV = 'globalThis.__VIKE__IS_NON_RUNNABLE_DEV';
 const DYNAMIC_IMPORT = '__VIKE__DYNAMIC_IMPORT';
+// === Rolldown filter
+const filterRolldown1 = {
+    code: {
+        include: IS_NON_RUNNABLE_DEV,
+    },
+};
+const filterFunction1 = (code) => {
+    return code.includes(IS_NON_RUNNABLE_DEV);
+};
+const filterRolldown2 = {
+    code: {
+        include: DYNAMIC_IMPORT,
+    },
+};
+const filterFunction2 = (code) => {
+    return code.includes(DYNAMIC_IMPORT);
+};
+// We cannot use [`filter.id`](https://rolldown.rs/plugins/hook-filters) because Vite's optimizeDeps bundles packages (e.g. `vike` or `telefunc`) into node_modules/.vite/deps_ssr/chunk-WBC5FHD7.js
+//
+// Therefore, we cannot do this:
+// ```js
+// const distFileIsNonRunnableDev = requireResolveDistFile('dist/utils/isNonRunnableDevProcess.js')
+// const distFileGlobalContext = requireResolveDistFile('dist/server/runtime/globalContext.js')
+// const filterRolldown = {
+//   id: {
+//     include: [distFileIsNonRunnableDev, distFileGlobalContext].map(
+//       (filePath) => new RegExp(`^${escapeRegex(filePath)}($|${escapeRegex('?')}.*)`),
+//     ),
+//   },
+// }
+// ```
+// ===
 function pluginReplaceConstantsNonRunnableDev() {
     return [
         {
             name: 'vike:pluginReplaceConstantsNonRunnableDev:IS_NON_RUNNABLE_DEV',
             apply: (_, configEnv) => isDevCheck(configEnv),
             transform: {
-                filter: {
-                    code: {
-                        include: IS_NON_RUNNABLE_DEV,
-                    },
-                },
+                filter: filterRolldown1,
                 handler(code, id) {
+                    assert(filterFunction1(code));
                     if (isRunnableDevEnvironment(this.environment))
                         return;
                     const { magicString, getMagicStringResult } = getMagicString(code, id);
@@ -29,12 +57,9 @@ function pluginReplaceConstantsNonRunnableDev() {
             name: 'vike:pluginReplaceConstantsNonRunnableDev:DYNAMIC_IMPORT',
             apply: (_, configEnv) => isDevCheck(configEnv),
             transform: {
-                filter: {
-                    code: {
-                        include: DYNAMIC_IMPORT,
-                    },
-                },
+                filter: filterRolldown2,
                 handler(code, id) {
+                    assert(filterFunction2(code));
                     if (isRunnableDevEnvironment(this.environment))
                         return;
                     const { magicString, getMagicStringResult } = getMagicString(code, id);

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

@@ -1,5 +1,5 @@
 export { pluginAssertFileEnv };
-import { assert, assertUsage, assertWarning, capitalizeFirstLetter, isFilePathAbsolute, joinEnglish, rollupSourceMapRemove, } from '../utils.js';
+import { applyDev, assert, assertUsage, assertWarning, capitalizeFirstLetter, isFilePathAbsolute, joinEnglish, rollupSourceMapRemove, } from '../utils.js';
 import { extractAssetsRE } from './pluginExtractAssets.js';
 import { extractExportNamesRE } from './pluginExtractExportNames.js';
 import pc from '@brillout/picocolors';
@@ -10,6 +10,7 @@ import { isV1Design } from '../shared/resolveVikeConfigInternal.js';
 import { isViteServerSide, isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
 import { suffixesAssertFileEnv } from '../../../shared-server-node/getFileSuffixes.js';
 const envS = suffixesAssertFileEnv;
+// === Rolldown filter
 const skipNodeModules = '/node_modules/'; // Only assert `.server.js`, `.client.js` and `.ssr.js` for user files
 const filterRolldown = {
     id: {
@@ -22,18 +23,19 @@ const filterFunction = (id) => {
         return false;
     return envS.some((suffix) => id.includes(getSuffix(suffix)));
 };
+// ===
 function pluginAssertFileEnv() {
     let config;
     let viteDevServer;
     return [
         {
-            name: 'vike:pluginAssertFileEnv',
+            name: 'vike:pluginAssertFileEnv:dev',
+            // In build, we use generateBundle() instead of the load() hook. Using load() works for dynamic imports in dev thanks to Vite's lazy transpiling, but it doesn't work in build because Rollup transpiles any dynamically imported module even if it's never actually imported.
+            apply: applyDev,
             load: {
                 filter: filterRolldown,
                 handler(id, options) {
-                    // In build, we use generateBundle() instead of the load() hook. Using load() works for dynamic imports in dev thanks to Vite's lazy transpiling, but it doesn't work in build because Rollup transpiles any dynamically imported module even if it's never actually imported.
-                    if (!viteDevServer)
-                        return;
+                    assert(viteDevServer);
                     if (!isV1Design())
                         return;
                     if (skip(id, config.root))
@@ -53,14 +55,26 @@ function pluginAssertFileEnv() {
                     true);
                 },
             },
+            configureServer: {
+                handler(viteDevServer_) {
+                    viteDevServer = viteDevServer_;
+                },
+            },
+            configResolved: {
+                handler(config_) {
+                    config = config_;
+                },
+            },
+        },
+        {
+            name: 'vike:pluginAssertFileEnv:build',
+            // In dev, only using load() is enough as it also works for dynamic imports (see sibling comment).
+            apply: 'build',
             // In production, we have to use transform() to replace modules with a runtime error because generateBundle() doesn't work for dynamic imports. In production, dynamic imports can only be verified at runtime.
             transform: {
                 filter: filterRolldown,
                 async handler(code, id, options) {
                     id = normalizeId(id);
-                    // In dev, only using load() is enough as it also works for dynamic imports (see sibling comment).
-                    if (viteDevServer)
-                        return;
                     if (skip(id, config.root))
                         return;
                     const isServerSide = isViteServerSide_extraSafe(config, this.environment, options);
@@ -101,11 +115,6 @@ function pluginAssertFileEnv() {
                     config = config_;
                 },
             },
-            configureServer: {
-                handler(viteDevServer_) {
-                    viteDevServer = viteDevServer_;
-                },
-            },
         },
     ];
     function assertFileEnv(moduleId, isServerSide, importers, onlyWarn) {

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

@@ -23,12 +23,14 @@ const rawRE = /(\?|&)raw(?:&|$)/;
 const urlRE = /(\?|&)url(?:&|$)/;
 const EMPTY_MODULE_ID = 'virtual:vike:empty-module';
 const debug = createDebug('vike:pluginExtractAssets');
+// === Rolldown filter
 const filterRolldown = {
     id: {
         include: extractAssetsRE,
     },
 };
 const filterFunction = (id) => extractAssetsRE.test(id);
+// ===
 function pluginExtractAssets() {
     let config;
     let vikeConfig;

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

@@ -8,12 +8,14 @@ import { isViteServerSide_extraSafe } from '../shared/isViteServerSide.js';
 const extractExportNamesRE = /(\?|&)extractExportNames(?:&|$)/;
 const debug = createDebug('vike:pluginExtractExportNames');
 const globalObject = getGlobalObject('plugins/pluginExtractExportNames.ts', {});
+// === Rolldown filter
 const filterRolldown = {
     id: {
         include: extractExportNamesRE,
     },
 };
 const filterFunction = (id) => extractExportNamesRE.test(id);
+// ===
 function pluginExtractExportNames() {
     let isDev = false;
     let config;

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

@@ -14,6 +14,7 @@ const PUBLIC_ENV_ALLOWLIST = [
 // - Make import.meta.env work inside +config.js
 //   - For it to work, we'll probably need the user to define the settings (e.g. `envDir`) for loadEnv() inside vike.config.js instead of vite.config.js
 //   - Or stop using Vite's `mode` implementation and have Vike implement its own `mode` feature? (So that the only dependencies are `$ vike build --mode staging` and `$ MODE=staging vike build`.)
+// === Rolldown filter
 const skipNodeModules = '/node_modules/';
 const skipIrrelevant = 'import.meta.env.';
 const filterRolldown = {
@@ -31,6 +32,7 @@ const filterFunction = (id, code) => {
         return false;
     return true;
 };
+// ===
 function pluginReplaceConstantsEnvVars() {
     let envVarsAll;
     let envPrefix;

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

@@ -2,16 +2,18 @@ export { pluginReplaceConstantsGlobalThis };
 export { VIRTUAL_FILE_ID_constantsGlobalThis };
 import { assert, isDebug, addVirtualFileIdPrefix, escapeRegex } from '../utils.js';
 import { isViteServerSide_applyToEnvironment, isViteServerSide_configEnvironment, isViteServerSide_extraSafe, } from '../shared/isViteServerSide.js';
+const VIRTUAL_FILE_ID_constantsGlobalThis = 'virtual:vike:server:constantsGlobalThis';
 const isDebugVal = isDebug();
 globalThis.__VIKE__IS_CLIENT = false;
 globalThis.__VIKE__IS_DEBUG = isDebugVal;
-const VIRTUAL_FILE_ID_constantsGlobalThis = 'virtual:vike:server:constantsGlobalThis';
+// === Rolldown filter
 const filterRolldown = {
     id: {
         include: new RegExp(escapeRegex(VIRTUAL_FILE_ID_constantsGlobalThis)),
     },
 };
 const filterFunction = (id) => id === VIRTUAL_FILE_ID_constantsGlobalThis || id === addVirtualFileIdPrefix(VIRTUAL_FILE_ID_constantsGlobalThis);
+// ===
 function pluginReplaceConstantsGlobalThis() {
     let config;
     let isDev;

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

@@ -11,6 +11,7 @@ const constantsIsClientSide = [
 ];
 // - See https://vike.dev/pageContext#narrowing-down
 // - We cannot use [`define`](https://vite.dev/config/shared-options.html#define) because of https://github.com/rolldown/rolldown/issues/4300
+// === Rolldown filter
 const skipNodeModules = '/node_modules/';
 const skipIrrelevant = 'Context.isClientSide';
 assert(constantsIsClientSide.every((constant) => constant.endsWith(skipIrrelevant)));
@@ -29,6 +30,7 @@ const filterFunction = (id, code) => {
         return false;
     return true;
 };
+// ===
 function pluginReplaceConstantsPageContext() {
     let config;
     return [

package/dist/node/vite/plugins/pluginStaticReplace/applyStaticReplace.d.ts

@@ -0,0 +1,126 @@
+export { applyStaticReplace };
+export type { StaticReplace };
+/**
+ * Condition to match an argument value.
+ * - string starting with 'import:' matches an imported identifier
+ * - { prop, equals } matches a property value inside an object argument
+ * - { call, args } matches a call expression with specific arguments
+ * - { member, object, property } matches a member expression like $setup["ClientOnly"]
+ */
+type ArgCondition = string | {
+    prop: string;
+    equals: unknown;
+} | {
+    call: string;
+    args?: Record<number, ArgCondition>;
+} | {
+    member: true;
+    object: string;
+    property: string | ArgCondition;
+};
+/**
+ * Target for replace operation.
+ */
+type ReplaceTarget = {
+    with: unknown;
+} | {
+    arg: number;
+    prop: string;
+    with: unknown;
+} | {
+    arg: number;
+    with: unknown;
+} | {
+    argsFrom: number;
+    with: unknown;
+};
+/**
+ * Target for remove operation.
+ */
+type RemoveTarget = {
+    arg: number;
+    prop: string;
+} | {
+    arg: number;
+} | {
+    argsFrom: number;
+};
+/**
+ * Rule for static replacement/removal.
+ *
+ * @example
+ * // jsx/jsxs/jsxDEV: replace children prop with null
+ * {
+ *   env: 'server',
+ *   type: 'call',
+ *   match: {
+ *     function: ['jsx', 'jsxs', 'jsxDEV'],
+ *     args: { 0: 'import:vike-react/ClientOnly:ClientOnly' }
+ *   },
+ *   replace: { arg: 1, prop: 'children', with: null }
+ * }
+ *
+ * @example
+ * // createElement: remove all children (args from index 2)
+ * {
+ *   env: 'server',
+ *   type: 'call',
+ *   match: {
+ *     function: 'createElement',
+ *     args: { 0: 'import:vike-react/ClientOnly:ClientOnly' }
+ *   },
+ *   remove: { argsFrom: 2 }
+ * }
+ *
+ * @example
+ * // ssrRenderComponent: match nested call expression and remove default slot
+ * {
+ *   env: 'server',
+ *   type: 'call',
+ *   match: {
+ *     function: 'import:vue/server-renderer:ssrRenderComponent',
+ *     args: {
+ *       0: {
+ *         call: 'import:vue:unref',
+ *         args: { 0: 'import:vike-vue/ClientOnly:ClientOnly' }
+ *       }
+ *     }
+ *   },
+ *   remove: { arg: 2, prop: 'default' }
+ * }
+ */
+type StaticReplace = {
+    /** Environment filter: 'client' = client only, 'server' = everything except client */
+    env: 'server' | 'client';
+    /** Rolldown filter — MUST be narrowing as much as possible, otherwise you'll get significant performance degradation */
+    filter: string;
+    /** Type of transformation - currently only 'call' is supported, but can be extended in the future */
+    type: 'call';
+    /** Match criteria */
+    match: {
+        /**
+         * Function name(s) to match.
+         * - Plain string: matches function name directly (e.g., 'jsx')
+         * - Import string: 'import:importPath:exportName' (e.g., 'import:react/jsx-runtime:jsx')
+         */
+        function: string | string[];
+        /** Conditions on arguments: index -> condition */
+        args?: Record<number, ArgCondition>;
+    };
+    /** Replace target (optional) */
+    replace?: ReplaceTarget;
+    /** Remove target (optional) */
+    remove?: RemoveTarget;
+};
+declare function applyStaticReplace(code: string, staticReplaceList: StaticReplace[], id: string, env: 'server' | 'client'): Promise<{
+    code: string;
+    map: {
+        version: number;
+        sources: string[];
+        names: string[];
+        sourceRoot?: string | undefined;
+        sourcesContent?: string[] | undefined;
+        mappings: string;
+        file: string;
+    } | null | undefined;
+} | null | undefined>;