@starci/hfs 4.11.22 → 4.12.2

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

@@ -0,0 +1,75 @@
+import type { Bindings, NearestSlot, Variant } from './slot-match.mjs';
+import type { Slot, SlotManifest, SlotPresence, SlotTracking } from './manifest-shape.mjs';
+import type { RepoView } from './slots.mjs';
+/** One scope (the app root or one side) as slots.mjs builds it: the manifest, the declaration view and the slots enabled for the profile and edition. */
+export interface Scope {
+    manifest: SlotManifest;
+    repo: RepoView;
+    profile: string;
+    slots: Slot[];
+    byId: Map<string, Slot>;
+    variants: Variant[];
+    appKind: Map<string, string>;
+}
+/** A path two slots own with equal specificity (a manifest gap). */
+export interface AmbiguousPath {
+    path: string;
+    status: 'ambiguous';
+    candidates: string[];
+    side?: string;
+    slot?: undefined;
+    root?: undefined;
+    bindings?: undefined;
+    tracking?: undefined;
+    nearest?: undefined;
+}
+/** A path no slot owns (code HFS_SLOT_UNDECLARED), with the nearest slot. */
+export interface UndeclaredPath {
+    path: string;
+    status: 'no-slot';
+    code: 'HFS_SLOT_UNDECLARED';
+    nearest: NearestSlot | null;
+    side?: string;
+    slot?: undefined;
+    root?: undefined;
+    bindings?: undefined;
+    tracking?: undefined;
+}
+/** A path a slot owns: the slot, its instance root and bound variables, and what the slot says about it. */
+export interface PlacedPath {
+    path: string;
+    status: 'owned' | 'forbidden' | 'not-enabled';
+    slot: string;
+    root: string;
+    bindings: Bindings;
+    kind?: string;
+    role?: string;
+    presence: SlotPresence;
+    tracking: SlotTracking;
+    goesTo?: string | undefined;
+    side?: string;
+    nearest?: undefined;
+}
+/**
+ * The answer of classifyPath. status: owned | forbidden (external slot) | not-enabled (opt-in slot the repository did not declare) |
+ * ambiguous | no-slot. Through the app resolver a path below a side folder also carries `side`.
+ */
+export type ClassifiedPath = AmbiguousPath | UndeclaredPath | PlacedPath;
+/** The owner unit of a path: the owner slot instance containing it. */
+export interface OwnerUnit {
+    slot: string;
+    root: string;
+    bindings: Bindings;
+    side?: string;
+}
+/** Whether the repository of the scope holds the slot. */
+export declare function slotEnabled(scope: Scope, slot: Slot): boolean;
+/**
+ * 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 declare function classifyIn(scope: Scope, input: string): ClassifiedPath;
+/** The owner unit of `p`: the most specific owner slot instance containing it (a slot's own root when it owns nothing). */
+export declare function ownerIn(scope: Scope, input: string): OwnerUnit | 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 declare function tierIn(scope: Scope, input: string): string | 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.d.mts

@@ -0,0 +1,6 @@
+export declare class HfsSlotsError extends Error {
+    code: string;
+    details: Record<string, unknown>;
+    constructor(code: string, message: string, details?: Record<string, unknown>);
+}
+export declare const fail: (code: string, message: string, details?: Record<string, unknown>) => never;

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); };

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

@@ -0,0 +1,8 @@
+import type { Scope } from './slot-classify.mjs';
+import type { ImportVerdict } from './slots.mjs';
+/**
+ * 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 declare function importAllowedIn(scope: Scope, fromPath: string, toPath: string): ImportVerdict;

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

@@ -0,0 +1,9 @@
+import type { Parsed } from './manifest-shape.mjs';
+/** A side of an app: the folder of that name holds it. */
+export type Side = 'be' | 'fe';
+export declare const PROFILES: readonly Side[];
+/** Whether `value` names a side of an app. */
+export declare const isSide: (value: unknown) => value is Side;
+export declare const APP_SCOPE = "app";
+export declare const SCOPES: string[];
+export declare function manifestShapeProblems(m: Parsed): string[];