@starci/hfs 4.11.22 → 4.12.2

package/runtime/scripts/hfs/architecture/operation-contract-roots.d.mts

@@ -0,0 +1,10 @@
+import type { TypeChecker } from 'typescript';
+import type { ArchitectureConfig, TypeScriptApi } from './config.mjs';
+import type { HfsGraph } from './hfs-graph.mjs';
+/** The part of the TypeScript context this check reads. */
+export interface OperationContext {
+    ts: TypeScriptApi;
+    checkerFor?: (fileName: string) => TypeChecker | undefined;
+}
+/** Only the emitter's exact entry of a declared API app is a contract root; workers and arbitrary app files remain judged. */
+export declare function operationContractRoots(context: OperationContext, graph: HfsGraph, config: ArchitectureConfig): string[];

package/runtime/scripts/hfs/architecture/operation-contract-roots.mjs

@@ -1,53 +1,55 @@
 /** The app emitter consumes the API app's declared operation table without importing it from app.module.ts. */
 import path from 'node:path';
 import { hasAnyFlag } from '../../lib/ts-ast.mjs';
-
 const actualSymbol = (ts, checker, symbol) => symbol && hasAnyFlag(symbol.flags, ts.SymbolFlags.Alias) ? checker.getAliasedSymbol(symbol) : symbol;
-
 /** Follow declaration aliases while retaining the actual expression rather than an asserted type. */
 const initializerOf = (ts, checker, node, seen = new Set()) => {
-  if (!node || seen.has(node)) return null;
-  seen.add(node);
-  if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)
-    || ts.isSatisfiesExpression(node) || ts.isNonNullExpression(node)) return initializerOf(ts, checker, node.expression, seen);
-  if (!ts.isIdentifier(node) && !ts.isPropertyAccessExpression(node)) return node;
-  const declaration = actualSymbol(ts, checker, checker.getSymbolAtLocation(node))?.valueDeclaration;
-  return declaration?.initializer ? initializerOf(ts, checker, declaration.initializer, seen) : node;
+    if (!node || seen.has(node))
+        return null;
+    seen.add(node);
+    if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isTypeAssertionExpression(node)
+        || ts.isSatisfiesExpression(node) || ts.isNonNullExpression(node))
+        return initializerOf(ts, checker, node.expression, seen);
+    if (!ts.isIdentifier(node) && !ts.isPropertyAccessExpression(node))
+        return node;
+    const declaration = actualSymbol(ts, checker, checker.getSymbolAtLocation(node))?.valueDeclaration; // reason: a value declaration may or may not be a variable declaration; `initializer` is read only when present
+    return declaration?.initializer ? initializerOf(ts, checker, declaration.initializer, seen) : node;
 };
-
 /** A same-named local function cannot declare the platform operation contract. */
 const isOperationDefiner = (ts, checker, graph, config, expression, seen = new Set()) => {
-  const symbol = actualSymbol(ts, checker, checker.getSymbolAtLocation(expression));
-  if (!symbol || seen.has(symbol)) return false;
-  seen.add(symbol);
-  return (symbol?.declarations ?? []).some(declaration => {
-    const relative = path.relative(config.root, declaration.getSourceFile().fileName).split(path.sep).join('/');
-    const owner = graph.resolver.ownerOf(relative);
-    if (declaration.name?.text === 'defineOperations' && owner?.slot === 'be.platform' && path.posix.basename(owner.root) === 'operations') return true;
-    const alias = declaration.initializer;
-    return Boolean(alias && (ts.isIdentifier(alias) || ts.isPropertyAccessExpression(alias)) && isOperationDefiner(ts, checker, graph, config, alias, seen));
-  });
+    const symbol = actualSymbol(ts, checker, checker.getSymbolAtLocation(expression));
+    if (!symbol || seen.has(symbol))
+        return false;
+    seen.add(symbol);
+    return (symbol.declarations ?? []).some((declaration) => {
+        const relative = path.relative(config.root, declaration.getSourceFile().fileName).split(path.sep).join('/');
+        const owner = graph.resolver.ownerOf(relative);
+        if (declaration.name?.text === 'defineOperations' && owner?.slot === 'be.platform' && path.posix.basename(owner.root) === 'operations')
+            return true;
+        const alias = declaration.initializer;
+        return Boolean(alias && (ts.isIdentifier(alias) || ts.isPropertyAccessExpression(alias)) && isOperationDefiner(ts, checker, graph, config, alias, seen));
+    });
 };
-
 /** True only for an exported, nonempty registration by the canon platform capability. */
 const declaresOperations = (context, graph, config, sourceFile) => {
-  const { ts } = context;
-  const checker = context.checkerFor?.(sourceFile.fileName);
-  const moduleSymbol = checker?.getSymbolAtLocation(sourceFile);
-  if (!moduleSymbol) return false;
-  const exported = checker.getExportsOfModule(moduleSymbol).find(symbol => symbol.getName() === 'OPERATIONS');
-  const declaration = actualSymbol(ts, checker, exported)?.valueDeclaration;
-  const registration = initializerOf(ts, checker, declaration?.initializer);
-  if (!registration || !ts.isCallExpression(registration) || !isOperationDefiner(ts, checker, graph, config, registration.expression)) return false;
-  const entries = initializerOf(ts, checker, registration.arguments[0]);
-  return entries !== null && ts.isObjectLiteralExpression(entries) && checker.getPropertiesOfType(checker.getTypeAtLocation(entries)).length > 0;
+    const { ts } = context;
+    const checker = context.checkerFor?.(sourceFile.fileName);
+    const moduleSymbol = checker?.getSymbolAtLocation(sourceFile);
+    if (!checker || !moduleSymbol)
+        return false;
+    const exported = checker.getExportsOfModule(moduleSymbol).find(symbol => symbol.getName() === 'OPERATIONS');
+    const declaration = actualSymbol(ts, checker, exported)?.valueDeclaration; // reason: see initializerOf
+    const registration = initializerOf(ts, checker, declaration?.initializer);
+    if (!registration || !ts.isCallExpression(registration) || !isOperationDefiner(ts, checker, graph, config, registration.expression))
+        return false;
+    const entries = initializerOf(ts, checker, registration.arguments[0]);
+    return entries !== null && ts.isObjectLiteralExpression(entries) && checker.getPropertiesOfType(checker.getTypeAtLocation(entries)).length > 0;
 };
-
 /** Only the emitter's exact entry of a declared API app is a contract root; workers and arbitrary app files remain judged. */
 export function operationContractRoots(context, graph, config) {
-  return (config.apps ?? []).filter(app => app.kind === 'api').flatMap(app => {
-    const relative = `apps/${app.name}/src/operations.ts`;
-    const node = graph.files.get(relative);
-    return node?.tier === 'app' && node.slot === 'be.app.api' && declaresOperations(context, graph, config, node.sourceFile) ? [relative] : [];
-  });
+    return (config.apps ?? []).filter(app => app.kind === 'api').flatMap(app => {
+        const relative = `apps/${app.name}/src/operations.ts`;
+        const node = graph.files.get(relative);
+        return node?.tier === 'app' && node.slot === 'be.app.api' && declaresOperations(context, graph, config, node.sourceFile) ? [relative] : [];
+    });
 }

package/runtime/scripts/hfs/architecture/owners.d.mts

@@ -0,0 +1,5 @@
+import type { ArchitectureConfig } from './config.mjs';
+import type { ArchitectureViolation } from './hfs-graph.mjs';
+import type { TypeContext } from './type-context.mjs';
+/** Enforce explicit same-source owner entries without constraining imports inside one owner. */
+export declare function checkOwners(config: ArchitectureConfig, context: TypeContext): ArchitectureViolation[];

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

@@ -5,139 +5,138 @@ import { sourceLocation } from '../../lib/ts-ast.mjs';
 import { globExpression } from '../../lib/glob.mjs';
 import { posixPath } from '../../lib/path-key.mjs';
 import { registryImporter, registrySlot } from './entity-registry.mjs';
-
 function absolute(root, relative) {
-  return canonical(path.resolve(root, ...relative.split('/')));
+    return canonical(path.resolve(root, ...relative.split('/')));
 }
-
 /**
  * The extra public entries the slot manifest declares for the owner (slot field `entries`, on the slot that holds its entry file):
  * exact files as absolute paths, and the entries holding a `*` (one file per operation, `graphql/queries/query-*.ts`) as patterns.
  */
 function slotEntries(config, owner) {
-  const found = config.hfs?.classifyPath?.(owner.entry);
-  const names = found?.slot ? config.hfs.slot(found.slot)?.entries ?? [] : [];
-  const exact = names.filter(name => !name.includes('*')).map(name => absolute(config.root, `${found.root}/${name}`));
-  const patterns = names.filter(name => name.includes('*')).map(name => globExpression(`${posixPath(absolute(config.root, found.root))}/${name}`));
-  return { exact, patterns };
+    const found = config.hfs?.classifyPath?.(owner.entry);
+    if (!found?.slot)
+        return { exact: [], patterns: [] };
+    const names = config.hfs.slot(found.slot)?.entries ?? [];
+    const exact = names.filter(name => !name.includes('*')).map(name => absolute(config.root, `${found.root}/${name}`));
+    const patterns = names.filter(name => name.includes('*')).map(name => globExpression(`${posixPath(absolute(config.root, found.root))}/${name}`));
+    return { exact, patterns };
 }
-
 /** The owner's public entries: its declared entry, the `entries` its slot declares, plus every source file its package.json `exports` maps when the owner is a workspace package. */
 function ownerDeclarations(config, context) {
-  return config.owners.map(owner => {
-    const root = absolute(config.root, owner.root);
-    const entry = absolute(config.root, owner.entry);
-    const workspace = context.workspaces?.find(item => item.root === root);
-    const { exact: declared, patterns } = slotEntries(config, owner);
-    const entries = new Set([entry, ...declared, ...(workspace ? workspaceExportSources(context.ts, workspace) : [])]);
-    const isEntry = file => entries.has(file) || patterns.some(pattern => pattern.test(posixPath(file)));
-    return { ...owner, root, entry, entries, isEntry, declared };
-  }).sort((a, b) => b.root.length - a.root.length);
+    return config.owners.map((owner) => {
+        const root = absolute(config.root, owner.root);
+        const entry = absolute(config.root, owner.entry);
+        const workspace = context.workspaces?.find(item => item.root === root);
+        const { exact: declared, patterns } = slotEntries(config, owner);
+        const entries = new Set([entry, ...declared, ...(workspace ? workspaceExportSources(context.ts, workspace) : [])]);
+        const isEntry = (file) => entries.has(file) || patterns.some(pattern => pattern.test(posixPath(file)));
+        return { ...owner, root, entry, entries, isEntry, declared };
+    }).sort((a, b) => b.root.length - a.root.length);
 }
-
 function ownerOf(owners, file) {
-  return owners.find(owner => isInside(owner.root, file)) ?? null;
+    return owners.find(owner => isInside(owner.root, file)) ?? null;
 }
-
 function reexportSteps(context, current) {
-  return (context.edges.get(current.file) ?? []).filter(candidate => candidate.reexport).map(candidate => ({ file: candidate.to, chain: [...current.chain, candidate.to] }));
+    return (context.edges.get(current.file) ?? []).filter(candidate => candidate.reexport).map(candidate => ({ file: candidate.to, chain: [...current.chain, candidate.to] }));
 }
-
 function privateOwnerChain(context, owners, edge) {
-  const sourceOwner = ownerOf(owners, edge.from);
-  const queue = [{ file: edge.to, chain: [edge.from, edge.to] }];
-  const visited = new Set();
-  while (queue.length) {
-    const current = queue.shift();
-    if (visited.has(current.file)) continue;
-    visited.add(current.file);
-    const owner = ownerOf(owners, current.file);
-    if (owner && sourceOwner?.id !== owner.id) return owner.isEntry(current.file) ? null : { owner, chain: current.chain };
-    queue.push(...reexportSteps(context, current));
-  }
-  return null;
+    const sourceOwner = ownerOf(owners, edge.from);
+    const queue = [{ file: edge.to, chain: [edge.from, edge.to] }];
+    const visited = new Set();
+    for (let current = queue.shift(); current; current = queue.shift()) {
+        if (visited.has(current.file))
+            continue;
+        visited.add(current.file);
+        const owner = ownerOf(owners, current.file);
+        if (owner && sourceOwner?.id !== owner.id)
+            return owner.isEntry(current.file) ? null : { owner, chain: current.chain };
+        queue.push(...reexportSteps(context, current));
+    }
+    return null;
 }
-
 /**
  * A `*.builder.ts` of slot be.tests.fixtures.builders arranges data at the schema level: it may deep-import the persistence
  * entity classes and connection entity lists (slot be.persistence) of any capability. No other file may.
  */
 function arrangesSchema(config, from, to) {
-  const resolver = config.hfs;
-  if (!resolver?.classifyPath) return false;
-  return resolver.classifyPath(relativePath(config.root, from)).slot === 'be.tests.fixtures.builders'
-    && resolver.classifyPath(relativePath(config.root, to)).slot === 'be.persistence';
+    const resolver = config.hfs;
+    if (!resolver?.classifyPath)
+        return false;
+    return resolver.classifyPath(relativePath(config.root, from)).slot === 'be.tests.fixtures.builders'
+        && resolver.classifyPath(relativePath(config.root, to)).slot === 'be.persistence';
 }
-
 /**
  * The entity registry (slot role entity-registry, entity-registry.mjs) is imported by deep path, and only from the files its slot's
  * `importedBy` names: app composition and the test world. Any other importer goes through the owner's entry, which never exports it.
  */
 function importsRegistry(config, from, to) {
-  const slot = registrySlot(config.hfs, relativePath(config.root, to));
-  return slot !== null && registryImporter(config.hfs, slot, relativePath(config.root, from));
+    const slot = registrySlot(config.hfs, relativePath(config.root, to));
+    return slot !== null && registryImporter(config.hfs, slot, relativePath(config.root, from));
 }
-
 function publicEntryViolations(config, context, owners, sourceFiles) {
-  const violations = [];
-  for (const owner of owners) {
-    const sourceFile = sourceFiles.get(owner.entry);
-    if (!sourceFile) {
-      violations.push({ ruleId: 'ARCH_OWNER_EXPORT_BYPASS', path: relativePath(config.root, owner.entry), line: 1, column: 1, owner: owner.id,
-        message: `Owner ${owner.id} public entry is outside the configured TypeScript programs, so its boundary cannot be checked.` });
-      continue;
-    }
-    const publicFiles = new Set([
-      sourceFile,
-      ...owner.declared.map(file => sourceFiles.get(file)).filter(Boolean),
-    ]);
-    for (const entryFile of publicFiles) {
-      for (const statement of entryFile.statements) if (context.ts.isExportDeclaration(statement) && !statement.exportClause) {
-        violations.push({
-          ruleId: 'ARCH_OWNER_EXPORT_STAR',
-          path: relativePath(config.root, canonical(entryFile.fileName)),
-          ...sourceLocation(entryFile, statement),
-          owner: owner.id,
-          message: `Owner ${owner.id} public entry must use explicit named exports rather than export *.`,
-        });
-      }
+    const violations = [];
+    for (const owner of owners) {
+        const sourceFile = sourceFiles.get(owner.entry);
+        if (!sourceFile) {
+            violations.push({ ruleId: 'ARCH_OWNER_EXPORT_BYPASS', path: relativePath(config.root, owner.entry), line: 1, column: 1, owner: owner.id,
+                message: `Owner ${owner.id} public entry is outside the configured TypeScript programs, so its boundary cannot be checked.` });
+            continue;
+        }
+        const publicFiles = new Set([
+            sourceFile,
+            ...owner.declared.map(file => sourceFiles.get(file)).filter((file) => Boolean(file)),
+        ]);
+        for (const entryFile of publicFiles) {
+            for (const statement of entryFile.statements)
+                if (context.ts.isExportDeclaration(statement) && !statement.exportClause) {
+                    violations.push({
+                        ruleId: 'ARCH_OWNER_EXPORT_STAR',
+                        path: relativePath(config.root, canonical(entryFile.fileName)),
+                        ...sourceLocation(entryFile, statement),
+                        owner: owner.id,
+                        message: `Owner ${owner.id} public entry must use explicit named exports rather than export *.`,
+                    });
+                }
+        }
     }
-  }
-  return violations;
+    return violations;
 }
-
 function ownerImportViolations(config, context, owners) {
-  const violations = [];
-  for (const sourceFile of context.files) {
-    const from = canonical(sourceFile.fileName);
-    for (const edge of context.edges.get(from) ?? []) {
-      const bypass = privateOwnerChain(context, owners, edge);
-      if (!bypass) continue;
-      if (arrangesSchema(config, from, bypass.chain.at(-1))) continue;
-      if (bypass.chain.length === 2 && importsRegistry(config, from, bypass.chain.at(-1))) continue;
-      violations.push({
-        ruleId: 'ARCH_OWNER_EXPORT_BYPASS',
-        path: relativePath(config.root, from),
-        line: edge.line,
-        column: edge.column,
-        owner: bypass.owner.id,
-        specifier: edge.specifier,
-        resolvedPath: relativePath(config.root, bypass.chain.at(-1)),
-        dependencyChain: bypass.chain.map(file => relativePath(config.root, file)),
-        message: `Cross-owner dependency must enter ${bypass.owner.id} through ${relativePath(config.root, bypass.owner.entry)}.`,
-      });
+    const violations = [];
+    for (const sourceFile of context.files) {
+        const from = canonical(sourceFile.fileName);
+        for (const edge of context.edges.get(from) ?? []) {
+            const bypass = privateOwnerChain(context, owners, edge);
+            if (!bypass)
+                continue;
+            const target = bypass.chain.at(-1) ?? edge.to;
+            if (arrangesSchema(config, from, target))
+                continue;
+            if (bypass.chain.length === 2 && importsRegistry(config, from, target))
+                continue;
+            violations.push({
+                ruleId: 'ARCH_OWNER_EXPORT_BYPASS',
+                path: relativePath(config.root, from),
+                line: edge.line,
+                column: edge.column,
+                owner: bypass.owner.id,
+                specifier: edge.specifier,
+                resolvedPath: relativePath(config.root, target),
+                dependencyChain: bypass.chain.map(file => relativePath(config.root, file)),
+                message: `Cross-owner dependency must enter ${bypass.owner.id} through ${relativePath(config.root, bypass.owner.entry)}.`,
+            });
+        }
     }
-  }
-  return violations;
+    return violations;
 }
-
 /** Enforce explicit same-source owner entries without constraining imports inside one owner. */
 export function checkOwners(config, context) {
-  if (!config.owners?.length) return [];
-  const owners = ownerDeclarations(config, context);
-  const sourceFiles = new Map(context.files.map(file => [canonical(file.fileName), file]));
-  return [
-    ...publicEntryViolations(config, context, owners, sourceFiles),
-    ...ownerImportViolations(config, context, owners),
-  ];
+    if (!config.owners?.length)
+        return [];
+    const owners = ownerDeclarations(config, context);
+    const sourceFiles = new Map(context.files.map((file) => [canonical(file.fileName), file]));
+    return [
+        ...publicEntryViolations(config, context, owners, sourceFiles),
+        ...ownerImportViolations(config, context, owners),
+    ];
 }

package/runtime/scripts/hfs/architecture/package-shape.d.mts

@@ -0,0 +1,26 @@
+import type { ArchitectureConfig } from './config.mjs';
+import type { ArchitectureViolation, HfsGraph } from './hfs-graph.mjs';
+/**
+ * R63 `package-shape` (FE_PACKAGE_SHAPE, knowledge/hfs/README.md 6.2). A shared package is built to `dist` and says what it
+ * exports. The package manifest of every package owner (slots repo.packages and fe.package.ui, packages/<pkg>/package.json)
+ * must have:
+ *
+ *   - a `scripts.build`;
+ *   - an explicit `exports` map: present, no `*` pattern in a subpath, no folder mapping;
+ *   - every export target, and `main`, `module`, `types` and `typings` when present, inside `./dist/`: a target into `src/`
+ *     ships source that was never built.
+ *
+ * `export *` in the package entry is ARCH_OWNER_EXPORT_STAR, a dead unit is HFS_UNUSED_EXPORT and the package tiers are the
+ * eslint rule `monorepo-tier-belongs-to-its-side`; none is judged a second time here.
+ */
+export declare const PACKAGE_SHAPE_RULE_IDS: string[];
+export declare function checkPackageShape({ config, graph }: {
+    config: ArchitectureConfig;
+    graph: HfsGraph;
+}): {
+    violations: ArchitectureViolation[];
+    coverage: {
+        status: string;
+        packages: number;
+    };
+};

package/runtime/scripts/hfs/architecture/package-shape.mjs

@@ -2,7 +2,6 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { treeOf } from './required-files.mjs';
 import { byCodeUnit } from '../../lib/list.mjs';
-
 /**
  * R63 `package-shape` (FE_PACKAGE_SHAPE, knowledge/hfs/README.md 6.2). A shared package is built to `dist` and says what it
  * exports. The package manifest of every package owner (slots repo.packages and fe.package.ui, packages/<pkg>/package.json)
@@ -17,75 +16,77 @@ import { byCodeUnit } from '../../lib/list.mjs';
  * eslint rule `monorepo-tier-belongs-to-its-side`; none is judged a second time here.
  */
 export const PACKAGE_SHAPE_RULE_IDS = ['FE_PACKAGE_SHAPE'];
-
 const RULE = 'FE_PACKAGE_SHAPE';
 const UNREADABLE = Symbol('unreadable');
-
 /** Every string target of an exports value (a string, a condition map, an array of either), with the condition path. */
 function targetsOf(value, trail = []) {
-  if (typeof value === 'string') return [{ target: value, trail }];
-  if (Array.isArray(value)) return value.flatMap((item, index) => targetsOf(item, [...trail, String(index)]));
-  if (value && typeof value === 'object') return Object.entries(value).flatMap(([key, item]) => targetsOf(item, [...trail, key]));
-  return [];
+    if (typeof value === 'string')
+        return [{ target: value, trail }];
+    if (Array.isArray(value))
+        return value.flatMap((item, index) => targetsOf(item, [...trail, String(index)]));
+    if (value && typeof value === 'object')
+        return Object.entries(value).flatMap(([key, item]) => targetsOf(item, [...trail, key]));
+    return [];
 }
-
-const insideDist = target => path.posix.normalize(target).replace(/^\.\//u, '').startsWith('dist/');
-
+const insideDist = (target) => path.posix.normalize(target).replace(/^\.\//u, '').startsWith('dist/');
 function packageRoots(config, resolver) {
-  const roots = new Set();
-  for (const rel of treeOf(config.root).files) {
-    const owner = resolver.ownerOf(rel);
-    if (owner && resolver.slot(owner.slot)?.tier === 'package') roots.add(owner.root);
-  }
-  return [...roots].sort(byCodeUnit);
+    const roots = new Set();
+    for (const rel of treeOf(config.root).files) {
+        const owner = resolver.ownerOf(rel);
+        if (owner && resolver.slot(owner.slot)?.tier === 'package')
+            roots.add(owner.root);
+    }
+    return [...roots].sort(byCodeUnit);
 }
-
 function readManifest(config, manifestRel) {
-  try {
-    return JSON.parse(fs.readFileSync(path.join(config.root, ...manifestRel.split('/')), 'utf8'));
-  } catch {
-    return UNREADABLE;
-  }
+    try {
+        return JSON.parse(fs.readFileSync(path.join(config.root, ...manifestRel.split('/')), 'utf8')); // reason: parsed from disk; the fields read are checked at use
+    }
+    catch {
+        return UNREADABLE;
+    }
 }
-
 function reportExportIssues(manifest, manifestRel, report) {
-  if (manifest.exports === undefined) {
-    report(`${manifestRel} declares no exports map; a package lists what it exports, subpath by subpath, each pointing into ./dist/.`);
-    return;
-  }
-  if (typeof manifest.exports === 'object' && !Array.isArray(manifest.exports)) {
-    for (const key of Object.keys(manifest.exports)) {
-      if (key.includes('*') || key.endsWith('/')) report(`exports key "${key}" of ${manifestRel} is a pattern or folder mapping; list each exported subpath explicitly.`, { export: key });
+    if (manifest.exports === undefined) {
+        report(`${manifestRel} declares no exports map; a package lists what it exports, subpath by subpath, each pointing into ./dist/.`);
+        return;
+    }
+    if (typeof manifest.exports === 'object' && !Array.isArray(manifest.exports)) {
+        for (const key of Object.keys(manifest.exports)) { // reason: typeof narrows to object | null; a null exports map throws here exactly as before
+            if (key.includes('*') || key.endsWith('/'))
+                report(`exports key "${key}" of ${manifestRel} is a pattern or folder mapping; list each exported subpath explicitly.`, { export: key });
+        }
+    }
+    for (const { target, trail } of targetsOf(manifest.exports)) {
+        if (!insideDist(target))
+            report(`exports target "${target}" (${trail.join(' > ') || '.'}) of ${manifestRel} is not inside ./dist/; a package exports what it built, never its source.`, { export: target });
     }
-  }
-  for (const { target, trail } of targetsOf(manifest.exports)) {
-    if (!insideDist(target)) report(`exports target "${target}" (${trail.join(' > ') || '.'}) of ${manifestRel} is not inside ./dist/; a package exports what it built, never its source.`, { export: target });
-  }
 }
-
 function reportManifestIssues(manifest, manifestRel, report) {
-  if (typeof manifest.scripts?.build !== 'string' || !manifest.scripts.build.trim()) report(`${manifestRel} has no scripts.build; a shared package is built to dist before an app consumes it.`);
-  reportExportIssues(manifest, manifestRel, report);
-  for (const field of ['main', 'module', 'types', 'typings']) {
-    if (typeof manifest[field] === 'string' && !insideDist(manifest[field])) report(`${field} "${manifest[field]}" of ${manifestRel} is not inside ./dist/; a package points at what it built.`, { field });
-  }
+    if (typeof manifest.scripts?.build !== 'string' || !manifest.scripts.build.trim())
+        report(`${manifestRel} has no scripts.build; a shared package is built to dist before an app consumes it.`);
+    reportExportIssues(manifest, manifestRel, report);
+    for (const field of ['main', 'module', 'types', 'typings']) {
+        if (typeof manifest[field] === 'string' && !insideDist(manifest[field]))
+            report(`${field} "${manifest[field]}" of ${manifestRel} is not inside ./dist/; a package points at what it built.`, { field });
+    }
 }
-
 function inspectPackage(config, root, violations) {
-  const manifestRel = `${root}/package.json`;
-  const report = (message, extra = {}) => violations.push({ ruleId: RULE, path: manifestRel, line: 1, column: 1, package: root, message, ...extra });
-  const manifest = readManifest(config, manifestRel);
-  if (manifest === UNREADABLE) return false;
-  reportManifestIssues(manifest, manifestRel, report);
-  return true;
+    const manifestRel = `${root}/package.json`;
+    const report = (message, extra = {}) => violations.push({ ruleId: RULE, path: manifestRel, line: 1, column: 1, package: root, message, ...extra });
+    const manifest = readManifest(config, manifestRel);
+    if (manifest === UNREADABLE)
+        return false;
+    reportManifestIssues(manifest, manifestRel, report);
+    return true;
 }
-
 export function checkPackageShape({ config, graph }) {
-  const roots = packageRoots(config, graph.resolver);
-  const violations = [];
-  let packages = 0;
-  for (const root of roots) {
-    if (inspectPackage(config, root, violations)) packages += 1;
-  }
-  return { violations, coverage: { status: 'checked', packages } };
+    const roots = packageRoots(config, graph.resolver);
+    const violations = [];
+    let packages = 0;
+    for (const root of roots) {
+        if (inspectPackage(config, root, violations))
+            packages += 1;
+    }
+    return { violations, coverage: { status: 'checked', packages } };
 }

package/runtime/scripts/hfs/architecture/presentation.d.mts

@@ -0,0 +1,24 @@
+import type { ArchitectureViolation } from './hfs-graph.mjs';
+/** The repository tree view the presentation checks read. */
+export interface PresentationTree {
+    source: string;
+    top: readonly string[];
+    hasDir(dir: string): boolean;
+    hasFile(file: string): boolean;
+}
+/** What `checkRepoPresentationImpl` judges. */
+export interface PresentationInput {
+    root: string;
+    runtime: boolean;
+    tree: PresentationTree;
+    profile: string;
+    edition: string;
+    nonNpmEntries: ReadonlySet<string>;
+}
+export declare function checkRepoPresentationImpl({ root, runtime, tree, profile, edition, nonNpmEntries }: PresentationInput): {
+    violations: ArchitectureViolation[];
+    coverage: {
+        status: string;
+        source: string;
+    };
+};