@starci/eslint-grammar-core 0.15.34 → 0.16.2

package/runtime/scripts/hfs/rule-params-shape.mjs

@@ -1,85 +1,98 @@
-// rule-params-shape.mjs - the shape of `ruleParams` of an app slot manifest (knowledge/hfs/slots.yaml): the parameters both sides
-// share (`common`), the back end's own (`be`) and the front end's overrides (`fe`). Pure: a parsed manifest in, a list of
-// problems out, in the words of modules/schemas/hfs-slots.schema.yaml. scripts/hfs/slots.mjs (loadSlotManifest) is the reader.
 import { isPlainObject } from '../../engine/plain-object.mjs';
 import { paramNamesOk } from './param-names.mjs';
 import { kindParamProblems, scenarioProblem } from './declaration-slots.mjs';
 import { NAME, namedMapValid, PACKAGE_NAME, roleListProblems, SCHEMA_AUTHORITIES, unitRolesProblems } from './manifest-shape.mjs';
 import { byCodeUnit, nonemptyUniqueList } from '../lib/list.mjs';
 import { ruleEditionProblems } from './edition-slots.mjs';
-
 const PROFILES = ['be', 'fe'];
 const BE_OWN = ['infraOwners', 'eventBus', 'specDoubles', 'paramNames', 'suffixes', 'bannedSuffixes', 'contractShape', 'unitRoles', 'logicRoles', 'valueRoles', 'thinRoles', 'patternScenarios', 'kindPatterns', 'addKinds', 'backing'];
 const backingEntryOk = (entry) => isPlainObject(entry) && Object.keys(entry).every((key) => ['clients', 'images', 'patterns', 'editions'].includes(key))
-  && nonemptyUniqueList(entry.clients, (name) => PACKAGE_NAME.test(String(name)))
-  && Array.isArray(entry.patterns) && entry.patterns.every((name) => NAME.test(String(name))) && new Set(entry.patterns).size === entry.patterns.length
-  && nonemptyUniqueList(entry.images, (name) => PACKAGE_NAME.test(String(name)))
-  && ruleEditionProblems(entry, 'backing service').length === 0;
+    && nonemptyUniqueList(entry.clients, (name) => PACKAGE_NAME.test(String(name)))
+    && Array.isArray(entry.patterns) && entry.patterns.every((name) => NAME.test(String(name))) && new Set(entry.patterns).size === entry.patterns.length
+    && nonemptyUniqueList(entry.images, (name) => PACKAGE_NAME.test(String(name)))
+    && ruleEditionProblems(entry, 'backing service').length === 0;
 const FORM_NAMES = new Set(['call', 'new', 'curried', 'object', 'primitive', 'array']);
 const blockOk = (v) => isPlainObject(v) && Number.isInteger(v.lines) && v.lines >= 2 && Number.isInteger(v.tokens) && v.tokens >= 1 && Object.keys(v).length === 2;
 const fileLinesOk = (v) => isPlainObject(v) && Number.isInteger(v.soft) && v.soft >= 1 && typeof v.hardGrowth === 'boolean' && Object.keys(v).length === 2;
 const SHARED_PARAMS = {
-  fileLines: fileLinesOk,
-  duplicateBlock: blockOk,
-  functionLines: v => Number.isInteger(v) && v >= 1,
-  featureFiles: v => Number.isInteger(v) && v >= 1,
+    fileLines: fileLinesOk,
+    duplicateBlock: blockOk,
+    functionLines: (v) => Number.isInteger(v) && v >= 1,
+    featureFiles: (v) => Number.isInteger(v) && v >= 1,
 };
 const SHARED_KEYS = Object.keys(SHARED_PARAMS);
 const sharedParam = (key, v) => Object.hasOwn(SHARED_PARAMS, key) && SHARED_PARAMS[key](v);
 const sideOk = (side, own, extra = []) => own.every((k) => side[k] !== undefined) && Object.entries(side).every(([k, v]) => own.includes(k) || extra.includes(k) || sharedParam(k, v));
 const liteKeyOk = (lite, key, keys) => key !== 'lite' && keys.includes(key)
-  && (!['functionLines', 'featureFiles'].includes(key) || sharedParam(key, lite[key]));
+    && (!['functionLines', 'featureFiles'].includes(key) || sharedParam(key, lite[key]));
 const liteOk = (lite, keys) => lite === undefined || (isPlainObject(lite) && Object.keys(lite).length > 0 && Object.keys(lite).every((k) => liteKeyOk(lite, k, keys)));
 const memberMap = (v, allowEmpty) => isPlainObject(v) && Object.keys(v).length > 0 && Object.values(v).every((list) => Array.isArray(list) && (allowEmpty || list.length > 0) && list.every((x) => /^[A-Z][A-Za-z0-9]*$/.test(String(x))) && new Set(list).size === list.length);
 const roleList = (v) => nonemptyUniqueList(v, (role) => NAME.test(String(role)));
 const formsOk = (v) => Array.isArray(v) && v.length > 0 && v.every((x) => FORM_NAMES.has(x)) && new Set(v).size === v.length;
 const doubleOk = (v) => isPlainObject(v) && /^[A-Za-z][A-Za-z0-9]*$/.test(String(v.double)) && formsOk(v.forms);
-const regexOk = (v) => { try { return typeof v === 'string' && v.length > 0 && Boolean(new RegExp(v)); } catch { return false; } };
+const regexOk = (v) => { try {
+    return typeof v === 'string' && v.length > 0 && Boolean(new RegExp(v));
+}
+catch {
+    return false;
+} };
 const dbExtensionsOk = (value) => Array.isArray(value) && value.every((name) => typeof name === 'string' && name.length > 0) && new Set(value).size === value.length;
 const DB_PARAMS = { extensions: dbExtensionsOk };
 const dbParamsOk = (db) => db === undefined || (isPlainObject(db) && Object.entries(db).every(([key, value]) => Object.hasOwn(DB_PARAMS, key) && DB_PARAMS[key](value)));
-
 function beSpecificProblems(be, manifest) {
-  const bad = [];
-  bad.push(...scenarioProblem(be.patternScenarios), ...kindParamProblems(be, manifest.triggerKinds));
-  if (!isPlainObject(be.contractShape) || Object.keys(be.contractShape).length !== 1 || !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(String(be.contractShape.helper))) bad.push('ruleParams.be.contractShape must be {helper: <identifier>}');
-  const owners = be.infraOwners;
-  const ownerId = /^(platform|integrations)\/[a-z][a-z0-9-]*$/;
-  if (!isPlainObject(owners) || !Object.keys(owners).length || !Object.entries(owners).every(([key, list]) => key && Array.isArray(list) && list.every((o) => ownerId.test(String(o))) && new Set(list).size === list.length)) bad.push('ruleParams.be.infraOwners must map a non-empty specifier to a list of unique platform/<capability> or integrations/<provider> owners ([] means nowhere)');
-  const eventBus = be.eventBus;
-  if (!isPlainObject(eventBus) || Object.keys(eventBus).sort(byCodeUnit).join() !== 'classes,imports' || !memberMap(eventBus.imports, true) || !memberMap(eventBus.classes, false)) bad.push('ruleParams.be.eventBus must be {imports: {<module>: [unique PascalCase members]}, classes: {<module>: [non-empty unique PascalCase classes]}}');
-  if (!paramNamesOk(be.paramNames)) bad.push('ruleParams.be.paramNames must be a non-empty list of unique {type | typeSuffix, names, nameSuffix?} entries');
-  if (!namedMapValid(be.backing, backingEntryOk)) bad.push('ruleParams.be.backing must map a backing service name to {clients: [unique package names], patterns: [unique pattern names], images: [unique image repositories], editions?: [unique known editions]}');
-  if (!roleList(be.suffixes)) bad.push('ruleParams.be.suffixes must be a non-empty list of unique kebab-case role suffixes');
-  if (!roleList(be.bannedSuffixes)) bad.push('ruleParams.be.bannedSuffixes must be a non-empty list of unique kebab-case suffixes');
-  else if (roleList(be.suffixes) && be.suffixes.some((x) => be.bannedSuffixes.includes(x))) bad.push('ruleParams.be.suffixes and bannedSuffixes must be disjoint');
-  const sd = be.specDoubles;
-  if (!isPlainObject(sd) || Object.keys(sd).sort(byCodeUnit).join() !== 'doubles,fallback,kit' || typeof sd.kit !== 'string' || !sd.kit || !Array.isArray(sd.doubles) || !sd.doubles.length || !sd.doubles.every((e) => doubleOk(e) && regexOk(e.token) && (e.from === undefined || regexOk(e.from)) && Object.keys(e).length === (e.from === undefined ? 3 : 4)) || !doubleOk(sd.fallback) || Object.keys(sd.fallback).length !== 2) bad.push('ruleParams.be.specDoubles must be {kit, doubles: [{token: regex, double, forms}], fallback: {double, forms}} with forms drawn from call, new, curried, object, primitive, array');
-  return bad;
+    const bad = [];
+    bad.push(...scenarioProblem(be.patternScenarios), ...kindParamProblems(be, manifest.triggerKinds));
+    if (!isPlainObject(be.contractShape) || Object.keys(be.contractShape).length !== 1 || !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(String(be.contractShape.helper)))
+        bad.push('ruleParams.be.contractShape must be {helper: <identifier>}');
+    const owners = be.infraOwners;
+    const ownerId = /^(platform|integrations)\/[a-z][a-z0-9-]*$/;
+    if (!isPlainObject(owners) || !Object.keys(owners).length || !Object.entries(owners).every(([key, list]) => key && Array.isArray(list) && list.every((o) => ownerId.test(String(o))) && new Set(list).size === list.length))
+        bad.push('ruleParams.be.infraOwners must map a non-empty specifier to a list of unique platform/<capability> or integrations/<provider> owners ([] means nowhere)');
+    const eventBus = be.eventBus;
+    if (!isPlainObject(eventBus) || Object.keys(eventBus).sort(byCodeUnit).join() !== 'classes,imports' || !memberMap(eventBus.imports, true) || !memberMap(eventBus.classes, false))
+        bad.push('ruleParams.be.eventBus must be {imports: {<module>: [unique PascalCase members]}, classes: {<module>: [non-empty unique PascalCase classes]}}');
+    if (!paramNamesOk(be.paramNames))
+        bad.push('ruleParams.be.paramNames must be a non-empty list of unique {type | typeSuffix, names, nameSuffix?} entries');
+    if (!namedMapValid(be.backing, backingEntryOk))
+        bad.push('ruleParams.be.backing must map a backing service name to {clients: [unique package names], patterns: [unique pattern names], images: [unique image repositories], editions?: [unique known editions]}');
+    if (!roleList(be.suffixes))
+        bad.push('ruleParams.be.suffixes must be a non-empty list of unique kebab-case role suffixes');
+    if (!roleList(be.bannedSuffixes))
+        bad.push('ruleParams.be.bannedSuffixes must be a non-empty list of unique kebab-case suffixes');
+    else if (roleList(be.suffixes) && be.suffixes.some((x) => be.bannedSuffixes.includes(x)))
+        bad.push('ruleParams.be.suffixes and bannedSuffixes must be disjoint');
+    const sd = be.specDoubles;
+    if (!isPlainObject(sd) || Object.keys(sd).sort(byCodeUnit).join() !== 'doubles,fallback,kit' || typeof sd.kit !== 'string' || !sd.kit || !Array.isArray(sd.doubles) || !sd.doubles.length || !sd.doubles.every((e) => doubleOk(e) && regexOk(e.token) && (e.from === undefined || regexOk(e.from)) && Object.keys(e).length === (e.from === undefined ? 3 : 4)) || !doubleOk(sd.fallback) || Object.keys(sd.fallback).length !== 2)
+        bad.push('ruleParams.be.specDoubles must be {kit, doubles: [{token: regex, double, forms}], fallback: {double, forms}} with forms drawn from call, new, curried, object, primitive, array');
+    return bad;
 }
-
 /** A database function name (R334): `schema.name` outside pg_catalog, or, where `bare` admits it, a pg built-in named alone. */
 const dbFunctionNameOk = (name, bare) => typeof name === 'string' && (/^[a-z_][a-z0-9_]*\.[a-z_][a-z0-9_]*$/.test(name) ? !name.startsWith('pg_catalog.') : bare && /^[a-z_][a-z0-9_]*$/.test(name));
-
 /**
  * True for an absent list or a list of {name, reason} database functions, names unique and schema-qualified; `bare` also admits
  * a bare name, which only the canon's list (ruleParams.be.dbFunctions) uses, for the pg built-ins its helpers call.
  */
 export const dbFunctionsOk = (list, { bare = false } = {}) => list === undefined || (Array.isArray(list) && list.every((entry) => isPlainObject(entry) && Object.keys(entry).sort().join() === 'name,reason' && dbFunctionNameOk(entry.name, bare) && typeof entry.reason === 'string' && entry.reason.trim().length > 0) && new Set(list.map((entry) => entry.name)).size === list.length);
-
 /** The shape problems of `m.ruleParams`. */
 export function ruleParamsProblems(m) {
-  const bad = [];
-  const rp = m.ruleParams;
-  if (!isPlainObject(rp) || Object.keys(rp).some((k) => ![...PROFILES, 'common', 'db'].includes(k)) || !isPlainObject(rp.common) || !isPlainObject(rp.be) || (rp.fe !== undefined && !isPlainObject(rp.fe))) return ['ruleParams must be a map with common, be and optionally fe and db'];
-  else {
-    // common holds the parameters both sides share; a side may restate one of them (a valid value) as an override, nothing else.
-    // Edition lite: a side's optional `lite` map overrides keys of the same side (never `lite` itself) when the app declares edition lite.
-    if (!sideOk(rp.common, []) || !fileLinesOk(rp.common.fileLines) || !blockOk(rp.common.duplicateBlock)) bad.push('ruleParams.common needs fileLines {soft, hardGrowth} and duplicateBlock {lines >= 2, tokens >= 1}; optional functionLines and featureFiles must be positive integers');
-    if (!sideOk(rp.be, BE_OWN, ['schemaAuthority', 'lite', 'dbFunctions']) || (rp.be.schemaAuthority !== undefined && !SCHEMA_AUTHORITIES.includes(rp.be.schemaAuthority)) || !dbFunctionsOk(rp.be.dbFunctions, { bare: true }) || !liteOk(rp.be.lite, [...BE_OWN, ...SHARED_KEYS, 'schemaAuthority', 'dbFunctions'])) bad.push('ruleParams.be needs infraOwners, eventBus, specDoubles, paramNames, suffixes, bannedSuffixes, contractShape {helper}, unitRoles, logicRoles, thinRoles, patternScenarios, kindPatterns, addKinds and backing (shared parameters live in ruleParams.common, a side may override them); optional: schemaAuthority (' + SCHEMA_AUTHORITIES.join(' | ') + '), dbFunctions ([{name, reason}]: a pg built-in bare, every other function schema.name) and lite (overrides of the same keys)'); else bad.push(...unitRolesProblems(rp.be), ...roleListProblems(rp.be));
-    bad.push(...beSpecificProblems(rp.be, m));
-    if (rp.fe !== undefined && (!sideOk(rp.fe, [], ['lite']) || !liteOk(rp.fe.lite, SHARED_KEYS))) bad.push('ruleParams.fe may only restate the shared parameters of ruleParams.common, and carry a lite override of them');
-    if (!dbParamsOk(rp.db)) bad.push('ruleParams.db may contain only extensions (a list of unique non-empty extension names)');
-  }
-  return bad;
+    const bad = [];
+    const rp = m.ruleParams;
+    if (!isPlainObject(rp) || Object.keys(rp).some((k) => ![...PROFILES, 'common', 'db'].includes(k)) || !isPlainObject(rp.common) || !isPlainObject(rp.be) || (rp.fe !== undefined && !isPlainObject(rp.fe)))
+        return ['ruleParams must be a map with common, be and optionally fe and db'];
+    else {
+        // common holds the parameters both sides share; a side may restate one of them (a valid value) as an override, nothing else.
+        // Edition lite: a side's optional `lite` map overrides keys of the same side (never `lite` itself) when the app declares edition lite.
+        if (!sideOk(rp.common, []) || !fileLinesOk(rp.common.fileLines) || !blockOk(rp.common.duplicateBlock))
+            bad.push('ruleParams.common needs fileLines {soft, hardGrowth} and duplicateBlock {lines >= 2, tokens >= 1}; optional functionLines and featureFiles must be positive integers');
+        if (!sideOk(rp.be, BE_OWN, ['schemaAuthority', 'lite', 'dbFunctions']) || (rp.be.schemaAuthority !== undefined && !SCHEMA_AUTHORITIES.includes(rp.be.schemaAuthority)) || !dbFunctionsOk(rp.be.dbFunctions, { bare: true }) || !liteOk(rp.be.lite, [...BE_OWN, ...SHARED_KEYS, 'schemaAuthority', 'dbFunctions']))
+            bad.push('ruleParams.be needs infraOwners, eventBus, specDoubles, paramNames, suffixes, bannedSuffixes, contractShape {helper}, unitRoles, logicRoles, thinRoles, patternScenarios, kindPatterns, addKinds and backing (shared parameters live in ruleParams.common, a side may override them); optional: schemaAuthority (' + SCHEMA_AUTHORITIES.join(' | ') + '), dbFunctions ([{name, reason}]: a pg built-in bare, every other function schema.name) and lite (overrides of the same keys)');
+        else
+            bad.push(...unitRolesProblems(rp.be), ...roleListProblems(rp.be));
+        bad.push(...beSpecificProblems(rp.be, m));
+        if (rp.fe !== undefined && (!sideOk(rp.fe, [], ['lite']) || !liteOk(rp.fe.lite, SHARED_KEYS)))
+            bad.push('ruleParams.fe may only restate the shared parameters of ruleParams.common, and carry a lite override of them');
+        if (!dbParamsOk(rp.db))
+            bad.push('ruleParams.db may contain only extensions (a list of unique non-empty extension names)');
+    }
+    return bad;
 }

package/runtime/scripts/hfs/slot-app-view.mjs

@@ -1,102 +1,97 @@
 // slot-app-view.mjs - the resolver of a whole app: a root path is answered by the scope of the app root, a path below a side folder
 // (be/, fe/) by that side's scope with the side prefixed back onto every path and root it returns. Only the declared `reads` cross sides.
 // slots.mjs builds the scopes (`root` and `sides`, each a resolver of one scope) and hands them to appResolver.
-import { APP_SCOPE, PROFILES } from './slot-manifest-shape.mjs';
+import { APP_SCOPE, isSide, PROFILES } from './slot-manifest-shape.mjs';
 import { cleanSlotPath } from './slot-path.mjs';
-
+/** True for the view of a whole app (profile app), the one resolveRepoDeclaration builds with both sides. */
+export const isAppRepo = (repo) => repo.sides !== undefined;
 /** { side, rest } when `p` lies below a side folder, else null. */
 function splitSide(input) {
-  const p = cleanSlotPath(input);
-  const slash = p.indexOf('/');
-  const head = slash < 0 ? p : p.slice(0, slash);
-  return PROFILES.includes(head) && slash > 0 ? { side: head, rest: p.slice(slash + 1) } : null;
+    const p = cleanSlotPath(input);
+    const slash = p.indexOf('/');
+    const head = slash < 0 ? p : p.slice(0, slash);
+    return isSide(head) && slash > 0 ? { side: head, rest: p.slice(slash + 1) } : null;
 }
-
 const under = (side, rel) => (rel ? `${side}/${rel}` : side);
-
 function prefixed(side, c) {
-  return {
-    ...c,
-    path: under(side, c.path),
-    side,
-    ...(c.root !== undefined ? { root: under(side, c.root) } : {}),
-    ...(c.nearest ? { nearest: { ...c.nearest, matchedPrefix: under(side, c.nearest.matchedPrefix), matchedDepth: c.nearest.matchedDepth + 1 } } : {}),
-  };
+    return {
+        ...c,
+        path: under(side, c.path),
+        side,
+        ...(c.root !== undefined ? { root: under(side, c.root) } : {}),
+        ...(c.nearest ? { nearest: { ...c.nearest, matchedPrefix: under(side, c.nearest.matchedPrefix), matchedDepth: c.nearest.matchedDepth + 1 } } : {}),
+    };
 }
-
 function classifyApp({ root, sides }, input) {
-  const at = splitSide(input);
-  return at ? prefixed(at.side, sides[at.side].classifyPath(at.rest)) : root.classifyPath(input);
+    const at = splitSide(input);
+    return at ? prefixed(at.side, sides[at.side].classifyPath(at.rest)) : root.classifyPath(input);
 }
-
 function ownerApp({ root, sides }, input) {
-  const at = splitSide(input);
-  if (!at) return root.ownerOf(input);
-  const owner = sides[at.side].ownerOf(at.rest);
-  return owner ? { ...owner, root: under(at.side, owner.root), side: at.side } : null;
+    const at = splitSide(input);
+    if (!at)
+        return root.ownerOf(input);
+    const owner = sides[at.side].ownerOf(at.rest);
+    return owner ? { ...owner, root: under(at.side, owner.root), side: at.side } : null;
 }
-
 /** Whether `toPath`, of the other side, lies below a path `fromSide` declares it reads. */
 const readsPath = (repo, fromSide, toPath) => repo.sides[fromSide].reads.some((read) => `${cleanSlotPath(toPath)}/`.startsWith(read));
-
 /** The verdict of an import from a side file to a path of the other side (or of the app root, `toSide` null): allowed only through a declared read. */
 function sideCrossing(repo, fromSide, toSide, toPath) {
-  return readsPath(repo, fromSide, toPath)
-    ? { allowed: true, reason: 'sideRead', fromSide, toSide }
-    : { allowed: false, reason: 'crossSide', fromSide, toSide, reads: repo.sides[fromSide].reads };
+    return readsPath(repo, fromSide, toPath)
+        ? { allowed: true, reason: 'sideRead', fromSide, toSide }
+        : { allowed: false, reason: 'crossSide', fromSide, toSide, reads: repo.sides[fromSide].reads };
 }
-
 function importAllowedApp({ repo, root, sides }, fromPath, toPath) {
-  const from = splitSide(fromPath);
-  const to = splitSide(toPath);
-  // A side file may read an app-root path (db/types/) only through a declared read, exactly as it reads the other side.
-  if (from && from.side !== to?.side) return sideCrossing(repo, from.side, to?.side ?? null, toPath);
-  if (from && to) return sides[from.side].importAllowed(from.rest, to.rest);
-  return root.importAllowed(fromPath, toPath);
+    const from = splitSide(fromPath);
+    const to = splitSide(toPath);
+    // A side file may read an app-root path (db/types/) only through a declared read, exactly as it reads the other side.
+    if (from && from.side !== to?.side)
+        return sideCrossing(repo, from.side, to?.side ?? null, toPath);
+    if (from && to)
+        return sides[from.side].importAllowed(from.rest, to.rest);
+    return root.importAllowed(fromPath, toPath);
 }
-
 function requiredPathsApp({ root, sides }) {
-  const own = root.requiredPaths();
-  const paths = [...own.paths];
-  const minimums = [...own.minimums];
-  for (const side of PROFILES) {
-    const required = sides[side].requiredPaths();
-    paths.push(...required.paths.map((entry) => ({ ...entry, path: under(side, entry.path), side })));
-    minimums.push(...required.minimums.map((entry) => ({ ...entry, side })));
-  }
-  return { paths, minimums };
+    const own = root.requiredPaths();
+    const paths = [...own.paths];
+    const minimums = [...own.minimums];
+    for (const side of PROFILES) {
+        const required = sides[side].requiredPaths();
+        paths.push(...required.paths.map((entry) => ({ ...entry, path: under(side, entry.path), side })));
+        minimums.push(...required.minimums.map((entry) => ({ ...entry, side })));
+    }
+    return { paths, minimums };
 }
-
 function slotEnabledApp({ root, sides }, slot) {
-  if (slot.profiles.includes(APP_SCOPE)) return root.slotEnabled(slot);
-  return PROFILES.some((side) => slot.profiles.includes(side) && sides[side].slotEnabled(slot));
+    if (slot.profiles.includes(APP_SCOPE))
+        return root.slotEnabled(slot);
+    return PROFILES.some((side) => slot.profiles.includes(side) && sides[side].slotEnabled(slot));
 }
-
 /** The resolver of the app `repo`: `root` answers its root paths and `sides[side]` the paths below that side's folder. */
 export function appResolver(repo, root, sides) {
-  const view = { repo, root, sides };
-  const allSlots = [...new Map([...root.slots(), ...PROFILES.flatMap((side) => sides[side].slots())].map((s) => [s.id, s])).values()];
-  const byId = new Map(allSlots.map((s) => [s.id, s]));
-  const classifyPath = (input) => classifyApp(view, input);
-  return Object.freeze({
-    repo,
-    sides: Object.freeze(sides),
-    /** The side of a path (be, fe) or null for a root path. */
-    sideOf: (input) => splitSide(input)?.side ?? null,
-    slot: (id) => byId.get(id) ?? null,
-    slots: () => allSlots,
-    slotEnabled: (slot) => slotEnabledApp(view, slot),
-    classifyPath,
-    slotOf: (p) => { const c = classifyPath(p); return c.slot ? byId.get(c.slot) : null; },
-    ownerOf: (input) => ownerApp(view, input),
-    tierOf: (input) => { const at = splitSide(input); return at ? sides[at.side].tierOf(at.rest) : root.tierOf(input); },
-    importAllowed: (fromPath, toPath) => importAllowedApp(view, fromPath, toPath),
-    requiredFiles: (input) => { const at = splitSide(input); return at ? sides[at.side].requiredFiles(at.rest).map((p) => under(at.side, p)) : root.requiredFiles(input); },
-    requiredPaths: () => requiredPathsApp(view),
-    trackingOf: (p) => classifyPath(p).tracking ?? null,
-    isTracked: (p) => classifyPath(p).tracking === 'tracked',
-    // The root has no tier and no rule parameters of its own; each side has them (sides.<side>.ruleParams()).
-    ruleParams: () => null,
-    allowedImports: () => null,
-  });
+    const view = { repo, root, sides };
+    const allSlots = [...new Map([...root.slots(), ...PROFILES.flatMap((side) => sides[side].slots())].map((s) => [s.id, s])).values()];
+    const byId = new Map(allSlots.map((s) => [s.id, s]));
+    const classifyPath = (input) => classifyApp(view, input);
+    return Object.freeze({
+        repo,
+        sides: Object.freeze(sides),
+        /** The side of a path (be, fe) or null for a root path. */
+        sideOf: (input) => splitSide(input)?.side ?? null,
+        slot: (id) => byId.get(id) ?? null,
+        slots: () => allSlots,
+        slotEnabled: (slot) => slotEnabledApp(view, slot),
+        classifyPath,
+        slotOf: (p) => { const c = classifyPath(p); return c.slot ? byId.get(c.slot) : null; },
+        ownerOf: (input) => ownerApp(view, input),
+        tierOf: (input) => { const at = splitSide(input); return at ? sides[at.side].tierOf(at.rest) : root.tierOf(input); },
+        importAllowed: (fromPath, toPath) => importAllowedApp(view, fromPath, toPath),
+        requiredFiles: (input) => { const at = splitSide(input); return at ? sides[at.side].requiredFiles(at.rest).map((p) => under(at.side, p)) : root.requiredFiles(input); },
+        requiredPaths: () => requiredPathsApp(view),
+        trackingOf: (p) => classifyPath(p).tracking ?? null,
+        isTracked: (p) => classifyPath(p).tracking === 'tracked',
+        // The root has no tier and no rule parameters of its own; each side has them (sides.<side>.ruleParams()).
+        ruleParams: () => null,
+        allowedImports: () => null,
+    });
 }

package/runtime/scripts/hfs/slot-classify.mjs

@@ -4,62 +4,66 @@ import { globExpression } from '../lib/glob.mjs';
 import { declaredSlotEnabled } from './declaration-slots.mjs';
 import { bestMatch, fillVars, matchVariants, nearestSlot } from './slot-match.mjs';
 import { cleanSlotPath } from './slot-path.mjs';
-
 /** Whether the repository of the scope holds the slot. */
 export function slotEnabled(scope, slot) {
-  // A provider slot is gated by its provider in every edition: litePresence may lift it to required, but it still
-  // exists for this repository only while a connection declares the provider.
-  if (slot.provider !== undefined) return declaredSlotEnabled(slot, scope.repo);
-  if (slot.presence !== 'opt-in') return true;
-  return declaredSlotEnabled(slot, scope.repo);
+    // A provider slot is gated by its provider in every edition: litePresence may lift it to required, but it still
+    // exists for this repository only while a connection declares the provider.
+    if (slot.provider !== undefined)
+        return declaredSlotEnabled(slot, scope.repo);
+    if (slot.presence !== 'opt-in')
+        return true;
+    return declaredSlotEnabled(slot, scope.repo);
 }
-
 /** The folder kind of a file in its slot, from a named layer or kind folder. */
 function kindOf({ variant, slot, root }, p) {
-  const names = [...(slot.layers ?? []), ...(slot.kinds ?? [])];
-  if (!names.length) return null;
-  const literal = variant.segments.find((segment) => names.includes(segment));
-  if (literal) return literal;
-  const below = root ? p.slice(root.length + 1) : p;
-  return below.split('/').slice(0, -1).find((segment) => names.includes(segment)) ?? null;
+    const names = [...(slot.layers ?? []), ...(slot.kinds ?? [])];
+    if (!names.length)
+        return null;
+    const literal = variant.segments.find((segment) => names.includes(segment));
+    if (literal)
+        return literal;
+    const below = root ? p.slice(root.length + 1) : p;
+    return below.split('/').slice(0, -1).find((segment) => names.includes(segment)) ?? null;
 }
-
 /** The role of a file in its slot: the entry of `roles` whose file name (variables filled from the path, `*` a wildcard inside the name) matches the file's name. */
 function roleOf(slot, bindings, p) {
-  const name = p.split('/').pop();
-  for (const [role, file] of Object.entries(slot.roles ?? {})) if (globExpression(fillVars(file, bindings)).test(name)) return role;
-  return null;
+    const name = p.split('/').pop();
+    for (const [role, file] of Object.entries(slot.roles ?? {}))
+        if (globExpression(fillVars(file, bindings)).test(name))
+            return role;
+    return null;
 }
-
 /**
  * status: owned | forbidden (external slot) | not-enabled (opt-in slot the repository did not declare) | ambiguous
  * (two slots of equal specificity; a manifest gap) | no-slot (code HFS_SLOT_UNDECLARED, with the nearest slot).
  */
 export function classifyIn(scope, input) {
-  const p = cleanSlotPath(input);
-  const { hit, ambiguous } = bestMatch(matchVariants(scope, p));
-  if (ambiguous.length) return { path: p, status: 'ambiguous', candidates: ambiguous };
-  if (!hit) return { path: p, status: 'no-slot', code: 'HFS_SLOT_UNDECLARED', nearest: nearestSlot(scope.variants, p) };
-  const { slot, root, bindings } = hit;
-  const status = (slot.presence === 'forbidden' && 'forbidden') || (slotEnabled(scope, slot) ? 'owned' : 'not-enabled');
-  const kind = kindOf(hit, p);
-  const role = roleOf(slot, bindings, p);
-  return { path: p, status, slot: slot.id, root, bindings, ...(kind ? { kind } : {}), ...(role ? { role } : {}), presence: slot.presence, tracking: slot.tracked, ...(status === 'forbidden' ? { goesTo: slot.goesTo } : {}) };
+    const p = cleanSlotPath(input);
+    const { hit, ambiguous } = bestMatch(matchVariants(scope, p));
+    if (ambiguous.length)
+        return { path: p, status: 'ambiguous', candidates: ambiguous };
+    if (!hit)
+        return { path: p, status: 'no-slot', code: 'HFS_SLOT_UNDECLARED', nearest: nearestSlot(scope.variants, p) };
+    const { slot, root, bindings } = hit;
+    const status = (slot.presence === 'forbidden' && 'forbidden') || (slotEnabled(scope, slot) ? 'owned' : 'not-enabled');
+    const kind = kindOf(hit, p);
+    const role = roleOf(slot, bindings, p);
+    return { path: p, status, slot: slot.id, root, bindings, ...(kind ? { kind } : {}), ...(role ? { role } : {}), presence: slot.presence, tracking: slot.tracked, ...(status === 'forbidden' ? { goesTo: slot.goesTo } : {}) };
 }
-
 /** The owner unit of `p`: the most specific owner slot instance containing it (a slot's own root when it owns nothing). */
 export function ownerIn(scope, input) {
-  const p = cleanSlotPath(input);
-  const { hit } = bestMatch(matchVariants(scope, p, (s) => s.owner === true));
-  return hit ? { slot: hit.slot.id, root: hit.root, bindings: hit.bindings } : null;
+    const p = cleanSlotPath(input);
+    const { hit } = bestMatch(matchVariants(scope, p, (s) => s.owner === true));
+    return hit ? { slot: hit.slot.id, root: hit.root, bindings: hit.bindings } : null;
 }
-
 /** The tier of `p` in the direction matrix: its slot's tier, the owner's for an inheriting slot, none for an untiered one; null when no slot owns it. */
 export function tierIn(scope, input) {
-  const c = classifyIn(scope, input);
-  if (!c.slot) return null;
-  const tier = scope.byId.get(c.slot).tier;
-  if (tier !== 'inherit') return tier;
-  const owner = ownerIn(scope, input);
-  return owner ? scope.byId.get(owner.slot).tier : 'none';
+    const c = classifyIn(scope, input);
+    if (!c.slot)
+        return null;
+    const tier = scope.byId.get(c.slot).tier;
+    if (tier !== 'inherit')
+        return tier;
+    const owner = ownerIn(scope, input);
+    return owner ? scope.byId.get(owner.slot).tier : 'none';
 }

package/runtime/scripts/hfs/slot-errors.mjs

@@ -1,11 +1,12 @@
 // slot-errors.mjs - the shared refusal type for HFS manifest and declaration loaders.
 export class HfsSlotsError extends Error {
-  constructor(code, message, details = {}) {
-    super(`${code}: ${message}`);
-    this.name = 'HfsSlotsError';
-    this.code = code;
-    this.details = details;
-  }
+    code;
+    details;
+    constructor(code, message, details = {}) {
+        super(`${code}: ${message}`);
+        this.name = 'HfsSlotsError';
+        this.code = code;
+        this.details = details;
+    }
 }
-
 export const fail = (code, message, details) => { throw new HfsSlotsError(code, message, details); };