@starci/hfs 4.11.22 → 4.12.2

package/runtime/scripts/hfs/architecture/machine-ast.d.mts

@@ -0,0 +1,88 @@
+import type { Declaration, Decorator, Expression, Node, ObjectLiteralExpression, PropertyAssignment, ShorthandPropertyAssignment, SourceFile, Symbol as TsSymbol, TypeChecker } from 'typescript';
+import type { TypeScriptApi } from './config.mjs';
+import type { GraphFile, HfsGraph } from './hfs-graph.mjs';
+/** The part of the checker context the reading kit uses: the compiler API and the per-file checker. */
+export interface MachineContext {
+    ts: TypeScriptApi;
+    checkerFor: (fileName: string) => TypeChecker;
+}
+/** What `machineKit` is built from: the checker context and the HFS graph. */
+export interface MachineInput {
+    context: MachineContext;
+    graph: HfsGraph;
+}
+/** The environment every kit operation receives as its first argument. */
+export interface MachineEnv {
+    ts: TypeScriptApi;
+    context: MachineContext;
+    graph: HfsGraph;
+}
+/** A name bound by an import: the imported name (`default` or `*` for those forms) and its module specifier. */
+export interface ImportBinding {
+    name: string;
+    module: string;
+}
+/** The capability (owner) of a declaration: its file, owner root, slot, tier and owner directory name. */
+export interface DeclarationOwner {
+    rel: string;
+    root: string;
+    slot: string;
+    tier: string | null;
+    name: string;
+}
+/** One `{ provide: <token>, ... }` provider literal found by `providersOf`. */
+export interface ProviderEntry {
+    node: Node;
+    useClass: Expression | null;
+    checker: TypeChecker;
+}
+/** A property of an object literal the kit can read by name. */
+export type NamedProperty = PropertyAssignment | ShorthandPropertyAssignment;
+/** A location row: repository-relative path, 1-based line and column, plus the caller's extra fields (`path` is typed optional so a call site may spread the row after its own `path`). */
+export interface LocatedRow {
+    path?: string;
+    line: number;
+    column: number;
+    [extra: string]: unknown;
+}
+/**
+ * Whether a repository-relative file is a composition group of an app: `apps/<app>/src/compose/<area>.ts`, the module list of
+ * one area that the app root spreads into its imports (slot allows `compose/<area>.ts` of every be.app.* slot).
+ */
+export declare const isComposeGroup: (rel: string) => boolean;
+/**
+ * The small TypeScript reading kit the R33/R38/R39/R41/R45/R84/R86 machine checks share (connection-map, sql-owner,
+ * register-once, error-masked, default-deny-app-guard, entrypoint-only-in-apps, error-home). Everything is decided by
+ * the checker and by where a declaration lives (the HFS graph), never by a variable name: a framework symbol is
+ * recognised by the package it is imported from, a capability class by the file that declares it.
+ */
+export declare function machineKit({ context, graph }: MachineInput): {
+    ts: typeof import("typescript");
+    resolver: import("../slots.mts").OpenedHfs;
+    providersOf: (file: {
+        sourceFile: SourceFile;
+    }, name: string, moduleName: string) => ProviderEntry[];
+    checkerOf: (sourceFile: SourceFile) => TypeChecker;
+    aliased: (checker: TypeChecker, symbol: TsSymbol | null | undefined) => TsSymbol | null | undefined;
+    symbolAt: (checker: TypeChecker, node: Node | null | undefined) => TsSymbol | null;
+    importBinding: (checker: TypeChecker, node: Node) => ImportBinding | null;
+    isImportOf: (checker: TypeChecker, node: Node, name: string, moduleName: string) => boolean;
+    declarationsOf: (checker: TypeChecker, node: Node | null | undefined) => Declaration[];
+    graphPath: (declaration: Declaration) => string | null;
+    graphFile: (rel: string) => GraphFile | null;
+    ownerOfDeclaration: (declaration: Declaration) => DeclarationOwner | null;
+    stringValue: (checker: TypeChecker, node: Node | null | undefined) => string | null;
+    walk: (node: Node, visit: (child: Node) => boolean | void) => void;
+    decorators: (node: Node) => readonly Decorator[];
+    isExported: (node: Node) => boolean;
+    propertyNameText: (name: Node | null | undefined) => string | null;
+    propertyOf: (literal: ObjectLiteralExpression, key: string) => NamedProperty | undefined;
+    valueOfProperty: (property: NamedProperty) => Expression;
+    at: (rel: string, sourceFile: SourceFile, node: Node, extra?: Record<string, unknown> | undefined) => LocatedRow;
+    appRoot: (name: string) => GraphFile | null;
+    appCompositionFiles: (name: string) => GraphFile[];
+};
+/** The reading kit `machineKit` builds. */
+export type MachineKit = ReturnType<typeof machineKit>;
+export declare const upperSnake: (name: string) => string;
+export declare const pascal: (name: string) => string;

package/runtime/scripts/hfs/architecture/machine-ast.mjs

@@ -2,177 +2,187 @@ import path from 'node:path';
 import { canonical } from './config.mjs';
 import { hasAnyFlag, sourceLocation } from '../../lib/ts-ast.mjs';
 import { byCodeUnit } from '../../lib/list.mjs';
-
 const HELPER_DEPTH = 4;
-
 const checkerOf = (env, sourceFile) => env.context.checkerFor(sourceFile.fileName);
-
 function aliased(env, checker, symbol) {
-  const { ts } = env;
-  const seen = new Set();
-  let current = symbol;
-  while (current && hasAnyFlag(current.flags, ts.SymbolFlags.Alias) && !seen.has(current)) {
-    seen.add(current);
-    let target;
-    try { target = checker.getAliasedSymbol(current); } catch { break; }
-    if (!target || target === current || !(target.declarations?.length)) break;
-    current = target;
-  }
-  return current;
-}
-
+    const { ts } = env;
+    const seen = new Set();
+    let current = symbol;
+    while (current && hasAnyFlag(current.flags, ts.SymbolFlags.Alias) && !seen.has(current)) {
+        seen.add(current);
+        let target;
+        try {
+            target = checker.getAliasedSymbol(current);
+        }
+        catch {
+            break;
+        }
+        if (!target || target === current || !(target.declarations?.length))
+            break;
+        current = target;
+    }
+    return current;
+}
 function symbolAt(env, checker, node) {
-  const { ts } = env;
-  if (!node) return null;
-  if (ts.isShorthandPropertyAssignment(node.parent ?? {}) && node.parent.name === node) return checker.getShorthandAssignmentValueSymbol(node.parent) ?? null;
-  return checker.getSymbolAtLocation(node) ?? null;
+    const { ts } = env;
+    if (!node)
+        return null;
+    const parent = node.parent;
+    if (parent && ts.isShorthandPropertyAssignment(parent) && parent.name === node)
+        return checker.getShorthandAssignmentValueSymbol(parent) ?? null;
+    return checker.getSymbolAtLocation(node) ?? null;
 }
-
 /** {name, module} when `target` is bound directly by an import specifier, default import or namespace import, else null. */
 function ownImportBinding(env, checker, target) {
-  const { ts } = env;
-  const declaration = symbolAt(env, checker, target)?.declarations?.[0];
-  if (!declaration) return null;
-  if (ts.isImportSpecifier(declaration)) return { name: (declaration.propertyName ?? declaration.name).text, module: declaration.parent.parent.parent.moduleSpecifier.text };
-  if (ts.isImportClause(declaration)) return { name: 'default', module: declaration.parent.moduleSpecifier.text };
-  if (ts.isNamespaceImport(declaration)) return { name: '*', module: declaration.parent.parent.moduleSpecifier.text };
-  return null;
-}
-
+    const { ts } = env;
+    const declaration = symbolAt(env, checker, target)?.declarations?.[0];
+    if (!declaration)
+        return null;
+    // The module specifier of an import declaration is always a string literal in a program that parses.
+    if (ts.isImportSpecifier(declaration))
+        return { name: (declaration.propertyName ?? declaration.name).text, module: declaration.parent.parent.parent.moduleSpecifier.text };
+    if (ts.isImportClause(declaration))
+        return { name: 'default', module: declaration.parent.moduleSpecifier.text };
+    if (ts.isNamespaceImport(declaration))
+        return { name: '*', module: declaration.parent.parent.moduleSpecifier.text };
+    return null;
+}
 /** {name, module} when `node` (identifier, or namespace.member) is bound by an import from a module specifier, else null. */
 function importBinding(env, checker, node) {
-  const { ts } = env;
-  if (ts.isIdentifier(node)) return ownImportBinding(env, checker, node);
-  if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)) {
-    const namespace = ownImportBinding(env, checker, node.expression);
-    return namespace?.name === '*' ? { name: node.name.text, module: namespace.module } : null;
-  }
-  return null;
-}
-
+    const { ts } = env;
+    if (ts.isIdentifier(node))
+        return ownImportBinding(env, checker, node);
+    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)) {
+        const namespace = ownImportBinding(env, checker, node.expression);
+        return namespace?.name === '*' ? { name: node.name.text, module: namespace.module } : null;
+    }
+    return null;
+}
 function isImportOf(env, checker, node, name, moduleName) {
-  const binding = importBinding(env, checker, node);
-  return Boolean(binding) && binding.name === name && binding.module === moduleName;
+    const binding = importBinding(env, checker, node);
+    return binding !== null && binding.name === name && binding.module === moduleName;
 }
-
 /** The declarations `node` resolves to through aliases. */
 const declarationsOf = (env, checker, node) => aliased(env, checker, symbolAt(env, checker, node))?.declarations ?? [];
-
 /** The repository-relative graph path of the file declaring `declaration`, or null when it is outside the program. */
 const graphPath = (env, declaration) => env.graph.abs(canonical(declaration.getSourceFile().fileName));
-
 const graphFile = (env, rel) => env.graph.files.get(rel) ?? null;
-
 /** The capability (owner) root, slot and tier of a declaration, or null. */
 function ownerOfDeclaration(env, declaration) {
-  const rel = graphPath(env, declaration);
-  const file = rel ? graphFile(env, rel) : null;
-  return file?.owner ? { rel, root: file.owner.root, slot: file.owner.slot, tier: file.tier, name: path.posix.basename(file.owner.root) } : null;
+    const rel = graphPath(env, declaration);
+    const file = rel ? graphFile(env, rel) : null;
+    return rel && file?.owner ? { rel, root: file.owner.root, slot: file.owner.slot, tier: file.tier, name: path.posix.basename(file.owner.root) } : null;
 }
-
 /** The string a node evaluates to: a literal, or a const whose type is a string literal. */
 function stringValue(env, checker, node) {
-  const { ts } = env;
-  if (!node) return null;
-  if (ts.isStringLiteralLike(node)) return node.text;
-  let type;
-  try { type = checker.getTypeAtLocation(node); } catch { return null; }
-  if (type?.isStringLiteral?.()) return type.value;
-  const declaration = declarationsOf(env, checker, ts.isPropertyAccessExpression(node) ? node.name : node)[0];
-  if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer) return stringValue(env, checker, declaration.initializer);
-  return null;
-}
-
+    const { ts } = env;
+    if (!node)
+        return null;
+    if (ts.isStringLiteralLike(node))
+        return node.text;
+    let type;
+    try {
+        type = checker.getTypeAtLocation(node);
+    }
+    catch {
+        return null;
+    }
+    if (type?.isStringLiteral?.())
+        return type.value;
+    const declaration = declarationsOf(env, checker, ts.isPropertyAccessExpression(node) ? node.name : node)[0];
+    if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer)
+        return stringValue(env, checker, declaration.initializer);
+    return null;
+}
 function walk(env, node, visit) {
-  const step = child => {
-    if (visit(child) === false) return;
-    env.ts.forEachChild(child, step);
-  };
-  step(node);
+    const step = (child) => {
+        if (visit(child) === false)
+            return;
+        env.ts.forEachChild(child, step);
+    };
+    step(node);
 }
-
 const decorators = (env, node) => (env.ts.canHaveDecorators?.(node) ? env.ts.getDecorators(node) ?? [] : []);
+// reason: getCombinedModifierFlags reads only the modifiers, which a VariableStatement carries as well as a Declaration.
 const isExported = (env, node) => hasAnyFlag(env.ts.getCombinedModifierFlags?.(node), env.ts.ModifierFlags.Export);
-
 function propertyNameText(env, name) {
-  if (!name) return null;
-  if (env.ts.isIdentifier(name) || env.ts.isStringLiteralLike(name)) return name.text;
-  return null;
+    if (!name)
+        return null;
+    if (env.ts.isIdentifier(name) || env.ts.isStringLiteralLike(name))
+        return name.text;
+    return null;
 }
-
 /** The object literal properties of `literal` by static name. */
 const propertyOf = (env, literal, key) => literal.properties
-  .find(property => (env.ts.isPropertyAssignment(property) || env.ts.isShorthandPropertyAssignment(property)) && propertyNameText(env, property.name) === key);
-
+    .find((property) => (env.ts.isPropertyAssignment(property) || env.ts.isShorthandPropertyAssignment(property)) && propertyNameText(env, property.name) === key);
 const valueOfProperty = (env, property) => (env.ts.isPropertyAssignment(property) ? property.initializer : property.name);
-
-const at = (env, rel, sourceFile, node, extra = {}) => ({ path: rel, ...sourceLocation(sourceFile, node), ...extra });
-
+const at = (_env, rel, sourceFile, node, extra = {}) => ({ path: rel, ...sourceLocation(sourceFile, node), ...extra });
 /** The app root file of an app (apps/<name>/src/app.module.ts), or null when the program does not hold it. */
 const appRoot = (env, name) => graphFile(env, `apps/${name}/src/app.module.ts`);
-
 /**
  * Whether a repository-relative file is a composition group of an app: `apps/<app>/src/compose/<area>.ts`, the module list of
  * one area that the app root spreads into its imports (slot allows `compose/<area>.ts` of every be.app.* slot).
  */
-export const isComposeGroup = rel => /^apps\/[^/]+\/src\/compose\/[^/]+\.ts$/.test(rel) && !/\.(?:spec|d)\.ts$/.test(rel);
-
+export const isComposeGroup = (rel) => /^apps\/[^/]+\/src\/compose\/[^/]+\.ts$/.test(rel) && !/\.(?:spec|d)\.ts$/.test(rel);
 /** The app root and the composition groups of an app, in path order (the root first); [] when the program holds no root. */
 const appCompositionFiles = (env, name) => {
-  const root = appRoot(env, name);
-  if (!root) return [];
-  const prefix = `apps/${name}/src/compose/`;
-  const groups = [...env.graph.files.values()].filter(file => file.rel.startsWith(prefix) && isComposeGroup(file.rel));
-  return [root, ...groups.sort((a, b) => byCodeUnit(a.rel, b.rel))];
+    const root = appRoot(env, name);
+    if (!root)
+        return [];
+    const prefix = `apps/${name}/src/compose/`;
+    const groups = [...env.graph.files.values()].filter(file => file.rel.startsWith(prefix) && isComposeGroup(file.rel));
+    return [root, ...groups.sort((a, b) => byCodeUnit(a.rel, b.rel))];
 };
-
 /** The body a call or a spread identifier resolves to when it is a function or a const declared in a file of the program (not a package), else null. */
 function helperBodyOf(env, checker, node) {
-  const { ts } = env;
-  const target = ts.isCallExpression(node) ? node.expression : node;
-  for (const declaration of declarationsOf(env, checker, ts.isPropertyAccessExpression(target) ? target.name : target)) {
-    if (!graphPath(env, declaration)) continue;
-    if (ts.isFunctionDeclaration(declaration) && declaration.body) return { declaration, body: declaration.body };
-    if (ts.isVariableDeclaration(declaration) && declaration.initializer) return { declaration, body: declaration.initializer };
-  }
-  return null;
-}
-
+    const { ts } = env;
+    const target = ts.isCallExpression(node) ? node.expression : node;
+    for (const declaration of declarationsOf(env, checker, ts.isPropertyAccessExpression(target) ? target.name : target)) {
+        if (!graphPath(env, declaration))
+            continue;
+        if (ts.isFunctionDeclaration(declaration) && declaration.body)
+            return { declaration, body: declaration.body };
+        if (ts.isVariableDeclaration(declaration) && declaration.initializer)
+            return { declaration, body: declaration.initializer };
+    }
+    return null;
+}
 /** The provider entry of an object literal that provides `name` imported from `moduleName`, or null. */
 function providerEntry(env, search, checker, literal, anchor) {
-  const provide = propertyOf(env, literal, 'provide');
-  if (!provide || !isImportOf(env, checker, valueOfProperty(env, provide), search.name, search.moduleName)) return null;
-  const use = propertyOf(env, literal, 'useClass');
-  return { node: anchor ?? literal, useClass: use ? valueOfProperty(env, use) : null, checker };
+    const provide = propertyOf(env, literal, 'provide');
+    if (!provide || !isImportOf(env, checker, valueOfProperty(env, provide), search.name, search.moduleName))
+        return null;
+    const use = propertyOf(env, literal, 'useClass');
+    return { node: anchor ?? literal, useClass: use ? valueOfProperty(env, use) : null, checker };
 }
-
 /** The expression that may reference a helper: the argument of a spread, or the call itself. */
 function helperReferenceOf(ts, node) {
-  if (ts.isSpreadElement(node)) return node.expression;
-  return ts.isCallExpression(node) ? node : null;
+    if (ts.isSpreadElement(node))
+        return node.expression;
+    return ts.isCallExpression(node) ? node : null;
 }
-
 function followHelper(env, search, checker, node, anchor, depth) {
-  const reference = helperReferenceOf(env.ts, node);
-  if (!reference || depth >= HELPER_DEPTH) return;
-  const helper = helperBodyOf(env, checker, reference);
-  if (!helper || search.seen.has(helper.declaration)) return;
-  search.seen.add(helper.declaration);
-  scanProviders(env, search, helper.body, anchor ?? node, depth + 1);
-}
-
+    const reference = helperReferenceOf(env.ts, node);
+    if (!reference || depth >= HELPER_DEPTH)
+        return;
+    const helper = helperBodyOf(env, checker, reference);
+    if (!helper || search.seen.has(helper.declaration))
+        return;
+    search.seen.add(helper.declaration);
+    scanProviders(env, search, helper.body, anchor ?? node, depth + 1);
+}
 function scanProviders(env, search, root, anchor, depth) {
-  const checker = checkerOf(env, root.getSourceFile());
-  walk(env, root, node => {
-    if (!env.ts.isObjectLiteralExpression(node)) {
-      followHelper(env, search, checker, node, anchor, depth);
-      return;
-    }
-    const entry = providerEntry(env, search, checker, node, anchor);
-    if (entry) search.found.push(entry);
-  });
+    const checker = checkerOf(env, root.getSourceFile());
+    walk(env, root, node => {
+        if (!env.ts.isObjectLiteralExpression(node)) {
+            followHelper(env, search, checker, node, anchor, depth);
+            return;
+        }
+        const entry = providerEntry(env, search, checker, node, anchor);
+        if (entry)
+            search.found.push(entry);
+    });
 }
-
 /**
  * The `{ provide: <token>, ... }` provider literals of `file` whose token is `name` imported from `moduleName`, in source order.
  * A call or a spread of a function or a const declared in another file of the program is followed (to a depth of four), so a
@@ -180,11 +190,10 @@ function scanProviders(env, search, root, anchor, depth) {
  * call or spread inside the app root (where the entry is provided), its `useClass` and `checker` those of the helper's file.
  */
 function providersOf(env, file, name, moduleName) {
-  const search = { name, moduleName, found: [], seen: new Set() };
-  scanProviders(env, search, file.sourceFile, null, 0);
-  return search.found.sort((a, b) => a.node.getStart() - b.node.getStart());
+    const search = { name, moduleName, found: [], seen: new Set() };
+    scanProviders(env, search, file.sourceFile, null, 0);
+    return search.found.sort((a, b) => a.node.getStart() - b.node.getStart());
 }
-
 /**
  * The small TypeScript reading kit the R33/R38/R39/R41/R45/R84/R86 machine checks share (connection-map, sql-owner,
  * register-once, error-masked, default-deny-app-guard, entrypoint-only-in-apps, error-home). Everything is decided by
@@ -192,33 +201,32 @@ function providersOf(env, file, name, moduleName) {
  * recognised by the package it is imported from, a capability class by the file that declares it.
  */
 export function machineKit({ context, graph }) {
-  const env = { ts: context.ts, context, graph };
-  const bound = operation => (...args) => operation(env, ...args);
-  return {
-    ts: env.ts,
-    resolver: graph.resolver,
-    providersOf: bound(providersOf),
-    checkerOf: bound(checkerOf),
-    aliased: bound(aliased),
-    symbolAt: bound(symbolAt),
-    importBinding: bound(importBinding),
-    isImportOf: bound(isImportOf),
-    declarationsOf: bound(declarationsOf),
-    graphPath: bound(graphPath),
-    graphFile: bound(graphFile),
-    ownerOfDeclaration: bound(ownerOfDeclaration),
-    stringValue: bound(stringValue),
-    walk: bound(walk),
-    decorators: bound(decorators),
-    isExported: bound(isExported),
-    propertyNameText: bound(propertyNameText),
-    propertyOf: bound(propertyOf),
-    valueOfProperty: bound(valueOfProperty),
-    at: bound(at),
-    appRoot: bound(appRoot),
-    appCompositionFiles: bound(appCompositionFiles),
-  };
-}
-
-export const upperSnake = name => name.replaceAll('-', '_').toUpperCase();
-export const pascal = name => name.split('-').filter(Boolean).map(part => part[0].toUpperCase() + part.slice(1)).join('');
+    const env = { ts: context.ts, context, graph };
+    const bound = (operation) => (...args) => operation(env, ...args);
+    return {
+        ts: env.ts,
+        resolver: graph.resolver,
+        providersOf: bound(providersOf),
+        checkerOf: bound(checkerOf),
+        aliased: bound(aliased),
+        symbolAt: bound(symbolAt),
+        importBinding: bound(importBinding),
+        isImportOf: bound(isImportOf),
+        declarationsOf: bound(declarationsOf),
+        graphPath: bound(graphPath),
+        graphFile: bound(graphFile),
+        ownerOfDeclaration: bound(ownerOfDeclaration),
+        stringValue: bound(stringValue),
+        walk: bound(walk),
+        decorators: bound(decorators),
+        isExported: bound(isExported),
+        propertyNameText: bound(propertyNameText),
+        propertyOf: bound(propertyOf),
+        valueOfProperty: bound(valueOfProperty),
+        at: bound(at),
+        appRoot: bound(appRoot),
+        appCompositionFiles: bound(appCompositionFiles),
+    };
+}
+export const upperSnake = (name) => name.replaceAll('-', '_').toUpperCase();
+export const pascal = (name) => name.split('-').filter(Boolean).map(part => part.charAt(0).toUpperCase() + part.slice(1)).join('');

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

@@ -0,0 +1,2 @@
+/** The script names of a profile/edition template after its partials are expanded. */
+export declare function managedScriptNames(profile: string, edition?: string): Set<string>;

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

@@ -4,30 +4,29 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { managedGroupOf } from '../edition-slots.mjs';
 import { loadSlotManifest } from '../slots.mjs';
-
 const TEMPLATE_ROOTS = [
-  path.resolve(import.meta.dirname, '..', '..', '..', 'packages', 'hfs', 'templates'),
-  path.resolve(import.meta.dirname, '..', '..', '..', '..', 'templates'),
+    path.resolve(import.meta.dirname, '..', '..', '..', 'packages', 'hfs', 'templates'),
+    path.resolve(import.meta.dirname, '..', '..', '..', '..', 'templates'),
 ];
 const managedScriptCache = new Map();
-const SCRIPT_ENTRY_START = String.raw`^\s*"`;
-const SCRIPT_ENTRY_NAME = String.raw`([^"\n]+)`;
-const SCRIPT_ENTRY_END = String.raw`":\s*"`;
+const SCRIPT_ENTRY_START = String.raw `^\s*"`;
+const SCRIPT_ENTRY_NAME = String.raw `([^"\n]+)`;
+const SCRIPT_ENTRY_END = String.raw `":\s*"`;
 const SCRIPT_ENTRY = new RegExp([SCRIPT_ENTRY_START, SCRIPT_ENTRY_NAME, SCRIPT_ENTRY_END].join(''), 'gmu');
-
 /** The script names of a profile/edition template after its partials are expanded. */
 export function managedScriptNames(profile, edition = 'full') {
-  const key = `${profile}:${edition}`;
-  if (!managedScriptCache.has(key)) {
-    const slot = loadSlotManifest().slots.find((entry) => entry.id === `${profile}.package-manifest`);
-    const group = slot && managedGroupOf(slot, edition);
-    const templates = group && TEMPLATE_ROOTS.find((dir) => fs.existsSync(path.join(dir, profile, group, 'package.json')));
-    if (!templates) throw new Error(`The managed package-scripts template of profile ${profile} cannot be found next to the runtime.`);
-    const text = fs.readFileSync(path.join(templates, profile, group, 'package.json'), 'utf8')
-      .replace(/^\{\{> ([\w./-]+)\}\}\r?\n/gmu, (_, partial) => fs.readFileSync(path.join(templates, partial), 'utf8'));
-    // The key is bounded by quotes, never the colon, so `[^"]` cannot backtrack; the strict script-name class filters after.
-    const names = [...text.matchAll(SCRIPT_ENTRY)].map((match) => match[1]);
-    managedScriptCache.set(key, new Set(names.filter((name) => /^[A-Za-z0-9:_.-]+$/.test(name))));
-  }
-  return managedScriptCache.get(key);
+    const key = `${profile}:${edition}`;
+    if (!managedScriptCache.has(key)) {
+        const slot = loadSlotManifest().slots.find((entry) => entry.id === `${profile}.package-manifest`);
+        const group = slot && managedGroupOf(slot, edition);
+        const templates = group && TEMPLATE_ROOTS.find((dir) => fs.existsSync(path.join(dir, profile, group, 'package.json')));
+        if (!templates)
+            throw new Error(`The managed package-scripts template of profile ${profile} cannot be found next to the runtime.`);
+        const text = fs.readFileSync(path.join(templates, profile, group, 'package.json'), 'utf8')
+            .replace(/^\{\{> ([\w./-]+)\}\}\r?\n/gmu, (_, partial) => fs.readFileSync(path.join(templates, partial), 'utf8'));
+        // The key is bounded by quotes, never the colon, so `[^"]` cannot backtrack; the strict script-name class filters after.
+        const names = [...text.matchAll(SCRIPT_ENTRY)].map((match) => match[1]);
+        managedScriptCache.set(key, new Set(names.filter((name) => /^[A-Za-z0-9:_.-]+$/.test(name))));
+    }
+    return managedScriptCache.get(key);
 }

package/runtime/scripts/hfs/architecture/module-per-transport.d.mts

@@ -0,0 +1,35 @@
+import type { ArchitectureConfig } from './config.mjs';
+import type { ArchitectureViolation, HfsGraph } from './hfs-graph.mjs';
+import type { MachineContext } from './machine-ast.mjs';
+/**
+ * R45 `module-per-transport` (BE_MODULE_SHAPE, BE-CONVENTION 1.2 and 1.6). A feature has one Nest module for its
+ * application (`<f>.module.ts` at the feature root) and exactly one module per transport folder
+ * (`transport/<protocol>/<f>-<protocol>.module.ts`). Never one module per operation. Every one of these modules has its own
+ * module-definition beside it (owner ruling module-definition-everywhere, R295):
+ *
+ *   - a `*.module.ts` file below a transport folder other than `<f>-<protocol>.module.ts`, a `*.module-definition.ts` that is
+ *     not the sibling of the application module or of the transport module of its own folder, and an `@Module` class (or a
+ *     `ConfigurableModuleBuilder`/`ConfigurableModuleClass` use) in a feature file that is neither the application module, the
+ *     transport module of its own folder nor that module's definition are refused;
+ *   - apps import only transport modules, of the kinds their app kind allows: the `composedBy` list of each transport slot
+ *     in knowledge/hfs/slots.yaml (api: graphql, http, websocket; worker: schedule, message). An app root (app.module.ts
+ *     or a composition group of its compose/ folder) that lists a feature's application module, or the transport module
+ *     of another kind, is refused;
+ *   - a composed root (an owner slot with `composedBy`, be.cli) holds one static module per folder, named after the folder
+ *     (cli.module.ts, <group>/<group>.module.ts); an app of a composing kind lists the root module only, and an app of any
+ *     other kind lists none of its modules.
+ */
+export declare const MODULE_PER_TRANSPORT_RULE_IDS: string[];
+export declare function checkModulePerTransport(input: {
+    config: ArchitectureConfig;
+    context: MachineContext;
+    graph: HfsGraph;
+}): {
+    violations: ArchitectureViolation[];
+    coverage: {
+        status: string;
+        modules: number;
+        transportModules: number;
+        appReferences: number;
+    };
+};