vike 0.4.247-commit-903de25 → 0.4.247-commit-14351e3

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

@@ -0,0 +1,141 @@
+export { getOutDirs };
+export { resolveOutDir };
+import pc from '@brillout/picocolors';
+import { assert, assertPosixPath, assertUsage, createDebug, pathJoin, toPosixPath } from '../utils.js';
+import { isViteServerSide_viteEnvOptional } from './isViteServerSide.js';
+const debug = createDebug('vike:outDir');
+function getOutDirs(configGlobal, viteEnv) {
+    debug('getOutDirs()', new Error().stack);
+    const outDir = getOutDirFromResolvedConfig(configGlobal, viteEnv);
+    assertOutDirResolved(outDir, configGlobal, viteEnv);
+    const outDirs = getOutDirsAll(outDir, configGlobal.root);
+    assertNormalization(outDirs.outDirRoot);
+    assertNormalization(outDirs.outDirClient);
+    assertNormalization(outDirs.outDirServer);
+    return outDirs;
+}
+/** Appends `client/` or `server/` to `config.build.outDir` */
+function resolveOutDir(config, isServerSide) {
+    debug('resolveOutDir()');
+    const outDir = getOutDirFromViteUserConfig(config) || 'dist';
+    debug('outDir', outDir);
+    const { outDirClient, outDirServer } = getOutDirsAll(outDir);
+    if (isServerSide) {
+        debug('outDirServer', 'outDirServer');
+        return outDirServer;
+    }
+    else {
+        debug('outDirClient', 'outDirClient');
+        return outDirClient;
+    }
+}
+function determineOutDirs(outDirRoot) {
+    assertPosixPath(outDirRoot);
+    assert(isOutDirRoot(outDirRoot));
+    const outDirClient = pathJoin(outDirRoot, 'client');
+    const outDirServer = pathJoin(outDirRoot, 'server');
+    assertIsNotOutDirRoot(outDirClient);
+    assertIsNotOutDirRoot(outDirServer);
+    return { outDirClient, outDirServer };
+}
+function getOutDirsAll(outDir, root) {
+    let outDirRoot;
+    {
+        if (isOutDirRoot(outDir)) {
+            outDirRoot = outDir;
+        }
+        else {
+            assert(outDir.endsWith('/server') || outDir.endsWith('/client'));
+            assert('/client'.length === '/server'.length);
+            outDirRoot = outDir.slice(0, -1 * '/client'.length);
+        }
+    }
+    debug('outDirRoot', outDirRoot);
+    let outDirs;
+    if (root) {
+        outDirs = getOutDirsAllFromRootNormalized(outDirRoot, root);
+    }
+    else {
+        outDirs = getOutDirsAllFromRoot(outDirRoot);
+    }
+    debug('outDirs', outDirs);
+    return outDirs;
+}
+function getOutDirsAllFromRoot(outDirRoot) {
+    let { outDirClient, outDirServer } = determineOutDirs(outDirRoot);
+    return { outDirRoot, outDirClient, outDirServer };
+}
+function getOutDirsAllFromRootNormalized(outDirRoot, root) {
+    if (root && !outDirIsAbsolutePath(outDirRoot)) {
+        assertPosixPath(outDirRoot);
+        assertPosixPath(root);
+        outDirRoot = pathJoin(root, outDirRoot);
+    }
+    let { outDirClient, outDirServer } = determineOutDirs(outDirRoot);
+    outDirRoot = outDirRoot + '/';
+    outDirClient = outDirClient + '/';
+    outDirServer = outDirServer + '/';
+    assertNormalization(outDirRoot);
+    assertNormalization(outDirClient);
+    assertNormalization(outDirServer);
+    return { outDirRoot, outDirClient, outDirServer };
+}
+function assertNormalization(outDirAny) {
+    assertPosixPath(outDirAny);
+    assert(outDirIsAbsolutePath(outDirAny), outDirAny);
+    assert(outDirAny.endsWith('/'), outDirAny);
+    assert(!outDirAny.endsWith('//'), outDirAny);
+}
+function isOutDirRoot(outDirRot) {
+    const p = outDirRot.split('/').filter(Boolean);
+    const lastDir = p[p.length - 1];
+    return lastDir !== 'client' && lastDir !== 'server';
+}
+function assertIsNotOutDirRoot(outDir) {
+    assert(outDir.endsWith('/client') || outDir.endsWith('/server'));
+}
+/** Assert that `outDir` ends with the correct directory `/server` or `/client` */
+function assertOutDirResolved(outDir, configGlobal, viteEnv) {
+    assertPosixPath(outDir);
+    if (isOutDirRoot(outDir))
+        return;
+    assert(outDir.endsWith('/client') || outDir.endsWith('/server')); // we normalized outDir
+    assert('/client'.length === '/server'.length);
+    const outDirCorrected = outDir.slice(0, -1 * '/client'.length);
+    const wrongUsage = `You've set Vite's config.build.outDir to ${pc.cyan(outDir)} but you should set it to ${pc.cyan(outDirCorrected)} instead.`;
+    const isServerSide = isViteServerSide_viteEnvOptional(configGlobal, viteEnv);
+    if (isServerSide) {
+        assertUsage(outDir.endsWith('/server'), wrongUsage);
+    }
+    else {
+        assertUsage(outDir.endsWith('/client'), wrongUsage);
+    }
+}
+function getOutDirFromViteUserConfig(config) {
+    let outDir = config.build?.outDir;
+    if (outDir === undefined)
+        return undefined;
+    outDir = normalizeOutDir(outDir);
+    return outDir;
+}
+function getOutDirFromResolvedConfig(config, viteEnv) {
+    let outDir = viteEnv?.config.build?.outDir ?? config.build.outDir;
+    assert(outDir);
+    outDir = normalizeOutDir(outDir);
+    return outDir;
+}
+function normalizeOutDir(outDir) {
+    outDir = toPosixPath(outDir);
+    outDir = outDir.replace(/\/+$/, ''); // remove trailing slashes
+    return outDir;
+}
+function outDirIsAbsolutePath(outDir) {
+    // There doesn't seem to be a better alternative to determine whether `outDir` is an absolute path
+    //  - Very unlikely that `outDir`'s first dir matches the filesystem's first dir
+    //    - Although more likely to happen with Docker
+    return getFirstDir(outDir) === getFirstDir(process.cwd());
+}
+function getFirstDir(p) {
+    const firstDir = p.split(/\/|\\/).filter(Boolean)[0];
+    return firstDir;
+}

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

@@ -0,0 +1,79 @@
+export { isViteServerSide };
+export { isViteServerSide_viteEnvOptional };
+export { isViteServerSide_onlySsrEnv };
+export { isViteServerSide_extraSafe };
+export { isViteServerSide_applyToEnvironment };
+export { isViteServerSide_configEnvironment };
+import { assert, assertUsage, viteVersionMin } from '../utils.js';
+function isViteServerSide_impl(configGlobal, viteEnv) {
+    assert(!('consumer' in configGlobal)); // make sure configGlobal isn't viteEnv.config
+    const debug = {
+        viteEnvIsUndefined: !viteEnv,
+        viteEnvName: viteEnv?.name ?? null,
+        viteEnvConsumer: viteEnv?.config.consumer ?? null,
+        configEnvBuildSsr: viteEnv?.config.build?.ssr ?? null,
+        configGlobalBuildSsr: configGlobal.build?.ssr ?? null,
+    };
+    if (!viteEnv) {
+        const isServerSide = getBuildSsrValue(configGlobal.build?.ssr);
+        assert(typeof isServerSide === 'boolean', debug);
+        return isServerSide;
+    }
+    else {
+        const isServerSide1 = !viteEnv.config.consumer ? null : viteEnv.config.consumer !== 'client';
+        const isServerSide2 = getBuildSsrValue(viteEnv.config.build?.ssr);
+        const isServerSide3 = viteEnv.name === 'ssr' ? true : viteEnv.name === 'client' ? false : null;
+        const isServerSide = isServerSide1 ?? isServerSide2;
+        assert(isServerSide === isServerSide1 || isServerSide1 === null, debug);
+        assert(isServerSide === isServerSide2 || isServerSide2 === null, debug);
+        assert(isServerSide === isServerSide3 || isServerSide3 === null, debug);
+        assert(isServerSide !== null);
+        return isServerSide;
+    }
+}
+function getBuildSsrValue(buildSsr) {
+    if (buildSsr === undefined)
+        return null;
+    assert(typeof buildSsr === 'boolean' || typeof buildSsr === 'string');
+    return !!buildSsr;
+}
+function isViteServerSide(configGlobal, viteEnv) {
+    return isViteServerSide_impl(configGlobal, viteEnv);
+}
+function isViteServerSide_viteEnvOptional(configGlobal, viteEnv) {
+    return isViteServerSide_impl(configGlobal, viteEnv);
+}
+// Only `ssr` env: for example don't include `vercel_edge` nor `vercel_node`.
+function isViteServerSide_onlySsrEnv(configGlobal, viteEnv) {
+    return viteEnv.name ? viteEnv.name === 'ssr' : isViteServerSide(configGlobal, viteEnv);
+}
+// Vite is quite messy about setting config.build.ssr — for security purposes, we use an extra safe implementation with lots of assertions, which is needed for the .client.js and .server.js guarantee.
+function isViteServerSide_extraSafe(config, viteEnv, options) {
+    const isServerSide = isViteServerSide(config, viteEnv);
+    const debug = {
+        isServerSide,
+        configCommand: config.command,
+        configBuildSsr: getBuildSsrValue(config.build.ssr),
+        optionsIsUndefined: options === undefined,
+        optionsSsr: options?.ssr ?? null,
+    };
+    assert(options, debug);
+    /* TO-DO/eventually: use internal assert() instead of assertUsage() once we can use this.meta.viteVersion — see utils/assertViteVersion.ts
+    assert(typeof options.ssr === 'boolean', debug)
+    /*/
+    assertUsage(typeof options.ssr === 'boolean', `You're using an old Vite version — update Vite to ${viteVersionMin} or above.`);
+    //*/
+    assert(options.ssr === isServerSide, debug);
+    return isServerSide;
+}
+function isViteServerSide_applyToEnvironment(env) {
+    const { consumer } = env.config;
+    return isViteServerSide_consumer(consumer);
+}
+function isViteServerSide_configEnvironment(name, config) {
+    const consumer = config.consumer ?? (name === 'client' ? 'client' : 'server');
+    return isViteServerSide_consumer(consumer);
+}
+function isViteServerSide_consumer(consumer) {
+    return consumer !== 'client';
+}

package/dist/node/vite/shared/loggerDev.d.ts

@@ -0,0 +1,9 @@
+export { logVite };
+export { logConfigInfo };
+export { logErrorServerDev };
+export type { LogType };
+import { type PageContext_logRuntime } from '../../../server/runtime/loggerRuntime.js';
+type LogType = 'info' | 'warn' | 'error' | 'error-resolve';
+declare function logConfigInfo(msg: string, logType: LogType): void;
+declare function logVite(msg: string, logType: LogType, requestId: number | null, prependViteTag: boolean): void;
+declare function logErrorServerDev(err: unknown, pageContext: PageContext_logRuntime, errorComesFromVite?: boolean): void;

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

@@ -0,0 +1,190 @@
+// TO-DO/eventually:
+// - New hook onLog(): https://github.com/vikejs/vike/issues/1438
+// - Exact same logs between prod and dev, only difference is that some log objects have:
+//   - `isDevLog: true`
+//   - `willBeLogged: false` in production
+//   - `showTimestamp: true`
+// - Never clear screen (it's complex with little benefit)
+// - Only show a one-liner init log (instead of Vite's multi-line log)
+export { logVite };
+export { logConfigInfo };
+export { logErrorServerDev };
+import { isAbortError } from '../../../shared-server-client/route/abort.js';
+import { getViteConfig } from '../../../server/runtime/globalContext.js';
+import { assertPageContext_logRuntime, setLogRuntimeDev, } from '../../../server/runtime/loggerRuntime.js';
+import { addOnBeforeAssertErr, assert, assertIsNotProductionRuntime, formatHintLog, hasGreen, hasProp, hasRed, hasYellow, isDebugError, stripAnsi, } from '../utils.js';
+import { isErrorWithCodeSnippet, getPrettyErrorWithCodeSnippet } from './loggerDev/errorWithCodeSnippet.js';
+import { getConfigExecutionErrorIntroMsg, getConfigBuildErrorFormatted, } from './resolveVikeConfigInternal/transpileAndExecuteFile.js';
+import pc from '@brillout/picocolors';
+import { isUserHookError } from '../../../shared-server-client/hooks/execHook.js';
+import { getViteDevServer } from '../../../server/runtime/globalContext.js';
+import { logErrorServer } from '../../../server/runtime/logErrorServer.js';
+import { getBetterError } from '../../../utils/getBetterError.js';
+import { getHttpRequestId_withAsyncHook } from '../../../server/runtime/asyncHook.js';
+assertIsNotProductionRuntime();
+setLogRuntimeDev(logErrorServerDev, logRuntimeInfoDev);
+addOnBeforeAssertErr((err) => {
+    // We must directly apply vite.ssrFixStacktrace() to `assertWarning(..., { showStackTrace: true })` because warnings aren't caught by the try-catch of renderPageServer()
+    applyViteSourceMapToStackTrace(err);
+});
+function logRuntimeInfoDev(msg, pageContext, logType) {
+    assertPageContext_logRuntime(pageContext);
+    const tagSource = getTagSource(pageContext?._requestId);
+    logDev(msg, logType, tagSource, '[vike]');
+}
+function logConfigInfo(msg, logType) {
+    const tagSource = getTagSource() ?? 'config';
+    logDev(msg, logType, tagSource, '[vike]');
+}
+function logVite(msg, logType, requestId, prependViteTag) {
+    const tagSource = getTagSource(requestId);
+    logDev(msg, logType, tagSource, '[vite]', !prependViteTag);
+}
+function logErrorServerDev(err, pageContext, errorComesFromVite = false) {
+    assertPageContext_logRuntime(pageContext);
+    applyViteSourceMapToStackTrace(err);
+    // Skip `throw render()` / `throw redirect()`
+    if (isAbortError(err) && !isDebugError()) {
+        return;
+    }
+    const tagSource = getTagSource(pageContext?._requestId);
+    const logErr = (err) => {
+        logErrorServer(err, pageContext);
+    };
+    if (isErrorWithCodeSnippet(err)) {
+        // We handle transpile errors globally because wrapping viteDevServer.ssrLoadModule() wouldn't be enough: transpile errors can be thrown not only when calling viteDevServer.ssrLoadModule() but also later when loading user code with import() (since Vite lazy-transpiles import() calls)
+        const viteConfig = getViteConfig();
+        assert(viteConfig);
+        let message = getPrettyErrorWithCodeSnippet(err, viteConfig.root);
+        assert(stripAnsi(message).startsWith('Failed to transpile'));
+        message = prependTags(message, '[vite]', tagSource, 'error');
+        message = appendErrorDebugNote(message);
+        const errBetter = getBetterError(err, { message, hideStack: true });
+        logErr(errBetter);
+        return;
+    }
+    {
+        const errMsgFormatted = getConfigBuildErrorFormatted(err);
+        if (errMsgFormatted) {
+            assert(stripAnsi(errMsgFormatted).startsWith('Failed to transpile'));
+            let message = errMsgFormatted;
+            message = prependTags(message, '[vike]', tagSource, 'error');
+            const errBetter = getBetterError(err, { message, hideStack: true });
+            logErr(errBetter);
+            return;
+        }
+    }
+    {
+        const errIntro = getConfigExecutionErrorIntroMsg(err);
+        if (errIntro) {
+            assert(stripAnsi(errIntro).startsWith('Failed to execute'));
+            let message = getErrMsgWithIntro(err, errIntro);
+            message = prependTags(message, '[vike]', tagSource, 'error');
+            const errBetter = getBetterError(err, { message });
+            logErr(errBetter);
+            return;
+        }
+    }
+    {
+        const hook = isUserHookError(err);
+        if (hook) {
+            const { hookName, hookFilePath } = hook;
+            const errIntro = pc.red(`Following error was thrown by the ${hookName}() hook defined at ${hookFilePath}`);
+            let message = getErrMsgWithIntro(err, errIntro);
+            message = prependTags(message, '[vike]', tagSource, 'error');
+            const errBetter = getBetterError(err, { message });
+            logErr(errBetter);
+            return;
+        }
+    }
+    if (tagSource) {
+        const errIntro = pc.bold(pc.red(`[Error] ${errorComesFromVite ? 'Transpilation error' : 'An error was thrown'}:`));
+        let message = getErrMsgWithIntro(err, errIntro);
+        message = prependTags(message, '[vike]', tagSource, 'error');
+        const errBetter = getBetterError(err, { message });
+        logErr(errBetter);
+        return;
+    }
+    logErr(err);
+}
+function logDev(msg, logType, tagSource, tagTool, doNotPrependTags) {
+    if (!doNotPrependTags) {
+        msg = prependTags(msg, tagTool, tagSource, logType);
+    }
+    if (logType === 'info') {
+        console.log(msg);
+        return;
+    }
+    if (logType === 'warn') {
+        console.warn(msg);
+        return;
+    }
+    if (logType === 'error') {
+        console.error(msg);
+        return;
+    }
+    if (logType === 'error-resolve') {
+        // stderr because user will most likely want to know about error recovering
+        console.error(msg);
+        return;
+    }
+    assert(false);
+}
+// Note shown to user when Vike modifies errors in a risky fashion.
+function appendErrorDebugNote(errMsg) {
+    const errorDebugNote = pc.dim(formatHintLog("Error isn't helpful? See https://vike.dev/debug#verbose-errors"));
+    return errMsg + '\n' + errorDebugNote;
+}
+function getTagSource(requestId = null) {
+    const requestIdFromStore = getHttpRequestId_withAsyncHook();
+    if (requestIdFromStore !== null) {
+        if (requestId === null) {
+            requestId = requestIdFromStore;
+        }
+        else {
+            assert(requestId === requestIdFromStore);
+        }
+    }
+    if (requestId === null)
+        return null;
+    // const tagSource = requestId % 2 === 1 ? (`request-${requestId}` as const) : (`request(${requestId})` as const)
+    const tagSource = `request(${requestId})`;
+    return tagSource;
+}
+function applyViteSourceMapToStackTrace(thing) {
+    if (isDebugError())
+        return;
+    if (!hasProp(thing, 'stack'))
+        return;
+    const viteDevServer = getViteDevServer();
+    if (!viteDevServer)
+        return;
+    // Apply Vite's source maps
+    viteDevServer.ssrFixStacktrace(thing);
+}
+function prependTags(msg, tagTool, tagSource, logType) {
+    const color = (s) => {
+        if (logType === 'error' && !hasRed(msg))
+            return pc.bold(pc.red(s));
+        if (logType === 'error-resolve' && !hasGreen(msg))
+            return pc.bold(pc.green(s));
+        if (logType === 'warn' && !hasYellow(msg))
+            return pc.yellow(s);
+        if (tagTool === '[vite]')
+            return pc.bold(pc.cyan(s));
+        if (tagTool === '[vike]')
+            return pc.bold(pc.cyan(s));
+        assert(false);
+    };
+    let tag = color(tagTool);
+    if (tagSource) {
+        tag = tag + pc.dim(`[${tagSource}]`);
+    }
+    const timestamp = pc.dim(new Date().toLocaleTimeString());
+    const whitespace = /\s|\[/.test(stripAnsi(msg)[0]) ? '' : ' ';
+    return `${timestamp} ${tag}${whitespace}${msg}`;
+}
+function getErrMsgWithIntro(err, errIntro) {
+    const errMsg = String(err?.message || '');
+    return errIntro + '\n' + errMsg;
+}

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

@@ -0,0 +1,52 @@
+export { improveViteLogs };
+import { assert, isDebugError, removeEmptyLines, trimWithAnsi, trimWithAnsiTrailOnly } from '../utils.js';
+import { getHttpRequestId_withAsyncHook } from '../../../server/runtime/asyncHook.js';
+import { logErrorServerDev, logVite } from './loggerDev.js';
+import { removeSuperfluousViteLog } from './loggerVite/removeSuperfluousViteLog.js';
+function improveViteLogs(config) {
+    intercept('info', config);
+    intercept('warn', config);
+    intercept('error', config);
+}
+function intercept(loggerType, config) {
+    config.logger[loggerType] = (msg, options = {}) => {
+        assert(!isDebugError());
+        if (removeSuperfluousViteLog(msg))
+            return;
+        if (!!options.timestamp) {
+            msg = trimWithAnsi(msg);
+        }
+        else {
+            // No timestamp => no "[vite]" tag prepended => we don't trim the beginning of the message
+            msg = trimWithAnsiTrailOnly(msg);
+        }
+        msg = cleanFirstViteLog(msg);
+        if (options.error) {
+            // Vite does a poor job of handling errors.
+            //  - It doesn't format error code snippets.
+            //  - It only shows error.message which means that crucial information such as error.id isn't shown to the user.
+            logErrorServerDev(options.error, null, true);
+            // We swallow Vite's message: we didn't see it add any value so far.
+            //  - It can even be confusing, such as the following:
+            //    ```
+            //    Error when evaluating SSR module virtual:vike:page-entry:server:/pages/abort: failed to import "/pages/abort/+Page.mdx"
+            //    ```
+            assert(!isDebugError());
+            return;
+        }
+        const requestId = getHttpRequestId_withAsyncHook();
+        // Vite's default logger preprends the "[vite]" tag if and only if options.timestamp is true
+        const prependViteTag = options.timestamp || typeof requestId === 'number';
+        // If it's an actual error => options.error is set => it's handled with logErrorServerDev() above
+        logVite(msg, loggerType, requestId, prependViteTag);
+    };
+}
+function cleanFirstViteLog(msg) {
+    const isFirstVitLog = msg.includes('VITE') && msg.includes('ready');
+    if (isFirstVitLog) {
+        return removeEmptyLines(msg);
+    }
+    else {
+        return msg;
+    }
+}

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

@@ -0,0 +1,89 @@
+export { configDefinitionsBuiltIn };
+export type { ConfigDefinition };
+export type { ConfigDefinitions };
+export type { ConfigDefinitionsInternal };
+export type { ConfigDefinitionInternal };
+export type { ConfigEffect };
+import type { ConfigEnvInternal, ConfigEnv, DefinedAtFilePath } from '../../../../types/PageConfig.js';
+import type { Config, ConfigNameBuiltIn, ConfigNameGlobal } from '../../../../types/Config.js';
+import { type ConfigDefinedAt } from '../../../../shared-server-client/page-configs/getConfigDefinedAt.js';
+import type { PageConfigBuildTimeBeforeComputed } from '../resolveVikeConfigInternal.js';
+/** The meta definition of a config.
+ *
+ * https://vike.dev/meta
+ */
+type ConfigDefinition = ConfigDefinition_ | ConfigDefinitionDefinedByPeerDependency;
+type ConfigDefinition_ = {
+    /** In what environment(s) the config value is loaded.
+     *
+     * https://vike.dev/meta
+     */
+    env: ConfigEnv;
+    /** Disable config overriding and make config values cumulative instead.
+     *
+     * @default false
+     *
+     * https://vike.dev/meta
+     */
+    cumulative?: boolean;
+    /**
+     * Function called when the config value is defined.
+     *
+     * https://vike.dev/meta
+     */
+    effect?: ConfigEffect;
+    /**
+     * Always load the configuration value, and as soon as possible.
+     *
+     * @default false
+     *
+     * https://vike.dev/meta
+     */
+    eager?: boolean;
+    /**
+     * Whether the configuration always applies to all pages (no config inheritance).
+     *
+     * @default false
+     *
+     * https://vike.dev/extends#inheritance
+     */
+    global?: boolean | ((value: unknown, moreInfo: {
+        isGlobalLocation: boolean;
+    }) => boolean);
+};
+type ConfigDefinitionDefinedByPeerDependency = {
+    /**
+     * Omit the "unknown config" error without defining the config — useful for optional peer dependencies: for example, vike-server sets +stream.require which is defined by vike-{react,vue,solid} but some users don't use vike-{react,vue,solid}
+     */
+    isDefinedByPeerDependency: true;
+};
+/**
+ * Function called when the config value is defined.
+ *
+ * https://vike.dev/meta
+ */
+type ConfigEffect = (config: {
+    /** The config value.
+     *
+     * https://vike.dev/meta
+     */
+    configValue: unknown;
+    /** Where the config value is defined.
+     *
+     * https://vike.dev/meta
+     */
+    configDefinedAt: ConfigDefinedAt;
+}) => Config | undefined;
+/** For Vike internal use */
+type ConfigDefinitionInternal = Omit<ConfigDefinition_, 'env'> & {
+    _computed?: (pageConfig: PageConfigBuildTimeBeforeComputed) => unknown;
+    _valueIsFilePath?: true;
+    _userEffectDefinedAtFilePath?: DefinedAtFilePath;
+    env: ConfigEnvInternal;
+};
+type ConfigDefinitions = Record<string, // configName
+ConfigDefinition>;
+type ConfigDefinitionsInternal = Record<string, // configName
+ConfigDefinitionInternal>;
+type ConfigDefinitionsBuiltIn = Record<ConfigNameBuiltIn | ConfigNameGlobal, ConfigDefinitionInternal>;
+declare const configDefinitionsBuiltIn: ConfigDefinitionsBuiltIn;