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

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "cookies", {
+    enumerable: true,
+    get: function() {
+        return cookies;
+    }
+});
+const _requestcookies = require("../web/spec-extension/adapters/request-cookies");
+const _cookies = require("../web/spec-extension/cookies");
+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 cookies() {
+    const callingExpression = 'cookies';
+    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(// TODO(after): clarify that this only applies to pages?
+            `Route ${workStore.route} used \`cookies()\` inside \`after()\`. This is not supported. If you need this data inside an \`after()\` callback, use \`cookies()\` outside of the callback. See more info here: https://nextjs.org/docs/canary/app/api-reference/functions/after`), "__NEXT_ERROR_CODE", {
+                value: "E843",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (workStore.forceStatic) {
+            // When using forceStatic we override all other logic and always just return an empty
+            // cookies object without tracking
+            const underlyingCookies = createEmptyCookies();
+            return makeUntrackedCookies(underlyingCookies);
+        }
+        if (workStore.dynamicShouldError) {
+            throw Object.defineProperty(new _staticgenerationbailout.StaticGenBailoutError(`Route ${workStore.route} with \`dynamic = "error"\` couldn't be rendered statically because it used \`cookies()\`. See more info here: https://nextjs.org/docs/app/building-your-application/rendering/static-and-dynamic#dynamic-rendering`), "__NEXT_ERROR_CODE", {
+                value: "E849",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (workUnitStore) {
+            switch(workUnitStore.type){
+                case 'cache':
+                    const error = Object.defineProperty(new Error(`Route ${workStore.route} used \`cookies()\` inside "use cache". Accessing Dynamic data sources inside a cache scope is not supported. If you need this data inside a cached function use \`cookies()\` 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: "E831",
+                        enumerable: false,
+                        configurable: true
+                    });
+                    Error.captureStackTrace(error, cookies);
+                    workStore.invalidDynamicUsageError ??= error;
+                    throw error;
+                case 'unstable-cache':
+                    throw Object.defineProperty(new Error(`Route ${workStore.route} used \`cookies()\` 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 \`cookies()\` 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: "E846",
+                        enumerable: false,
+                        configurable: true
+                    });
+                case 'prerender':
+                    return makeHangingCookies(workStore, workUnitStore);
+                case 'prerender-client':
+                    const exportName = '`cookies`';
+                    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: "E832",
+                        enumerable: false,
+                        configurable: true
+                    });
+                case 'prerender-ppr':
+                    // We need track dynamic access here eagerly to keep continuity with
+                    // how cookies has worked in PPR without cacheComponents.
+                    return (0, _dynamicrendering.postponeWithTracking)(workStore.route, callingExpression, workUnitStore.dynamicTracking);
+                case 'prerender-legacy':
+                    // We track dynamic access here so we don't need to wrap the cookies
+                    // in individual property access tracking.
+                    return (0, _dynamicrendering.throwToInterruptStaticGeneration)(callingExpression, workStore, workUnitStore);
+                case 'prerender-runtime':
+                    return (0, _dynamicrendering.delayUntilRuntimeStage)(workUnitStore, makeUntrackedCookies(workUnitStore.cookies));
+                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 makeUntrackedCookies(workUnitStore.cookies);
+                case 'request':
+                    (0, _dynamicrendering.trackDynamicDataInDynamicRender)(workUnitStore);
+                    let underlyingCookies;
+                    if ((0, _requestcookies.areCookiesMutableInCurrentPhase)(workUnitStore)) {
+                        // We can't conditionally return different types here based on the context.
+                        // To avoid confusion, we always return the readonly type here.
+                        underlyingCookies = workUnitStore.userspaceMutableCookies;
+                    } else {
+                        underlyingCookies = workUnitStore.cookies;
+                    }
+                    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 makeUntrackedCookiesWithDevWarnings(workUnitStore, underlyingCookies, workStore == null ? void 0 : workStore.route);
+                    } else {
+                        return makeUntrackedCookies(underlyingCookies);
+                    }
+                default:
+                    workUnitStore;
+            }
+        }
+    }
+    // If we end up here, there was no work store or work unit store present.
+    (0, _workunitasyncstorageexternal.throwForMissingRequestStore)(callingExpression);
+}
+function createEmptyCookies() {
+    return _requestcookies.RequestCookiesAdapter.seal(new _cookies.RequestCookies(new Headers({})));
+}
+const CachedCookies = new WeakMap();
+function makeHangingCookies(workStore, prerenderStore) {
+    const cachedPromise = CachedCookies.get(prerenderStore);
+    if (cachedPromise) {
+        return cachedPromise;
+    }
+    const promise = (0, _dynamicrenderingutils.makeHangingPromise)(prerenderStore.renderSignal, workStore.route, '`cookies()`');
+    CachedCookies.set(prerenderStore, promise);
+    return promise;
+}
+function makeUntrackedCookies(underlyingCookies) {
+    const cachedCookies = CachedCookies.get(underlyingCookies);
+    if (cachedCookies) {
+        return cachedCookies;
+    }
+    const promise = Promise.resolve(underlyingCookies);
+    CachedCookies.set(underlyingCookies, promise);
+    return promise;
+}
+function makeUntrackedCookiesWithDevWarnings(requestStore, underlyingCookies, route) {
+    if (requestStore.asyncApiPromises) {
+        let promise;
+        if (underlyingCookies === requestStore.mutableCookies) {
+            promise = requestStore.asyncApiPromises.mutableCookies;
+        } else if (underlyingCookies === requestStore.cookies) {
+            promise = requestStore.asyncApiPromises.cookies;
+        } else {
+            throw Object.defineProperty(new _invarianterror.InvariantError('Received an underlying cookies object that does not match either `cookies` or `mutableCookies`'), "__NEXT_ERROR_CODE", {
+                value: "E890",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        return instrumentCookiesPromiseWithDevWarnings(promise, route);
+    }
+    const cachedCookies = CachedCookies.get(underlyingCookies);
+    if (cachedCookies) {
+        return cachedCookies;
+    }
+    const promise = (0, _dynamicrenderingutils.makeDevtoolsIOAwarePromise)(underlyingCookies, requestStore, _stagedrendering.RenderStage.Runtime);
+    const proxiedPromise = instrumentCookiesPromiseWithDevWarnings(promise, route);
+    CachedCookies.set(underlyingCookies, proxiedPromise);
+    return proxiedPromise;
+}
+const warnForSyncAccess = (0, _creatededupedbycallsiteservererrorlogger.createDedupedByCallsiteServerErrorLoggerDev)(createCookiesAccessError);
+function instrumentCookiesPromiseWithDevWarnings(promise, route) {
+    Object.defineProperties(promise, {
+        [Symbol.iterator]: replaceableWarningDescriptorForSymbolIterator(promise, route),
+        size: replaceableWarningDescriptor(promise, 'size', route),
+        get: replaceableWarningDescriptor(promise, 'get', route),
+        getAll: replaceableWarningDescriptor(promise, 'getAll', route),
+        has: replaceableWarningDescriptor(promise, 'has', route),
+        set: replaceableWarningDescriptor(promise, 'set', route),
+        delete: replaceableWarningDescriptor(promise, 'delete', route),
+        clear: replaceableWarningDescriptor(promise, 'clear', route),
+        toString: replaceableWarningDescriptor(promise, 'toString', route)
+    });
+    return promise;
+}
+function replaceableWarningDescriptor(target, prop, route) {
+    return {
+        enumerable: false,
+        get () {
+            warnForSyncAccess(route, `\`cookies().${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, '`...cookies()` or similar iteration');
+            return undefined;
+        },
+        set (value) {
+            Object.defineProperty(target, Symbol.iterator, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        },
+        configurable: true
+    };
+}
+function createCookiesAccessError(route, expression) {
+    const prefix = route ? `Route "${route}" ` : 'This route ';
+    return Object.defineProperty(new Error(`${prefix}used ${expression}. ` + `\`cookies()\` 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: "E830",
+        enumerable: false,
+        configurable: true
+    });
+}
+
+//# sourceMappingURL=cookies.js.map