@starci/eslint-canon-be 3.2.19 → 3.3.0

package/runtime/scripts/hfs/architecture/canon-jsx-clones.mjs

@@ -0,0 +1,143 @@
+/** Imported JSX components receive repeated data contracts; executable prop values remain compared. */
+import { unwrapExpression as unwrap } from '../../lib/ts-analysis.mjs';
+
+const TRANSLATION_MODULES = new Set(['next-intl', 'next-intl/server']);
+const TRANSLATION_FACTORIES = new Set(['useTranslations', 'getTranslations']);
+const uppercase = (name) => /^[A-Z]/.test(name);
+
+function bindName(ts, scope, name, binding) {
+  if (ts.isIdentifier(name)) scope.bindings.set(name.text, binding);
+  else if (ts.isObjectBindingPattern(name) || ts.isArrayBindingPattern(name)) {
+    for (const element of name.elements) if (ts.isBindingElement(element)) bindName(ts, scope, element.name, binding);
+  }
+}
+
+function importBindings(ts, scope, statement) {
+  const clause = statement.importClause;
+  if (!clause || clause.isTypeOnly || !ts.isStringLiteral(statement.moduleSpecifier)) return;
+  const module = statement.moduleSpecifier.text;
+  if (clause.name) scope.bindings.set(clause.name.text, { kind: 'component' });
+  const named = clause.namedBindings;
+  if (!named) return;
+  if (ts.isNamespaceImport(named)) scope.bindings.set(named.name.text, { kind: 'namespace', module });
+  else for (const element of named.elements) {
+    if (element.isTypeOnly) continue;
+    const imported = element.propertyName?.text ?? element.name.text;
+    const kind = TRANSLATION_MODULES.has(module) && TRANSLATION_FACTORIES.has(imported) ? 'translation-factory' : 'component';
+    scope.bindings.set(element.name.text, { kind });
+  }
+}
+
+function lexicalBindings(ts, sourceFile) {
+  const scopes = new WeakMap();
+  const root = { parent: null, bindings: new Map() };
+  root.functionScope = root;
+  const visit = (node, outer) => {
+    if ((ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) && node.name) bindName(ts, outer, node.name, { kind: 'local' });
+    const functionScope = ts.isFunctionLike(node);
+    const nested = functionScope || ts.isBlock(node) || ts.isCatchClause(node) || ts.isClassExpression(node)
+      || ts.isForStatement(node) || ts.isForOfStatement(node) || ts.isForInStatement(node);
+    const scope = nested ? { parent: outer, bindings: new Map(), functionScope: functionScope ? null : outer.functionScope } : outer;
+    if (functionScope) scope.functionScope = scope;
+    scopes.set(node, scope);
+    if (ts.isImportDeclaration(node)) importBindings(ts, scope, node);
+    if (ts.isParameter(node)) bindName(ts, scope, node.name, { kind: 'local' });
+    if (ts.isFunctionExpression(node) && node.name) bindName(ts, scope, node.name, { kind: 'local' });
+    if (ts.isVariableDeclaration(node)) {
+      const flags = node.parent?.flags ?? ts.NodeFlags.Const;
+      bindName(ts, flags & ts.NodeFlags.BlockScoped ? scope : scope.functionScope, node.name,
+        { kind: flags & ts.NodeFlags.Const ? 'constant' : 'local', declaration: node });
+    }
+    ts.forEachChild(node, (child) => { visit(child, scope); });
+  };
+  visit(sourceFile, root);
+  return (identifier) => {
+    for (let scope = scopes.get(identifier); scope; scope = scope.parent) {
+      if (scope.bindings.has(identifier.text)) return scope.bindings.get(identifier.text);
+    }
+    return null;
+  };
+}
+
+function translationFactory(ts, node, bindingOf) {
+  node = unwrap(ts, node);
+  if (ts.isIdentifier(node)) return bindingOf(node)?.kind === 'translation-factory';
+  return ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)
+    && TRANSLATION_FACTORIES.has(node.name.text) && bindingOf(node.expression)?.kind === 'namespace'
+    && TRANSLATION_MODULES.has(bindingOf(node.expression).module);
+}
+
+function translator(ts, node, bindingOf) {
+  if (!ts.isIdentifier(node)) return false;
+  const binding = bindingOf(node);
+  if (binding?.kind !== 'constant') return false;
+  let initializer = unwrap(ts, binding.declaration.initializer);
+  if (initializer && ts.isAwaitExpression(initializer)) initializer = unwrap(ts, initializer.expression);
+  return Boolean(initializer && ts.isCallExpression(initializer) && translationFactory(ts, initializer.expression, bindingOf));
+}
+
+function importedComponent(ts, tag, bindingOf) {
+  if (ts.isIdentifier(tag)) return uppercase(tag.text) && bindingOf(tag)?.kind === 'component';
+  if (!ts.isPropertyAccessExpression(tag) || !uppercase(tag.name.text)) return false;
+  let root = tag.expression;
+  while (ts.isPropertyAccessExpression(root)) root = root.expression;
+  return ts.isIdentifier(root) && bindingOf(root)?.kind === 'namespace';
+}
+
+function dataProperty(ts, property, mapping) {
+  if (ts.isSpreadAssignment(property)) return mapping(property.expression);
+  if (ts.isShorthandPropertyAssignment(property)) return !property.objectAssignmentInitializer;
+  if (!ts.isPropertyAssignment(property)) return false;
+  return (!ts.isComputedPropertyName(property.name) || mapping(property.name.expression)) && mapping(property.initializer);
+}
+
+function dataMapping(ts, expression, bindingOf) {
+  const node = unwrap(ts, expression);
+  if (!node) return false;
+  const mapping = (value) => dataMapping(ts, value, bindingOf);
+  if (ts.isIdentifier(node) || ts.isLiteralExpression(node) || node.kind === ts.SyntaxKind.TrueKeyword
+    || node.kind === ts.SyntaxKind.FalseKeyword || node.kind === ts.SyntaxKind.NullKeyword || node.kind === ts.SyntaxKind.ThisKeyword) return true;
+  if (ts.isPropertyAccessExpression(node)) return mapping(node.expression);
+  if (ts.isElementAccessExpression(node)) return mapping(node.expression) && mapping(node.argumentExpression);
+  if (ts.isObjectLiteralExpression(node)) return node.properties.every((property) => dataProperty(ts, property, mapping));
+  if (ts.isArrayLiteralExpression(node)) return node.elements.every((element) => ts.isOmittedExpression(element)
+    || mapping(ts.isSpreadElement(element) ? element.expression : element));
+  if (ts.isTemplateExpression(node)) return node.templateSpans.every((span) => mapping(span.expression));
+  if (ts.isPrefixUnaryExpression(node)) return [ts.SyntaxKind.PlusToken, ts.SyntaxKind.MinusToken].includes(node.operator)
+    && ts.isNumericLiteral(node.operand);
+  return ts.isCallExpression(node) && translator(ts, node.expression, bindingOf) && node.arguments.every(mapping);
+}
+
+/** Only object/array values belong to the prop contract; do not descend into a call or function body. */
+function nestedDataObjects(ts, expression, bindingOf, excluded) {
+  const node = unwrap(ts, expression);
+  if (!node) return;
+  if (ts.isObjectLiteralExpression(node)) {
+    if (dataMapping(ts, node, bindingOf)) { excluded.add(node); return; }
+    for (const property of node.properties) if (ts.isPropertyAssignment(property)) {
+      nestedDataObjects(ts, property.initializer, bindingOf, excluded);
+    }
+  } else if (ts.isArrayLiteralExpression(node)) {
+    for (const element of node.elements) if (!ts.isSpreadElement(element)) nestedDataObjects(ts, element, bindingOf, excluded);
+  }
+}
+
+/** Canon data prop objects qualify through an imported component binding, never its chosen name or file path. */
+export function canonJsxCloneNodes(ts, sourceFile) {
+  const bindingOf = lexicalBindings(ts, sourceFile);
+  const excluded = new Set();
+  const visit = (node) => {
+    if ((ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) && importedComponent(ts, node.tagName, bindingOf)) {
+      for (const attribute of node.attributes.properties) {
+        if (!ts.isJsxAttribute(attribute) || !attribute.initializer || !ts.isJsxExpression(attribute.initializer)) continue;
+        const value = unwrap(ts, attribute.initializer.expression);
+        if (!value || !ts.isObjectLiteralExpression(value)) continue;
+        if (dataMapping(ts, value, bindingOf)) excluded.add(attribute);
+        else nestedDataObjects(ts, value, bindingOf, excluded);
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return excluded;
+}

package/runtime/scripts/hfs/architecture/clones.mjs

@@ -21,8 +21,12 @@
  * helper because NestFactory is allowed only in main.ts (BE_ENTRYPOINT_ONLY_IN_APPS), so what repeats there is the
  * canonical shape of section 5 of BE-CONVENTION. A door or main.ts that grows logic is refused by those enforcers, not
  * excused here; every other file of the same slots (mappers, dto, app.module.ts) stays compared.
+ * Canon scaffold subtrees (job fences, read/mapping methods, queue producers/definitions, CQRS wiring and data
+ * props of imported JSX frames) are also dropped through their imported shape markers. Each exclusion ends a
+ * token segment, so a window cannot join unrelated code across omitted scaffold lines. Custom bodies stay compared.
  */
 import { byCodeUnit } from '../../lib/list.mjs';
+import { canonCloneNodes } from './canon-clones.mjs';
 
 export const CLONE_RULE_IDS = ['HFS_DUPLICATE_CODE'];
 
@@ -61,11 +65,13 @@ function visitToken(walk, node, inType) {
   const { ts, sourceFile, kinds, lines, types, lineStarts, literalKinds } = walk;
   const { SyntaxKind } = ts;
   if (isTriviaNode(SyntaxKind, node)) return;
+  if (walk.excluded?.has(node)) { walk.segment += 1; return; }
   const kind = node.kind;
   const typeScope = inType || kind === SyntaxKind.InterfaceDeclaration || kind === SyntaxKind.TypeAliasDeclaration;
   kinds.push(normalizedKindOf(SyntaxKind, literalKinds, kind));
   lines.push(lineOfPosition(lineStarts, node.getStart(sourceFile)));
   types.push(typeScope ? 1 : 0);
+  walk.segments.push(walk.segment);
   ts.forEachChild(node, (child) => { visitToken(walk, child, typeScope); });
 }
 
@@ -73,13 +79,14 @@ function visitToken(walk, node, inType) {
 const isDroppedStatement = (SyntaxKind, statement) => statement.kind === SyntaxKind.ImportDeclaration || statement.kind === SyntaxKind.ImportEqualsDeclaration
   || (statement.kind === SyntaxKind.ExportDeclaration && statement.moduleSpecifier);
 
-export function tokenize(ts, sourceFile) {
+export function tokenize(ts, sourceFile, { excluded = null } = {}) {
   const { SyntaxKind } = ts;
-  const walk = { ts, sourceFile, kinds: [], lines: [], types: [], lineStarts: sourceFile.getLineStarts(), literalKinds: literalKindSet(SyntaxKind) };
+  const walk = { ts, sourceFile, kinds: [], lines: [], types: [], segments: [], segment: 0, excluded,
+    lineStarts: sourceFile.getLineStarts(), literalKinds: literalKindSet(SyntaxKind) };
   for (const statement of sourceFile.statements) {
     if (!isDroppedStatement(SyntaxKind, statement)) visitToken(walk, statement, false);
   }
-  return { kinds: Int32Array.from(walk.kinds), lines: Int32Array.from(walk.lines), types: Uint8Array.from(walk.types) };
+  return { kinds: Int32Array.from(walk.kinds), lines: Int32Array.from(walk.lines), types: Uint8Array.from(walk.types), segments: Int32Array.from(walk.segments) };
 }
 
 /** The app a file belongs to, by the slot binding of the manifest; null for a file of no app. */
@@ -142,15 +149,15 @@ const addToBucket = (buckets, key, item) => {
 
 const addFileWindows = (buckets, file, fileIndex, N, T, hashing) => {
   const { pow1, pow2, B1, B2 } = hashing;
-  const { kinds, lines } = file;
+  const { kinds, lines, segments } = file;
   const count = kinds.length;
   const { pre1, pre2 } = prefixHashes(kinds, B1, B2);
   let end = 0;
   for (let start = 0; start < count; start += 1) {
-    if (start > 0 && lines[start] === lines[start - 1]) continue;
+    if (start > 0 && lines[start] === lines[start - 1] && segments[start] === segments[start - 1]) continue;
     const limit = lines[start] + N;
     if (end < start) end = start;
-    while (end < count && lines[end] < limit) end += 1;
+    while (end < count && lines[end] < limit && segments[end] === segments[start]) end += 1;
     if (end === start || lines[end - 1] - lines[start] + 1 < N) continue;
     const length = end - start;
     if (length < T) continue;
@@ -224,7 +231,8 @@ const cloneBlocks = (entries, hits, N) => {
     group.sort((x, y) => x[0] - y[0]);
     let [start, end] = group[0];
     for (const [nextStart, nextEnd] of group.slice(1)) {
-      if (nextStart <= end) { end = Math.max(end, nextEnd); continue; }
+      if (nextStart <= end && fileA.segments[nextStart] === fileA.segments[start]
+        && fileB.segments[nextStart + diag] === fileB.segments[start + diag]) { end = Math.max(end, nextEnd); continue; }
       appendCloneBlock(blocks, fileA, fileB, start, end, diag, N);
       start = nextStart; end = nextEnd;
     }
@@ -263,7 +271,8 @@ export function checkClones({ config, context, graph } = {}) {
     if (/\.d\.[cm]?tsx?$/.test(rel) || uniformByDesign(graph.resolver, rel)) continue;
     const unit = graph.unit(rel);
     if (!unit) continue;
-    entries.push({ rel, unit, ...tokenize(ts, graph.files.get(rel).sourceFile) });
+    const sourceFile = graph.files.get(rel).sourceFile;
+    entries.push({ rel, unit, ...tokenize(ts, sourceFile, { excluded: canonCloneNodes(ts, sourceFile, graph.profile) }) });
   }
   const buckets = cloneBuckets(entries, N, T);
   const blocks = cloneBlocks(entries, cloneHits(entries, buckets), N);

package/runtime/scripts/hfs/architecture/connection-map.mjs

@@ -226,18 +226,20 @@ const passConnections = (argument, scope) => {
 const checkAppRegistrations = (config, kit, ts, byName, report) => {
   let registrations = 0;
   for (const app of config.apps) {
-    const root = kit.appRoot(app.name);
-    if (!root) continue;
-    const checker = kit.checkerOf(root.sourceFile);
-    const scope = { ts, kit, checker, byName, passed: new Map(), root, app, report };
-    kit.walk(root.sourceFile, node => {
-      const receiver = registerReceiver(ts, node);
-      if (!receiver) return;
-      const owner = kit.declarationsOf(checker, receiver).map(kit.ownerOfDeclaration).find(Boolean);
-      if (owner?.tier !== 'platform' || owner.name !== 'database') return;
-      registrations += 1;
-      for (const argument of node.arguments) passConnections(argument, scope);
-    });
+    // The root and its composition groups (compose/<area>.ts) are one composition: a connection is passed once across them.
+    const passed = new Map();
+    for (const root of kit.appCompositionFiles(app.name)) {
+      const checker = kit.checkerOf(root.sourceFile);
+      const scope = { ts, kit, checker, byName, passed, root, app, report };
+      kit.walk(root.sourceFile, node => {
+        const receiver = registerReceiver(ts, node);
+        if (!receiver) return;
+        const owner = kit.declarationsOf(checker, receiver).map(kit.ownerOfDeclaration).find(Boolean);
+        if (owner?.tier !== 'platform' || owner.name !== 'database') return;
+        registrations += 1;
+        for (const argument of node.arguments) passConnections(argument, scope);
+      });
+    }
   }
   return registrations;
 };

package/runtime/scripts/hfs/architecture/context-map.mjs

@@ -74,10 +74,16 @@ const nameFromIdentifier = (ctx, checker, node, depth) => {
     ? nameOfExpression(ctx, kit.checkerOf(declaration.getSourceFile()), declaration.initializer, depth + 1) : null;
 };
 
+/** True when `declaration` is a property of the `<app>.env.ts` reader's own interface that sits beside the options file declaring `target`: the reader feeds the options value, so its property is the same slot. */
+const feedsOptions = (declaration, target) => {
+  const home = declaration?.getSourceFile().fileName ?? '';
+  return home.endsWith('.env.ts') && path.posix.dirname(home) === path.posix.dirname(target.getSourceFile().fileName);
+};
+
 const nameFromProperty = (ctx, checker, node, depth) => {
   const target = ctx.kit.declarationsOf(checker, node.name)[0];
   if (!target) return null;
-  const names = new Set(assignmentsOf(ctx, node.name.text).filter(item => item.declaration === target)
+  const names = new Set(assignmentsOf(ctx, node.name.text).filter(item => item.declaration === target || feedsOptions(item.declaration, target))
     .map(item => nameOfExpression(ctx, item.checker, item.initializer, depth + 1)).filter(Boolean));
   return names.size === 1 ? [...names][0] : null;
 };
@@ -282,30 +288,35 @@ const composedConnection = (kit, declared, checker, inner) => {
   return value !== null && declared.has(value) ? value : null;
 };
 
-const collectComposedConnections = (kit, declared, checker, call, items) => {
+const collectComposedConnections = (kit, declared, checker, call, file, items) => {
   for (const argument of call.arguments) {
     kit.walk(argument, inner => {
       const value = composedConnection(kit, declared, checker, inner);
       if (value === null) return true;
-      items.push({ connection: value, node: inner });
+      items.push({ connection: value, node: inner, file });
       return false;
     });
   }
 };
 
-/** The declared connection names the composition root of `app` passes to the database module registration, as [{connection, node}] in source order. */
+/**
+ * The declared connection names the composition of `app` (its root app.module.ts and the composition groups of compose/) passes to
+ * the database module registration, as [{connection, node, file}] in path then source order.
+ */
 export function connectionsComposedBy(kit, app) {
   const { ts } = kit;
-  const root = kit.appRoot(app);
-  if (!root) return { root: null, items: [] };
+  const files = kit.appCompositionFiles(app);
+  if (!files.length) return { root: null, items: [] };
   const declared = new Set(kit.resolver.repo.connections.map(connection => connection.name));
-  const checker = kit.checkerOf(root.sourceFile);
   const items = [];
-  kit.walk(root.sourceFile, node => {
-    if (!(ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'register')) return;
-    const owner = kit.declarationsOf(checker, node.expression.expression).map(kit.ownerOfDeclaration).find(Boolean);
-    if (owner?.tier !== 'platform' || owner.name !== 'database') return;
-    collectComposedConnections(kit, declared, checker, node, items);
-  });
-  return { root, items };
+  for (const file of files) {
+    const checker = kit.checkerOf(file.sourceFile);
+    kit.walk(file.sourceFile, node => {
+      if (!(ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'register')) return;
+      const owner = kit.declarationsOf(checker, node.expression.expression).map(kit.ownerOfDeclaration).find(Boolean);
+      if (owner?.tier !== 'platform' || owner.name !== 'database') return;
+      collectComposedConnections(kit, declared, checker, node, file, items);
+    });
+  }
+  return { root: files[0], items };
 }

package/runtime/scripts/hfs/architecture/context-owner.mjs

@@ -23,8 +23,7 @@ const RUNNER_KINDS = new Set(['migrate', 'cli']);
 const compositionsOf = (kit, resolver, model, appOf) => {
   const composed = new Map(resolver.repo.apps.map(app => [app.name, { items: [], unresolved: false }]));
   for (const app of resolver.repo.apps) {
-    const { root, items } = connectionsComposedBy(kit, app.name);
-    for (const item of items) composed.get(app.name).items.push({ ...item, file: root });
+    for (const item of connectionsComposedBy(kit, app.name).items) composed.get(app.name).items.push(item);
   }
   for (const site of model.registrations) {
     const app = appOf(site.file.rel);

package/runtime/scripts/hfs/architecture/dead-exports.mjs

@@ -25,7 +25,7 @@
  * (ruleParams.be.logicRoles: `<name>.policy.spec.ts`, `<name>.client.spec.ts`, ...), a
  * unit spec of a webhook, gateway or subscription door (`.webhook.spec.ts`, `.gateway.spec.ts`, `.subscription.spec.ts`: a door has no service of its own), a
  * `*.builder.ts` under src/tests/fixtures/builders, and a file of the test world (slots be.tests.world and be.tests.world.kit, which
- * open and migrate the real databases of the e2e run) read from disk count as consumers, because a spec can only provide an
+ * open and migrate the real databases of the e2e run) read from disk or staged in the git index count as consumers, because a spec can only provide an
  * Inject*() token or a param type the entry exports, and the world wires the same capabilities the apps do. An integration
  * spec (slot be.tests.integration, `src/tests/integration/<capability>/*.integration-spec.ts`) counts as a consumer of exactly one
  * owner: the integration (slot be.integrations, `src/modules/integrations/<provider>/`) whose provider folder is its capability
@@ -38,6 +38,7 @@ import { canonical } from './config.mjs';
 import path from 'node:path';
 import { treeOf } from './required-files.mjs';
 import { globExpression } from '../../lib/glob.mjs';
+import { stagedConsumerSources } from './staged-consumers.mjs';
 
 export const DEAD_EXPORT_RULE_IDS = ['HFS_UNUSED_EXPORT', 'HFS_UNUSED_FILE'];
 
@@ -241,10 +242,12 @@ function inIntegrationOf(graph, to, provider) {
 }
 
 /** The pseudo edges of one test consumer file: its import/export declarations that resolve to graph files it may reach. */
-function consumerFileEdges({ ts, options, graph, config }, rel, provider) {
+function consumerFileEdges({ ts, options, graph, config }, rel, provider, indexedText) {
   const abs = path.join(config.root, ...rel.split('/'));
-  let text;
-  try { text = fs.readFileSync(abs, 'utf8'); } catch { return []; }
+  let text = indexedText;
+  if (text === undefined) {
+    try { text = fs.readFileSync(abs, 'utf8'); } catch { return []; }
+  }
   const sourceFile = ts.createSourceFile(abs, text, ts.ScriptTarget.Latest, true);
   const edges = [];
   for (const statement of sourceFile.statements) {
@@ -257,17 +260,19 @@ function consumerFileEdges({ ts, options, graph, config }, rel, provider) {
 }
 
 /**
- * Pseudo edges (read from disk, outside the production program) to graph files: from the unit role specs, the fixture builders and
+ * Pseudo edges (read from disk and staged index sources, outside the production program) to graph files: from the unit role specs, the fixture builders and
  * the test world files to anything, and from an integration spec only to the integration of its own provider folder.
  */
 function testConsumerEdges({ context, graph, config }) {
   const resolution = { ts: context.ts, options: context.projects?.[0]?.options ?? {}, graph, config };
-  const consumers = [...treeOf(config.root).files]
-    .map(file => ({ file, any: testConsumer(graph, file) }))
-    .map(({ file, any }) => ({ file, provider: any ? null : integrationSpecProvider(graph, file), any }))
+  // Live lint keeps tracked disk consumers; staged snapshots add the consumers present in the same commit.
+  const staged = stagedConsumerSources(config.root, file => testConsumer(graph, file) || integrationSpecProvider(graph, file) !== null);
+  const consumers = [...[...treeOf(config.root).files].map(file => ({ file })), ...staged]
+    .map(source => ({ ...source, any: testConsumer(graph, source.file) }))
+    .map(({ file, text, any }) => ({ file, text, provider: any ? null : integrationSpecProvider(graph, file), any }))
     .filter(({ any, provider }) => any || provider !== null)
     .sort((a, b) => a.file.localeCompare(b.file));
-  return consumers.flatMap(({ file: rel, provider }) => consumerFileEdges(resolution, rel, provider));
+  return consumers.flatMap(({ file: rel, text, provider }) => consumerFileEdges(resolution, rel, provider, text));
 }
 
 const edgeIndex = edges => {

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

@@ -0,0 +1,104 @@
+import path from 'node:path';
+import { normalizedSymbolValue } from './ast-walks.mjs';
+import { unwrapExpression } from './typescript.mjs';
+
+/** Feature composition may inject block renders into a pure view without making the view a world owner. */
+export class BlockRenderAnalysis {
+  constructor(renderer) {
+    this.renderer = renderer;
+    this.world = renderer.world;
+  }
+
+  featureComposition(expression, expectedFile) {
+    const file = expression?.getSourceFile().fileName;
+    return Boolean(file && !expectedFile && this.world.insideAny(this.world.roots.features, file)
+      && path.basename(file) === 'index.tsx');
+  }
+
+  renderProp(expression, checker, expectedFile) {
+    return this.featureComposition(expression, expectedFile) && this.renderValue(expression, checker);
+  }
+
+  blockTarget(expression, checker) {
+    const functions = this.world.expressionFunctions(expression, checker);
+    return functions.length > 0 && functions.every(fn => {
+      const file = fn.getSourceFile().fileName;
+      return this.world.sourceSet.has(path.resolve(file)) && path.basename(file) === 'index.tsx'
+        && this.world.tierOf(this.world.roots.components, file)?.tier === 'blocks'
+        && this.renderer.functionHasRender(fn, checker);
+    });
+  }
+
+  callbacksRender(functions, checker, seen) {
+    return functions.length > 0 && functions.every(fn => {
+      const values = this.renderer.helpers.returnedExpressions(this.world.ts, fn);
+      return !this.world.functionUsesWorld(fn, checker) && values.length > 0
+        && values.every(value => this.renderValue(value, checker, seen));
+    });
+  }
+
+  renderValue(input, checker, seen = new Set()) {
+    const ts = this.world.ts;
+    const value = unwrapExpression(ts, input);
+    if (!value) return false;
+    if (value.kind === ts.SyntaxKind.NullKeyword || value.kind === ts.SyntaxKind.FalseKeyword) return true;
+    if (ts.isConditionalExpression(value)) return this.renderValue(value.whenTrue, checker, seen)
+      && this.renderValue(value.whenFalse, checker, seen);
+    if (ts.isBinaryExpression(value) && value.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken)
+      return this.renderValue(value.right, checker, seen);
+    if (ts.isArrayLiteralExpression(value)) return value.elements.every(item => this.renderValue(item, checker, seen));
+    if (ts.isJsxFragment(value)) return this.fragmentBlocks(value, checker, seen);
+    if (ts.isJsxElement(value) || ts.isJsxSelfClosingElement(value)) return this.jsxBlock(value, checker, seen);
+    if (ts.isCallExpression(value)) return this.createdBlock(value, checker, seen) || this.mappedBlocks(value, checker, seen);
+    if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) return this.callbacksRender([value], checker, seen);
+    return this.referencedBlocks(value, checker, seen);
+  }
+
+  fragmentBlocks(value, checker, seen) {
+    const ts = this.world.ts;
+    return value.children.every(child => {
+      if (ts.isJsxText(child)) return !child.text.trim();
+      return this.renderValue(ts.isJsxExpression(child) ? child.expression : child, checker, seen);
+    });
+  }
+
+  jsxBlock(value, checker, seen) {
+    const ts = this.world.ts;
+    const opening = ts.isJsxElement(value) ? value.openingElement : value;
+    if (!this.blockTarget(opening.tagName, checker)) return false;
+    const boundary = { hasBoundary: true };
+    return this.renderer.jsxChildrenBoundary(value, opening, checker, seen, null, false, boundary)
+      && this.renderer.jsxAttributesBoundary(opening, checker, seen, null, boundary);
+  }
+
+  mappedBlocks(value, checker, seen) {
+    const ts = this.world.ts;
+    const callee = unwrapExpression(ts, value.expression);
+    if (!ts.isPropertyAccessExpression(callee) && !ts.isElementAccessExpression(callee)) return false;
+    let name = ts.isPropertyAccessExpression(callee) ? callee.name.text : null;
+    if (name === null && ts.isStringLiteralLike(callee.argumentExpression)) name = callee.argumentExpression.text;
+    return name === 'map' && value.arguments.length > 0
+      && this.callbacksRender(this.world.expressionFunctions(value.arguments[0], checker), checker, seen);
+  }
+
+  createdBlock(value, checker, seen) {
+    const ts = this.world.ts;
+    if (!this.renderer.isCreateElement(value, checker) || !value.arguments[0]
+      || !this.blockTarget(value.arguments[0], checker)) return false;
+    const boundary = { hasBoundary: true };
+    const props = value.arguments[1] ? unwrapExpression(ts, value.arguments[1]) : null;
+    return this.renderer.createElementPropsBoundary(props, checker, seen, null, boundary, false)
+      && value.arguments.slice(2).every(child => this.renderer.renderBoundary(child, checker, seen));
+  }
+
+  referencedBlocks(value, checker, seen) {
+    const ts = this.world.ts;
+    const symbol = normalizedSymbolValue(ts, checker, this.renderer.helpers.selectedSymbol(ts, checker, value));
+    if (!symbol || seen.has(symbol)) return false;
+    const nextSeen = new Set(seen).add(symbol);
+    const values = (symbol.getDeclarations?.() ?? []).flatMap(declaration => ts.isVariableDeclaration(declaration)
+      && declaration.initializer ? [declaration.initializer] : []);
+    if (values.length) return values.every(item => this.renderValue(item, checker, nextSeen));
+    return this.callbacksRender(this.world.expressionFunctions(value, checker), checker, nextSeen);
+  }
+}

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

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { normalizedSymbolValue } from './ast-walks.mjs';
 import { relativePath, unwrapExpression } from './typescript.mjs';
+import { BlockRenderAnalysis } from './frontend-block-render.mjs';
 function importDeclarationFor(ts, node) {
   for (let current = node; current; current = current.parent) if (ts.isImportDeclaration(current)) return current;
   return null;
@@ -41,12 +42,14 @@ export class WorldRenderAnalysis {
   constructor(world, helpers) {
     this.world = world;
     this.helpers = helpers;
+    this.blocks = new BlockRenderAnalysis(this);
   }
 
   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.isArrayLiteralExpression(expression)) return expression.elements.some(item => this.expressionHasRender(item, checker, seen));
     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);
@@ -148,6 +151,22 @@ export class WorldRenderAnalysis {
       || this.world.expressionFunctions(expression, checker).some(fn => this.functionHasRender(fn, checker));
   }
 
+  isCreateElement(expression, checker) {
+    return isReactCreateElement(this.world.ts, checker, expression);
+  }
+
+  propValueBoundary(input, checker, seen, expectedFile, pureTarget) {
+    const ts = this.world.ts;
+    const value = unwrapExpression(ts, input);
+    if (pureTarget && this.blocks.renderProp(value, checker, expectedFile)) return true;
+    if (pureTarget && this.blocks.featureComposition(value, expectedFile) && ts.isObjectLiteralExpression(value)) {
+      return value.properties.every(property => !ts.isPropertyAssignment(property)
+        || this.propValueBoundary(property.initializer, checker, seen, expectedFile, pureTarget));
+    }
+    return !this.expressionSuppliesRender(value, checker) || this.pureRenderTarget(value, checker, expectedFile)
+      || this.renderBoundary(value, checker, seen, true, expectedFile);
+  }
+
   routedLayoutChild(opening, child, checker) {
     const ts = this.world.ts;
     if (!ts.isJsxExpression(child) || !child.expression) return false;
@@ -216,7 +235,7 @@ export class WorldRenderAnalysis {
     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;
+    if (!this.createElementPropsBoundary(props, checker, seen, expectedFile, boundary, pureTarget)) return false;
     const children = expression.arguments.slice(2);
     if (children.length) {
       if (!children.every(child => this.renderBoundary(child, checker, seen, false, expectedFile))) return false;
@@ -225,19 +244,19 @@ export class WorldRenderAnalysis {
     return boundary.hasBoundary;
   }
 
-  createElementPropsBoundary(props, checker, seen, expectedFile, boundary) {
+  createElementPropsBoundary(props, checker, seen, expectedFile, boundary, pureTarget) {
     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));
+    return props.properties.every(property => this.propsPropertyBoundary(property, checker, seen, expectedFile, boundary, pureTarget));
   }
 
-  propsPropertyBoundary(property, checker, seen, expectedFile, boundary) {
+  propsPropertyBoundary(property, checker, seen, expectedFile, boundary, pureTarget) {
     const ts = this.world.ts;
     if (!ts.isPropertyAssignment(property)) return true;
     const value = unwrapExpression(ts, property.initializer);
+    if (!this.propValueBoundary(value, checker, seen, expectedFile, pureTarget)) return false;
     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;
@@ -270,7 +289,7 @@ export class WorldRenderAnalysis {
     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;
+    if (!this.jsxAttributesBoundary(opening, checker, seen, expectedFile, boundary, pureTarget)) return false;
     return boundary.hasBoundary;
   }
 
@@ -286,13 +305,13 @@ export class WorldRenderAnalysis {
     return true;
   }
 
-  jsxAttributesBoundary(opening, checker, seen, expectedFile, boundary) {
+  jsxAttributesBoundary(opening, checker, seen, expectedFile, boundary, pureTarget = false) {
     const ts = this.world.ts;
     return opening.attributes.properties.every(attribute => !ts.isJsxAttribute(attribute) || !attribute.initializer
-      || this.jsxAttributeBoundary(attribute, checker, seen, expectedFile, boundary));
+      || this.jsxAttributeBoundary(attribute, checker, seen, expectedFile, boundary, pureTarget));
   }
 
-  jsxAttributeBoundary(attribute, checker, seen, expectedFile, boundary) {
+  jsxAttributeBoundary(attribute, checker, seen, expectedFile, boundary, pureTarget) {
     const ts = this.world.ts;
     const name = attribute.name.text;
     if (['fallback', 'errorElement'].includes(name)) {
@@ -300,10 +319,10 @@ export class WorldRenderAnalysis {
       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.propValueBoundary(attribute.initializer.expression, checker, seen, expectedFile, pureTarget)) 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;