feat(blog): add file-based blog with dynamic slugs, MDX content and layout shell

- Introduced blog routing using Next.js App Router
- Implemented dynamic [slug] pages for blog posts
- Added MDX-based content loading via lib/posts
- Integrated shared TopBar layout with navigation
- Established clear content, lib and component separation

apps/public-web/node_modules/next/dist/esm/build/webpack-build/impl.js

@@ -0,0 +1,314 @@
+import { stringBufferUtils } from 'next/dist/compiled/webpack-sources3';
+import { red } from '../../lib/picocolors';
+import formatWebpackMessages from '../../shared/lib/format-webpack-messages';
+import { nonNullable } from '../../lib/non-nullable';
+import { COMPILER_NAMES, CLIENT_STATIC_FILES_RUNTIME_MAIN_APP, APP_CLIENT_INTERNALS, PHASE_PRODUCTION_BUILD } from '../../shared/lib/constants';
+import { runCompiler } from '../compiler';
+import * as Log from '../output/log';
+import getBaseWebpackConfig, { loadProjectInfo } from '../webpack-config';
+import { TelemetryPlugin } from '../webpack/plugins/telemetry-plugin/telemetry-plugin';
+import { NextBuildContext, resumePluginState, getPluginState } from '../build-context';
+import { createEntrypoints } from '../entries';
+import loadConfig from '../../server/config';
+import { getTraceEvents, initializeTraceState, setGlobal, trace } from '../../trace';
+import { WEBPACK_LAYERS } from '../../lib/constants';
+import { TraceEntryPointsPlugin } from '../webpack/plugins/next-trace-entrypoints-plugin';
+import origDebug from 'next/dist/compiled/debug';
+import { Telemetry } from '../../telemetry/storage';
+import { durationToString, hrtimeToSeconds } from '../duration-to-string';
+import { installBindings } from '../swc/install-bindings';
+const debug = origDebug('next:build:webpack-build');
+function isTelemetryPlugin(plugin) {
+    return plugin instanceof TelemetryPlugin;
+}
+function isTraceEntryPointsPlugin(plugin) {
+    return plugin instanceof TraceEntryPointsPlugin;
+}
+export async function webpackBuildImpl(compilerName) {
+    var _clientConfig_plugins, _serverConfig_plugins;
+    let result = {
+        warnings: [],
+        errors: [],
+        stats: []
+    };
+    let webpackBuildStart;
+    const nextBuildSpan = NextBuildContext.nextBuildSpan;
+    const dir = NextBuildContext.dir;
+    const config = NextBuildContext.config;
+    process.env.NEXT_COMPILER_NAME = compilerName || 'server';
+    const runWebpackSpan = nextBuildSpan.traceChild('run-webpack-compiler');
+    const entrypoints = await nextBuildSpan.traceChild('create-entrypoints').traceAsyncFn(()=>createEntrypoints({
+            buildId: NextBuildContext.buildId,
+            config: config,
+            envFiles: NextBuildContext.loadedEnvFiles,
+            isDev: false,
+            rootDir: dir,
+            pageExtensions: config.pageExtensions,
+            pagesDir: NextBuildContext.pagesDir,
+            appDir: NextBuildContext.appDir,
+            pages: NextBuildContext.mappedPages,
+            appPaths: NextBuildContext.mappedAppPages,
+            previewMode: NextBuildContext.previewProps,
+            rootPaths: NextBuildContext.mappedRootPaths,
+            hasInstrumentationHook: NextBuildContext.hasInstrumentationHook
+        }));
+    const commonWebpackOptions = {
+        isServer: false,
+        isCompileMode: NextBuildContext.isCompileMode,
+        buildId: NextBuildContext.buildId,
+        encryptionKey: NextBuildContext.encryptionKey,
+        config: config,
+        appDir: NextBuildContext.appDir,
+        pagesDir: NextBuildContext.pagesDir,
+        rewrites: NextBuildContext.rewrites,
+        originalRewrites: NextBuildContext.originalRewrites,
+        originalRedirects: NextBuildContext.originalRedirects,
+        reactProductionProfiling: NextBuildContext.reactProductionProfiling,
+        noMangling: NextBuildContext.noMangling,
+        clientRouterFilters: NextBuildContext.clientRouterFilters,
+        previewProps: NextBuildContext.previewProps,
+        allowedRevalidateHeaderKeys: NextBuildContext.allowedRevalidateHeaderKeys,
+        fetchCacheKeyPrefix: NextBuildContext.fetchCacheKeyPrefix
+    };
+    const configs = await runWebpackSpan.traceChild('generate-webpack-config').traceAsyncFn(async ()=>{
+        const info = await loadProjectInfo({
+            dir,
+            config: commonWebpackOptions.config,
+            dev: false
+        });
+        return Promise.all([
+            getBaseWebpackConfig(dir, {
+                ...commonWebpackOptions,
+                middlewareMatchers: entrypoints.middlewareMatchers,
+                runWebpackSpan,
+                compilerType: COMPILER_NAMES.client,
+                entrypoints: entrypoints.client,
+                ...info
+            }),
+            getBaseWebpackConfig(dir, {
+                ...commonWebpackOptions,
+                runWebpackSpan,
+                middlewareMatchers: entrypoints.middlewareMatchers,
+                compilerType: COMPILER_NAMES.server,
+                entrypoints: entrypoints.server,
+                ...info
+            }),
+            getBaseWebpackConfig(dir, {
+                ...commonWebpackOptions,
+                runWebpackSpan,
+                middlewareMatchers: entrypoints.middlewareMatchers,
+                compilerType: COMPILER_NAMES.edgeServer,
+                entrypoints: entrypoints.edgeServer,
+                ...info
+            })
+        ]);
+    });
+    const clientConfig = configs[0];
+    const serverConfig = configs[1];
+    const edgeConfig = configs[2];
+    if (clientConfig.optimization && (clientConfig.optimization.minimize !== true || clientConfig.optimization.minimizer && clientConfig.optimization.minimizer.length === 0)) {
+        Log.warn(`Production code optimization has been disabled in your project. Read more: https://nextjs.org/docs/messages/minification-disabled`);
+    }
+    webpackBuildStart = process.hrtime();
+    debug(`starting compiler`, compilerName);
+    // We run client and server compilation separately to optimize for memory usage
+    await runWebpackSpan.traceAsyncFn(async ()=>{
+        var _inputFileSystem_purge;
+        if (config.experimental.webpackMemoryOptimizations) {
+            stringBufferUtils.disableDualStringBufferCaching();
+            stringBufferUtils.enterStringInterningRange();
+        }
+        // Run the server compilers first and then the client
+        // compiler to track the boundary of server/client components.
+        let clientResult = null;
+        // During the server compilations, entries of client components will be
+        // injected to this set and then will be consumed by the client compiler.
+        let serverResult = null;
+        let edgeServerResult = null;
+        let inputFileSystem;
+        if (!compilerName || compilerName === 'server') {
+            debug('starting server compiler');
+            const start = Date.now();
+            [serverResult, inputFileSystem] = await runCompiler(serverConfig, {
+                runWebpackSpan,
+                inputFileSystem
+            });
+            debug(`server compiler finished ${Date.now() - start}ms`);
+        }
+        if (!compilerName || compilerName === 'edge-server') {
+            debug('starting edge-server compiler');
+            const start = Date.now();
+            [edgeServerResult, inputFileSystem] = edgeConfig ? await runCompiler(edgeConfig, {
+                runWebpackSpan,
+                inputFileSystem
+            }) : [
+                null
+            ];
+            debug(`edge-server compiler finished ${Date.now() - start}ms`);
+        }
+        // Only continue if there were no errors
+        if (!(serverResult == null ? void 0 : serverResult.errors.length) && !(edgeServerResult == null ? void 0 : edgeServerResult.errors.length)) {
+            const pluginState = getPluginState();
+            for(const key in pluginState.injectedClientEntries){
+                const value = pluginState.injectedClientEntries[key];
+                const clientEntry = clientConfig.entry;
+                if (key === APP_CLIENT_INTERNALS) {
+                    clientEntry[CLIENT_STATIC_FILES_RUNTIME_MAIN_APP] = {
+                        import: [
+                            // TODO-APP: cast clientEntry[CLIENT_STATIC_FILES_RUNTIME_MAIN_APP] to type EntryDescription once it's available from webpack
+                            // @ts-expect-error clientEntry['main-app'] is type EntryDescription { import: ... }
+                            ...clientEntry[CLIENT_STATIC_FILES_RUNTIME_MAIN_APP].import,
+                            value
+                        ],
+                        layer: WEBPACK_LAYERS.appPagesBrowser
+                    };
+                } else {
+                    clientEntry[key] = {
+                        dependOn: [
+                            CLIENT_STATIC_FILES_RUNTIME_MAIN_APP
+                        ],
+                        import: value,
+                        layer: WEBPACK_LAYERS.appPagesBrowser
+                    };
+                }
+            }
+            if (!compilerName || compilerName === 'client') {
+                debug('starting client compiler');
+                const start = Date.now();
+                [clientResult, inputFileSystem] = await runCompiler(clientConfig, {
+                    runWebpackSpan,
+                    inputFileSystem
+                });
+                debug(`client compiler finished ${Date.now() - start}ms`);
+            }
+        }
+        if (config.experimental.webpackMemoryOptimizations) {
+            stringBufferUtils.exitStringInterningRange();
+        }
+        inputFileSystem == null ? void 0 : (_inputFileSystem_purge = inputFileSystem.purge) == null ? void 0 : _inputFileSystem_purge.call(inputFileSystem);
+        result = {
+            warnings: [
+                ...(clientResult == null ? void 0 : clientResult.warnings) ?? [],
+                ...(serverResult == null ? void 0 : serverResult.warnings) ?? [],
+                ...(edgeServerResult == null ? void 0 : edgeServerResult.warnings) ?? []
+            ].filter(nonNullable),
+            errors: [
+                ...(clientResult == null ? void 0 : clientResult.errors) ?? [],
+                ...(serverResult == null ? void 0 : serverResult.errors) ?? [],
+                ...(edgeServerResult == null ? void 0 : edgeServerResult.errors) ?? []
+            ].filter(nonNullable),
+            stats: [
+                clientResult == null ? void 0 : clientResult.stats,
+                serverResult == null ? void 0 : serverResult.stats,
+                edgeServerResult == null ? void 0 : edgeServerResult.stats
+            ]
+        };
+    });
+    result = nextBuildSpan.traceChild('format-webpack-messages').traceFn(()=>formatWebpackMessages(result, true));
+    const telemetryPlugin = (_clientConfig_plugins = clientConfig.plugins) == null ? void 0 : _clientConfig_plugins.find(isTelemetryPlugin);
+    const traceEntryPointsPlugin = (_serverConfig_plugins = serverConfig.plugins) == null ? void 0 : _serverConfig_plugins.find(isTraceEntryPointsPlugin);
+    const webpackBuildEnd = process.hrtime(webpackBuildStart);
+    if (result.errors.length > 0) {
+        // Only keep the first few errors. Others are often indicative
+        // of the same problem, but confuse the reader with noise.
+        if (result.errors.length > 5) {
+            result.errors.length = 5;
+        }
+        let error = result.errors.filter(Boolean).join('\n\n');
+        console.error(red('Failed to compile.\n'));
+        if (error.indexOf('private-next-pages') > -1 && error.indexOf('does not contain a default export') > -1) {
+            const page_name_regex = /'private-next-pages\/(?<page_name>[^']*)'/;
+            const parsed = page_name_regex.exec(error);
+            const page_name = parsed && parsed.groups && parsed.groups.page_name;
+            throw Object.defineProperty(new Error(`webpack build failed: found page without a React Component as default export in pages/${page_name}\n\nSee https://nextjs.org/docs/messages/page-without-valid-component for more info.`), "__NEXT_ERROR_CODE", {
+                value: "E164",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        console.error(error);
+        console.error();
+        if (error.indexOf('private-next-pages') > -1 || error.indexOf('__next_polyfill__') > -1) {
+            const err = Object.defineProperty(new Error('webpack config.resolve.alias was incorrectly overridden. https://nextjs.org/docs/messages/invalid-resolve-alias'), "__NEXT_ERROR_CODE", {
+                value: "E70",
+                enumerable: false,
+                configurable: true
+            });
+            err.code = 'INVALID_RESOLVE_ALIAS';
+            throw err;
+        }
+        const err = Object.defineProperty(new Error(`Build failed because of ${process.env.NEXT_RSPACK ? 'Rspack' : 'webpack'} errors`), "__NEXT_ERROR_CODE", {
+            value: "E661",
+            enumerable: false,
+            configurable: true
+        });
+        err.code = 'WEBPACK_ERRORS';
+        throw err;
+    } else {
+        const duration = hrtimeToSeconds(webpackBuildEnd);
+        const durationString = durationToString(duration);
+        if (result.warnings.length > 0) {
+            Log.warn(`Compiled with warnings in ${durationString}\n`);
+            console.warn(result.warnings.filter(Boolean).join('\n\n'));
+            console.warn();
+        } else if (!compilerName) {
+            Log.event(`Compiled successfully in ${durationString}`);
+        }
+        return {
+            duration,
+            buildTraceContext: traceEntryPointsPlugin == null ? void 0 : traceEntryPointsPlugin.buildTraceContext,
+            pluginState: getPluginState(),
+            telemetryState: {
+                usages: (telemetryPlugin == null ? void 0 : telemetryPlugin.usages()) || [],
+                packagesUsedInServerSideProps: (telemetryPlugin == null ? void 0 : telemetryPlugin.packagesUsedInServerSideProps()) || [],
+                useCacheTracker: (telemetryPlugin == null ? void 0 : telemetryPlugin.getUseCacheTracker()) || {}
+            }
+        };
+    }
+}
+// the main function when this file is run as a worker
+export async function workerMain(workerData) {
+    var _config_experimental;
+    // Clone the telemetry for worker
+    const telemetry = new Telemetry({
+        distDir: workerData.buildContext.config.distDir
+    });
+    setGlobal('telemetry', telemetry);
+    // setup new build context from the serialized data passed from the parent
+    Object.assign(NextBuildContext, workerData.buildContext);
+    // Initialize tracer state from the parent
+    initializeTraceState(workerData.traceState);
+    // Resume plugin state
+    resumePluginState(NextBuildContext.pluginState);
+    /// load the config because it's not serializable
+    const config = NextBuildContext.config = await loadConfig(PHASE_PRODUCTION_BUILD, NextBuildContext.dir, {
+        debugPrerender: NextBuildContext.debugPrerender,
+        reactProductionProfiling: NextBuildContext.reactProductionProfiling
+    });
+    await installBindings((_config_experimental = config.experimental) == null ? void 0 : _config_experimental.useWasmBinary);
+    NextBuildContext.nextBuildSpan = trace(`worker-main-${workerData.compilerName}`);
+    const result = await webpackBuildImpl(workerData.compilerName);
+    const { entriesTrace, chunksTrace } = result.buildTraceContext ?? {};
+    if (entriesTrace) {
+        const { entryNameMap, depModArray } = entriesTrace;
+        if (depModArray) {
+            result.buildTraceContext.entriesTrace.depModArray = depModArray;
+        }
+        if (entryNameMap) {
+            const entryEntries = entryNameMap;
+            result.buildTraceContext.entriesTrace.entryNameMap = entryEntries;
+        }
+    }
+    if (chunksTrace == null ? void 0 : chunksTrace.entryNameFilesMap) {
+        const entryNameFilesMap = chunksTrace.entryNameFilesMap;
+        result.buildTraceContext.chunksTrace.entryNameFilesMap = entryNameFilesMap;
+    }
+    NextBuildContext.nextBuildSpan.stop();
+    await telemetry.flush();
+    return {
+        ...result,
+        debugTraceEvents: getTraceEvents()
+    };
+}
+
+//# sourceMappingURL=impl.js.map

apps/public-web/node_modules/next/dist/esm/build/webpack-build/index.js

@@ -0,0 +1,123 @@
+import * as Log from '../output/log';
+import { NextBuildContext } from '../build-context';
+import { Worker } from '../../lib/worker';
+import origDebug from 'next/dist/compiled/debug';
+import path from 'path';
+import { exportTraceState, recordTraceEvents } from '../../trace';
+import { mergeUseCacheTrackers } from '../webpack/plugins/telemetry-plugin/use-cache-tracker-utils';
+import { durationToString } from '../duration-to-string';
+const debug = origDebug('next:build:webpack-build');
+const ORDERED_COMPILER_NAMES = [
+    'server',
+    'edge-server',
+    'client'
+];
+let pluginState = {};
+function deepMerge(target, source) {
+    const result = {
+        ...target,
+        ...source
+    };
+    for (const key of Object.keys(result)){
+        result[key] = Array.isArray(target[key]) ? target[key] = [
+            ...target[key],
+            ...source[key] || []
+        ] : typeof target[key] == 'object' && typeof source[key] == 'object' ? deepMerge(target[key], source[key]) : result[key];
+    }
+    return result;
+}
+async function webpackBuildWithWorker(compilerNamesArg) {
+    const compilerNames = compilerNamesArg || ORDERED_COMPILER_NAMES;
+    const { nextBuildSpan, ...prunedBuildContext } = NextBuildContext;
+    prunedBuildContext.pluginState = pluginState;
+    const combinedResult = {
+        duration: 0,
+        buildTraceContext: {}
+    };
+    for (const compilerName of compilerNames){
+        var _curResult_buildTraceContext;
+        const worker = new Worker(path.join(__dirname, 'impl.js'), {
+            exposedMethods: [
+                'workerMain'
+            ],
+            debuggerPortOffset: -1,
+            isolatedMemory: false,
+            numWorkers: 1,
+            maxRetries: 0,
+            forkOptions: {
+                env: {
+                    NEXT_PRIVATE_BUILD_WORKER: '1'
+                }
+            }
+        });
+        const curResult = await worker.workerMain({
+            buildContext: prunedBuildContext,
+            compilerName,
+            traceState: {
+                ...exportTraceState(),
+                defaultParentSpanId: nextBuildSpan == null ? void 0 : nextBuildSpan.getId(),
+                shouldSaveTraceEvents: true
+            }
+        });
+        if (nextBuildSpan && curResult.debugTraceEvents) {
+            recordTraceEvents(curResult.debugTraceEvents);
+        }
+        // destroy worker so it's not sticking around using memory
+        await worker.end();
+        // Update plugin state
+        pluginState = deepMerge(pluginState, curResult.pluginState);
+        prunedBuildContext.pluginState = pluginState;
+        if (curResult.telemetryState) {
+            var _NextBuildContext_telemetryState;
+            NextBuildContext.telemetryState = {
+                ...curResult.telemetryState,
+                useCacheTracker: mergeUseCacheTrackers((_NextBuildContext_telemetryState = NextBuildContext.telemetryState) == null ? void 0 : _NextBuildContext_telemetryState.useCacheTracker, curResult.telemetryState.useCacheTracker)
+            };
+        }
+        combinedResult.duration += curResult.duration;
+        if ((_curResult_buildTraceContext = curResult.buildTraceContext) == null ? void 0 : _curResult_buildTraceContext.entriesTrace) {
+            var _curResult_buildTraceContext1;
+            const { entryNameMap } = curResult.buildTraceContext.entriesTrace;
+            if (entryNameMap) {
+                combinedResult.buildTraceContext.entriesTrace = curResult.buildTraceContext.entriesTrace;
+                combinedResult.buildTraceContext.entriesTrace.entryNameMap = entryNameMap;
+            }
+            if ((_curResult_buildTraceContext1 = curResult.buildTraceContext) == null ? void 0 : _curResult_buildTraceContext1.chunksTrace) {
+                const { entryNameFilesMap } = curResult.buildTraceContext.chunksTrace;
+                if (entryNameFilesMap) {
+                    combinedResult.buildTraceContext.chunksTrace = curResult.buildTraceContext.chunksTrace;
+                    combinedResult.buildTraceContext.chunksTrace.entryNameFilesMap = entryNameFilesMap;
+                }
+            }
+        }
+    }
+    if (compilerNames.length === 3) {
+        const durationString = durationToString(combinedResult.duration);
+        Log.event(`Compiled successfully in ${durationString}`);
+    }
+    return combinedResult;
+}
+export async function webpackBuild(withWorker, compilerNames) {
+    const nextBuildSpan = NextBuildContext.nextBuildSpan;
+    return nextBuildSpan.traceChild('run-webpack').traceAsyncFn(async ()=>{
+        if (withWorker) {
+            debug('using separate compiler workers');
+            return await webpackBuildWithWorker(compilerNames);
+        } else {
+            debug('building all compilers in same process');
+            const webpackBuildImpl = require('./impl').webpackBuildImpl;
+            const curResult = await webpackBuildImpl(null);
+            // Mirror what happens in webpackBuildWithWorker
+            if (curResult.telemetryState) {
+                var _NextBuildContext_telemetryState;
+                NextBuildContext.telemetryState = {
+                    ...curResult.telemetryState,
+                    useCacheTracker: mergeUseCacheTrackers((_NextBuildContext_telemetryState = NextBuildContext.telemetryState) == null ? void 0 : _NextBuildContext_telemetryState.useCacheTracker, curResult.telemetryState.useCacheTracker)
+                };
+            }
+            return curResult;
+        }
+    });
+}
+
+//# sourceMappingURL=index.js.map