@starci/hfs 4.0.10 → 4.1.0

package/runtime/scripts/hfs/architecture/frontend-world-render.mjs

@@ -0,0 +1,311 @@
+import path from 'node:path';
+import { normalizedSymbolValue } from './ast-walks.mjs';
+import { relativePath, unwrapExpression } from './typescript.mjs';
+function importDeclarationFor(ts, node) {
+  for (let current = node; current; current = current.parent) if (ts.isImportDeclaration(current)) return current;
+  return null;
+}
+
+function isReactCreateElement(ts, checker, call) {
+  const expression = unwrapExpression(ts, call.expression);
+  if (ts.isIdentifier(expression)) {
+    const symbol = checker.getSymbolAtLocation(expression);
+    return (symbol?.declarations ?? []).some(declaration => {
+      const imported = ts.isImportSpecifier(declaration) ? declaration.propertyName?.text ?? declaration.name.text : null;
+      const parent = importDeclarationFor(ts, declaration);
+      return imported === 'createElement' && parent && ts.isStringLiteralLike(parent.moduleSpecifier) && parent.moduleSpecifier.text === 'react';
+    });
+  }
+  if (!ts.isPropertyAccessExpression(expression) || expression.name.text !== 'createElement') return false;
+  const symbol = checker.getSymbolAtLocation(expression.expression);
+  return (symbol?.declarations ?? []).some(declaration => {
+    const parent = importDeclarationFor(ts, declaration);
+    return (ts.isNamespaceImport(declaration) || ts.isImportClause(declaration))
+      && parent && ts.isStringLiteralLike(parent.moduleSpecifier) && parent.moduleSpecifier.text === 'react';
+  });
+}
+
+function jsxTagName(ts, tagName) {
+  if (ts.isIdentifier(tagName)) return tagName.text;
+  if (ts.isPropertyAccessExpression(tagName)) return tagName.name.text;
+  return null;
+}
+
+function wrapperTag(ts, tagName) {
+  const name = jsxTagName(ts, tagName);
+  return name === 'Suspense' || name === 'SWRConfig' || name === 'Provider'
+    || Boolean(name && (name.endsWith('Provider') || name.endsWith('ErrorBoundary')));
+}
+
+export class WorldRenderAnalysis {
+  constructor(world, helpers) {
+    this.world = world;
+    this.helpers = helpers;
+  }
+
+  expressionHasRender(expression, checker, seen = new Set()) {
+    expression = unwrapExpression(this.world.ts, expression);
+    if (!expression) return false;
+    if (this.world.ts.isJsxElement(expression) || this.world.ts.isJsxSelfClosingElement(expression) || this.world.ts.isJsxFragment(expression)) return true;
+    if (this.world.ts.isCallExpression(expression) && isReactCreateElement(this.world.ts, checker, expression)) return true;
+    if (this.world.ts.isConditionalExpression(expression)) return this.conditionalExpressionHasRender(expression, checker, seen);
+    const logicalRender = this.logicalExpressionHasRender(expression, checker, seen);
+    if (logicalRender !== null) return logicalRender;
+    if (this.world.ts.isCallExpression(expression)) {
+      const mapped = this.mappedExpressionHasRender(expression, checker, seen);
+      if (mapped !== null) return mapped;
+    }
+    return this.referencedExpressionHasRender(expression, checker, seen);
+  }
+
+  conditionalExpressionHasRender(expression, checker, seen) {
+    return this.expressionHasRender(expression.whenTrue, checker, seen)
+      || this.expressionHasRender(expression.whenFalse, checker, seen);
+  }
+
+  logicalExpressionHasRender(expression, checker, seen) {
+    const ts = this.world.ts;
+    if (!ts.isBinaryExpression(expression) || ![ts.SyntaxKind.AmpersandAmpersandToken, ts.SyntaxKind.BarBarToken,
+      ts.SyntaxKind.QuestionQuestionToken].includes(expression.operatorToken.kind)) return null;
+    return this.expressionHasRender(expression.left, checker, seen) || this.expressionHasRender(expression.right, checker, seen);
+  }
+
+  mappedExpressionHasRender(expression, checker, seen) {
+    const ts = this.world.ts;
+    if (!ts.isPropertyAccessExpression(expression.expression) && !ts.isElementAccessExpression(expression.expression)) return null;
+    let name = ts.isPropertyAccessExpression(expression.expression) ? expression.expression.name.text : null;
+    if (name === null && ts.isStringLiteralLike(expression.expression.argumentExpression)) name = expression.expression.argumentExpression.text;
+    if (name !== 'map' || !expression.arguments[0]) return null;
+    return this.world.expressionFunctions(expression.arguments[0], checker).some(fn => this.functionHasRender(fn, checker, seen));
+  }
+
+  referencedExpressionHasRender(expression, checker, seen) {
+    const ts = this.world.ts;
+    const selected = ts.isCallExpression(expression) ? expression.expression : expression;
+    const symbol = normalizedSymbolValue(ts, checker, this.helpers.selectedSymbol(ts, checker, selected));
+    if (!symbol || seen.has(symbol)) return false;
+    const nextSeen = new Set(seen).add(symbol);
+    if (ts.isIdentifier(expression) && this.identifierInitializerHasRender(symbol, checker, nextSeen)) return true;
+    if (ts.isCallExpression(expression)) return this.world.expressionFunctions(expression.expression, checker, seen)
+      .some(fn => this.functionHasRender(fn, checker, nextSeen));
+    return false;
+  }
+
+  identifierInitializerHasRender(symbol, checker, seen) {
+    for (const declaration of symbol.getDeclarations?.() ?? []) {
+      if (this.world.ts.isVariableDeclaration(declaration) && declaration.initializer
+        && this.expressionHasRender(declaration.initializer, checker, seen)) return true;
+    }
+    return false;
+  }
+
+  functionHasRender(fn, checker, seen = new Set()) {
+    if (this.world.renderOutputCache.has(fn)) return this.world.renderOutputCache.get(fn);
+    this.world.renderOutputCache.set(fn, false);
+    const found = this.helpers.returnedExpressions(this.world.ts, fn).some(expression => this.expressionHasRender(expression, checker, seen));
+    this.world.renderOutputCache.set(fn, found);
+    return found;
+  }
+
+  capturesOuterFunction(fn, checker) {
+    const outers = [];
+    for (let parent = fn.parent; parent; parent = parent.parent) if (this.world.ts.isFunctionLike(parent)) outers.push(parent);
+    if (!outers.length) return false;
+    const capture = { found: false };
+    this.visitOuterReferences(fn.body ?? fn, fn, checker, outers, capture);
+    return capture.found;
+  }
+
+  visitOuterReferences(node, fn, checker, outers, capture) {
+    if (capture.found) return;
+    if (this.referencesOuterFunction(node, fn, checker, outers)) {
+      capture.found = true;
+      return;
+    }
+    this.world.ts.forEachChild(node, child => this.visitOuterReferences(child, fn, checker, outers, capture));
+  }
+
+  referencesOuterFunction(node, fn, checker, outers) {
+    if (!this.world.ts.isIdentifier(node)) return false;
+    const symbol = checker.getSymbolAtLocation(node);
+    for (const declaration of symbol?.getDeclarations?.() ?? []) {
+      if (declaration.pos >= fn.pos && declaration.end <= fn.end) continue;
+      if (outers.some(outer => declaration.pos >= outer.pos && declaration.end <= outer.end)) return true;
+    }
+    return false;
+  }
+
+  pureRenderTarget(expression, checker, expectedFile = null) {
+    const functions = this.world.expressionFunctions(expression, checker);
+    return functions.length > 0 && functions.every(fn => this.world.sourceSet.has(path.resolve(fn.getSourceFile().fileName))
+      && (this.world.insideAny(this.world.roots.components, fn.getSourceFile().fileName) || this.world.insideAny(this.world.roots.features, fn.getSourceFile().fileName))
+      && (!expectedFile || path.resolve(fn.getSourceFile().fileName) === expectedFile)
+      && this.functionHasRender(fn, checker) && !this.world.functionUsesWorld(fn, checker) && !this.capturesOuterFunction(fn, checker));
+  }
+
+  expressionSuppliesRender(expression, checker) {
+    return this.expressionHasRender(expression, checker)
+      || this.world.expressionFunctions(expression, checker).some(fn => this.functionHasRender(fn, checker));
+  }
+
+  routedLayoutChild(opening, child, checker) {
+    const ts = this.world.ts;
+    if (!ts.isJsxExpression(child) || !child.expression) return false;
+    const source = opening.getSourceFile().fileName;
+    if (!/^apps\/[^/]+\/src\/features\/layouts\/[^/]+\/index\.tsx$/.test(relativePath(this.world.config.root, source))) return false;
+    const sibling = path.resolve(path.dirname(source), 'component.tsx');
+    if (!this.pureRenderTarget(opening.tagName, checker, sibling)) return false;
+    const value = unwrapExpression(ts, child.expression);
+    if (!ts.isPropertyAccessExpression(value) || !['content', 'children'].includes(value.name.text)) return false;
+    const receiver = unwrapExpression(ts, value.expression);
+    if (!ts.isIdentifier(receiver)) return false;
+    const symbol = checker.getSymbolAtLocation(receiver);
+    return (symbol?.getDeclarations?.() ?? []).some(declaration => ts.isParameter(declaration));
+  }
+
+  renderBoundary(expression, checker, seen = new Set(), allowEmpty = false, expectedFile = null) {
+    const ts = this.world.ts;
+    expression = unwrapExpression(ts, expression);
+    if (!expression) return allowEmpty;
+    if (expression.kind === ts.SyntaxKind.NullKeyword || expression.kind === ts.SyntaxKind.FalseKeyword) return allowEmpty;
+    if (ts.isConditionalExpression(expression)) return this.conditionalRenderBoundary(expression, checker, seen, allowEmpty, expectedFile);
+    if (ts.isBinaryExpression(expression) && expression.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+      return this.renderBoundary(expression.right, checker, seen, true, expectedFile);
+    }
+    if (ts.isArrayLiteralExpression(expression)) return this.arrayRenderBoundary(expression, checker, seen, allowEmpty, expectedFile);
+    if (ts.isIdentifier(expression)) return this.identifierRenderBoundary(expression, checker, seen, allowEmpty, expectedFile);
+    if (ts.isCallExpression(expression)) return this.callRenderBoundary(expression, checker, seen, expectedFile);
+    if (ts.isJsxFragment(expression)) return this.fragmentRenderBoundary(expression, checker, seen, expectedFile);
+    if (ts.isJsxElement(expression) || ts.isJsxSelfClosingElement(expression)) return this.jsxRenderBoundary(expression, checker, seen, expectedFile);
+    return false;
+  }
+
+  conditionalRenderBoundary(expression, checker, seen, allowEmpty, expectedFile) {
+    return this.renderBoundary(expression.whenTrue, checker, seen, allowEmpty, expectedFile)
+      && this.renderBoundary(expression.whenFalse, checker, seen, allowEmpty, expectedFile);
+  }
+
+  arrayRenderBoundary(expression, checker, seen, allowEmpty, expectedFile) {
+    return expression.elements.length > 0
+      && expression.elements.every(item => this.renderBoundary(item, checker, seen, allowEmpty, expectedFile));
+  }
+
+  identifierRenderBoundary(expression, checker, seen, allowEmpty, expectedFile) {
+    const symbol = normalizedSymbolValue(this.world.ts, checker, checker.getSymbolAtLocation(expression));
+    if (!symbol || seen.has(symbol)) return false;
+    const nextSeen = new Set(seen).add(symbol);
+    const values = (symbol.getDeclarations?.() ?? []).flatMap(declaration => this.world.ts.isVariableDeclaration(declaration) && declaration.initializer
+      ? [declaration.initializer] : []);
+    if (values.length) return values.every(value => this.renderBoundary(value, checker, nextSeen, allowEmpty, expectedFile));
+    return false;
+  }
+
+  callRenderBoundary(expression, checker, seen, expectedFile) {
+    if (isReactCreateElement(this.world.ts, checker, expression)) return this.createElementBoundary(expression, checker, seen, expectedFile);
+    const mapped = this.mappedCallBoundary(expression, checker, seen, expectedFile);
+    if (mapped !== null) return mapped;
+    return this.pureRenderTarget(expression.expression, checker, expectedFile);
+  }
+
+  createElementBoundary(expression, checker, seen, expectedFile) {
+    const ts = this.world.ts;
+    const target = expression.arguments[0] ? unwrapExpression(ts, expression.arguments[0]) : null;
+    if (!target || ts.isStringLiteralLike(target)) return false;
+    const pureTarget = this.pureRenderTarget(target, checker, expectedFile) && !wrapperTag(ts, target);
+    const wrapper = wrapperTag(ts, target);
+    if (!pureTarget && !wrapper) return false;
+    const boundary = { hasBoundary: pureTarget };
+    const props = expression.arguments[1] ? unwrapExpression(ts, expression.arguments[1]) : null;
+    if (!this.createElementPropsBoundary(props, checker, seen, expectedFile, boundary)) return false;
+    const children = expression.arguments.slice(2);
+    if (children.length) {
+      if (!children.every(child => this.renderBoundary(child, checker, seen, false, expectedFile))) return false;
+      boundary.hasBoundary = true;
+    }
+    return boundary.hasBoundary;
+  }
+
+  createElementPropsBoundary(props, checker, seen, expectedFile, boundary) {
+    const ts = this.world.ts;
+    if (!props || props.kind === ts.SyntaxKind.NullKeyword) return true;
+    if (!ts.isObjectLiteralExpression(props) || props.properties.some(property => ts.isSpreadAssignment(property))) return false;
+    return props.properties.every(property => this.propsPropertyBoundary(property, checker, seen, expectedFile, boundary));
+  }
+
+  propsPropertyBoundary(property, checker, seen, expectedFile, boundary) {
+    const ts = this.world.ts;
+    if (!ts.isPropertyAssignment(property)) return true;
+    const value = unwrapExpression(ts, property.initializer);
+    if (!this.expressionSuppliesRender(value, checker)) return true;
+    if (!this.pureRenderTarget(value, checker, expectedFile) && !this.renderBoundary(value, checker, seen, true, expectedFile)) return false;
+    const name = property.name && (ts.isIdentifier(property.name) || ts.isStringLiteralLike(property.name)) ? property.name.text : null;
+    if (['children', 'component', 'content', 'render', 'view'].includes(name)) boundary.hasBoundary = true;
+    return true;
+  }
+
+  mappedCallBoundary(expression, checker, seen, expectedFile) {
+    const ts = this.world.ts;
+    if (!ts.isPropertyAccessExpression(expression.expression) && !ts.isElementAccessExpression(expression.expression)) return null;
+    let name = ts.isPropertyAccessExpression(expression.expression) ? expression.expression.name.text : null;
+    if (name === null && ts.isStringLiteralLike(expression.expression.argumentExpression)) name = expression.expression.argumentExpression.text;
+    if (name !== 'map' || !expression.arguments[0]) return null;
+    const renderers = this.world.expressionFunctions(expression.arguments[0], checker);
+    return renderers.length > 0 && renderers.every(fn => !this.world.functionUsesWorld(fn, checker)
+      && this.helpers.returnedExpressions(ts, fn).length > 0
+      && this.helpers.returnedExpressions(ts, fn).every(value => this.renderBoundary(value, checker, seen, true, expectedFile)));
+  }
+
+  fragmentRenderBoundary(expression, checker, seen, expectedFile) {
+    const ts = this.world.ts;
+    const children = expression.children.filter(child => !ts.isJsxText(child) || child.text.trim());
+    return children.length > 0 && children.every(child => !ts.isJsxText(child)
+      && this.renderBoundary(ts.isJsxExpression(child) ? child.expression : child, checker, seen, false, expectedFile));
+  }
+
+  jsxRenderBoundary(expression, checker, seen, expectedFile) {
+    const ts = this.world.ts;
+    const opening = ts.isJsxElement(expression) ? expression.openingElement : expression;
+    const pureTarget = this.pureRenderTarget(opening.tagName, checker, expectedFile) && !wrapperTag(ts, opening.tagName);
+    const wrapper = wrapperTag(ts, opening.tagName);
+    if (!pureTarget && !wrapper) return false;
+    const boundary = { hasBoundary: pureTarget };
+    if (!this.jsxChildrenBoundary(expression, opening, checker, seen, expectedFile, pureTarget, boundary)) return false;
+    if (!this.jsxAttributesBoundary(opening, checker, seen, expectedFile, boundary)) return false;
+    return boundary.hasBoundary;
+  }
+
+  jsxChildrenBoundary(expression, opening, checker, seen, expectedFile, pureTarget, boundary) {
+    const ts = this.world.ts;
+    const children = ts.isJsxElement(expression)
+      ? expression.children.filter(child => !ts.isJsxText(child) || child.text.trim()) : [];
+    if (!children.length) return true;
+    const routedChild = pureTarget && children.length === 1 && this.routedLayoutChild(opening, children[0], checker);
+    if (!routedChild && !children.every(child => !ts.isJsxText(child)
+      && this.renderBoundary(ts.isJsxExpression(child) ? child.expression : child, checker, seen, false, expectedFile))) return false;
+    boundary.hasBoundary = true;
+    return true;
+  }
+
+  jsxAttributesBoundary(opening, checker, seen, expectedFile, boundary) {
+    const ts = this.world.ts;
+    return opening.attributes.properties.every(attribute => !ts.isJsxAttribute(attribute) || !attribute.initializer
+      || this.jsxAttributeBoundary(attribute, checker, seen, expectedFile, boundary));
+  }
+
+  jsxAttributeBoundary(attribute, checker, seen, expectedFile, boundary) {
+    const ts = this.world.ts;
+    const name = attribute.name.text;
+    if (['fallback', 'errorElement'].includes(name)) {
+      if (ts.isStringLiteral(attribute.initializer)) return false;
+      if (ts.isJsxExpression(attribute.initializer)
+        && !this.renderBoundary(attribute.initializer.expression, checker, seen, true, expectedFile)) return false;
+    }
+    if (ts.isJsxExpression(attribute.initializer) && attribute.initializer.expression
+      && this.expressionSuppliesRender(attribute.initializer.expression, checker)) {
+      if (!this.pureRenderTarget(attribute.initializer.expression, checker, expectedFile)
+        && !this.renderBoundary(attribute.initializer.expression, checker, seen, true, expectedFile)) return false;
+      if (['component', 'content', 'render', 'view'].includes(name)) boundary.hasBoundary = true;
+    }
+    return true;
+  }
+}

package/runtime/scripts/hfs/architecture/frontend-world.mjs

@@ -0,0 +1,328 @@
+import path from 'node:path';
+import { normalizedSymbolValue, returnedExpressions as sharedReturnedExpressions } from './ast-walks.mjs';
+import { reachableViolation, relativePath, unwrapExpression } from './typescript.mjs';
+import { WorldRenderAnalysis } from './frontend-world-render.mjs';
+const WORLD_NAVIGATION_CALLS = new Set(['useParams', 'usePathname', 'useRouter', 'useSearchParams', 'useSelectedLayoutSegment', 'useSelectedLayoutSegments']);
+const WORLD_INTL_CALLS = new Set(['useLocale', 'useMessages', 'useNow', 'useTimeZone', 'useTranslations']);
+const WORLD_SWR_CALLS = new Set(['default', 'useSWR', 'useSWRConfig', 'useSWRImmutable', 'useSWRMutation']);
+const LOWER_COMPONENT_TIERS = new Set(['composites', 'branches', 'leaves']);
+function selectedSymbol(ts, checker, expression) {
+  const selected = unwrapExpression(ts, expression);
+  if (!selected) return null;
+  if (ts.isIdentifier(selected)) return checker.getSymbolAtLocation(selected) ?? null;
+  if (ts.isPropertyAccessExpression(selected)) return checker.getSymbolAtLocation(selected.name) ?? null;
+  if (ts.isElementAccessExpression(selected) && ts.isStringLiteralLike(selected.argumentExpression)) {
+    return checker.getSymbolAtLocation(selected.argumentExpression)
+      ?? checker.getTypeAtLocation(selected.expression).getProperty(selected.argumentExpression.text)
+      ?? null;
+  }
+  return null;
+}
+
+/* The wider boundary set: `ts.isFunctionLike` (includes call signatures' declarations) rather than the
+ * four default callable kinds. */
+const returnedExpressions = (ts, declaration) => sharedReturnedExpressions(ts, declaration, { functionLike: ts.isFunctionLike });
+
+function knownWorldImport(specifier, imported) {
+  if (specifier === 'next-intl') return WORLD_INTL_CALLS.has(imported);
+  if (specifier === 'next/navigation' || /(?:^|\/)i18n\/navigation$/.test(specifier)) return WORLD_NAVIGATION_CALLS.has(imported);
+  if (specifier === 'swr' || specifier === 'swr/immutable' || specifier === 'swr/mutation') return WORLD_SWR_CALLS.has(imported);
+  if (specifier === 'next-auth/react') return imported === 'useSession';
+  return false;
+}
+
+class WorldAnalysis {
+  constructor(config, context, roots, helpers) {
+    this.config = config;
+    this.context = context;
+    this.roots = roots;
+    this.ts = context.ts;
+    Object.assign(this, helpers);
+    this.violations = [];
+    this.sourceSet = new Set(context.files.map(source => path.resolve(source.fileName)));
+    this.worldInfoCache = new Map();
+    this.functionWorldCache = new Map();
+    this.renderOutputCache = new Map();
+    this.intrinsicUiHookCache = new Map();
+    this.renderer = new WorldRenderAnalysis(this, { selectedSymbol, returnedExpressions });
+  }
+
+  forbiddenIntrinsicEdge(edge, nextVisiting) {
+    const forbidden = reachableViolation(this.context.edges, edge, target => this.insideAny(this.roots.transport, target)
+      || this.insideAny(this.roots.modules, target) || this.insideAny(this.roots.features, target) || this.insideAny(this.roots.routes, target)
+      || (this.insideAny(this.roots.hooks, target) && relativePath(this.rootFor(this.roots.hooks, target), target).split('/')[0] !== 'ui'),
+    { follow: candidate => candidate.runtime });
+    return Boolean(forbidden || (this.insideAny(this.roots.hooks, edge.to) && !this.intrinsicUiHookFile(edge.to, nextVisiting)));
+  }
+
+  forbiddenWorldImport(statement) {
+    if (!this.ts.isImportDeclaration(statement) || !statement.importClause || statement.importClause.isTypeOnly
+      || !this.ts.isStringLiteralLike(statement.moduleSpecifier)) return false;
+    const specifier = statement.moduleSpecifier.text;
+    const bindings = [];
+    if (statement.importClause.name) bindings.push('default');
+    const named = statement.importClause.namedBindings;
+    if (named && this.ts.isNamespaceImport(named)
+      && ['next/navigation', 'next-intl', 'swr', 'swr/immutable', 'swr/mutation', 'next-auth/react'].includes(specifier)) return true;
+    if (named && this.ts.isNamedImports(named)) {
+      for (const element of named.elements) if (!element.isTypeOnly) bindings.push(element.propertyName?.text ?? element.name.text);
+    }
+    return bindings.some(imported => knownWorldImport(specifier, imported));
+  }
+
+  containsUnshadowedFetch(sourceFile, checker) {
+    let found = false;
+    const visit = node => {
+      if (!found && this.ts.isCallExpression(node) && this.ts.isIdentifier(node.expression) && node.expression.text === 'fetch'
+        && !checker.getSymbolAtLocation(node.expression)) found = true;
+      if (!found) this.ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return found;
+  }
+
+  intrinsicUiHookFile(fileName, visiting = new Set()) {
+    const resolved = path.resolve(fileName);
+    if (this.intrinsicUiHookCache.has(resolved)) return this.intrinsicUiHookCache.get(resolved);
+    const hookRoot = this.rootFor(this.roots.hooks, resolved);
+    if (!hookRoot || relativePath(hookRoot, resolved).split('/')[0] !== 'ui' || visiting.has(resolved)) return false;
+    const sourceFile = this.context.files.find(source => path.resolve(source.fileName) === resolved);
+    if (!sourceFile) return false;
+    this.intrinsicUiHookCache.set(resolved, false);
+    const nextVisiting = new Set(visiting).add(resolved);
+    const checker = this.context.checkerFor(resolved);
+    const edges = this.importsForSource(this.context, resolved);
+    let intrinsic = true;
+    for (const edge of edges.filter(candidate => candidate.runtime)) {
+      if (this.forbiddenIntrinsicEdge(edge, nextVisiting)) {
+        intrinsic = false;
+        break;
+      }
+    }
+    for (const statement of sourceFile.statements) {
+      if (!intrinsic) break;
+      if (this.forbiddenWorldImport(statement)) { intrinsic = false; break; }
+    }
+    if (intrinsic && this.containsUnshadowedFetch(sourceFile, checker)) intrinsic = false;
+    this.intrinsicUiHookCache.set(resolved, intrinsic);
+    return intrinsic;
+  }
+
+  intrinsicUiHookSymbol(symbol, checker) {
+    const identity = normalizedSymbolValue(this.ts, checker, symbol);
+    const declarations = identity?.getDeclarations?.() ?? [];
+    return declarations.length > 0 && declarations.every(declaration => this.intrinsicUiHookFile(declaration.getSourceFile().fileName));
+  }
+
+  worldEdgeOf(edge) {
+    return edge && Boolean(reachableViolation(this.context.edges, edge,
+      target => this.insideAny(this.roots.hooks, target) || this.insideAny(this.roots.transport, target),
+      { follow: candidate => candidate.reexport && candidate.runtime }));
+  }
+
+  collectNamedWorldImports(checker, named, specifier, worldEdge, symbols) {
+    for (const element of named.elements) {
+      if (element.isTypeOnly) continue;
+      const imported = element.propertyName?.text ?? element.name.text;
+      const symbol = checker.getSymbolAtLocation(element.name);
+      if (symbol && (worldEdge || knownWorldImport(specifier, imported))) symbols.add(symbol);
+    }
+  }
+
+  inspectWorldImportStatement(sourceFile, checker, byStart, symbols, namespaces, statement) {
+    if (!this.ts.isImportDeclaration(statement) || !statement.importClause || statement.importClause.isTypeOnly
+      || !this.ts.isStringLiteralLike(statement.moduleSpecifier)) return;
+    const specifier = statement.moduleSpecifier.text;
+    const worldEdge = this.worldEdgeOf(byStart.get(statement.moduleSpecifier.getStart(sourceFile)));
+    const clause = statement.importClause;
+    if (clause.name) {
+      const symbol = checker.getSymbolAtLocation(clause.name);
+      if (symbol && (worldEdge || knownWorldImport(specifier, 'default'))) symbols.add(symbol);
+    }
+    const named = clause.namedBindings;
+    if (named && this.ts.isNamedImports(named)) this.collectNamedWorldImports(checker, named, specifier, worldEdge, symbols);
+    if (named && this.ts.isNamespaceImport(named)) {
+      const symbol = checker.getSymbolAtLocation(named.name);
+      if (symbol) namespaces.set(symbol, { specifier, worldEdge });
+    }
+  }
+
+  importInfo(sourceFile) {
+    const key = path.resolve(sourceFile.fileName);
+    if (this.worldInfoCache.has(key)) return this.worldInfoCache.get(key);
+    const checker = this.context.checkerFor(sourceFile.fileName);
+    const edges = this.importsForSource(this.context, sourceFile.fileName);
+    const byStart = new Map(edges.map(edge => [edge.node.getStart(sourceFile), edge]));
+    const symbols = new Set();
+    const namespaces = new Map();
+    for (const statement of sourceFile.statements) this.inspectWorldImportStatement(sourceFile, checker, byStart, symbols, namespaces, statement);
+    const value = { checker, symbols, namespaces };
+    this.worldInfoCache.set(key, value);
+    return value;
+  }
+
+  collectExpressionFunctions(declaration, checker, seen, functions) {
+    if (this.ts.isFunctionDeclaration(declaration) || this.ts.isMethodDeclaration(declaration)) functions.push(declaration);
+    else if (this.ts.isVariableDeclaration(declaration) && declaration.initializer) {
+      functions.push(...this.expressionFunctions(declaration.initializer, checker, seen));
+    } else if (this.ts.isClassDeclaration(declaration)) {
+      functions.push(...declaration.members.filter(member => this.ts.isMethodDeclaration(member)
+        && member.name && (this.ts.isIdentifier(member.name) || this.ts.isStringLiteralLike(member.name)) && member.name.text === 'render'));
+    }
+  }
+
+  isComponentWrapperCall(call) {
+    const selected = unwrapExpression(this.ts, call.expression);
+    const name = (this.ts.isIdentifier(selected) && selected.text) || (this.ts.isPropertyAccessExpression(selected) && selected.name.text) || null;
+    return ['forwardRef', 'memo'].includes(name);
+  }
+
+  expressionFunctions(expression, checker, seen = new Set()) {
+    expression = unwrapExpression(this.ts, expression);
+    if (!expression) return [];
+    if (this.ts.isArrowFunction(expression) || this.ts.isFunctionExpression(expression) || this.ts.isMethodDeclaration(expression)
+      || this.ts.isFunctionDeclaration(expression)) return [expression];
+    if (this.ts.isConditionalExpression(expression)) {
+      return [...this.expressionFunctions(expression.whenTrue, checker, seen), ...this.expressionFunctions(expression.whenFalse, checker, seen)];
+    }
+    if (this.ts.isCallExpression(expression) && this.isComponentWrapperCall(expression) && expression.arguments[0]) {
+      return this.expressionFunctions(expression.arguments[0], checker, seen);
+    }
+    const symbol = normalizedSymbolValue(this.ts, checker, selectedSymbol(this.ts, checker, expression));
+    if (!symbol || seen.has(symbol)) return [];
+    const nextSeen = new Set(seen).add(symbol);
+    const functions = [];
+    for (const declaration of symbol.getDeclarations?.() ?? []) this.collectExpressionFunctions(declaration, checker, nextSeen, functions);
+    return [...new Set(functions.filter(fn => fn.body))];
+  }
+
+  symbolIsWorld(raw, sourceFile, propertyName = null) {
+    if (!raw) return false;
+    const info = this.importInfo(sourceFile);
+    if (this.intrinsicUiHookSymbol(raw, info.checker)) return false;
+    if (info.symbols.has(raw)) return true;
+    for (const [namespace, declaration] of info.namespaces) if (namespace === raw) {
+      return declaration.worldEdge || knownWorldImport(declaration.specifier, propertyName ?? '');
+    }
+    const identity = normalizedSymbolValue(this.ts, info.checker, raw);
+    return (identity?.getDeclarations?.() ?? []).some(declaration => {
+      const fileName = declaration.getSourceFile().fileName;
+      return this.insideAny(this.roots.hooks, fileName) || this.insideAny(this.roots.transport, fileName);
+    });
+  }
+
+  namespaceIsWorld(raw, sourceFile, propertyName) {
+    const info = this.importInfo(sourceFile);
+    const declaration = info.namespaces.get(raw);
+    return Boolean(declaration && (declaration.worldEdge || knownWorldImport(declaration.specifier, propertyName ?? '')));
+  }
+
+  worldMemberCallee(expression, checker, sourceFile) {
+    let property = this.ts.isPropertyAccessExpression(expression) ? expression.name.text : null;
+    if (property === null && this.ts.isStringLiteralLike(expression.argumentExpression)) property = expression.argumentExpression.text;
+    const namespace = checker.getSymbolAtLocation(expression.expression);
+    if (this.intrinsicUiHookSymbol(selectedSymbol(this.ts, checker, expression), checker)) return false;
+    if (this.namespaceIsWorld(namespace, sourceFile, property)) return true;
+    return this.symbolIsWorld(selectedSymbol(this.ts, checker, expression), sourceFile);
+  }
+
+  worldVariableInitializer(symbol, checker, nextSeen) {
+    for (const declaration of symbol.getDeclarations?.() ?? []) {
+      if (this.ts.isVariableDeclaration(declaration) && declaration.initializer
+        && this.calleeIsWorld(declaration.initializer, checker, declaration.getSourceFile(), nextSeen)) return true;
+    }
+    return false;
+  }
+
+  calleeIsWorld(input, checker, sourceFile, seen = new Set()) {
+    const expression = unwrapExpression(this.ts, input);
+    if (this.ts.isIdentifier(expression) && this.symbolIsWorld(checker.getSymbolAtLocation(expression), sourceFile)) return true;
+    if (this.ts.isPropertyAccessExpression(expression) || this.ts.isElementAccessExpression(expression))
+      if (this.worldMemberCallee(expression, checker, sourceFile)) return true;
+    const symbol = normalizedSymbolValue(this.ts, checker, selectedSymbol(this.ts, checker, expression));
+    if (!symbol || seen.has(symbol)) return false;
+    const nextSeen = new Set(seen).add(symbol);
+    if (this.worldVariableInitializer(symbol, checker, nextSeen)) return true;
+    return this.expressionFunctions(expression, checker).some(fn => this.functionUsesWorld(fn, checker, nextSeen));
+  }
+
+  callIsWorld(call, checker, sourceFile, seen) { return this.calleeIsWorld(call.expression, checker, sourceFile, seen); }
+
+  functionUsesWorld(fn, checker, seen = new Set()) {
+    if (this.functionWorldCache.has(fn)) return this.functionWorldCache.get(fn);
+    this.functionWorldCache.set(fn, false);
+    let found = false;
+    const sourceFile = fn.getSourceFile();
+    const visit = node => {
+      if (found) return;
+      if (this.ts.isCallExpression(node) && this.callIsWorld(node, checker, sourceFile, seen)) { found = true; return; }
+      this.ts.forEachChild(node, visit);
+    };
+    visit(fn.body ?? fn);
+    this.functionWorldCache.set(fn, found);
+    return found;
+  }
+
+  collectFunctionNodes(node, functions) {
+    if (this.ts.isFunctionDeclaration(node) || this.ts.isMethodDeclaration(node) || this.ts.isArrowFunction(node) || this.ts.isFunctionExpression(node)) functions.push(node);
+    this.ts.forEachChild(node, child => this.collectFunctionNodes(child, functions));
+  }
+
+  inspectBlockProductHooks(sourceFile, checker, tier, functions) {
+    for (const fn of functions) {
+      const name = this.declarationName(this.ts, fn);
+      if (tier?.tier === 'blocks' && name && /^use[A-Z0-9]/.test(name.text) && this.functionUsesWorld(fn, checker)) {
+        this.violations.push(this.violation(this.config, sourceFile, name, 'FE_BLOCK_PRODUCT_HOOK_DEFINITION',
+          'A block may call a product hook from hooks but cannot define product-world or data lifecycle under the block.', { ts: this.ts }));
+      }
+    }
+  }
+
+  inspectWorldOwner(sourceFile, checker, tier, fn) {
+    if (!this.renderer.functionHasRender(fn, checker) || !this.functionUsesWorld(fn, checker)) return;
+    const returned = returnedExpressions(this.ts, fn);
+    if (!returned.length || returned.some(expression => !this.renderer.renderBoundary(expression, checker, new Set(), true))) {
+      this.violations.push(this.violation(this.config, sourceFile, fn, 'FE_WORLD_OWNER_RENDER_BOUNDARY',
+        'A visual owner that reads product/world state must hand every render path to a statically resolved pure render function or component; intrinsic-only interaction does not select this rule.', { ts: this.ts }));
+    }
+    if (tier && LOWER_COMPONENT_TIERS.has(tier.tier)) {
+      this.violations.push(this.violation(this.config, sourceFile, fn, 'FE_COMPONENT_WORLD_OWNERSHIP',
+        `${tier.tier} may own intrinsic browser interaction but cannot own product-world, navigation, locale, session or data lifecycle.`, { ts: this.ts }));
+    }
+    if (tier?.tier === 'blocks') this.inspectConnectedBlock(sourceFile, checker, fn, returned);
+  }
+
+  inspectConnectedBlock(sourceFile, checker, fn, returned) {
+    const expected = path.resolve(path.dirname(sourceFile.fileName), 'component.tsx');
+    const index = path.basename(sourceFile.fileName).toLowerCase() === 'index.tsx';
+    if (!index || !this.sourceSet.has(expected) || !returned.length
+      || returned.some(expression => !this.renderer.renderBoundary(expression, checker, new Set(), true, expected))) {
+      this.violations.push(this.violation(this.config, sourceFile, fn, 'FE_CONNECTED_BLOCK_RENDER_PAIR',
+        'A connected blocks/index.tsx must hand every nonempty render path to a resolved pure export from its sibling component.tsx; pure blocks and lower tiers need no twin.', { ts: this.ts }));
+    }
+  }
+
+  inspectWorldOwners(sourceFile, checker, tier, functions) {
+    for (const fn of functions) this.inspectWorldOwner(sourceFile, checker, tier, fn);
+  }
+
+  inspectSourceFile(sourceFile) {
+    if ((!this.insideAny(this.roots.components, sourceFile.fileName) && !this.insideAny(this.roots.features, sourceFile.fileName))
+      || !/\.[cm]?tsx$/i.test(sourceFile.fileName)) return;
+    const checker = this.context.checkerFor(sourceFile.fileName);
+    const tier = this.tierOf(this.roots.components, sourceFile.fileName);
+    const functions = [];
+    this.collectFunctionNodes(sourceFile, functions);
+    this.inspectBlockProductHooks(sourceFile, checker, tier, functions);
+    this.inspectWorldOwners(sourceFile, checker, tier, functions);
+  }
+
+  check() {
+    for (const sourceFile of this.context.files) this.inspectSourceFile(sourceFile);
+    return this.violations;
+  }
+}
+
+export function checkWorldRenderBoundaries(config, context, roots, helpers) {
+  return new WorldAnalysis(config, context, roots, helpers).check();
+}