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

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "headers", {
+    enumerable: true,
+    get: function() {
+        return headers;
+    }
+});
+const _headers = require("../web/spec-extension/adapters/headers");
+const _workasyncstorageexternal = require("../app-render/work-async-storage.external");
+const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
+const _dynamicrendering = require("../app-render/dynamic-rendering");
+const _staticgenerationbailout = require("../../client/components/static-generation-bailout");
+const _dynamicrenderingutils = require("../dynamic-rendering-utils");
+const _creatededupedbycallsiteservererrorlogger = require("../create-deduped-by-callsite-server-error-logger");
+const _utils = require("./utils");
+const _invarianterror = require("../../shared/lib/invariant-error");
+const _stagedrendering = require("../app-render/staged-rendering");
+function headers() {
+    const callingExpression = 'headers';
+    const workStore = _workasyncstorageexternal.workAsyncStorage.getStore();
+    const workUnitStore = _workunitasyncstorageexternal.workUnitAsyncStorage.getStore();
+    if (workStore) {
+        if (workUnitStore && workUnitStore.phase === 'after' && !(0, _utils.isRequestAPICallableInsideAfter)()) {
+            throw Object.defineProperty(new Error(`Route ${workStore.route} used \`headers()\` inside \`after()\`. This is not supported. If you need this data inside an \`after()\` callback, use \`headers()\` outside of the callback. See more info here: https://nextjs.org/docs/canary/app/api-reference/functions/after`), "__NEXT_ERROR_CODE", {
+                value: "E839",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (workStore.forceStatic) {
+            // When using forceStatic we override all other logic and always just return an empty
+            // headers object without tracking
+            const underlyingHeaders = _headers.HeadersAdapter.seal(new Headers({}));
+            return makeUntrackedHeaders(underlyingHeaders);
+        }
+        if (workUnitStore) {
+            switch(workUnitStore.type){
+                case 'cache':
+                    {
+                        const error = Object.defineProperty(new Error(`Route ${workStore.route} used \`headers()\` inside "use cache". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use \`headers()\` outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/messages/next-request-in-use-cache`), "__NEXT_ERROR_CODE", {
+                            value: "E833",
+                            enumerable: false,
+                            configurable: true
+                        });
+                        Error.captureStackTrace(error, headers);
+                        workStore.invalidDynamicUsageError ??= error;
+                        throw error;
+                    }
+                case 'unstable-cache':
+                    throw Object.defineProperty(new Error(`Route ${workStore.route} used \`headers()\` inside a function cached with \`unstable_cache()\`. Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use \`headers()\` outside of the cached function and pass the required dynamic data in as an argument. See more info here: https://nextjs.org/docs/app/api-reference/functions/unstable_cache`), "__NEXT_ERROR_CODE", {
+                        value: "E838",
+                        enumerable: false,
+                        configurable: true
+                    });
+                case 'prerender':
+                case 'prerender-client':
+                case 'private-cache':
+                case 'prerender-runtime':
+                case 'prerender-ppr':
+                case 'prerender-legacy':
+                case 'request':
+                    break;
+                default:
+                    workUnitStore;
+            }
+        }
+        if (workStore.dynamicShouldError) {
+            throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${workStore.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`headers()\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+                value: "E828",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (workUnitStore) {
+            switch(workUnitStore.type){
+                case 'prerender':
+                    return makeHangingHeaders(workStore, workUnitStore);
+                case 'prerender-client':
+                    const exportName = '`headers`';
+                    throw Object.defineProperty(new _invarianterror.InvariantError(`${exportName} must not be used within a client component. Next.js should be preventing ${exportName} from being included in client components statically, but did not in this case.`), "__NEXT_ERROR_CODE", {
+                        value: "E693",
+                        enumerable: false,
+                        configurable: true
+                    });
+                case 'prerender-ppr':
+                    // PPR Prerender (no cacheComponents)
+                    // We are prerendering with PPR. We need track dynamic access here eagerly
+                    // to keep continuity with how headers has worked in PPR without cacheComponents.
+                    // TODO consider switching the semantic to throw on property access instead
+                    return (0, _dynamicrendering.postponeWithTracking)(workStore.route, callingExpression, workUnitStore.dynamicTracking);
+                case 'prerender-legacy':
+                    // Legacy Prerender
+                    // We are in a legacy static generation mode while prerendering
+                    // We track dynamic access here so we don't need to wrap the headers in
+                    // individual property access tracking.
+                    return (0, _dynamicrendering.throwToInterruptStaticGeneration)(callingExpression, workStore, workUnitStore);
+                case 'prerender-runtime':
+                    return (0, _dynamicrendering.delayUntilRuntimeStage)(workUnitStore, makeUntrackedHeaders(workUnitStore.headers));
+                case 'private-cache':
+                    // Private caches are delayed until the runtime stage in use-cache-wrapper,
+                    // so we don't need an additional delay here.
+                    return makeUntrackedHeaders(workUnitStore.headers);
+                case 'request':
+                    (0, _dynamicrendering.trackDynamicDataInDynamicRender)(workUnitStore);
+                    if (process.env.NODE_ENV === 'development') {
+                        // Semantically we only need the dev tracking when running in `next dev`
+                        // but since you would never use next dev with production NODE_ENV we use this
+                        // as a proxy so we can statically exclude this code from production builds.
+                        return makeUntrackedHeadersWithDevWarnings(workUnitStore.headers, workStore == null ? void 0 : workStore.route, workUnitStore);
+                    } else {
+                        return makeUntrackedHeaders(workUnitStore.headers);
+                    }
+                    break;
+                default:
+                    workUnitStore;
+            }
+        }
+    }
+    // If we end up here, there was no work store or work unit store present.
+    (0, _workunitasyncstorageexternal.throwForMissingRequestStore)(callingExpression);
+}
+const CachedHeaders = new WeakMap();
+function makeHangingHeaders(workStore, prerenderStore) {
+    const cachedHeaders = CachedHeaders.get(prerenderStore);
+    if (cachedHeaders) {
+        return cachedHeaders;
+    }
+    const promise = (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`headers()`');
+    CachedHeaders.set(prerenderStore, promise);
+    return promise;
+}
+function makeUntrackedHeaders(underlyingHeaders) {
+    const cachedHeaders = CachedHeaders.get(underlyingHeaders);
+    if (cachedHeaders) {
+        return cachedHeaders;
+    }
+    const promise = Promise.resolve(underlyingHeaders);
+    CachedHeaders.set(underlyingHeaders, promise);
+    return promise;
+}
+function makeUntrackedHeadersWithDevWarnings(underlyingHeaders, route, requestStore) {
+    if (requestStore.asyncApiPromises) {
+        const promise = requestStore.asyncApiPromises.headers;
+        return instrumentHeadersPromiseWithDevWarnings(promise, route);
+    }
+    const cachedHeaders = CachedHeaders.get(underlyingHeaders);
+    if (cachedHeaders) {
+        return cachedHeaders;
+    }
+    const promise = (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(underlyingHeaders, requestStore, _stagedrendering.RenderStage.Runtime);
+    const proxiedPromise = instrumentHeadersPromiseWithDevWarnings(promise, route);
+    CachedHeaders.set(underlyingHeaders, proxiedPromise);
+    return proxiedPromise;
+}
+const warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createHeadersAccessError);
+function instrumentHeadersPromiseWithDevWarnings(promise, route) {
+    Object.defineProperties(promise, {
+        [Symbol.iterator]: replaceableWarningDescriptorForSymbolIterator(promise, route),
+        append: replaceableWarningDescriptor(promise, 'append', route),
+        delete: replaceableWarningDescriptor(promise, 'delete', route),
+        get: replaceableWarningDescriptor(promise, 'get', route),
+        has: replaceableWarningDescriptor(promise, 'has', route),
+        set: replaceableWarningDescriptor(promise, 'set', route),
+        getSetCookie: replaceableWarningDescriptor(promise, 'getSetCookie', route),
+        forEach: replaceableWarningDescriptor(promise, 'forEach', route),
+        keys: replaceableWarningDescriptor(promise, 'keys', route),
+        values: replaceableWarningDescriptor(promise, 'values', route),
+        entries: replaceableWarningDescriptor(promise, 'entries', route)
+    });
+    return promise;
+}
+function replaceableWarningDescriptor(target, prop, route) {
+    return {
+        enumerable: false,
+        get () {
+            warnForSyncAccess(route, `\`headers().${prop}\``);
+            return undefined;
+        },
+        set (value) {
+            Object.defineProperty(target, prop, {
+                value,
+                writable: true,
+                configurable: true
+            });
+        },
+        configurable: true
+    };
+}
+function replaceableWarningDescriptorForSymbolIterator(target, route) {
+    return {
+        enumerable: false,
+        get () {
+            warnForSyncAccess(route, '`...headers()` or similar iteration');
+            return undefined;
+        },
+        set (value) {
+            Object.defineProperty(target, Symbol.iterator, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        },
+        configurable: true
+    };
+}
+function createHeadersAccessError(route, expression) {
+    const prefix = route ? `Route "${route}" ` : 'This route ';
+    return Object.defineProperty(new Error(`${prefix}used ${expression}. ` + `\`headers()\` returns a Promise and must be unwrapped with \`await\` or \`React.use()\` before accessing its properties. ` + `Learn more: https://nextjs.org/docs/messages/sync-dynamic-apis`), "__NEXT_ERROR_CODE", {
+        value: "E836",
+        enumerable: false,
+        configurable: true
+    });
+}
+
+//# sourceMappingURL=headers.js.map