@universalcms/connect 0.1.0 → 0.13.0

package/dist/source-collect.mjs

@@ -0,0 +1,80 @@
+import { projectRoot, readProjectFile } from './project-files.mjs';
+import { inspectSourceRoutes } from './source-routes.mjs';
+import { extractStaticPage } from './source-extract.mjs';
+import { nextPublicationProxyTemplate } from './publication-next-setup.mjs';
+import { readContentRegistry, readFrozenContent } from './content-registry.mjs';
+import { inspectReviewedNativeOwnership } from './reviewed-native-ownership.mjs';
+import { REVIEWED_NEXT_NATIVE_PROFILE } from './native-routes.mjs';
+import { inspectReviewedCommerceOwnership } from './reviewed-commerce-ownership.mjs';
+
+const protectedSegment = /^(?:admin|account|dashboard|profile|auth|login|register|checkout|orders|settings|billing|portal|patient|patients|vault|records)(?:-|$)|(?:^|-)vault$|^(?:medical|health)-records(?:-|$)/;
+const accessLogic = /\b(?:cookies|headers|useSession|getServerSession|auth|requireAuth|currentUser|redirect)\s*\(/;
+
+/** Parse public static source only. No page execution, HTML fetching or CMS writes. */
+export async function collectSource({ root: directory, locale = 'en', skipSlugs = [], excludedRoutes = [] }) {
+  const root = await projectRoot(directory), inventory = await inspectSourceRoutes(root);
+  if (inventory.routes.includes('') && inventory.routes.includes('home')) throw Error('Ambiguous home identity');
+  const entries = [], warnings = [];
+  const content = await readContentRegistry(root);
+  let websiteSettings = null;
+  if (await readProjectFile(root, '.universalcms/website.integration.json') !== null) {
+    // Website runtimes (for example a bundled Next source route) must not bundle
+    // the setup toolchain and its framework compilers. Node resolves it on demand.
+    // A non-literal specifier keeps bundlers from copying the module as an asset.
+    const setup = new URL(['.', 'website-setup.mjs'].join('/'), import.meta.url).href;
+    const { planWebsiteSettings } = await import(/* webpackIgnore: true */ /* turbopackIgnore: true */ /* @vite-ignore */ setup);
+    websiteSettings = await planWebsiteSettings(root);
+  }
+  const nativeOwnership = await inspectReviewedNativeOwnership(root) ?? await inspectReviewedCommerceOwnership(root);
+  // The reviewed product detail module accounts for exactly one dynamic route.
+  // Any other unresolved route remains in the diagnostic count for review.
+  const reviewedDynamic = name => nativeOwnership?.dynamicDirectories?.includes(name) || nativeOwnership?.profile === 'reviewed-icecream-commerce-2026-10-15' && name === 'src/app/menu/[id]' || websiteSettings?.files.some(file => ['js','jsx','ts','tsx'].some(ext => file.path === `${name}/page.${ext}`));
+  let skippedPages = 0, unsupportedRoutes = inventory.unresolvedPaths.filter(name => !reviewedDynamic(name)).length, bytes = 0;
+  const hasMiddleware = (await Promise.all(['middleware', 'src/middleware', 'proxy', 'src/proxy'].flatMap(name => ['js', 'ts'].map(async extension => {
+    const content = await readProjectFile(root, `${name}.${extension}`);
+    if (!content) return false;
+    if (websiteSettings?.files.some(file => file.path === `${name}.${extension}` && file.content === content)) return false;
+    // Our exact generated proxy only filters publications; it adds no private
+    // application content. Every other middleware still requires access review.
+    return !(extension === 'ts' && (name === 'proxy' && [nextPublicationProxyTemplate('app'), nextPublicationProxyTemplate('app', true)].includes(content) || name === 'src/proxy' && [nextPublicationProxyTemplate('src/app'), nextPublicationProxyTemplate('src/app', true)].includes(content)));
+  })))).some(Boolean);
+  const excludes = pathname => excludedRoutes.some(route => route === '/' || pathname === route || pathname.startsWith(`${route}/`));
+  const started = Date.now();
+  for (const route of [...inventory.routes].sort()) {
+    if (Date.now() - started > 8000) throw Error('Source inspection deadline');
+    const slug = route || 'home', filename = inventory.files[slug];
+    if (nativeOwnership?.nativePaths.includes(`/${route}`)) { skippedPages++; continue; }
+    if (skipSlugs.includes(slug) || excludes(`/${route}`)) { skippedPages++; continue; }
+    // Conservative guards, not a replacement for choosing a public-content root.
+    if (hasMiddleware || route.split('/').some(segment => protectedSegment.test(segment))) {
+      unsupportedRoutes++; warnings.push({ slug, codes: ['access-review-required'] }); continue;
+    }
+    const bound = content?.routes.find(row => row.sourceFile === filename && row.path === `/${route}` && row.kind === 'page' && row.slug === slug && row.locale === locale);
+    const source = await readProjectFile(root, filename);
+    if (source === null) throw Error('Source changed during inspection');
+    bytes += Buffer.byteLength(source);
+    if (bytes > 8 * 1024 * 1024) throw Error('Source inventory byte budget');
+    let guarded = accessLogic.test(source);
+    const parts = filename.split('/'); parts.pop();
+    while (parts.length) {
+      for (const ext of ['js', 'jsx', 'ts', 'tsx']) {
+        const layout = await readProjectFile(root, `${parts.join('/')}/layout.${ext}`);
+        if (layout && accessLogic.test(layout)) guarded = true;
+      }
+      if (parts.at(-1) === 'app') break;
+      parts.pop();
+    }
+    if (guarded) { unsupportedRoutes++; warnings.push({ slug, codes: ['access-review-required'] }); continue; }
+    // A frozen baseline does not freeze authorization. Ancestor layouts remain
+    // current application policy and must be checked before exporting its text.
+    if (bound) { entries.push((await readFrozenContent(root, bound)).entry); continue; }
+    const result = extractStaticPage({ source, slug, locale, filename });
+    if (Date.now() - started > 8000) throw Error('Source inspection deadline');
+    if (result.entry) entries.push(result.entry); else unsupportedRoutes++;
+    const codes = [...(result.warnings ?? []), ...(result.entry && content ? ['content-binding-required'] : [])];
+    if (codes.length) warnings.push({ slug, codes });
+  }
+  const snapshot = { version: 1, entries, diagnostics: { discoveredPages: inventory.routes.length, automaticPages: entries.length, skippedPages, unsupportedRoutes, warnings, ...(nativeOwnership && nativeOwnership.profile !== REVIEWED_NEXT_NATIVE_PROFILE ? { nativeOwnership: { profile:nativeOwnership.profile,paths:nativeOwnership.nativePaths } } : {}) } };
+  if (Buffer.byteLength(JSON.stringify(snapshot)) > 20 * 1024 * 1024) throw Error('Source response byte budget');
+  return snapshot;
+}

package/dist/source-config.mjs

@@ -0,0 +1,20 @@
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const slug = /^[a-z0-9]+(?:[-/][a-z0-9]+)*$/;
+const fail = () => { throw Error('Invalid automatic source configuration'); };
+function origin(value) {
+  if (typeof value !== 'string' || value.length > 2048 || /[\s\\]|cms_server\.|sk-[\w-]{12,}/i.test(value)) return fail();
+  const url = new URL(value);
+  if (url.username || url.password || url.search || url.hash || url.pathname !== '/' ||
+      !(url.protocol === 'https:' || url.protocol === 'http:' && ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname))) return fail();
+  return url.origin;
+}
+export function validateSourceConfiguration(value) {
+  const names = ['version', 'siteId', 'environmentId', 'websiteOrigin', 'adminOrigin', 'locale', 'skipSlugs', 'excludedRoutes', 'publicStaticPages', 'exportClosed'];
+  if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).some(key => !names.includes(key)) || (value.exportClosed !== undefined && value.exportClosed !== true) || value.version !== 1 || value.publicStaticPages !== true || typeof value.siteId !== 'string' || typeof value.environmentId !== 'string' || !uuid.test(value.siteId) || !uuid.test(value.environmentId)) return fail();
+  const locale = value.locale ?? 'en';
+  if (typeof locale !== 'string' || locale.length > 35 || Intl.getCanonicalLocales(locale).length !== 1) return fail();
+  const skipSlugs = value.skipSlugs ?? [], excludedRoutes = value.excludedRoutes ?? [];
+  if (!Array.isArray(skipSlugs) || skipSlugs.length > 1000 || skipSlugs.some(item => typeof item !== 'string' || item.length > 160 || !slug.test(item)) || new Set(skipSlugs).size !== skipSlugs.length) return fail();
+  if (!Array.isArray(excludedRoutes) || excludedRoutes.length > 1000 || excludedRoutes.some(item => typeof item !== 'string' || item.length > 161 || item !== '/' && (!item.startsWith('/') || !slug.test(item.slice(1)))) || new Set(excludedRoutes).size !== excludedRoutes.length) return fail();
+  return { version: 1, siteId: value.siteId.toLowerCase(), environmentId: value.environmentId.toLowerCase(), websiteOrigin: origin(value.websiteOrigin), adminOrigin: origin(value.adminOrigin), locale: Intl.getCanonicalLocales(locale)[0], skipSlugs: [...skipSlugs], excludedRoutes: [...excludedRoutes], publicStaticPages: true, ...(value.exportClosed ? { exportClosed: true } : {}) };
+}

package/dist/source-extract.mjs

@@ -0,0 +1,514 @@
+/**
+ * Bounded, inert TSX-to-text projection. This is an AST interpreter for a small
+ * data/JSX subset, never an evaluator of customer JavaScript. The result is a
+ * draft source projection, not proof that an arbitrary React page is complete.
+ */
+import ts from './vendor/typescript.cjs';
+import { createHash } from 'node:crypto';
+
+export const SOURCE_EXTRACT_LIMITS = Object.freeze({ bytes: 512 * 1024, nodes: 30_000, depth: 100, steps: 200_000, blocks: 200, text: 30_000, array: 1000 });
+const UNKNOWN = Symbol('unknown'), FN = Symbol('inert-function'), TRACE = Symbol('source-trace');
+const privateKeys = new Set(['__proto__', 'prototype', 'constructor']);
+const excludedTags = new Set(['form', 'input', 'textarea', 'select', 'option', 'script', 'style', 'iframe', 'object', 'embed', 'noscript', 'svg', 'canvas']);
+const inlineTags = new Set(['span', 'strong', 'em', 'a', 'small', 'b', 'i', 'u', 's', 'del', 'sup', 'sub', 'code', 'mark', 'label']);
+const partialCodes = new Set(['component-unresolved', 'expression-unresolved', 'collection-unresolved', 'conditional-unresolved', 'table-unresolved', 'source-mutation', 'component-flow-unresolved', 'presentation-filter-initial-state']);
+const primitive = value => value === null || value === undefined || ['string', 'number', 'boolean'].includes(typeof value);
+const literalText = value => typeof value === 'string' || typeof value === 'number' ? String(value) : '';
+const normalize = value => value.replace(/\s+/g, ' ').trim();
+const jsxText = value => value.replace(/&(?:amp|lt|gt|quot|apos|nbsp|#\d{1,7}|#x[\da-fA-F]{1,6});/g, entity => {
+  const named = { '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"', '&apos;': "'", '&nbsp;': ' ' };
+  if (Object.hasOwn(named, entity)) return named[entity];
+  const code = entity.startsWith('&#x') ? Number.parseInt(entity.slice(3, -1), 16) : Number(entity.slice(2, -1));
+  return code > 0 && code <= 0x10ffff && (code < 0xd800 || code > 0xdfff) ? String.fromCodePoint(code) : entity;
+});
+const unbox = node => { while (node && (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isTypeAssertionExpression(node) || ts.isNonNullExpression(node) || ts.isSatisfiesExpression(node))) node = node.expression; return node; };
+const own = (object, key) => !privateKeys.has(String(key)) && Object.hasOwn(object, key);
+const uuid = key => { const value = createHash('sha256').update(key).digest('hex'); return `${value.slice(0, 8)}-${value.slice(8, 12)}-5${value.slice(13, 16)}-a${value.slice(17, 20)}-${value.slice(20, 32)}`; };
+
+/** No filesystem, network, dynamic import, eval, or customer function execution. */
+export function extractStaticPage({ source, slug, locale = 'en', filename = 'page.tsx', includeBindings = false } = {}) {
+  const warnings = new Set();
+  let filteredRowsOmitted = false;
+  const failure = code => ({ entry: null, warnings: [...warnings, code].filter((value, index, all) => all.indexOf(value) === index).sort(), complete: false });
+  if (typeof source !== 'string' || Buffer.byteLength(source) > SOURCE_EXTRACT_LIMITS.bytes || typeof slug !== 'string' || slug.length > 160 || !/^[a-z0-9]+(?:[-/][a-z0-9]+)*$/.test(slug) || typeof locale !== 'string' || !/^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/.test(locale)) return failure('invalid-input');
+  let steps = 0;
+  const step = depth => { if (++steps > SOURCE_EXTRACT_LIMITS.steps || depth > SOURCE_EXTRACT_LIMITS.depth) throw Error('budget'); };
+  try {
+    // filename is a parser hint only; it is never opened or emitted.
+    const file = ts.createSourceFile(typeof filename === 'string' ? filename.slice(-200) : 'page.tsx', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+    if (file.parseDiagnostics.length) return failure('syntax-error');
+    let nodes = 0;
+    const count = (node, depth = 0) => { if (++nodes > SOURCE_EXTRACT_LIMITS.nodes || depth > SOURCE_EXTRACT_LIMITS.depth) throw Error('budget'); ts.forEachChild(node, child => count(child, depth + 1)); };
+    count(file);
+    const moduleScope = new Map(), hooks = new Map(), setters = new Map(), selectors = new Set(), iconNames = new Set(), mutated = new Set(), stateImports = new Set(), reactImports = new Set();
+    let component;
+    const addDeclarations = (statements, scope) => {
+      for (const statement of statements) if (ts.isVariableStatement(statement) && statement.declarationList.flags & ts.NodeFlags.Const) {
+        for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name) && declaration.initializer) scope.set(declaration.name.text, { expression: declaration.initializer, scope });
+      }
+    };
+    addDeclarations(file.statements, moduleScope);
+    for (const statement of file.statements) {
+      if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === 'react') {
+        if (statement.importClause?.name) reactImports.add(statement.importClause.name.text);
+        const names = statement.importClause?.namedBindings;
+        if (names && ts.isNamespaceImport(names)) reactImports.add(names.name.text);
+        if (names && ts.isNamedImports(names)) for (const element of names.elements) if ((element.propertyName?.text ?? element.name.text) === 'useState') stateImports.add(element.name.text);
+      }
+      if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === 'lucide-react') {
+        const names = statement.importClause?.namedBindings;
+        if (names && ts.isNamedImports(names)) for (const element of names.elements) iconNames.add(element.name.text);
+      }
+      if (ts.isFunctionDeclaration(statement) && statement.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.DefaultKeyword)) component = statement;
+      if (ts.isExportAssignment(statement)) {
+        const expression = unbox(statement.expression);
+        if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)) component = expression;
+        else if (ts.isIdentifier(expression)) {
+          const declaration = file.statements.find(candidate => ts.isFunctionDeclaration(candidate) && candidate.name?.text === expression.text);
+          component = declaration ?? unbox(moduleScope.get(expression.text)?.expression);
+        }
+      }
+    }
+    if (!component || !component.body || !(ts.isFunctionDeclaration(component) || ts.isFunctionExpression(component) || ts.isArrowFunction(component))) return failure('component-unresolved');
+    // A zero-prop local component under React's Suspense boundary is still the
+    // same public page. Follow only this exact transparent wrapper shape; never
+    // infer custom HOCs, access guards, prop-dependent pages or imported code.
+    const suspenseNames = new Set();
+    for (const statement of file.statements) if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier) && statement.moduleSpecifier.text === 'react' && statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause.namedBindings)) {
+      for (const item of statement.importClause.namedBindings.elements) if ((item.propertyName?.text ?? item.name.text) === 'Suspense') suspenseNames.add(item.name.text);
+    }
+    const wrappedReturn = candidate => {
+      if (candidate.parameters.length !== 0 || !ts.isBlock(candidate.body) || candidate.body.statements.length !== 1 || !ts.isReturnStatement(candidate.body.statements[0])) return null;
+      const body = unbox(candidate.body.statements[0].expression);
+      if (!body || !ts.isJsxElement(body) || !suspenseNames.has(body.openingElement.tagName.getText(file))) return null;
+      if (body.openingElement.attributes.properties.some(attribute => !ts.isJsxAttribute(attribute) || attribute.name.getText(file) !== 'fallback')) return null;
+      const children = body.children.filter(child => !(ts.isJsxText(child) && !child.text.trim()) && !(ts.isJsxExpression(child) && !child.expression));
+      const child = children.length === 1 ? children[0] : null;
+      if (!child || !ts.isJsxSelfClosingElement(child) || !ts.isIdentifier(child.tagName) || child.attributes.properties.length) return null;
+      const target = file.statements.find(statement => ts.isFunctionDeclaration(statement) && statement.name?.text === child.tagName.text);
+      return target?.body && target.parameters.length === 0 ? target : null;
+    };
+    const wrapped = wrappedReturn(component);
+    if (wrapped) component = wrapped;
+    const componentScope = new Map(moduleScope);
+    if (ts.isBlock(component.body)) {
+      addDeclarations(component.body.statements, componentScope);
+      for (const statement of component.body.statements) if (ts.isVariableStatement(statement)) for (const declaration of statement.declarationList.declarations) {
+        const initializer = unbox(declaration.initializer);
+        if (!ts.isArrayBindingPattern(declaration.name) || !initializer || !ts.isCallExpression(initializer) || initializer.arguments.length !== 1) continue;
+        const callee = initializer.expression;
+        if (!(ts.isIdentifier(callee) && stateImports.has(callee.text) || ts.isPropertyAccessExpression(callee) && callee.name.text === 'useState' && ts.isIdentifier(callee.expression) && reactImports.has(callee.expression.text))) continue;
+        const [state, setter] = declaration.name.elements;
+        if (state && setter && ts.isBindingElement(state) && ts.isBindingElement(setter) && ts.isIdentifier(state.name) && ts.isIdentifier(setter.name)) {
+          hooks.set(state.name.text, initializer.arguments[0]); setters.set(setter.name.text, state.name.text);
+          componentScope.delete(state.name.text); componentScope.delete(setter.name.text);
+        }
+      }
+    }
+    // Mutated module objects are not immutable public data, even when declared
+    // const. Detect direct writes and unrecognized calls on their member paths.
+    const rootName = node => { node = unbox(node); while (node && (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node))) node = unbox(node.expression); return node && ts.isIdentifier(node) ? node.text : undefined; };
+    const aliases = new Map();
+    const aliasScan = node => {
+      if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+        // Objects/arrays can wrap references as well as directly alias them.
+        // Conservatively track every initializer dependency: an opaque call
+        // receiving { items: ITEMS } may sanitize or mutate ITEMS in place.
+        const values = aliases.get(node.name.text) ?? new Set();
+        const dependencies = item => {
+          step(0);
+          if (ts.isIdentifier(item) && item.text !== node.name.text && !(ts.isPropertyAccessExpression(item.parent) && item.parent.name === item) && !(ts.isPropertyAssignment(item.parent) && item.parent.name === item)) values.add(item.text);
+          ts.forEachChild(item, dependencies);
+        };
+        dependencies(node.initializer); aliases.set(node.name.text, values);
+      }
+      ts.forEachChild(node, aliasScan);
+    };
+    aliasScan(file);
+    for (const [state, initial] of hooks) { const from = rootName(initial); if (from) aliases.set(state, new Set([from])); }
+    const taint = (name, seen = new Set()) => {
+      step(0);
+      if (!name || seen.has(name)) return;
+      seen.add(name); if (moduleScope.has(name)) mutated.add(name);
+      for (const from of aliases.get(name) ?? []) taint(from, seen);
+    };
+    const taintReferences = node => {
+      if (ts.isIdentifier(node) && !(ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) && !(ts.isPropertyAssignment(node.parent) && node.parent.name === node)) taint(node.text);
+      ts.forEachChild(node, taintReferences);
+    };
+    const taintAll = () => { for (const name of moduleScope.keys()) mutated.add(name); };
+    // Unsupported executable module flow (loops, conditional sanitization,
+    // destructuring mutations, etc.) invalidates the assumption that literal
+    // module constants still describe public data when the page renders.
+    for (const statement of file.statements) if (!(ts.isImportDeclaration(statement) || ts.isImportEqualsDeclaration(statement) || ts.isExportDeclaration(statement) || ts.isExportAssignment(statement) || ts.isVariableStatement(statement) || ts.isFunctionDeclaration(statement) || ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement) || ts.isEmptyStatement(statement) || ts.isExpressionStatement(statement) && ts.isStringLiteral(statement.expression))) taintAll();
+    const eagerlyCalled = node => {
+      for (let parent = node.parent; parent; parent = parent.parent) {
+        if (parent === component) return true;
+        if (ts.isFunctionLike(parent)) return false;
+        if (ts.isSourceFile(parent)) return true;
+      }
+      return false;
+    };
+    const mutationScan = node => {
+      if (ts.isBinaryExpression(node) && node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment || ts.isPrefixUnaryExpression(node) && [ts.SyntaxKind.PlusPlusToken, ts.SyntaxKind.MinusMinusToken].includes(node.operator) || ts.isPostfixUnaryExpression(node)) {
+        taint(rootName(ts.isBinaryExpression(node) ? node.left : node.operand));
+      }
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && !['map', 'filter', 'slice', 'includes', 'toLowerCase', 'toUpperCase', 'trim', 'join', 'toFixed'].includes(node.expression.name.text)) {
+        taint(rootName(node.expression.expression));
+      }
+      if (ts.isCallExpression(node)) {
+        const callee = node.expression;
+        const stateCall = ts.isIdentifier(callee) && stateImports.has(callee.text) || ts.isPropertyAccessExpression(callee) && callee.name.text === 'useState' && ts.isIdentifier(callee.expression) && reactImports.has(callee.expression.text);
+        const readCall = ts.isPropertyAccessExpression(callee) && ['map', 'filter', 'slice', 'includes', 'toLowerCase', 'toUpperCase', 'trim', 'join', 'toFixed'].includes(callee.name.text);
+        // Passing a constant (or an alias) to arbitrary project code can mutate
+        // or sanitize it. Do not project an earlier literal as current content.
+        if (!stateCall && !readCall) {
+          for (const argument of node.arguments) taintReferences(argument);
+          // An opaque call can reach a constant via closures, destructuring,
+          // getters or indirect aliases that this small interpreter does not
+          // model. At execution scope, fail closed for all module data.
+          if (eagerlyCalled(node)) taintAll();
+        }
+      }
+      ts.forEachChild(node, mutationScan);
+    };
+    mutationScan(file);
+    if (mutated.size) warnings.add('source-mutation');
+    // Only controls outside forms establish a presentation selector. Hook
+    // initializers still never become ordinary content-interpolation values.
+    const controlScan = (node, scope, excluded = false, depth = 0) => {
+      step(depth);
+      // A control hidden behind an unresolved guard is not evidence that the
+      // associated state is a public presentation filter.
+      if (ts.isConditionalExpression(node) || ts.isBinaryExpression(node) && [ts.SyntaxKind.AmpersandAmpersandToken, ts.SyntaxKind.BarBarToken].includes(node.operatorToken.kind)) return;
+      if (ts.isCallExpression(node)) {
+        const rows = mapRows(node, scope, depth);
+        if (rows) for (const row of rows) if (row.node) controlScan(row.node, row.scope, excluded, depth + 1);
+        return;
+      }
+      const opening = ts.isJsxElement(node) ? node.openingElement : ts.isJsxSelfClosingElement(node) ? node : null;
+      if (opening) {
+        const tag = opening.tagName.getText(file);
+        excluded ||= tag === 'form' || /^[A-Z]/.test(tag) || opening.attributes.properties.some(attribute => ts.isJsxSpreadAttribute(attribute) || ts.isJsxAttribute(attribute) && ['data-cms-exclude', 'data-cms-private', 'hidden'].includes(attribute.name.getText(file)));
+        if (!excluded && ['button', 'input', 'select'].includes(tag)) for (const attribute of opening.attributes.properties) {
+          if (!ts.isJsxAttribute(attribute) || !['onClick', 'onChange'].includes(attribute.name.getText(file)) || !attribute.initializer || !ts.isJsxExpression(attribute.initializer)) continue;
+          const handler = unbox(attribute.initializer.expression);
+          if (!handler || !(ts.isArrowFunction(handler) || ts.isFunctionExpression(handler)) || handler.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword) || handler.parameters.length > 1 || handler.parameters.some(parameter => !ts.isIdentifier(parameter.name))) continue;
+          const body = ts.isBlock(handler.body) && handler.body.statements.length === 1 && ts.isExpressionStatement(handler.body.statements[0]) ? handler.body.statements[0].expression : handler.body;
+          const call = unbox(body);
+          if (!ts.isCallExpression(call) || !ts.isIdentifier(call.expression) || !setters.has(call.expression.text) || call.arguments.length !== 1) continue;
+          const state = setters.get(call.expression.text), initial = evaluate(hooks.get(state), moduleScope, false, depth + 1);
+          // Boolean state frequently represents access or verification. It is
+          // never evidence for expanding a conditional public-content branch.
+          if (!(initial === null || typeof initial === 'string' || typeof initial === 'number' && Number.isFinite(initial))) continue;
+          const argument = unbox(call.arguments[0]), parameter = handler.parameters[0]?.name;
+          const inputValue = attribute.name.getText(file) === 'onChange' && ['input', 'select'].includes(tag) && parameter && ts.isIdentifier(parameter) && ts.isPropertyAccessExpression(argument) && argument.name.text === 'value' && ts.isPropertyAccessExpression(argument.expression) && ['target', 'currentTarget'].includes(argument.expression.name.text) && ts.isIdentifier(argument.expression.expression) && argument.expression.expression.text === parameter.text;
+          const already = selectors.has(state);
+          selectors.add(state);
+          const value = inputValue ? '' : evaluate(argument, scope, true, depth + 1);
+          if (!(value === null || typeof value === 'string' || typeof value === 'number' && Number.isFinite(value)) && !already) selectors.delete(state);
+        }
+      }
+      ts.forEachChild(node, child => controlScan(child, scope, excluded, depth + 1));
+    };
+    let returned;
+    if (ts.isBlock(component.body)) {
+      const returns = component.body.statements.filter(statement => ts.isReturnStatement(statement));
+      if (returns.length !== 1 || component.body.statements.some(statement => !ts.isVariableStatement(statement) && !ts.isReturnStatement(statement) && !ts.isFunctionDeclaration(statement) && !ts.isEmptyStatement(statement))) return failure('component-flow-unresolved');
+      returned = returns[0].expression;
+    } else returned = component.body;
+    const resolving = new Set();
+    const readBinding = (name, scope, mode, depth) => {
+      if (mutated.has(name)) return UNKNOWN;
+      if (hooks.has(name)) {
+        if (!mode || !selectors.has(name)) return UNKNOWN;
+        const initial = evaluate(hooks.get(name), moduleScope, false, depth + 1);
+        warnings.add('presentation-filter-initial-state');
+        return initial === null || typeof initial === 'string' || typeof initial === 'number' && Number.isFinite(initial) ? initial : UNKNOWN;
+      }
+      const binding = scope.get(name);
+      if (!binding) return name === 'undefined' ? undefined : UNKNOWN;
+      if (Object.hasOwn(binding, 'value')) return binding.value;
+      if (resolving.has(binding)) return UNKNOWN;
+      resolving.add(binding);
+      try { return evaluate(binding.expression, binding.scope, mode, depth + 1); }
+      finally { resolving.delete(binding); }
+    };
+    const callback = (node, parentScope, args, mode, depth) => {
+      step(depth); node = unbox(node);
+      if (!node || !(ts.isArrowFunction(node) || ts.isFunctionExpression(node)) || node.parameters.some(parameter => !ts.isIdentifier(parameter.name) || parameter.dotDotDotToken || parameter.initializer)) return UNKNOWN;
+      const scope = new Map(parentScope);
+      node.parameters.forEach((parameter, index) => scope.set(parameter.name.text, { value: args[index] }));
+      if (!ts.isBlock(node.body)) return evaluate(node.body, scope, mode, depth + 1);
+      addDeclarations(node.body.statements, scope);
+      for (const statement of node.body.statements) {
+        if (ts.isReturnStatement(statement)) return statement.expression ? evaluate(statement.expression, scope, mode, depth + 1) : undefined;
+        if (!ts.isVariableStatement(statement) || !(statement.declarationList.flags & ts.NodeFlags.Const)) return UNKNOWN;
+      }
+      return UNKNOWN;
+    };
+    function evaluate(node, scope, mode = false, depth = 0) {
+      const value = evaluateValue(node, scope, mode, depth);
+      if (typeof value === 'string' && value.length > SOURCE_EXTRACT_LIMITS.text) throw Error('budget');
+      return typeof value === 'number' && !Number.isFinite(value) ? UNKNOWN : value;
+    }
+    function evaluateValue(node, scope, mode = false, depth = 0) {
+      step(depth); node = unbox(node); if (!node) return UNKNOWN;
+      if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+      if (ts.isNumericLiteral(node)) return Number(node.text);
+      if (node.kind === ts.SyntaxKind.TrueKeyword) return true;
+      if (node.kind === ts.SyntaxKind.FalseKeyword) return false;
+      if (node.kind === ts.SyntaxKind.NullKeyword) return null;
+      if (ts.isIdentifier(node)) return readBinding(node.text, scope, mode, depth);
+      if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) return { [FN]: node, scope };
+      if (ts.isArrayLiteralExpression(node)) {
+        if (node.elements.length > SOURCE_EXTRACT_LIMITS.array) throw Error('budget');
+        const values = node.elements.map(element => evaluate(element, scope, mode, depth + 1));
+        return values.includes(UNKNOWN) ? UNKNOWN : values;
+      }
+      if (ts.isObjectLiteralExpression(node)) {
+        const value = Object.create(null);
+        for (const property of node.properties) {
+          if (!(ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) || !property.name || ts.isComputedPropertyName(property.name)) return UNKNOWN;
+          const key = ts.isIdentifier(property.name) || ts.isStringLiteral(property.name) || ts.isNumericLiteral(property.name) ? property.name.text : null;
+          if (key === null || privateKeys.has(key)) return UNKNOWN;
+          // Unknown presentation properties (e.g. icon components) do not make
+          // independent literal text properties unavailable.
+          value[key] = evaluate(ts.isPropertyAssignment(property) ? property.initializer : property.name, scope, mode, depth + 1);
+        }
+        return value;
+      }
+      if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) {
+        const value = evaluate(node.expression, scope, mode, depth + 1);
+        const key = ts.isPropertyAccessExpression(node) ? node.name.text : evaluate(node.argumentExpression, scope, mode, depth + 1);
+        if (value === UNKNOWN || key === UNKNOWN || value == null || privateKeys.has(String(key))) return UNKNOWN;
+        return (typeof value === 'object' || typeof value === 'string') && own(value, key) ? value[key] : undefined;
+      }
+      if (ts.isConditionalExpression(node)) {
+        const condition = evaluate(node.condition, scope, mode, depth + 1);
+        return condition === UNKNOWN ? UNKNOWN : evaluate(condition ? node.whenTrue : node.whenFalse, scope, mode, depth + 1);
+      }
+      if (ts.isPrefixUnaryExpression(node)) {
+        const value = evaluate(node.operand, scope, mode, depth + 1); if (value === UNKNOWN || !primitive(value)) return UNKNOWN;
+        if (node.operator === ts.SyntaxKind.ExclamationToken) return !value;
+        if (node.operator === ts.SyntaxKind.MinusToken && typeof value === 'number') return -value;
+        if (node.operator === ts.SyntaxKind.PlusToken && typeof value === 'number') return value;
+        return UNKNOWN;
+      }
+      if (ts.isBinaryExpression(node)) {
+        const left = evaluate(node.left, scope, mode, depth + 1), operator = node.operatorToken.kind;
+        if (left === UNKNOWN) return UNKNOWN;
+        if (operator === ts.SyntaxKind.AmpersandAmpersandToken) return left ? evaluate(node.right, scope, mode, depth + 1) : left;
+        if (operator === ts.SyntaxKind.BarBarToken) return left ? left : evaluate(node.right, scope, mode, depth + 1);
+        if (operator === ts.SyntaxKind.QuestionQuestionToken) return left == null ? evaluate(node.right, scope, mode, depth + 1) : left;
+        const right = evaluate(node.right, scope, mode, depth + 1);
+        if (right === UNKNOWN || !primitive(left) || !primitive(right)) return UNKNOWN;
+        if (operator === ts.SyntaxKind.EqualsEqualsEqualsToken) return left === right;
+        if (operator === ts.SyntaxKind.ExclamationEqualsEqualsToken) return left !== right;
+        if (operator === ts.SyntaxKind.PlusToken && ['string', 'number'].includes(typeof left) && ['string', 'number'].includes(typeof right)) return left + right;
+        if (typeof left === 'number' && typeof right === 'number') {
+          if (operator === ts.SyntaxKind.MinusToken) return left - right;
+          if (operator === ts.SyntaxKind.AsteriskToken) return left * right;
+          if (operator === ts.SyntaxKind.SlashToken && right !== 0) return left / right;
+          if (operator === ts.SyntaxKind.LessThanToken) return left < right;
+          if (operator === ts.SyntaxKind.GreaterThanToken) return left > right;
+          if (operator === ts.SyntaxKind.LessThanEqualsToken) return left <= right;
+          if (operator === ts.SyntaxKind.GreaterThanEqualsToken) return left >= right;
+        }
+        return UNKNOWN;
+      }
+      if (ts.isTemplateExpression(node)) {
+        let value = node.head.text;
+        for (const span of node.templateSpans) { const item = evaluate(span.expression, scope, mode, depth + 1); if (item === UNKNOWN || !primitive(item)) return UNKNOWN; value += String(item) + span.literal.text; if (value.length > SOURCE_EXTRACT_LIMITS.text) throw Error('budget'); }
+        return value;
+      }
+      if (ts.isCallExpression(node)) {
+        if (ts.isPropertyAccessExpression(node.expression)) {
+          const method = node.expression.name.text, value = evaluate(node.expression.expression, scope, mode, depth + 1);
+          if (value === UNKNOWN) return UNKNOWN;
+          if (method === 'filter' && Array.isArray(value) && node.arguments.length === 1) {
+            const filtered = [];
+            for (let index = 0; index < value.length; index++) { const keep = callback(node.arguments[0], scope, [value[index], index], mode, depth + 1); if (keep === UNKNOWN || typeof keep !== 'boolean') return UNKNOWN; if (keep) filtered.push(value[index]); }
+            if (mode && filtered.length !== value.length) filteredRowsOmitted = true;
+            return filtered;
+          }
+          const args = node.arguments.map(argument => evaluate(argument, scope, mode, depth + 1));
+          if (args.includes(UNKNOWN)) return UNKNOWN;
+          if (typeof value === 'string') {
+            if (!args.length && method === 'toLowerCase') return value.toLowerCase();
+            if (!args.length && method === 'toUpperCase') return value.toUpperCase();
+            if (!args.length && method === 'trim') return value.trim();
+            if (args.length === 1 && typeof args[0] === 'string' && method === 'includes') return value.includes(args[0]);
+          }
+          if (typeof value === 'number' && Number.isFinite(value) && method === 'toFixed' && args.length === 1 && Number.isInteger(args[0]) && args[0] >= 0 && args[0] <= 6) return value.toFixed(args[0]);
+          if (Array.isArray(value) && method === 'join' && value.every(primitive) && args.length <= 1 && (args[0] === undefined || typeof args[0] === 'string')) {
+            if (value.reduce((total, item) => total + (item == null ? 0 : String(item).length), 0) + Math.max(0, value.length - 1) * (args[0]?.length ?? 1) > SOURCE_EXTRACT_LIMITS.text) throw Error('budget');
+            return value.join(args[0]);
+          }
+          return UNKNOWN;
+        }
+        const fn = evaluate(node.expression, scope, mode, depth + 1);
+        if (!fn || typeof fn !== 'object' || !fn[FN]) return UNKNOWN;
+        const args = node.arguments.map(argument => evaluate(argument, scope, mode, depth + 1));
+        return args.includes(UNKNOWN) ? UNKNOWN : callback(fn[FN], fn.scope, args, mode, depth + 1);
+      }
+      return UNKNOWN;
+    }
+    const controlled = (node, scope, seen = new Set(), depth = 0) => {
+      step(depth); node = unbox(node); if (!node) return false;
+      if (ts.isIdentifier(node)) {
+        if (hooks.has(node.text)) return selectors.has(node.text) && evaluate(node, scope, true) !== UNKNOWN;
+        if (seen.has(node.text)) return false;
+        const binding = scope.get(node.text);
+        if (!binding) return false;
+        if (Object.hasOwn(binding, 'value')) return true;
+        return controlled(binding.expression, binding.scope, new Set([...seen, node.text]), depth + 1);
+      }
+      if (evaluate(node, scope, false, depth + 1) !== UNKNOWN) return true;
+      if (ts.isBinaryExpression(node)) return controlled(node.left, scope, seen, depth + 1) && controlled(node.right, scope, seen, depth + 1);
+      if (ts.isPrefixUnaryExpression(node)) return node.operator === ts.SyntaxKind.ExclamationToken && controlled(node.operand, scope, seen, depth + 1);
+      return false;
+    };
+    const pieces = [], bindings = [];
+    const describe = (node, scope, kind = 'element', end) => ({ start: node.getStart(file), end: end ?? node.end, kind, trace: scope.get(TRACE) ?? [] });
+    let firstHeading = '', firstH1 = '';
+    const emit = (type, raw, level, binding) => {
+      const text = normalize(raw); if (!text) return;
+      if (text.length > SOURCE_EXTRACT_LIMITS.text || pieces.length >= SOURCE_EXTRACT_LIMITS.blocks) throw Error('budget');
+      if (type === 'heading') { firstHeading ||= text; if (level === 1) firstH1 ||= text; }
+      bindings.push(binding);
+      pieces.push({ type, text, ...(type === 'heading' && level > 1 ? { data: { level: Math.min(level, 4) } } : {}) });
+    };
+    const opening = node => ts.isJsxElement(node) ? node.openingElement : ts.isJsxSelfClosingElement(node) ? node : null;
+    const omit = node => {
+      const tag = opening(node); if (!tag) return false;
+      const name = tag.tagName.getText(file);
+      if (excludedTags.has(name)) { if (['form', 'input', 'textarea', 'select'].includes(name)) warnings.add('interactive-content-omitted'); return true; }
+      if (tag.attributes.properties.some(attribute => ts.isJsxSpreadAttribute(attribute) || ts.isJsxAttribute(attribute) && ['data-cms-exclude', 'data-cms-private', 'hidden'].includes(attribute.name.getText(file)))) { warnings.add('excluded-content'); return true; }
+      if (/^[A-Z]/.test(name)) { if (!iconNames.has(name)) warnings.add('component-unresolved'); return true; }
+      return false;
+    };
+    const mapRows = (node, scope, depth) => {
+      node = unbox(node);
+      if (!node || !ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression) || node.expression.name.text !== 'map' || node.arguments.length !== 1) return null;
+      const values = evaluate(node.expression.expression, scope, true, depth + 1), fn = unbox(node.arguments[0]);
+      if (!Array.isArray(values) || values.length > SOURCE_EXTRACT_LIMITS.array || !(ts.isArrowFunction(fn) || ts.isFunctionExpression(fn)) || fn.parameters.some(parameter => !ts.isIdentifier(parameter.name) || parameter.dotDotDotToken || parameter.initializer)) { warnings.add('collection-unresolved'); return []; }
+      return values.map((value, index) => {
+        const childScope = new Map(scope); fn.parameters.forEach((parameter, number) => childScope.set(parameter.name.text, { value: [value, index][number] }));
+        const name = fn.parameters[0]?.name.text;
+        const property = value && typeof value === 'object' ? ['id', 'slug', 'title', 'name', 'question', 'q', 'label'].find(key => typeof value[key] === 'string' || typeof value[key] === 'number') : undefined;
+        const selector = name && (property ? `${name}.${property}` : primitive(value) ? name : undefined);
+        const selected = property ? value[property] : primitive(value) ? value : undefined;
+        childScope.set(TRACE, [...(scope.get(TRACE) ?? []), { selector, value: selected }]);
+        if (!ts.isBlock(fn.body)) return { node: fn.body, scope: childScope };
+        addDeclarations(fn.body.statements, childScope);
+        const result = fn.body.statements.find(statement => ts.isReturnStatement(statement));
+        if (!result || fn.body.statements.some(statement => !ts.isVariableStatement(statement) && !ts.isReturnStatement(statement))) { warnings.add('collection-unresolved'); return null; }
+        return { node: result.expression, scope: childScope };
+      }).filter(Boolean);
+    };
+    const branches = (node, scope, depth) => {
+      if (ts.isConditionalExpression(node)) {
+        const condition = evaluate(node.condition, scope, false, depth + 1);
+        if (condition !== UNKNOWN) return [condition ? node.whenTrue : node.whenFalse];
+        if (controlled(node.condition, scope)) { warnings.add('interactive-content-omitted'); return [node.whenTrue, node.whenFalse]; }
+        warnings.add('conditional-unresolved'); return [];
+      }
+      if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+        const condition = evaluate(node.left, scope, false, depth + 1);
+        if (condition !== UNKNOWN) return condition ? [node.right] : [];
+        if (controlled(node.left, scope)) { warnings.add('interactive-content-omitted'); return [node.right]; }
+        warnings.add('conditional-unresolved'); return [];
+      }
+      return null;
+    };
+    function inline(node, scope, depth = 0) {
+      step(depth); node = unbox(node); if (!node) return '';
+      if (ts.isJsxText(node)) return jsxText(node.text);
+      if (ts.isJsxExpression(node)) return node.expression ? inline(node.expression, scope, depth + 1) : '';
+      if (ts.isJsxFragment(node)) return node.children.map(child => inline(child, scope, depth + 1)).join('');
+      if (opening(node)) {
+        if (omit(node)) return '';
+        if (opening(node).tagName.getText(file) === 'br') return ' ';
+        return ts.isJsxElement(node) ? node.children.map(child => inline(child, scope, depth + 1)).join('') : '';
+      }
+      const rows = mapRows(node, scope, depth); if (rows) return rows.map(row => inline(row.node, row.scope, depth + 1)).join(' ');
+      const selected = branches(node, scope, depth); if (selected) return selected.map(child => inline(child, scope, depth + 1)).join(' ');
+      const value = evaluate(node, scope, false, depth + 1);
+      if (value === UNKNOWN) { warnings.add('expression-unresolved'); return ''; }
+      return literalText(value);
+    }
+    function walk(node, scope, depth = 0) {
+      step(depth); node = unbox(node); if (!node) return;
+      if (ts.isJsxExpression(node)) { if (node.expression) walk(node.expression, scope, depth + 1); return; }
+      if (ts.isJsxFragment(node)) { flow(node.children, scope, depth + 1); return; }
+      if (opening(node)) {
+        if (omit(node)) return;
+        const tag = opening(node).tagName.getText(file);
+        if (tag === 'table') {
+          const rows = [];
+          let invalid = false, header = false;
+          const tableWalk = (item, itemScope, at) => {
+            step(at); item = unbox(item); if (!item) return;
+            if (ts.isJsxText(item)) return;
+            if (ts.isJsxExpression(item)) { if (item.expression) tableWalk(item.expression, itemScope, at + 1); return; }
+            if (ts.isJsxFragment(item)) { for (const child of item.children) tableWalk(child, itemScope, at + 1); return; }
+            const tagNode = opening(item);
+            if (tagNode) {
+              if (omit(item)) return;
+              const name = tagNode.tagName.getText(file);
+              if (name === 'tr' && ts.isJsxElement(item)) {
+                const cells = item.children.filter(child => opening(child) && ['td', 'th'].includes(opening(child).tagName.getText(file)));
+                if (item.children.some(child => !ts.isJsxText(child) && !cells.includes(child))) { invalid = true; return; }
+                const values = cells.map(child => normalize(inline(child, itemScope, at + 1)));
+                if (!values.length || values.length > 12 || values.some(value => value.length > 2000) || rows.length >= 100) { invalid = true; return; }
+                if (!rows.length) header = cells.every(child => opening(child).tagName.getText(file) === 'th');
+                rows.push(values); return;
+              }
+              if (!['table', 'thead', 'tbody', 'tfoot'].includes(name)) { invalid = true; return; }
+              if (ts.isJsxElement(item)) for (const child of item.children) tableWalk(child, itemScope, at + 1);
+              return;
+            }
+            const mapped = mapRows(item, itemScope, at); if (mapped) { for (const row of mapped) tableWalk(row.node, row.scope, at + 1); return; }
+            const selected = branches(item, itemScope, at); if (selected) { for (const child of selected) tableWalk(child, itemScope, at + 1); return; }
+            invalid = true;
+          };
+          tableWalk(node, scope, depth + 1);
+          if (invalid || !rows.length || rows.some(row => row.length !== rows[0].length)) warnings.add('table-unresolved');
+          else { if (pieces.length >= SOURCE_EXTRACT_LIMITS.blocks) throw Error('budget'); bindings.push(describe(node, scope)); pieces.push({ type: 'table', text: '', data: { header, rows } }); }
+          return;
+        }
+        if (/^h[1-6]$/.test(tag)) { emit('heading', inline(node, scope, depth + 1), Number(tag[1]), describe(node, scope)); return; }
+        if (['p', 'blockquote', 'li', 'pre'].includes(tag)) { emit(tag === 'li' ? 'list' : tag === 'blockquote' ? 'quote' : tag === 'pre' ? 'code' : 'paragraph', inline(node, scope, depth + 1), undefined, describe(node, scope)); return; }
+        if (ts.isJsxElement(node)) flow(node.children, scope, depth + 1);
+        return;
+      }
+      const rows = mapRows(node, scope, depth); if (rows) { for (const row of rows) walk(row.node, row.scope, depth + 1); return; }
+      const selected = branches(node, scope, depth); if (selected) { for (const child of selected) walk(child, scope, depth + 1); return; }
+      emit('paragraph', inline(node, scope, depth + 1), undefined, describe(node, scope, 'expression'));
+    }
+    function flow(children, scope, depth) {
+      let buffer = '', buffered = [];
+      const flush = () => { emit('paragraph', buffer, undefined, buffered.length ? describe(buffered[0], scope, 'inline', buffered.at(-1).end) : undefined); buffer = ''; buffered = []; };
+      for (const child of children) {
+        const tag = opening(child)?.tagName.getText(file);
+        if (ts.isJsxText(child) || tag && inlineTags.has(tag)) { buffer += inline(child, scope, depth + 1); buffered.push(child); continue; }
+        if (ts.isJsxExpression(child) && (!child.expression || !opening(unbox(child.expression)) && !ts.isJsxFragment(unbox(child.expression)))) {
+          const expression = unbox(child.expression);
+          if (!expression) continue;
+          const simple = evaluate(expression, scope, false, depth + 1);
+          if (simple !== UNKNOWN && primitive(simple)) { buffer += literalText(simple); buffered.push(child); continue; }
+        }
+        flush(); walk(child, scope, depth + 1);
+      }
+      flush();
+    }
+    if (returned) controlScan(returned, componentScope);
+    walk(returned, componentScope);
+    const title = firstH1 || firstHeading;
+    if (!title || title.length > 200) return failure('missing-title');
+    if (!pieces.length) return failure('empty-content');
+    const blocks = pieces.map((piece, index) => ({ id: uuid(`universalcms-static-v1:${locale}:${slug}:${index}:${piece.type}:${piece.text}`), version: 1, ...piece }));
+    return { ...(includeBindings ? { bindings, hasUnboundPresentationRows: filteredRowsOmitted && warnings.has('presentation-filter-initial-state'), returnRange: { start: unbox(returned).getStart(file), end: unbox(returned).end }, parameterCount: component.parameters.length } : {}), entry: { kind: 'page', slug, locale, document: { schemaVersion: 1, title, excerpt: (pieces.find(piece => piece.type === 'paragraph')?.text ?? '').slice(0, 1000), fields: {}, taxonomy: { categories: [], tags: [] }, blocks } }, warnings: [...warnings].sort(), complete: ![...warnings].some(code => partialCodes.has(code)) };
+  } catch { return failure('extraction-budget-or-unsupported'); }
+}