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/server/request/root-params.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getRootParam", {
+    enumerable: true,
+    get: function() {
+        return getRootParam;
+    }
+});
+const _invarianterror = require("../../shared/lib/invariant-error");
+const _dynamicrendering = require("../app-render/dynamic-rendering");
+const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
+const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
+const _dynamicrenderingutils = require("../dynamic-rendering-utils");
+const _reflectutils = require("../../shared/lib/utils/reflect-utils");
+const _actionasyncstorageexternal = require("../app-render/action-async-storage.external");
+function getRootParam(paramName) {
+    const apiName = `\`import('next/root-params').${paramName}()\``;
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    if (!workStore) {
+        throw Object.defineProperty(new _invarianterror.InvariantError(`Missing workStore in ${apiName}`), "__NEXT_ERROR_CODE", {
+            value: "E764",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (!workUnitStore) {
+        throw Object.defineProperty(new Error(`Route ${workStore.route} used ${apiName} outside of a Server Component. This is not allowed.`), "__NEXT_ERROR_CODE", {
+            value: "E774",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const actionStore = _actionasyncstorageexternal.actionAsyncStorage.getStore();
+    if (actionStore) {
+        if (actionStore.isAppRoute) {
+            // TODO(root-params): add support for route handlers
+            throw Object.defineProperty(new Error(`Route ${workStore.route} used ${apiName} inside a Route Handler. Support for this API in Route Handlers is planned for a future version of Next.js.`), "__NEXT_ERROR_CODE", {
+                value: "E765",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (actionStore.isAction && workUnitStore.phase === 'action') {
+            // Actions are not fundamentally tied to a route (even if they're always submitted from some page),
+            // so root params would be inconsistent if an action is called from multiple roots.
+            // Make sure we check if the phase is "action" - we should not error in the rerender
+            // after an action revalidates or updates cookies (which will still have `actionStore.isAction === true`)
+            throw Object.defineProperty(new Error(`${apiName} was used inside a Server Action. This is not supported. Functions from 'next/root-params' can only be called in the context of a route.`), "__NEXT_ERROR_CODE", {
+                value: "E766",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    }
+    switch(workUnitStore.type){
+        case 'unstable-cache':
+        case 'cache':
+            {
+                throw Object.defineProperty(new Error(`Route ${workStore.route} used ${apiName} inside \`"use cache"\` or \`unstable_cache\`. Support for this API inside cache scopes is planned for a future version of Next.js.`), "__NEXT_ERROR_CODE", {
+                    value: "E760",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        case 'prerender':
+        case 'prerender-client':
+        case 'prerender-ppr':
+        case 'prerender-legacy':
+            {
+                return createPrerenderRootParamPromise(paramName, workStore, workUnitStore, apiName);
+            }
+        case 'private-cache':
+        case 'prerender-runtime':
+        case 'request':
+            {
+                break;
+            }
+        default:
+            {
+                workUnitStore;
+            }
+    }
+    return Promise.resolve(workUnitStore.rootParams[paramName]);
+}
+function createPrerenderRootParamPromise(paramName, workStore, prerenderStore, apiName) {
+    switch(prerenderStore.type){
+        case 'prerender-client':
+            {
+                throw Object.defineProperty(new _invarianterror.InvariantError(`${apiName} must not be used within a client component. Next.js should be preventing ${apiName} from being included in client components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+                    value: "E693",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        case 'prerender':
+        case 'prerender-legacy':
+        case 'prerender-ppr':
+        default:
+    }
+    const underlyingParams = prerenderStore.rootParams;
+    switch(prerenderStore.type){
+        case 'prerender':
+            {
+                // We are in a cacheComponents prerender.
+                // The param is a fallback, so it should be treated as dynamic.
+                if (prerenderStore.fallbackRouteParams && prerenderStore.fallbackRouteParams.has(paramName)) {
+                    return (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, apiName);
+                }
+                break;
+            }
+        case 'prerender-ppr':
+            {
+                // We aren't in a cacheComponents prerender, but the param is a fallback,
+                // so we need to make an erroring params object which will postpone/error if you access it
+                if (prerenderStore.fallbackRouteParams && prerenderStore.fallbackRouteParams.has(paramName)) {
+                    return makeErroringRootParamPromise(paramName, workStore, prerenderStore, apiName);
+                }
+                break;
+            }
+        case 'prerender-legacy':
+            {
+                break;
+            }
+        default:
+            {
+                prerenderStore;
+            }
+    }
+    // If the param is not a fallback param, we just return the statically available value.
+    return Promise.resolve(underlyingParams[paramName]);
+}
+/** Deliberately async -- we want to create a rejected promise, not error synchronously. */ async function makeErroringRootParamPromise(paramName, workStore, prerenderStore, apiName) {
+    const expression = (0, _reflectutils.describeStringPropertyAccess)(apiName, paramName);
+    // In most dynamic APIs, we also throw if `dynamic = "error"`.
+    // However, root params are only dynamic when we're generating a fallback shell,
+    // and even with `dynamic = "error"` we still support generating dynamic fallback shells.
+    // TODO: remove this comment when cacheComponents is the default since there will be no `dynamic = "error"`
+    switch(prerenderStore.type){
+        case 'prerender-ppr':
+            {
+                return (0, _dynamicrendering.postponeWithTracking)(workStore.route, expression, prerenderStore.dynamicTracking);
+            }
+        case 'prerender-legacy':
+            {
+                return (0, _dynamicrendering.throwToInterruptStaticGeneration)(expression, workStore, prerenderStore);
+            }
+        default:
+            {
+                prerenderStore;
+            }
+    }
+}
+
+//# sourceMappingURL=root-params.js.map