@starci/hfs 4.11.22 → 4.12.0

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.d.mts

@@ -0,0 +1,50 @@
+import type { Slot } from './manifest-shape.mjs';
+/** The values the variables of a slot path took in a matched path. */
+export type Bindings = Record<string, string>;
+/** One brace-free slot path pattern compiled. */
+export interface Variant {
+    slot: Slot;
+    pattern: string;
+    dir: boolean;
+    segments: string[];
+    names: string[];
+    score: number;
+    wildcards: number;
+    regex: RegExp;
+    segmentRegexes: Array<RegExp | null>;
+}
+/** The match of a path against one variant: its slot, the instance root and the bound variables. */
+export interface Match {
+    variant: Variant;
+    slot: Slot;
+    root: string;
+    bindings: Bindings;
+}
+/** The slot nearest to a path no slot owns, and how far the path agreed with it. */
+export interface NearestSlot {
+    slot: string;
+    pattern: string;
+    matchedDepth: number;
+    matchedPrefix: string;
+    expectedNext: string | null;
+}
+/** What matchVariants needs of a scope: its compiled variants and the kind of each declared app. */
+export interface MatchScope {
+    variants: Variant[];
+    appKind: Map<string, string>;
+}
+export declare const varsOf: (text: string) => string[];
+/** `text` with the `<name>` variables filled from `bindings` (an unbound one stays as written). */
+export declare function fillVars(text: string, bindings: Bindings): string;
+/** One brace-free pattern compiled: `dir` patterns (trailing /) own everything below their root. */
+export declare function compileVariant(slot: Slot, pattern: string): Variant;
+export declare const variantsOf: (slot: Slot) => Variant[];
+/** Every variant matching `p`, with its root and bindings, minus app-kind slots of another kind, the most specific first. */
+export declare function matchVariants({ variants, appKind }: MatchScope, p: string, only?: (slot: Slot) => boolean): Match[];
+/** The single most specific match of a sorted list: {hit, ambiguous}; two slots of equal specificity are ambiguous. */
+export declare function bestMatch(found: Match[]): {
+    hit: Match | null;
+    ambiguous: string[];
+};
+/** The leading segments of `p` a variant accepts, and how far it got; how the nearest slot of an unknown path is found. */
+export declare function nearestSlot(variants: Variant[], p: string): NearestSlot | null;

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.d.mts

@@ -0,0 +1 @@
+export declare const cleanSlotPath: (value: string) => string;

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, '');

package/runtime/scripts/hfs/slot-required.d.mts

@@ -0,0 +1,11 @@
+import type { Scope } from './slot-classify.mjs';
+import type { RequiredPaths } from './slots.mjs';
+/** A populated fe.modules instance needs its index.ts only when it contains TypeScript, including nested files. */
+export declare function requiredFileApplies(slotId: string, target: string, files: Iterable<string>): boolean;
+/** The files and directories the instance holding `p` must contain (directories end with /); {path} entries are repo-relative. */
+export declare function requiredFilesIn(scope: Scope, input: string): string[];
+/**
+ * What the repository must contain, without walking it: {paths: [{slot, path, via}], minimums: [{slot, min}]}.
+ * via is slot (a fixed path), instance (a requiredInstances or app-kind root) or requires (a file an instance needs).
+ */
+export declare function requiredPathsIn(scope: Scope): RequiredPaths;