@starci/eslint-grammar-core 0.15.34 → 0.16.2

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

@@ -3,89 +3,96 @@
 import { RUNTIME_KIND } from './manifest-shape.mjs';
 import { classifyIn, ownerIn, tierIn } from './slot-classify.mjs';
 import { braceVariants, globExpression } from '../lib/glob.mjs';
-
 const isEntryFile = (name) => name === 'index.ts' || name === 'index.tsx';
-
 function declaredEntry(slot, relative) {
-  return (slot.entries ?? []).some(entry => braceVariants(entry).some(pattern => globExpression(pattern).test(relative)));
+    return (slot.entries ?? []).some((entry) => braceVariants(entry).some((pattern) => globExpression(pattern).test(relative)));
 }
-
 function unownedPathProblem(from, to) {
-  for (const side of [from, to]) {
-    if (side.status === 'no-slot') return { allowed: false, reason: 'unowned', code: side.code, path: side.path, nearest: side.nearest };
-  }
-  return null;
+    for (const side of [from, to]) {
+        if (side.status === 'no-slot')
+            return { allowed: false, reason: 'unowned', code: side.code, path: side.path, nearest: side.nearest };
+    }
+    return null;
 }
-
 function unavailableSlotProblem(from, to) {
-  for (const side of [from, to]) {
-    if (side.status !== 'owned') return { allowed: false, reason: `slot${side.status[0].toUpperCase()}${side.status.slice(1).replace(/-(.)/g, (_, c) => c.toUpperCase())}`, path: side.path, slot: side.slot };
-  }
-  return null;
+    for (const side of [from, to]) {
+        if (side.status !== 'owned')
+            return { allowed: false, reason: `slot${side.status[0].toUpperCase()}${side.status.slice(1).replace(/-(.)/g, (_, c) => c.toUpperCase())}`, path: side.path, slot: side.slot };
+    }
+    return null;
 }
-
 function sameOwnerUnit(side, owner) {
-  return owner ? `${owner.slot}:${owner.root}` : `${side.slot}:${side.root}`;
+    return owner ? `${owner.slot}:${owner.root}` : `${side.slot}:${side.root}`;
 }
-
 const layerIndex = (slot, root) => (slot.layers ? slot.layers.findIndex((layer) => root.split('/').includes(layer)) : -1);
-
 function lowerLayerProblem({ manifest, profile, byId }, from, to, fromTier, toTier, fromOwner, toOwner) {
-  if (manifest.tiers[profile][fromTier].lowerLayerOnly && fromTier === toTier) {
-    const fromSlot = byId.get((fromOwner ?? from).slot);
-    const a = layerIndex(fromSlot, fromOwner?.root ?? from.root);
-    const b = layerIndex(byId.get((toOwner ?? to).slot), toOwner?.root ?? to.root);
-    if (a >= 0 && b >= 0 && b <= a) return { allowed: false, reason: 'layerOrder', fromLayer: fromSlot.layers[a], toLayer: fromSlot.layers[b] };
-  }
-  return null;
+    if (manifest.tiers[profile][fromTier].lowerLayerOnly && fromTier === toTier) {
+        const fromSlot = byId.get((fromOwner ?? from).slot);
+        const a = layerIndex(fromSlot, fromOwner?.root ?? from.root);
+        const b = layerIndex(byId.get((toOwner ?? to).slot), toOwner?.root ?? to.root);
+        if (a >= 0 && b >= 0 && b <= a)
+            return { allowed: false, reason: 'layerOrder', fromLayer: fromSlot.layers[a], toLayer: fromSlot.layers[b] };
+    }
+    return null;
 }
-
 function privateEntryProblem({ repo, byId }, to, toOwner) {
-  if (toOwner && repo.kind !== RUNTIME_KIND) {
-    const relative = to.path === toOwner.root ? '' : to.path.slice(toOwner.root.length + 1);
-    const ownerSlot = byId.get(toOwner.slot);
-    const entry = isEntryFile(relative) || declaredEntry(byId.get(to.slot), to.path.slice(to.root.length + 1)) || (ownerSlot.tier === 'package' && relative === 'src/index.ts') || (ownerSlot.tier === 'app' && relative === 'app.module.ts');
-    if (!entry) return { allowed: false, reason: 'notPublicEntry', owner: toOwner.root, path: to.path };
-  }
-  return null;
+    if (toOwner && repo.kind !== RUNTIME_KIND) {
+        const relative = to.path === toOwner.root ? '' : to.path.slice(toOwner.root.length + 1);
+        const ownerSlot = byId.get(toOwner.slot);
+        const entry = isEntryFile(relative) || declaredEntry(byId.get(to.slot), to.path.slice(to.root.length + 1)) || (ownerSlot.tier === 'package' && relative === 'src/index.ts') || (ownerSlot.tier === 'app' && relative === 'app.module.ts');
+        if (!entry)
+            return { allowed: false, reason: 'notPublicEntry', owner: toOwner.root, path: to.path };
+    }
+    return null;
 }
-
 function tierImportProblem(scope, from, to, fromTier, toTier) {
-  const { mayImport, mayImportKinds, mayImportSlots } = scope.manifest.tiers[scope.profile][fromTier] ?? {};
-  if (!mayImport?.includes(toTier)) return { allowed: false, reason: 'tierDirection', fromTier, toTier, mayImport: mayImport ?? [] };
-  const kindRestriction = mayImportKinds?.[toTier];
-  if (kindRestriction && (!kindRestriction.from.includes(from.kind) || !kindRestriction.to.includes(to.kind))) return { allowed: false, reason: 'tierDirection', fromTier, toTier, mayImport, kindRestriction, fromKind: from.kind ?? null, toKind: to.kind ?? null };
-  const slotRestriction = mayImportSlots?.[toTier];
-  if (slotRestriction && !slotRestriction.from.includes(from.slot)) return { allowed: false, reason: 'tierDirection', fromTier, toTier, mayImport, slotRestriction, fromSlot: from.slot };
-  return null;
+    const { mayImport, mayImportKinds, mayImportSlots } = scope.manifest.tiers[scope.profile][fromTier] ?? {};
+    if (!mayImport?.includes(toTier))
+        return { allowed: false, reason: 'tierDirection', fromTier, toTier, mayImport: mayImport ?? [] };
+    const kindRestriction = mayImportKinds?.[toTier];
+    if (kindRestriction && (!kindRestriction.from.includes(from.kind) || !kindRestriction.to.includes(to.kind)))
+        return { allowed: false, reason: 'tierDirection', fromTier, toTier, mayImport, kindRestriction, fromKind: from.kind ?? null, toKind: to.kind ?? null };
+    const slotRestriction = mayImportSlots?.[toTier];
+    if (slotRestriction && !slotRestriction.from.includes(from.slot))
+        return { allowed: false, reason: 'tierDirection', fromTier, toTier, mayImport, slotRestriction, fromSlot: from.slot };
+    return null;
 }
-
 /**
  * Whether `fromPath` may import `toPath`: {allowed, reason, ...}. Reasons: sameOwner, untiered, crossApp,
  * tierDirection, layerOrder, notPublicEntry, allowed, slotForbidden, slotNotEnabled, slotAmbiguous, and unowned (HFS_SLOT_UNDECLARED for the path no slot owns).
  * Cycles are a graph property and belong to the architecture check, not to one edge.
  */
 export function importAllowedIn(scope, fromPath, toPath) {
-  const from = classifyIn(scope, fromPath);
-  const to = classifyIn(scope, toPath);
-  const unowned = unownedPathProblem(from, to);
-  if (unowned) return unowned;
-  const unavailable = unavailableSlotProblem(from, to);
-  if (unavailable) return unavailable;
-  const fromTier = tierIn(scope, from.path);
-  const toTier = tierIn(scope, to.path);
-  if (fromTier === 'none' || toTier === 'none') return { allowed: true, reason: 'untiered' };
-  if (from.bindings.app !== undefined && to.bindings.app !== undefined && from.bindings.app !== to.bindings.app)
-    return { allowed: false, reason: 'crossApp', from: from.bindings.app, to: to.bindings.app };
-  const fromOwner = ownerIn(scope, from.path);
-  const toOwner = ownerIn(scope, to.path);
-  if (sameOwnerUnit(from, fromOwner) === sameOwnerUnit(to, toOwner)) return { allowed: true, reason: 'sameOwner' };
-  const tierProblem = tierImportProblem(scope, from, to, fromTier, toTier);
-  if (tierProblem) return tierProblem;
-  const layerProblem = lowerLayerProblem(scope, from, to, fromTier, toTier, fromOwner, toOwner);
-  if (layerProblem) return layerProblem;
-  // A runtime owner is imported file by file (crossOwner of knowledge/hfs/runtime-slots.yaml): no public entry.
-  const privateEntry = privateEntryProblem(scope, to, toOwner);
-  if (privateEntry) return privateEntry;
-  return { allowed: true, reason: 'allowed', fromTier, toTier };
+    const fromClassified = classifyIn(scope, fromPath);
+    const toClassified = classifyIn(scope, toPath);
+    const unowned = unownedPathProblem(fromClassified, toClassified);
+    if (unowned)
+        return unowned;
+    const unavailable = unavailableSlotProblem(fromClassified, toClassified);
+    if (unavailable)
+        return unavailable;
+    // reason: unavailableSlotProblem answers for every status but owned, so both paths are placed from here on
+    const from = fromClassified;
+    const to = toClassified;
+    const fromTier = tierIn(scope, from.path);
+    const toTier = tierIn(scope, to.path);
+    if (fromTier === 'none' || toTier === 'none')
+        return { allowed: true, reason: 'untiered' };
+    if (from.bindings.app !== undefined && to.bindings.app !== undefined && from.bindings.app !== to.bindings.app)
+        return { allowed: false, reason: 'crossApp', from: from.bindings.app, to: to.bindings.app };
+    const fromOwner = ownerIn(scope, from.path);
+    const toOwner = ownerIn(scope, to.path);
+    if (sameOwnerUnit(from, fromOwner) === sameOwnerUnit(to, toOwner))
+        return { allowed: true, reason: 'sameOwner' };
+    const tierProblem = tierImportProblem(scope, from, to, fromTier, toTier);
+    if (tierProblem)
+        return tierProblem;
+    const layerProblem = lowerLayerProblem(scope, from, to, fromTier, toTier, fromOwner, toOwner);
+    if (layerProblem)
+        return layerProblem;
+    // A runtime owner is imported file by file (crossOwner of knowledge/hfs/runtime-slots.yaml): no public entry.
+    const privateEntry = privateEntryProblem(scope, to, toOwner);
+    if (privateEntry)
+        return privateEntry;
+    return { allowed: true, reason: 'allowed', fromTier, toTier };
 }

package/runtime/scripts/hfs/slot-manifest-shape.mjs

@@ -1,74 +1,96 @@
-// slot-manifest-shape.mjs - the product slot manifest's schema-shaped validation.
 import { isPlainObject } from '../../engine/plain-object.mjs';
 import { byCodeUnit } from '../lib/list.mjs';
 import { ruleParamsProblems } from './rule-params-shape.mjs';
 import { APP_KIND, EDITIONS, MANIFEST_KINDS, NAME, PRESENCE, RUNTIME_KIND, SEMVER, TESTS, TRACKED, manifestKind, runtimeShapeProblems, slotProblems, tierMapProblems } from './manifest-shape.mjs';
-
 export const PROFILES = ['be', 'fe'];
+/** Whether `value` names a side of an app. */
+export const isSide = (value) => PROFILES.includes(value);
 export const APP_SCOPE = 'app';
 export const SCOPES = [APP_SCOPE, ...PROFILES];
-
 /** Shape problems of a parsed manifest, in the words of modules/schemas/hfs-slots.schema.yaml. */
 function checkCoreManifestFields(m, bad) {
-  const allowed = new Set(['schema', 'kind', 'version', 'versioning', 'presenceValues', 'trackedValues', 'testValues', 'editions', 'sides', 'appKinds', 'triggerKinds', 'tiers', 'ruleParams', 'crossOwner', 'crossApp', 'slots', 'consumers', 'naming']);
-  for (const key of Object.keys(m)) if (!allowed.has(key)) bad.push(`unknown top-level key ${key}`);
-  if (!/^starci\/hfs-slots@\d+$/.test(String(m.schema))) bad.push('schema must be starci/hfs-slots@<major>');
-  if (!SEMVER.test(String(m.version))) bad.push('version must be MAJOR.MINOR.PATCH');
-  if (!isPlainObject(m.versioning) || !['patch', 'minor', 'major', 'pins'].every((k) => typeof m.versioning[k] === 'string')) bad.push('versioning needs patch, minor, major and pins text');
-  if (JSON.stringify(m.presenceValues) !== JSON.stringify(PRESENCE)) bad.push(`presenceValues must be ${PRESENCE.join(', ')}`);
-  if (JSON.stringify(m.trackedValues) !== JSON.stringify(TRACKED)) bad.push(`trackedValues must be ${TRACKED.join(', ')}`);
-  if (JSON.stringify(m.testValues) !== JSON.stringify(TESTS)) bad.push(`testValues must be ${TESTS.join(', ')}`);
-  if (JSON.stringify(m.editions) !== JSON.stringify(EDITIONS)) bad.push(`editions must be ${EDITIONS.join(', ')}`);
+    const allowed = new Set(['schema', 'kind', 'version', 'versioning', 'presenceValues', 'trackedValues', 'testValues', 'editions', 'sides', 'appKinds', 'triggerKinds', 'tiers', 'ruleParams', 'crossOwner', 'crossApp', 'slots', 'consumers', 'naming']);
+    for (const key of Object.keys(m))
+        if (!allowed.has(key))
+            bad.push(`unknown top-level key ${key}`);
+    if (!/^starci\/hfs-slots@\d+$/.test(String(m.schema)))
+        bad.push('schema must be starci/hfs-slots@<major>');
+    if (!SEMVER.test(String(m.version)))
+        bad.push('version must be MAJOR.MINOR.PATCH');
+    if (!isPlainObject(m.versioning) || !['patch', 'minor', 'major', 'pins'].every((k) => typeof m.versioning[k] === 'string'))
+        bad.push('versioning needs patch, minor, major and pins text');
+    if (JSON.stringify(m.presenceValues) !== JSON.stringify(PRESENCE))
+        bad.push(`presenceValues must be ${PRESENCE.join(', ')}`);
+    if (JSON.stringify(m.trackedValues) !== JSON.stringify(TRACKED))
+        bad.push(`trackedValues must be ${TRACKED.join(', ')}`);
+    if (JSON.stringify(m.testValues) !== JSON.stringify(TESTS))
+        bad.push(`testValues must be ${TESTS.join(', ')}`);
+    if (JSON.stringify(m.editions) !== JSON.stringify(EDITIONS))
+        bad.push(`editions must be ${EDITIONS.join(', ')}`);
 }
-
 function checkSideShapes(m, bad) {
-  if (!isPlainObject(m.sides) || Object.keys(m.sides).sort(byCodeUnit).join() !== PROFILES.join()) bad.push('sides must be a map with exactly be and fe');
-  else for (const side of PROFILES) {
-    const def = m.sides[side];
-    if (!isPlainObject(def) || Object.keys(def).join() !== 'reads' || !Array.isArray(def.reads) || !def.reads.every((r) => typeof r === 'string' && /^[a-z][a-z0-9-]*\/([^/]+\/)+$/.test(r)) || new Set(def.reads).size !== def.reads.length) bad.push(`sides.${side} must be {reads: [unique <owner>/<dir>/ paths]}`);
-  }
+    if (!isPlainObject(m.sides) || Object.keys(m.sides).sort(byCodeUnit).join() !== PROFILES.join())
+        bad.push('sides must be a map with exactly be and fe');
+    else
+        for (const side of PROFILES) {
+            const def = m.sides[side];
+            if (!isPlainObject(def) || Object.keys(def).join() !== 'reads' || !Array.isArray(def.reads) || !def.reads.every((r) => typeof r === 'string' && /^[a-z][a-z0-9-]*\/([^/]+\/)+$/.test(r)) || new Set(def.reads).size !== def.reads.length)
+                bad.push(`sides.${side} must be {reads: [unique <owner>/<dir>/ paths]}`);
+        }
 }
-
 function checkTriggerKinds(m, bad) {
-  if (m.triggerKinds !== undefined && (!Array.isArray(m.triggerKinds) || !m.triggerKinds.length || !m.triggerKinds.every((k) => NAME.test(String(k))) || new Set(m.triggerKinds).size !== m.triggerKinds.length)) bad.push('triggerKinds must be a non-empty list of unique names');
+    if (m.triggerKinds !== undefined && (!Array.isArray(m.triggerKinds) || !m.triggerKinds.length || !m.triggerKinds.every((k) => NAME.test(String(k))) || new Set(m.triggerKinds).size !== m.triggerKinds.length))
+        bad.push('triggerKinds must be a non-empty list of unique names');
 }
-
 function checkProfileMaps(m, bad) {
-  for (const key of ['appKinds', 'tiers']) {
-    if (!isPlainObject(m[key])) { bad.push(`${key} must be a map with be and fe`); continue; }
-    for (const extra of Object.keys(m[key])) if (!PROFILES.includes(extra)) bad.push(`${key}.${extra} is not a profile`);
-    for (const profile of PROFILES) if (!(profile in m[key])) bad.push(`${key}.${profile} is missing`);
-  }
+    for (const key of ['appKinds', 'tiers']) {
+        if (!isPlainObject(m[key])) {
+            bad.push(`${key} must be a map with be and fe`);
+            continue;
+        }
+        for (const extra of Object.keys(m[key]))
+            if (!isSide(extra))
+                bad.push(`${key}.${extra} is not a profile`);
+        for (const profile of PROFILES)
+            if (!(profile in m[key]))
+                bad.push(`${key}.${profile} is missing`);
+    }
 }
-
 function checkAppKindAndTierShapes(m, bad) {
-  for (const profile of PROFILES) {
-    const kinds = m.appKinds?.[profile];
-    if (kinds !== undefined && (!Array.isArray(kinds) || !kinds.length || !kinds.every((k) => NAME.test(String(k))) || new Set(kinds).size !== kinds.length)) bad.push(`appKinds.${profile} must be a non-empty list of unique names`);
-    const tiers = m.tiers?.[profile];
-    if (tiers === undefined) continue;
-    bad.push(...tierMapProblems(profile, tiers));
-  }
+    for (const profile of PROFILES) {
+        const kinds = m.appKinds?.[profile];
+        if (kinds !== undefined && (!Array.isArray(kinds) || !kinds.length || !kinds.every((k) => NAME.test(String(k))) || new Set(kinds).size !== kinds.length))
+            bad.push(`appKinds.${profile} must be a non-empty list of unique names`);
+        const tiers = m.tiers?.[profile];
+        if (tiers === undefined)
+            continue;
+        bad.push(...tierMapProblems(profile, tiers));
+    }
 }
-
 function checkSlotShapes(m, bad) {
-  if (!Array.isArray(m.slots) || !m.slots.length) { bad.push('slots must be a non-empty list'); return false; }
-  const logicRoles = Array.isArray(m.ruleParams?.be?.logicRoles) ? m.ruleParams.be.logicRoles : [];
-  m.slots.forEach((slot, index) => bad.push(...slotProblems(slot, index, APP_KIND, { appScope: APP_SCOPE, scopes: SCOPES, logicRoles })));
-  return true;
+    if (!Array.isArray(m.slots) || !m.slots.length) {
+        bad.push('slots must be a non-empty list');
+        return false;
+    }
+    const logicRoles = Array.isArray(m.ruleParams?.be?.logicRoles) ? m.ruleParams.be.logicRoles : [];
+    m.slots.forEach((slot, index) => bad.push(...slotProblems(slot, index, APP_KIND, { appScope: APP_SCOPE, scopes: SCOPES, logicRoles })));
+    return true;
 }
-
 export function manifestShapeProblems(m) {
-  const bad = [];
-  if (!isPlainObject(m)) return ['the manifest is not a map'];
-  if (!MANIFEST_KINDS.includes(manifestKind(m))) return [`kind must be one of ${MANIFEST_KINDS.join(', ')}`];
-  if (manifestKind(m) === RUNTIME_KIND) return runtimeShapeProblems(m);
-  checkCoreManifestFields(m, bad);
-  checkSideShapes(m, bad);
-  checkTriggerKinds(m, bad);
-  checkProfileMaps(m, bad);
-  checkAppKindAndTierShapes(m, bad);
-  bad.push(...ruleParamsProblems(m));
-  if (!checkSlotShapes(m, bad)) return bad;
-  return bad;
+    const bad = [];
+    if (!isPlainObject(m))
+        return ['the manifest is not a map'];
+    if (!MANIFEST_KINDS.includes(manifestKind(m)))
+        return [`kind must be one of ${MANIFEST_KINDS.join(', ')}`];
+    if (manifestKind(m) === RUNTIME_KIND)
+        return runtimeShapeProblems(m);
+    checkCoreManifestFields(m, bad);
+    checkSideShapes(m, bad);
+    checkTriggerKinds(m, bad);
+    checkProfileMaps(m, bad);
+    checkAppKindAndTierShapes(m, bad);
+    bad.push(...ruleParamsProblems(m));
+    if (!checkSlotShapes(m, bad))
+        return bad;
+    return bad;
 }

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

@@ -3,151 +3,162 @@
 import path from 'node:path';
 import { braceVariants } from '../lib/glob.mjs';
 import { captureNames } from '../lib/i18n.mjs';
-
 const VAR = /<([A-Za-z][A-Za-z0-9-]*)>/g;
 export const varsOf = (text) => captureNames(text, VAR);
 const hasWildcard = (segment) => /[*?]/.test(segment);
-
 /** `text` with the `<name>` variables filled from `bindings` (an unbound one stays as written). */
 export function fillVars(text, bindings) {
-  const bound = (whole, name) => bindings[name] ?? whole;
-  return `${text}`.replace(VAR, bound);
+    const bound = (whole, name) => bindings[name] ?? whole;
+    return `${text}`.replace(VAR, bound);
 }
-
 /** Weight of one pattern segment: literal 4, literal mixed with a variable 3, a bare variable 2, a wildcard 1, `**` 0. */
 function segmentWeight(segment) {
-  if (segment === '**') return 0;
-  if (hasWildcard(segment)) return 1;
-  if (/^<[^>]+>$/.test(segment)) return 2;
-  if (segment.includes('<')) return 3;
-  return 4;
+    if (segment === '**')
+        return 0;
+    if (hasWildcard(segment))
+        return 1;
+    if (/^<[^>]+>$/.test(segment))
+        return 2;
+    if (segment.includes('<'))
+        return 3;
+    return 4;
 }
-
 /** The RegExp source of one pattern segment (no separators); variables capture, and are listed in `names`. */
 function segmentSource(segment, names) {
-  let source = '', variableEnd = -1;
-  for (let i = 0; i < segment.length; i += 1) {
-    const c = segment[i];
-    if (i <= variableEnd) continue;
-    if (c === '<') {
-      variableEnd = segment.indexOf('>', i);
-      names.push(segment.slice(i + 1, variableEnd));
-      source += '([^/]+?)';
-    } else if (c === '*') source += '[^/]*';
-    else if (c === '?') source += '[^/]';
-    else source += /[.+^${}()|[\]\\]/.test(c) ? `\\${c}` : c;
-  }
-  return source;
+    let source = '', variableEnd = -1;
+    for (let i = 0; i < segment.length; i += 1) {
+        const c = segment[i];
+        if (i <= variableEnd)
+            continue;
+        if (c === '<') {
+            variableEnd = segment.indexOf('>', i);
+            names.push(segment.slice(i + 1, variableEnd));
+            source += '([^/]+?)';
+        }
+        else if (c === '*')
+            source += '[^/]*';
+        else if (c === '?')
+            source += '[^/]';
+        else
+            source += /[.+^${}()|[\]\\]/.test(c) ? `\\${c}` : c;
+    }
+    return source;
 }
-
 /** One brace-free pattern compiled: `dir` patterns (trailing /) own everything below their root. */
 export function compileVariant(slot, pattern) {
-  const dir = pattern.endsWith('/');
-  const body = dir ? pattern.slice(0, -1) : pattern;
-  const segments = body.split('/');
-  const names = [];
-  let source = '';
-  segments.forEach((segment, index) => {
-    const last = index === segments.length - 1;
-    if (segment === '**') source += last ? '.*' : '(?:.*/)?';
-    else source += segmentSource(segment, names) + (last ? '' : '/');
-  });
-  return {
-    slot,
-    pattern,
-    dir,
-    segments,
-    names,
-    score: segments.reduce((sum, s) => sum + segmentWeight(s), 0),
-    wildcards: segments.filter(hasWildcard).length,
-    regex: new RegExp(`^(${source})${dir ? '(?:/.*)?' : ''}$`),
-    segmentRegexes: segments.map((s) => (s === '**' ? null : new RegExp(`^${segmentSource(s, [])}$`))),
-  };
+    const dir = pattern.endsWith('/');
+    const body = dir ? pattern.slice(0, -1) : pattern;
+    const segments = body.split('/');
+    const names = [];
+    let source = '';
+    segments.forEach((segment, index) => {
+        const last = index === segments.length - 1;
+        if (segment === '**')
+            source += last ? '.*' : '(?:.*/)?';
+        else
+            source += segmentSource(segment, names) + (last ? '' : '/');
+    });
+    return {
+        slot,
+        pattern,
+        dir,
+        segments,
+        names,
+        score: segments.reduce((sum, s) => sum + segmentWeight(s), 0),
+        wildcards: segments.filter(hasWildcard).length,
+        regex: new RegExp(`^(${source})${dir ? '(?:/.*)?' : ''}$`),
+        segmentRegexes: segments.map((s) => (s === '**' ? null : new RegExp(`^${segmentSource(s, [])}$`))),
+    };
 }
-
 export const variantsOf = (slot) => braceVariants(slot.path).map((pattern) => compileVariant(slot, pattern));
-
 const levenshtein = (a, b) => {
-  const row = Array.from({ length: b.length + 1 }, (_, i) => i);
-  for (let i = 1; i <= a.length; i += 1) {
-    let prev = row[0];
-    row[0] = i;
-    for (let j = 1; j <= b.length; j += 1) {
-      const held = row[j];
-      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
-      prev = held;
+    const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i += 1) {
+        let prev = row[0];
+        row[0] = i;
+        for (let j = 1; j <= b.length; j += 1) {
+            const held = row[j];
+            row[j] = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+            prev = held;
+        }
     }
-  }
-  return row[b.length];
+    return row[b.length];
 };
-
 /** The match of `p` against one variant: its slot, root and bindings, or null (not matching, filtered out, or an app-kind slot of another kind). */
 function matchVariant(variant, p, only, appKind) {
-  if (only && !only(variant.slot)) return null;
-  const m = variant.regex.exec(p);
-  if (!m) return null;
-  const bindings = {};
-  variant.names.forEach((name, i) => { bindings[name] = m[i + 2]; });
-  if (variant.slot.appKind !== undefined && appKind.get(bindings.app) !== variant.slot.appKind) return null;
-  const root = variant.dir ? m[1] : path.posix.dirname(m[1]);
-  return { variant, slot: variant.slot, root: root === '.' ? '' : root, bindings };
+    if (only && !only(variant.slot))
+        return null;
+    const m = variant.regex.exec(p);
+    if (!m)
+        return null;
+    const bindings = {};
+    variant.names.forEach((name, i) => { bindings[name] = m[i + 2]; });
+    if (variant.slot.appKind !== undefined && appKind.get(bindings.app) !== variant.slot.appKind)
+        return null;
+    const root = variant.dir ? m[1] : path.posix.dirname(m[1]);
+    return { variant, slot: variant.slot, root: root === '.' ? '' : root, bindings };
 }
-
 /** Every variant matching `p`, with its root and bindings, minus app-kind slots of another kind, the most specific first. */
 export function matchVariants({ variants, appKind }, p, only) {
-  const found = [];
-  for (const variant of variants) {
-    const hit = matchVariant(variant, p, only, appKind);
-    if (hit) found.push(hit);
-  }
-  return found.sort((a, b) => b.variant.score - a.variant.score || a.variant.wildcards - b.variant.wildcards);
+    const found = [];
+    for (const variant of variants) {
+        const hit = matchVariant(variant, p, only, appKind);
+        if (hit)
+            found.push(hit);
+    }
+    return found.sort((a, b) => b.variant.score - a.variant.score || a.variant.wildcards - b.variant.wildcards);
 }
-
 /** The single most specific match of a sorted list: {hit, ambiguous}; two slots of equal specificity are ambiguous. */
 export function bestMatch(found) {
-  if (!found.length) return { hit: null, ambiguous: [] };
-  const top = found.filter((f) => f.variant.score === found[0].variant.score && f.variant.wildcards === found[0].variant.wildcards);
-  const distinct = [...new Set(top.map((f) => f.slot.id))];
-  return distinct.length > 1 ? { hit: null, ambiguous: distinct } : { hit: top[0], ambiguous: [] };
+    if (!found.length)
+        return { hit: null, ambiguous: [] };
+    const first = found[0];
+    const top = found.filter((f) => f.variant.score === first.variant.score && f.variant.wildcards === first.variant.wildcards);
+    const distinct = [...new Set(top.map((f) => f.slot.id))];
+    return distinct.length > 1 ? { hit: null, ambiguous: distinct } : { hit: top[0], ambiguous: [] };
 }
-
 /** How many leading segments of `parts` a variant accepts. */
 function acceptedDepth(variant, parts) {
-  let depth = 0;
-  while (depth < parts.length && depth < variant.segments.length) {
-    const rx = variant.segmentRegexes[depth];
-    if (rx === null || !rx.test(parts[depth])) break;
-    depth += 1;
-  }
-  return depth;
+    let depth = 0;
+    while (depth < parts.length && depth < variant.segments.length) {
+        const rx = variant.segmentRegexes[depth];
+        if (rx === null || !rx.test(parts[depth]))
+            break;
+        depth += 1;
+    }
+    return depth;
 }
-
 /** Whether `cand` is nearer to the path than `winner`: deeper, then closer in shape, then in spelling, then more specific. */
 function nearerCandidate(cand, winner) {
-  if (!winner) return true;
-  if (cand.depth !== winner.depth) return cand.depth > winner.depth;
-  if (cand.shape !== winner.shape) return cand.shape < winner.shape;
-  if (cand.distance !== winner.distance) return cand.distance < winner.distance;
-  return cand.variant.score > winner.variant.score;
+    if (!winner)
+        return true;
+    if (cand.depth !== winner.depth)
+        return cand.depth > winner.depth;
+    if (cand.shape !== winner.shape)
+        return cand.shape < winner.shape;
+    if (cand.distance !== winner.distance)
+        return cand.distance < winner.distance;
+    return cand.variant.score > winner.variant.score;
 }
-
 /** The leading segments of `p` a variant accepts, and how far it got; how the nearest slot of an unknown path is found. */
 export function nearestSlot(variants, p) {
-  const parts = p.split('/');
-  let winner = null;
-  for (const variant of variants) {
-    const depth = acceptedDepth(variant, parts);
-    const expected = variant.segments[depth] ?? '';
-    const distance = levenshtein(parts[depth] ?? '', expected.replace(VAR, ''));
-    const cand = { variant, depth, shape: Math.abs(variant.segments.length - parts.length), distance };
-    if (nearerCandidate(cand, winner)) winner = cand;
-  }
-  if (!winner) return null;
-  return {
-    slot: winner.variant.slot.id,
-    pattern: winner.variant.pattern,
-    matchedDepth: winner.depth,
-    matchedPrefix: parts.slice(0, winner.depth).join('/'),
-    expectedNext: winner.variant.segments[winner.depth] ?? null,
-  };
+    const parts = p.split('/');
+    let winner = null;
+    for (const variant of variants) {
+        const depth = acceptedDepth(variant, parts);
+        const expected = variant.segments[depth] ?? '';
+        const distance = levenshtein(parts[depth] ?? '', expected.replace(VAR, ''));
+        const cand = { variant, depth, shape: Math.abs(variant.segments.length - parts.length), distance };
+        if (nearerCandidate(cand, winner))
+            winner = cand;
+    }
+    if (!winner)
+        return null;
+    return {
+        slot: winner.variant.slot.id,
+        pattern: winner.variant.pattern,
+        matchedDepth: winner.depth,
+        matchedPrefix: parts.slice(0, winner.depth).join('/'),
+        expectedNext: winner.variant.segments[winner.depth] ?? null,
+    };
 }

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

@@ -1,8 +1,6 @@
 // slot-path.mjs - normalize a slot-relative path for resolver comparisons.
 import { posixPath } from '../lib/path-key.mjs';
-
 const SLASH = '/';
 const END = '$';
 const TRAILING_SLASHES = new RegExp(`${SLASH}+${END}`);
-
 export const cleanSlotPath = (value) => posixPath(value).replace(TRAILING_SLASHES, '');