@universalcms/connect 0.1.0 → 0.13.0

package/dist/native-website.mjs.LEGAL.txt

@@ -0,0 +1,56 @@
+Bundled license information:
+
+react/cjs/react.production.js:
+  /**
+   * @license React
+   * react.production.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+
+react-dom/cjs/react-dom.production.js:
+  /**
+   * @license React
+   * react-dom.production.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+
+react/cjs/react-jsx-runtime.production.js:
+  /**
+   * @license React
+   * react-jsx-runtime.production.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+
+scheduler/cjs/scheduler.production.js:
+  /**
+   * @license React
+   * scheduler.production.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+
+react-dom/cjs/react-dom-client.production.js:
+  /**
+   * @license React
+   * react-dom-client.production.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */

package/dist/next-publication.d.mts

@@ -0,0 +1,12 @@
+export const PUBLICATION_STATUS_PATH: string;
+export const PUBLICATION_SCRIPT_PATH: string;
+export const PUBLICATION_DOCUMENT_PATH: '/api/universalcms/document';
+export const publicationResponseHeaders: Readonly<Record<string, string>>;
+export function nextPublicationPath(pathname: string, indexIsManaged?: boolean): string;
+export function createNextPublicationProxy(options: {
+  configuration: unknown;
+  sourceConfiguration?: unknown;
+  contentBindings?: unknown;
+  env?: Record<string, string | undefined>;
+  fetcher?: typeof fetch;
+}): (request: Request) => Promise<{ response?: Response; requestHeaders: Headers; headers: Readonly<Record<string, string>> }>;

package/dist/next-publication.mjs

@@ -0,0 +1,107 @@
+import { createPublishedDocumentReader, isExcludedPublicationPath, normalizePublicationPath, validatePublicationConfig, publicationErrorHtml, publicationRevision, publicPublishedEntry } from './publication.mjs';
+import { createPublicationBrowserScript, PUBLICATION_DOCUMENT_PATH } from './publication-browser.mjs';
+import { matchesNativeRoutes } from './native-routes.mjs';
+import { publicationVerification, verificationRequest, verificationBody, publicationRouteHeaders } from './publication-verification.mjs';
+import { createWebsiteRequestHandler, WEBSITE_SETTINGS_PATH, WEBSITE_PAGE_PATH } from './website-http.mjs';
+
+export const PUBLICATION_STATUS_PATH = '/api/universalcms/publication';
+export const PUBLICATION_SCRIPT_PATH = '/.well-known/universalcms-publication-client.js';
+export { PUBLICATION_DOCUMENT_PATH };
+export const publicationResponseHeaders = Object.freeze({
+  'Cache-Control': 'private, no-store, max-age=0',
+  'CDN-Cache-Control': 'no-store',
+  'Vercel-CDN-Cache-Control': 'no-store',
+  'X-Content-Type-Options': 'nosniff',
+});
+
+/** Resolve transport aliases before matching the fixed public route registry. */
+export function nextPublicationPath(pathname, indexIsManaged = false) {
+  if (typeof pathname !== 'string') throw Error('Invalid publication path.');
+  let path = pathname;
+  const segment = path.match(/^(\/.*)\.segments\/[^?#]*\.segment\.rsc$/);
+  if (segment) path = segment[1];
+  else if (path.endsWith('.rsc')) path = path.slice(0, -4);
+  if (path === '/index' && path !== pathname && !indexIsManaged) path = '/';
+  return normalizePublicationPath(path || '/');
+}
+
+function cleanHeaders(headers) {
+  const copy = new Headers(headers);
+  for (const name of [...copy.keys()]) if (/^(?:x-universalcms-|x-cms-publication|x-middleware-subrequest$)/i.test(name)) copy.delete(name);
+  return copy;
+}
+
+function reply(request, body, status, contentType, extra = {}) {
+  return new Response(request.method === 'HEAD' ? null : body, {
+    status, headers: { ...publicationResponseHeaders, 'Content-Type': contentType, ...extra },
+  });
+}
+
+/** Next Proxy calls this before HTML, RSC and cached/prefetched page responses. */
+export function createNextPublicationProxy({ configuration, sourceConfiguration, contentBindings, env = process.env, fetcher = globalThis.fetch } = {}) {
+  const config = validatePublicationConfig(configuration);
+  const verification = publicationVerification(config, sourceConfiguration, contentBindings);
+  const read = createPublishedDocumentReader({ configuration: config, env, fetcher });
+  const script = createPublicationBrowserScript(config);
+  const website = createWebsiteRequestHandler({ configuration: config, sourceConfiguration, contentBindings, env, fetcher });
+  return async function handle(request) {
+    const requestHeaders = cleanHeaders(request.headers);
+    const pass = headers => ({ requestHeaders, headers });
+    let url;
+    try { url = new URL(request.url); } catch {
+      return { ...pass({}), response: reply(request, publicationErrorHtml(503), 503, 'text/html; charset=utf-8') };
+    }
+    if (url.pathname === WEBSITE_SETTINGS_PATH || url.pathname === WEBSITE_PAGE_PATH) {
+      const result = await website(request);
+      if (result instanceof Response) {
+        if ([301, 302, 307, 308].includes(result.status) && result.headers.get('location')?.startsWith('/')) {
+          result.headers.set('Location', new URL(result.headers.get('location'), config.websiteOrigin).href);
+        }
+        return { response: result, requestHeaders: new Headers(), headers: {} };
+      }
+    }
+    if (url.pathname === PUBLICATION_SCRIPT_PATH || url.pathname === PUBLICATION_STATUS_PATH || url.pathname === PUBLICATION_DOCUMENT_PATH) {
+      if (url.pathname === PUBLICATION_STATUS_PATH) {
+        const probe = verificationRequest({ configuration: config, verification, url, method: request.method, headers: request.headers });
+        if (probe) {
+          if (probe.status) return { ...pass({}), response: reply(request, probe.status === 204 ? null : '{"error":"Publication verification unavailable."}', probe.status, 'application/json', probe.headers) };
+          const result = await read(probe.pathname);
+          const probeHeaders = { ...probe.headers, ...(result.reason ? { 'X-UniversalCMS-Delivery-Status': result.reason } : {}) };
+          return { ...pass({}), response: reply(request, JSON.stringify(verificationBody(verification, probe.pathname, result)), result.state === 'unavailable' ? 503 : 200, 'application/json', probeHeaders) };
+        }
+      }
+      if (!['GET', 'HEAD'].includes(request.method)) return { ...pass({}), response: reply(request, '{"error":"Method not allowed."}', 405, 'application/json', { Allow: 'GET, HEAD' }) };
+      const origin = request.headers.get('origin');
+      if (request.headers.get('sec-fetch-site') === 'cross-site' || origin && origin !== config.websiteOrigin) {
+        return { ...pass({}), response: reply(request, '{"error":"Request not allowed."}', 403, 'application/json') };
+      }
+      if (url.pathname === PUBLICATION_SCRIPT_PATH) return { ...pass({}), response: reply(request, script, 200, 'text/javascript; charset=utf-8') };
+      if ([...url.searchParams.keys()].some(key => key !== 'path') || url.searchParams.getAll('path').length !== 1) {
+        return { ...pass({}), response: reply(request, '{"error":"Invalid publication request."}', 400, 'application/json') };
+      }
+      const result = await read(url.searchParams.get('path'));
+      const state = result.state === 'unmanaged' ? 'missing' : result.state;
+      const documentEndpoint = url.pathname === PUBLICATION_DOCUMENT_PATH;
+      // Already-open 0.5.0 clients require exactly { state }. New clients opt in;
+      // the dedicated document endpoint always identifies its publication.
+      const includeRevision = documentEndpoint || request.headers.get('x-universalcms-include-revision') === '1';
+      const body = { state, ...(result.entry && includeRevision ? { revision: publicationRevision(result.entry), ...(documentEndpoint ? { entry: publicPublishedEntry(result.entry) } : {}) } : {}) };
+      const extraHeaders = result.reason ? { 'X-UniversalCMS-Delivery-Status': result.reason } : {};
+      return { ...pass({}), response: reply(request, JSON.stringify(body), state === 'missing' ? 404 : result.status, 'application/json', extraHeaders) };
+    }
+    let pathname;
+    try { pathname = nextPublicationPath(url.pathname, config.routes.some(route => route.path === '/index')); } catch {
+      return { ...pass({}), response: reply(request, publicationErrorHtml(404), 404, 'text/html; charset=utf-8', { 'X-Robots-Tag': 'noindex' }) };
+    }
+    const result = await read(pathname);
+    if (result.state === 'unmanaged' && (isExcludedPublicationPath(pathname) || matchesNativeRoutes(verification, pathname))) return pass({});
+    const routeHeaders = result.state === 'unmanaged' ? {} : publicationRouteHeaders(config, pathname, result, verification, request.headers.get('origin'), request.headers.has('authorization') || request.headers.has('cookie'));
+    if (result.state === 'published') return pass({ ...publicationResponseHeaders, ...routeHeaders });
+    // A new public source route is not published merely because it exists in
+    // the Next tree. Rerun setup to add its reviewed identity to the registry.
+    const status = result.state === 'missing' || result.state === 'unmanaged' ? 404 : 503;
+    return { ...pass({}), response: reply(request, publicationErrorHtml(status), status, 'text/html; charset=utf-8', {
+      ...routeHeaders, 'X-Robots-Tag': 'noindex', ...(status === 503 ? { 'Retry-After': '30' } : {}),
+    }) };
+  };
+}

package/dist/next-settings-layout.mjs

@@ -0,0 +1,233 @@
+/** Explicit, source-only review of native Next layout settings slots. */
+import path from 'node:path';
+import { lstat } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import ts from './vendor/typescript.cjs';
+import { projectRoot, readProjectFile, SetupError } from './core.mjs';
+import { configureNextContent } from './content-next-setup.mjs';
+import { isNativeReviewFilePath } from './native-routes.mjs';
+import { setupReviewError, sanitizeSetupPaths } from './preflight-recovery.mjs';
+export const SETTINGS_LAYOUT_FILE = '.universalcms/settings.layout.json';
+const PROFILE = 'reviewed-next-settings-layout-v1';
+const digest = text => createHash('sha256').update(text).digest('hex');
+const json = value => JSON.stringify(value, null, 2) + '\n';
+const script = '<script id="universalcms-publication-client" src="/.well-known/universalcms-publication-client.js"></script>';
+const installedFiles = ['.universalcms/content.bindings.json','.universalcms/publication.config.json','.universalcms/website.integration.json','.universalcms/reviewed.integration.json'];
+const configurationFiles = ['package.json','tsconfig.json','jsconfig.json','next.config.js','next.config.mjs','next.config.cjs','next.config.ts'];
+// Next 16 prepares these compiler/build fields itself. Record the exact expected
+// object at review time rather than ignoring later tsconfig changes. Resolver
+// fields, application options and every other value remain part of the hash.
+function typescriptConfigurationHash(content, prepare = false) {
+  if (content === null) return null;
+  const parsed = ts.parseConfigFileTextToJson('tsconfig.json', content);
+  if (parsed.error || !parsed.config || typeof parsed.config !== 'object' || Array.isArray(parsed.config)) return null;
+  const config = parsed.config;
+  if (prepare) {
+    const options = config.compilerOptions;
+    if (!options || typeof options !== 'object' || Array.isArray(options) || !Array.isArray(config.include)) return null;
+    if (!Object.hasOwn(options, 'incremental')) options.incremental = true;
+    options.jsx = 'react-jsx';
+    for (const pattern of ['.next/types/**/*.ts', '.next/dev/types/**/*.ts']) if (!config.include.includes(pattern)) config.include.push(pattern);
+  }
+  const canonical = value => Array.isArray(value) ? value.map(canonical) : value && typeof value === 'object' ? Object.fromEntries(Object.keys(value).sort().map(key => [key, canonical(value[key])])) : value;
+  return digest(JSON.stringify(canonical(config)));
+}
+function preparedConfigurationHash(file) {
+  if (file.path === 'tsconfig.json') return typescriptConfigurationHash(file.content, true) ?? (file.content === null ? null : digest(file.content));
+  if (file.path.startsWith('next.config.')) return file.content === null ? (file.path === 'next.config.mjs' ? digest('export default { htmlLimitedBots: /.*/ };\n') : null) : digest(configureNextContent(file.content, file.path));
+  return file.content === null ? null : digest(file.content);
+}
+const fail = (message, files = []) => { const error = setupReviewError('native-settings-layout', files); const safe = sanitizeSetupPaths(files).paths; error.message = message + (safe.length ? ` Review paths: ${safe.join(', ')}.` : ''); throw error; };
+const relative = (from, to) => { const value = path.posix.relative(path.posix.dirname(from), to); return value.startsWith('.') ? value : './' + value; };
+const parse = (name, source) => { const ast = ts.createSourceFile(name, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX); if (ast.parseDiagnostics.length) fail('Correct the layout module syntax before review', [name]); return ast; };
+async function ordinary(root, name) { const content = await readProjectFile(root,name); if (content !== null && (await lstat(path.join(root,name))).nlink !== 1) fail('Layout review requires ordinary single-link files', [name]); return content; }
+function bodyOf(ast, filename) {
+  const bodies=[];
+  const visit=node=>{if(ts.isJsxElement(node)&&node.openingElement.tagName.getText(ast)==='body')bodies.push(node);ts.forEachChild(node,visit);};visit(ast);
+  if (bodies.length !== 1 || ast.statements.some(node=>ts.isExpressionStatement(node)&&ts.isStringLiteral(node.expression)&&node.expression.text==='use client')) fail('A reviewed layout needs one server-rendered literal body', [filename]);
+  return bodies[0];
+}
+function slotsOf(ast, filename) {
+  const slots=[];
+  function visit(node) {
+    if(ts.isJsxSelfClosingElement(node)&&['header','footer'].includes(node.tagName.getText(ast)))fail('Use explicit native header and footer elements before reviewing settings slots',[filename]);
+    if(ts.isJsxElement(node)&&['header','footer'].includes(node.openingElement.tagName.getText(ast))){
+      // Conditional, looped, or callback-owned chrome is not one stable slot.
+      for(let parent=node.parent;parent&&!ts.isSourceFile(parent);parent=parent.parent){
+        if(ts.isConditionalExpression(parent)||ts.isIfStatement(parent)||ts.isIterationStatement(parent,false)||ts.isCallExpression(parent)||ts.isBinaryExpression(parent))fail('Conditional or repeated header/footer elements need explicit framework integration',[filename]);
+      }
+      slots.push({kind:node.openingElement.tagName.getText(ast),node});
+    }
+    ts.forEachChild(node,visit);
+  }
+  visit(ast);return slots;
+}
+function defaultView(ast, filename, exportedName = 'default') {
+  const declarations = new Map();
+  for (const statement of ast.statements) {
+    if (ts.isFunctionDeclaration(statement) && statement.name) declarations.set(statement.name.text, statement);
+    if (ts.isVariableStatement(statement)) for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.initializer) declarations.set(declaration.name.text, declaration.initializer);
+  }
+  let component;
+  if(exportedName==='default'){
+    component = ast.statements.find(node => ts.isFunctionDeclaration(node) && node.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.DefaultKeyword));
+    if (!component) { const exported = ast.statements.find(ts.isExportAssignment); component = exported?.expression; if (component && ts.isIdentifier(component)) component = declarations.get(component.text); }
+  }else{
+    const declared=declarations.get(exportedName);
+    const statement=ast.statements.find(node=>node===declared||ts.isVariableStatement(node)&&node.declarationList.declarations.some(item=>item.initializer===declared));
+    if(statement?.modifiers?.some(modifier=>modifier.kind===ts.SyntaxKind.ExportKeyword))component=declared;
+  }
+  if (!component || !(ts.isFunctionDeclaration(component) || ts.isArrowFunction(component) || ts.isFunctionExpression(component)) || !component.body) fail('Settings slots need an ordinary exported component with one unconditional JSX return', [filename]);
+  let expression = component.body;
+  if (ts.isBlock(expression)) {
+    const returns = [];
+    const collect = node => { if (node !== expression && ts.isFunctionLike(node)) return; if (ts.isReturnStatement(node)) returns.push(node); ts.forEachChild(node, collect); };
+    collect(expression);
+    if (returns.length !== 1 || returns[0].parent !== expression) fail('Settings slots need one unconditional component return', [filename]);
+    expression = returns[0].expression;
+  }
+  while (expression && (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression))) expression = expression.expression;
+  if (!expression || !(ts.isJsxElement(expression) || ts.isJsxFragment(expression) || ts.isJsxSelfClosingElement(expression))) fail('Settings slots need an ordinary JSX component return', [filename]);
+  return expression;
+}
+// Review one actual root render, not merely an unused import containing a
+// header. The supported imported slot is a default component mounted once in
+// the root body; its native handlers and children remain untouched.
+function validateSlotMounts(rootLayout, files, slots, app) {
+  const rootAst = parse(rootLayout, files.get(rootLayout)), rootView = defaultView(rootAst, rootLayout);
+  const rootBody = bodyOf(rootAst, rootLayout);
+  if (!(ts.isJsxElement(rootView) && rootView.openingElement.tagName.getText(rootAst) === 'html' && rootView.children.includes(rootBody))) fail('Settings layout must return the native html document with its direct body', [rootLayout]);
+  let childrenSlots=0;
+  const scanChildren=node=>{if(ts.isJsxExpression(node)&&node.expression&&(ts.isIdentifier(node.expression)&&node.expression.text==='children'||ts.isPropertyAccessExpression(node.expression)&&node.expression.name.text==='children'))childrenSlots++;ts.forEachChild(node,scanChildren);};scanChildren(rootBody);
+  if(childrenSlots!==1)fail('The reviewed root body needs one explicit native children slot so original and CMS pages retain their route content',[rootLayout]);
+  const imports = new Map();
+  for (const statement of rootAst.statements) if (ts.isImportDeclaration(statement) && statement.importClause && ts.isStringLiteral(statement.moduleSpecifier)) {
+    const specifier=statement.moduleSpecifier.text;
+    const base=specifier.startsWith('@/')?(app==='src/app'?'src/':'')+specifier.slice(2):specifier.startsWith('.')?path.posix.normalize(path.posix.join(path.posix.dirname(rootLayout),specifier)):null;
+    if(base){const choices=[base,...['.ts','.tsx','.js','.jsx','.mjs','.cjs','/index.ts','/index.tsx','/index.js','/index.jsx'].map(suffix=>base+suffix)];const filename=choices.find(name=>files.has(name));if(filename){if(statement.importClause.name)imports.set(statement.importClause.name.text,{filename,exportedName:'default'});if(statement.importClause.namedBindings&&ts.isNamedImports(statement.importClause.namedBindings))for(const item of statement.importClause.namedBindings.elements)if(!item.isTypeOnly)imports.set(item.name.text,{filename,exportedName:item.propertyName?.text??item.name.text});}}
+  }
+  for (const slot of slots) {
+    const ast=slot.path===rootLayout?rootAst:parse(slot.path,files.get(slot.path));
+    const actual=slotsOf(ast,slot.path).find(item=>item.kind===slot.kind).node;
+    const contains=view=>{let within=false;const search=node=>{if(node===actual)within=true;ts.forEachChild(node,search);};search(view);return within;};
+    if(slot.path===rootLayout){if(!contains(rootView))fail('A semantic settings slot is outside its exported component render',[slot.path]);continue;}
+    const names=[...imports].filter(([,value])=>value.filename===slot.path).filter(([,value])=>{try{return contains(defaultView(ast,slot.path,value.exportedName));}catch{return false;}}).map(([name])=>name);let mounts=0;
+    if(!names.length)fail('A semantic settings slot is outside its exported component render',[slot.path]);
+    const scan=node=>{if((ts.isJsxElement(node)||ts.isJsxSelfClosingElement(node))&&names.includes((ts.isJsxElement(node)?node.openingElement:node).tagName.getText(rootAst))){mounts++;for(let parent=node.parent;parent&&parent!==rootBody;parent=parent.parent)if(ts.isJsxExpression(parent)||ts.isCallExpression(parent)||ts.isConditionalExpression(parent))fail('A settings component is conditional or repeated in the root layout',[rootLayout]);}ts.forEachChild(node,scan);};scan(rootBody);
+    if(mounts!==1)fail('Import and mount each reviewed header/footer component exactly once in the root body',[slot.path,rootLayout]);
+  }
+}
+const slotFragment = kind => kind==='header' ? '<__UniversalCmsBranding/><__UniversalCmsNavigation location="header"/><__UniversalCmsLanguages/>' : '<__UniversalCmsNavigation location="footer"/><__UniversalCmsSocialLinks/><__UniversalCmsExperience/>';
+function slotImport(kinds){return `\nimport { ${[...(kinds.includes('header')?['CmsBranding as __UniversalCmsBranding','CmsLanguages as __UniversalCmsLanguages']:[]),'CmsNavigation as __UniversalCmsNavigation',...(kinds.includes('footer')?['CmsSocialLinks as __UniversalCmsSocialLinks','CmsExperience as __UniversalCmsExperience']:[])].join(', ')} } from '@universalcms/connect/react-website';\n`;}
+const layoutImport=(review)=>`\nimport __UniversalCmsLayout from ${JSON.stringify(relative(review.rootLayout,review.serverFile).replace(/\.[jt]sx?$/,''))};\n`;
+function stripGenerated(text, filename, review) {
+  if(!text.includes('__UniversalCms'))return text;
+  const kinds=review.slots.filter(slot=>slot.path===filename).map(slot=>slot.kind);
+  const exact=[...(kinds.length?[slotImport(kinds),...kinds.map(slotFragment)]:[]),...(filename===review.rootLayout?[layoutImport(review),'<__UniversalCmsLayout>','</__UniversalCmsLayout>']:[])];
+  if(!exact.length||exact.some(value=>text.split(value).length!==2))fail('A reviewed settings layout adapter was customized; preserve it and review the exact changes',[filename]);
+  for(const value of exact)text=text.replace(value,'');
+  if(text.includes('__UniversalCms'))fail('A reviewed settings layout adapter contains unknown generated bindings',[filename]);
+  return text;
+}
+function originalText(text, file, review) {
+  text=stripGenerated(text,file.path,review);
+  const candidates=[text];
+  if(file.path===review.rootLayout&&text.split(script).length===2)candidates.push(text.replace(script,''),text.replace('<head>'+script+'</head>',''));
+  const original=candidates.find(value=>digest(value)===file.sha256);
+  if(original===undefined)fail('A reviewed layout dependency changed. Run layout review again before setup; existing files were preserved',[file.path]);
+  return original;
+}
+async function discover(root, overrides=new Map()) {
+  const read=async name=>overrides.has(name)?overrides.get(name):ordinary(root,name);
+  const configs=[];for(const name of configurationFiles)configs.push({path:name,content:await ordinary(root,name),state:'unchanged'});
+  for(const file of configs)if(file.content===null)file.state='absent';
+  let pkg;try{pkg=JSON.parse(configs[0].content);}catch{fail('Layout review needs a valid package.json');}
+  if(!/^(?:\^|~)?16\.\d+\.\d+$/.test(pkg.dependencies?.next??pkg.devDependencies?.next??'')||pkg.imports||pkg.workspaces)fail('Layout review supports one ordinary Next.js 16 App Router project');
+  const roots=[];for(const app of ['app','src/app'])for(const ext of ['tsx','jsx','ts','js'])if(await read(`${app}/layout.${ext}`)!==null)roots.push(`${app}/layout.${ext}`);
+  if(roots.length!==1)fail('Layout review needs one unambiguous App Router root layout',roots);
+  const rootLayout=roots[0],app=path.posix.dirname(rootLayout),serverFile=`${app}/universalcms.layout.server.tsx`;
+  let alias=false,count=0;
+  for(const file of configs.filter(file=>['tsconfig.json','jsconfig.json'].includes(file.path)&&file.content!==null)){
+    const parsed=ts.parseConfigFileTextToJson(file.path,file.content),options=parsed.config?.compilerOptions??{},expected=app==='src/app'?'./src/*':'./*';
+    if(++count>1||parsed.error||parsed.config.extends||parsed.config.references||options.baseUrl!==undefined||options.rootDirs||options.moduleSuffixes||options.paths&&(Object.keys(options.paths).join()!=='@/*'||JSON.stringify(options.paths['@/*'])!==JSON.stringify([expected])))fail('Custom module resolution requires an explicit layout adapter',[file.path]);
+    alias=!!options.paths;
+  }
+  if(configs.some(file=>file.path.startsWith('next.config.')&&/\b(?:webpack|resolveAlias|alias)\b/.test(file.content??'')))fail('Custom module aliases require an explicit layout adapter');
+  const seen=new Map(),slots=[];let bytes=0;
+  async function visit(filename){
+    if(seen.has(filename))return;
+    if(!isNativeReviewFilePath(filename))fail('A layout dependency is outside ordinary public application source',[filename]);
+    const text=await read(filename);if(text===null)fail('A layout dependency is missing',[filename]);
+    bytes+=Buffer.byteLength(text);if(seen.size>=200||bytes>8*1024*1024)fail('Layout review exceeded its bounded source budget');
+    seen.set(filename,text);
+    if(!/\.[cm]?[jt]sx?$/.test(filename))return;
+    if(text.includes('__UniversalCms'))fail('Reserved generated settings names already exist',[filename]);
+    const ast=parse(filename,text);if(filename===rootLayout)bodyOf(ast,filename);
+    slots.push(...slotsOf(ast,filename).map(({kind})=>({path:filename,kind,mode:'append'})));
+    const imports=[];
+    function scan(node){
+      if((ts.isImportDeclaration(node)||ts.isExportDeclaration(node))&&node.moduleSpecifier&&ts.isStringLiteral(node.moduleSpecifier))imports.push(node.moduleSpecifier.text);
+      if(ts.isCallExpression(node)&&(node.expression.kind===ts.SyntaxKind.ImportKeyword||ts.isIdentifier(node.expression)&&node.expression.text==='require'))fail('Dynamic module loading needs an explicit layout adapter',[filename]);
+      ts.forEachChild(node,scan);
+    }scan(ast);
+    for(const specifier of imports){
+      if(specifier.startsWith('#')||specifier.startsWith('/')||specifier.includes('\\')||specifier.startsWith('@/')&&!alias)fail('Unknown module aliases need an explicit layout adapter',[filename]);
+      if(!specifier.startsWith('.')&&!specifier.startsWith('@/')){
+        const packageName=specifier.startsWith('@')?specifier.split('/').slice(0,2).join('/'):specifier.split('/')[0];
+        if(!specifier.startsWith('node:')&&!Object.hasOwn(pkg.dependencies??{},packageName)&&!Object.hasOwn(pkg.devDependencies??{},packageName))fail('A layout import is not a declared dependency',[filename]);
+        continue;
+      }
+      const base=specifier.startsWith('@/')?(app==='src/app'?'src/':'')+specifier.slice(2):path.posix.normalize(path.posix.join(path.posix.dirname(filename),specifier));
+      const candidates=(/\.(?:[cm]?[jt]sx?|json|css)$/.test(base)?[base]:[base,...['.ts','.tsx','.js','.jsx','.mjs','.cjs','.mts','.cts','.json','/index.ts','/index.tsx','/index.js','/index.jsx'].map(suffix=>base+suffix)]).filter(isNativeReviewFilePath),found=[];
+      for(const candidate of candidates){try{if(await read(candidate)!==null)found.push(candidate);}catch(error){if(candidate!==base||candidates.length===1||error.message!=='A setup path has an incompatible file type.')throw error;}}
+
+      if(found.length!==1)fail('A local layout dependency is missing or ambiguous',[filename]);
+      await visit(found[0]);
+    }
+  }
+  await visit(rootLayout);
+  if(slots.length!==2||slots.filter(slot=>slot.kind==='header').length!==1||slots.filter(slot=>slot.kind==='footer').length!==1)fail('Layout review needs exactly one native header and one native footer. Keep mobile controls inside that header; ambiguous layouts need explicit integration',[...seen.keys()].filter(name=>/\.[jt]sx?$/.test(name)));
+  const safeSlots=sanitizeSetupPaths(slots.map(slot=>slot.path)).paths;
+  if(slots.some(slot=>!safeSlots.includes(slot.path)))fail('Settings slot paths must be safe public source paths');
+  validateSlotMounts(rootLayout,seen,slots,app);
+  const files=[...seen].sort(([a],[b])=>a.localeCompare(b)).map(([path,content])=>({path,content,state:'unchanged'}));
+  return {root,app,rootLayout,serverFile,slots:slots.sort((a,b)=>a.kind.localeCompare(b.kind)),files,configs};
+}
+export async function planSettingsLayoutReview(directory){
+  const root=await projectRoot(directory);
+  for(const name of installedFiles)if(await ordinary(root,name)!==null)fail('An integration is already installed. Review its adapter update without reassigning native layout ownership');
+  const found=await discover(root);
+  if(await ordinary(root,found.serverFile)!==null)fail('The generated settings server module path is occupied',[found.serverFile]);
+  const value={version:1,profile:PROFILE,app:found.app,rootLayout:found.rootLayout,serverFile:found.serverFile,slots:found.slots,files:found.files.map(file=>({path:file.path,sha256:digest(file.content)})),configuration:found.configs.filter(file=>file.path!=='package.json').map(file=>({path:file.path,sha256:file.content===null?null:digest(file.content),preparedSha256:preparedConfigurationHash(file)}))};
+  const old=await ordinary(root,SETTINGS_LAYOUT_FILE),content=json(value);
+  return {root,framework:'next',profile:PROFILE,slots:found.slots,files:[...found.files,...found.configs,...installedFiles.map(path=>({path,content:null,state:'absent'})),{path:found.serverFile,content:null,state:'absent'},{path:SETTINGS_LAYOUT_FILE,content,state:old===null?'create':old===content?'unchanged':'update',...(old!==null&&old!==content?{previous:old}:{})}]};
+}
+export async function inspectSettingsLayoutReview(directory){
+  const root=await projectRoot(directory),text=await ordinary(root,SETTINGS_LAYOUT_FILE);if(text===null)return null;
+  let value;try{value=JSON.parse(text);}catch{fail('Invalid settings layout review',[SETTINGS_LAYOUT_FILE]);}
+  if(!value||Object.keys(value).sort().join()!=='app,configuration,files,profile,rootLayout,serverFile,slots,version'||value.version!==1||value.profile!==PROFILE||!['app','src/app'].includes(value.app)||!['tsx','jsx','ts','js'].some(ext=>value.rootLayout===`${value.app}/layout.${ext}`)||value.serverFile!==`${value.app}/universalcms.layout.server.tsx`||!Array.isArray(value.files)||!value.files.length||value.files.length>200||new Set(value.files.map(file=>file?.path)).size!==value.files.length||value.files.some(file=>!file||Object.keys(file).sort().join()!=='path,sha256'||!isNativeReviewFilePath(file.path)||!/^[a-f0-9]{64}$/.test(file.sha256))||!Array.isArray(value.slots)||value.slots.length!==2||value.slots.some(slot=>!slot||Object.keys(slot).sort().join()!=='kind,mode,path'||!['header','footer'].includes(slot.kind)||slot.mode!=='append'||!value.files.some(file=>file.path===slot.path))||!Array.isArray(value.configuration)||value.configuration.length!==configurationFiles.length-1)fail('Invalid bounded settings layout review',[SETTINGS_LAYOUT_FILE]);
+  for(let i=0;i<value.configuration.length;i++){const row=value.configuration[i];if(!row||Object.keys(row).sort().join()!=='path,preparedSha256,sha256'||row.path!==configurationFiles[i+1]||row.sha256!==null&&!/^[a-f0-9]{64}$/.test(row.sha256)||row.preparedSha256!==null&&!/^[a-f0-9]{64}$/.test(row.preparedSha256))fail('Invalid settings layout configuration review',[SETTINGS_LAYOUT_FILE]);const content=await ordinary(root,row.path);if(![row.sha256,row.preparedSha256].includes(content===null?null:digest(content))&&!(row.path==='tsconfig.json'&&row.preparedSha256!==null&&typescriptConfigurationHash(content)===row.preparedSha256))fail('Module resolution changed after layout review',[row.path]);}
+  const originals=new Map(),observations=[];
+  for(const file of value.files){const content=await ordinary(root,file.path);if(content===null)fail('A reviewed layout dependency is missing',[file.path]);originals.set(file.path,originalText(content,file,value));observations.push({path:file.path,content,state:'unchanged'});}
+  const found=await discover(root,originals);
+  if(found.rootLayout!==value.rootLayout||JSON.stringify(found.slots)!==JSON.stringify(value.slots)||JSON.stringify(found.files.map(file=>({path:file.path,sha256:digest(file.content)})))!==JSON.stringify(value.files))fail('Layout review no longer matches its source dependency closure',[SETTINGS_LAYOUT_FILE]);
+  return {...value,root,originals,observations:[...observations,...found.configs,{path:SETTINGS_LAYOUT_FILE,content:text,state:'unchanged'}]};
+}
+function serverTemplate(review,config,native){return `// Generated settings owner for the reviewed native root layout. No private value enters props.\nimport type { ReactNode } from 'react';\nimport { connection } from 'next/server';\nimport { headers } from 'next/headers';\nimport { WebsiteProvider } from '@universalcms/connect/react-website';\nimport { createWebsiteRuntime } from '@universalcms/connect/website-runtime';\nimport '@universalcms/connect/website.css';\nimport configuration from ${JSON.stringify(relative(review.serverFile,'.universalcms/publication.config.json'))};\nconst runtime = createWebsiteRuntime({ configuration: configuration as Parameters<typeof createWebsiteRuntime>[0]['configuration']${native ? ', nativePaths: '+JSON.stringify(native.nativePaths)+', nativePatterns: '+JSON.stringify(native.nativePatterns) : ''} });\nexport default async function UniversalCmsLayout({children}: {children: ReactNode}) {\n  await connection();\n  const current = (await headers()).get('x-universalcms-layout-path');\n  let pathname: string | null = null;\n  try { if (current) pathname = decodeURIComponent(current); } catch {}\n  const [snapshot, page] = await Promise.all([runtime.settings(), pathname ? runtime.page(pathname) : Promise.resolve(null)]);\n  return <WebsiteProvider scope=${JSON.stringify(config.siteId+':'+config.environmentId)} initialSettings={snapshot} entry={page?.state === 'published' ? page.entry : undefined}>{children}</WebsiteProvider>;\n}\n`;}
+function transform(text,filename,review){
+  const ast=parse(filename,text),edits=[],kinds=review.slots.filter(slot=>slot.path===filename).map(slot=>slot.kind);
+  let insertion=0;for(const statement of ast.statements){if(ts.isExpressionStatement(statement)&&ts.isStringLiteral(statement.expression))insertion=statement.end;else break;}
+  let imports='';if(kinds.length){imports+=slotImport(kinds);for(const {kind,node} of slotsOf(ast,filename))edits.push({start:node.closingElement.pos,end:node.closingElement.pos,text:slotFragment(kind)});}
+  if(filename===review.rootLayout){imports+=layoutImport(review);const body=bodyOf(ast,filename);edits.push({start:body.openingElement.end,end:body.openingElement.end,text:'<__UniversalCmsLayout>'},{start:body.closingElement.pos,end:body.closingElement.pos,text:'</__UniversalCmsLayout>'});}
+  if(imports)edits.push({start:insertion,end:insertion,text:imports});
+  for(const edit of edits.sort((a,b)=>b.start-a.start))text=text.slice(0,edit.start)+edit.text+text.slice(edit.end);
+  return text;
+}
+export async function planNextSettingsLayout(directory,config,native=null){
+  const review=await inspectSettingsLayoutReview(directory);if(!review)return null;
+  const paths=new Set([review.rootLayout,...review.slots.map(slot=>slot.path)]),files=[];
+  for(const filename of paths){const current=await ordinary(review.root,filename),base=stripGenerated(current,filename,review),content=transform(base,filename,review);files.push({path:filename,content,state:current===content?'unchanged':'update',...(current!==content?{previous:current}:{})});}
+  const content=serverTemplate(review,config,native),old=await ordinary(review.root,review.serverFile);if(old!==null&&old!==content)fail('The native settings server adapter was customized',[review.serverFile]);
+  files.push({path:review.serverFile,content,state:old===null?'create':'unchanged'});
+  return {review,files,observations:review.observations};
+}

package/dist/next-source.d.mts

@@ -0,0 +1,8 @@
+/** Bounded public static-page discovery. No delivery credentials are accepted. */
+export declare function createNextSourceHandler(options: {
+  sourceRoot: string;
+  configuration: unknown;
+  snapshot: unknown;
+  /** Optional reviewed public documents retained alongside automatic pages. */
+  baseManifest?: () => unknown | Promise<unknown>;
+}): (request: Request) => Promise<Response>;

package/dist/next-source.mjs

@@ -0,0 +1,93 @@
+import { createSourceManifestProvider } from './vendor/source-manifest-provider.mjs';
+import { validateSourceConfiguration } from './source-config.mjs';
+import { REVIEWED_ICECREAM_PROFILE, reviewedNativePaths } from './content-registry-validation.mjs';
+
+const plain = value => value && typeof value === 'object' && !Array.isArray(value);
+function diagnosticsFor(snapshot) {
+  if (!plain(snapshot) || Object.keys(snapshot).sort().join() !== 'diagnostics,entries,version' || snapshot.version !== 1 || !Array.isArray(snapshot.entries) || snapshot.entries.length > 1000) throw Error('Invalid source snapshot');
+  const value = snapshot.diagnostics;
+  const keys = plain(value) && Object.hasOwn(value, 'nativeOwnership')
+    ? 'automaticPages,discoveredPages,nativeOwnership,skippedPages,unsupportedRoutes,warnings'
+    : 'automaticPages,discoveredPages,skippedPages,unsupportedRoutes,warnings';
+  if (!plain(value) || Object.keys(value).sort().join() !== keys ||
+      !['automaticPages', 'discoveredPages', 'skippedPages', 'unsupportedRoutes'].every(key => Number.isSafeInteger(value[key]) && value[key] >= 0 && value[key] <= 1000) ||
+      value.automaticPages !== snapshot.entries.length || !Array.isArray(value.warnings) || value.warnings.length > 1000 ||
+      value.warnings.some(item => !plain(item) || Object.keys(item).sort().join() !== 'codes,slug' || typeof item.slug !== 'string' || item.slug.length > 160 || !/^[a-z0-9]+(?:[-/][a-z0-9]+)*$/.test(item.slug) || !Array.isArray(item.codes) || item.codes.length > 30 || item.codes.some(code => typeof code !== 'string' || !/^[a-z-]{1,80}$/.test(code)))) throw Error('Invalid source diagnostics');
+  if (Object.hasOwn(value, 'nativeOwnership')) {
+    const native = value.nativeOwnership;
+    if (!plain(native) || Object.keys(native).sort().join() !== 'paths,profile' || native.profile !== REVIEWED_ICECREAM_PROFILE ||
+        !Array.isArray(native.paths) || JSON.stringify(native.paths) !== JSON.stringify(reviewedNativePaths(native.profile))) throw Error('Invalid native source diagnostics');
+  }
+  return { warnings: value.warnings.length, unsupported: value.unsupportedRoutes };
+}
+
+/** Next 16 can construct an internal localhost Request.url while retaining the
+ * original 127.0.0.1/[::1] Host header. Normalize only that observed loopback
+ * alias, never an arbitrary forwarded or hosted origin. The generic provider
+ * still enforces exact Host, CMS Origin, scope and credential rejection. */
+function nextSourceRequest(request, source) {
+  // Read framework getters outside error handling so Next runtime signals pass
+  // through unchanged instead of turning into ordinary source errors.
+  const method = request.method, headers = request.headers, raw = request.url;
+  let url = raw;
+  if (headers.get('host') === source.host && ['127.0.0.1', '[::1]'].includes(source.hostname)) {
+    let parsed;
+    try { parsed = new URL(raw); } catch { /* The provider rejects malformed URLs. */ }
+    if (parsed && parsed.hostname === 'localhost' && parsed.protocol === source.protocol && parsed.port === source.port && !parsed.username && !parsed.password) {
+      parsed.hostname = source.hostname;
+      url = parsed.href;
+    }
+  }
+  return { method, url, headers };
+}
+
+function respond(provider, request) {
+  let status = 404, headers = { 'Cache-Control': 'no-store' }, body;
+  provider({ method: request.method, url: request.url, headers: Object.fromEntries(request.headers.entries()) }, {
+    writeHead(code, values) { status = code; headers = values; }, end(value) { body = value; },
+  });
+  return new Response(request.method === 'HEAD' || status === 204 ? null : body, { status, headers });
+}
+
+/** Dev reads route sources afresh; production uses the snapshot refreshed by prebuild. */
+export function createNextSourceHandler({ sourceRoot, configuration, snapshot, baseManifest = () => ({ version: 1, entries: [] }) }) {
+  const config = validateSourceConfiguration(configuration), source = new URL(config.websiteOrigin);
+  const binding = { siteId: config.siteId, environmentId: config.environmentId, sourceOrigin: config.websiteOrigin, adminOrigin: config.adminOrigin, publicContent: true };
+  const probe = createSourceManifestProvider({ ...binding, manifestJson: '{"version":1,"entries":[]}' });
+  let pending;
+  async function read() {
+    const base = await baseManifest();
+    createSourceManifestProvider({ ...binding, manifestJson: JSON.stringify(base) });
+    const baseIds = new Set(base.entries.map(entry => `${entry.kind}:${entry.locale}:${entry.slug}`));
+    if (config.skipSlugs.some(slug => !baseIds.has(`page:${config.locale}:${slug}`))) throw Error('Missing reviewed source document');
+    // Keep the compiler/inspection modules out of the production route bundle.
+    const generated = process.env.NODE_ENV === 'production' ? snapshot : await (await import('./source-collect.mjs')).collectSource({ root: sourceRoot, locale: config.locale, skipSlugs: config.skipSlugs, excludedRoutes: config.excludedRoutes });
+    const { warnings, unsupported } = diagnosticsFor(generated);
+    const entries = [...base.entries, ...generated.entries.filter(entry => !baseIds.has(`${entry.kind}:${entry.locale}:${entry.slug}`))];
+    const provider = createSourceManifestProvider({ ...binding, manifestJson: JSON.stringify({ version: 1, entries }) });
+    return { provider, warnings, unsupported };
+  }
+  return async function handle(request) {
+    // Request getters remain outside the catch so Next runtime signals propagate.
+    const incoming = nextSourceRequest(request, source);
+    const gate = respond(probe, incoming);
+    if (gate.status !== 200 || !['GET', 'HEAD'].includes(request.method)) return gate;
+    if (config.exportClosed) return new Response(request.method === 'HEAD' ? null : JSON.stringify({ version: 1, siteId: config.siteId, environmentId: config.environmentId, sourceExport: 'closed' }), {
+      status: 410, headers: { 'Content-Type': 'application/json', 'Cache-Control': 'no-store', 'Access-Control-Allow-Origin': config.adminOrigin, 'Vary': 'Origin', 'X-Content-Type-Options': 'nosniff' },
+    });
+    try {
+      // Collapse concurrent scans only; never cache completed source inventories.
+      pending ??= read().finally(() => { pending = undefined; });
+      const result = await pending;
+      const response = respond(result.provider, incoming);
+      response.headers.set('Access-Control-Expose-Headers', 'ETag, X-UniversalCMS-Source-Warnings, X-UniversalCMS-Source-Omitted');
+      response.headers.set('X-UniversalCMS-Source-Warnings', String(result.warnings));
+      response.headers.set('X-UniversalCMS-Source-Omitted', String(result.unsupported));
+      return response;
+    } catch {
+      return new Response(request.method === 'HEAD' ? null : JSON.stringify({ error: 'Automatic source export could not be prepared. Run universalcms-connect sync-source in the website project and review its diagnostics.' }), {
+        status: 503, headers: { 'Content-Type': 'application/json', 'Cache-Control': 'no-store', 'Access-Control-Allow-Origin': config.adminOrigin, 'Vary': 'Origin', 'X-Content-Type-Options': 'nosniff' },
+      });
+    }
+  };
+}