@starci/hfs 4.11.21 → 4.12.0

package/runtime/scripts/hfs/grammar-presentation.d.mts

@@ -0,0 +1,74 @@
+/** A guidance entry of a presentation topic (universal or a family's concrete one). */
+export interface PresentationGuidance {
+    id: string;
+    requirement?: string;
+    familyRequirement?: string;
+    familySource?: string;
+    [key: string]: unknown;
+}
+/** One case of a rule (universal) or of a recipe (concrete). */
+export interface PresentationCase {
+    id: string;
+    owner?: string;
+    render?: string;
+    [key: string]: unknown;
+}
+/** The family's presentation data of one topic, as parsed from the grammar playbook. */
+export interface PresentationData {
+    inherits?: string;
+    scale?: {
+        steps: {
+            id: string;
+            value?: unknown;
+        }[];
+    };
+    componentOwnership?: {
+        rows: {
+            rule: string;
+        }[];
+    };
+    recipes?: {
+        rule: string;
+        title: string;
+        cases?: PresentationCase[];
+    }[];
+    guidance?: PresentationGuidance[];
+}
+/** A universal topic: a stable relative path and the parsed document. */
+export interface PresentationTopic {
+    rel: string;
+    doc: {
+        rules?: {
+            id: string;
+            cases?: PresentationCase[];
+            [key: string]: unknown;
+        }[];
+        guidance?: PresentationGuidance[];
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+/** The active CSS token scope, as far as font weights need it. */
+export interface TokenScope {
+    variable(name: string): {
+        value?: unknown;
+    } | null | undefined;
+}
+/** Resolve a recorded rem, px or unitless scale value at the proof's baseline root; unsupported values stay unavailable. */
+export declare const remPx: (value: unknown) => number | null;
+/** Resolve the selected family's published text weights through the active CSS token scope. */
+export declare function fontWeightsOf(guidance: PresentationGuidance | null | undefined, scope: TokenScope | null | undefined): number[];
+/**
+ * Bind supported universal presentation cases to the selected family's numerical recipes without mutation.
+ * Missing family data and incomplete coverage fail visibly rather than selecting another family.
+ * @param {object[]} knowledge - Universal topics with stable relative paths and parsed documents.
+ * @param {{ family?: string, repo?: string }} input - Explicit family or the app whose declaration selects it.
+ * @returns {{ family: string, knowledge: object[] }} Selected family and proof-ready topics with owner provenance.
+ */
+export declare function familyPresentationKnowledge(knowledge: PresentationTopic[], { family, repo }?: {
+    family?: string | null;
+    repo?: string | null;
+}): {
+    family: string;
+    knowledge: PresentationTopic[];
+};

package/runtime/scripts/hfs/grammar-presentation.mjs

@@ -6,131 +6,131 @@ import { parseYaml } from '../../engine/yaml.mjs';
 import { skillRoot } from '../../engine/runtime-root.mjs';
 import { openHfs } from './slots.mjs';
 import { grammarFamilyFor } from '../lib/grammar-lint.mjs';
-
 const GRAMMARS = fileURLToPath(new URL('../../knowledge/grammars/', import.meta.url));
 const PADDING_TOPIC = 'presentation/padding.yaml';
 const TOPIC_NAMES = ['padding', 'font'];
 const REM_PX = 16;
 const TEXT_WEIGHT_NAMES = ['normal', 'medium', 'semibold'];
-
 /** The Common text-weight matrix is complete only when each public weight has one declared class. */
 function fontWeightClasses(guidance) {
-  const matrix = guidance?.familyRequirement ?? guidance?.requirement ?? '';
-  const pattern = new RegExp('`font-(' + TEXT_WEIGHT_NAMES.join('|') + ')`', 'g');
-  const names = [...String(matrix).matchAll(pattern)].map(match => match[1]);
-  if (names.length !== TEXT_WEIGHT_NAMES.length || new Set(names).size !== TEXT_WEIGHT_NAMES.length) {
-    throw new Error('Grammar font weight matrix is missing or incomplete');
-  }
-  return names;
+    const matrix = guidance?.familyRequirement ?? guidance?.requirement ?? '';
+    const pattern = new RegExp('`font-(' + TEXT_WEIGHT_NAMES.join('|') + ')`', 'g');
+    const names = [...String(matrix).matchAll(pattern)].map((match) => match[1]);
+    if (names.length !== TEXT_WEIGHT_NAMES.length || new Set(names).size !== TEXT_WEIGHT_NAMES.length) {
+        throw new Error('Grammar font weight matrix is missing or incomplete');
+    }
+    return names;
 }
-
 /** Resolve a recorded rem, px or unitless scale value at the proof's baseline root; unsupported values stay unavailable. */
 export const remPx = (value) => {
-  const match = /^(-?(?:\d+(?:\.\d+)?|\.\d+))(rem|px)?$/.exec(String(value ?? '').trim());
-  if (!match) return null;
-  const px = Number(match[1]) * (match[2] === 'px' ? 1 : REM_PX);
-  return Number.isFinite(px) ? px : null;
+    const match = /^(-?(?:\d+(?:\.\d+)?|\.\d+))(rem|px)?$/.exec(String(value ?? '').trim());
+    if (!match)
+        return null;
+    const px = Number(match[1]) * (match[2] === 'px' ? 1 : REM_PX);
+    return Number.isFinite(px) ? px : null;
 };
-
 /** Resolve the selected family's published text weights through the active CSS token scope. */
 export function fontWeightsOf(guidance, scope) {
-  const weights = fontWeightClasses(guidance).map(name => Number(scope?.variable(`--font-weight-${name}`)?.value));
-  if (weights.some(weight => !Number.isFinite(weight))) throw new Error('Grammar font weight tokens are unresolved');
-  return weights;
+    const weights = fontWeightClasses(guidance).map(name => Number(scope?.variable(`--font-weight-${name}`)?.value));
+    if (weights.some(weight => !Number.isFinite(weight)))
+        throw new Error('Grammar font weight tokens are unresolved');
+    return weights;
 }
-
 /** Missing or ambiguous family weight data cannot remove the render's weight proof. */
 function validateFontGuidance(data) {
-  const weights = (data.guidance ?? []).filter(item => item.id === 'weight');
-  if (weights.length !== 1) throw new Error('Grammar font guidance needs one concrete weight matrix');
-  fontWeightClasses(weights[0]);
+    const weights = (data.guidance ?? []).filter((item) => item.id === 'weight');
+    if (weights.length !== 1)
+        throw new Error('Grammar font guidance needs one concrete weight matrix');
+    fontWeightClasses(weights[0]);
 }
-
 /** Read the explicit family or the app declaration; CSS discovery never chooses presentation law. */
 function selectedFamily(family, repo) {
-  if (family !== null && family !== undefined) return grammarFamilyFor(family).id;
-  if (!repo) throw new Error('Presentation proof needs an explicit Grammar family or an app repository');
-  const declaration = openHfs({ root: skillRoot, repoRoot: repo }).repo;
-  return grammarFamilyFor(declaration.grammar ?? declaration.sides?.fe?.grammar).id;
+    if (family !== null && family !== undefined)
+        return grammarFamilyFor(family).id;
+    if (!repo)
+        throw new Error('Presentation proof needs an explicit Grammar family or an app repository');
+    const declaration = openHfs({ root: skillRoot, repoRoot: repo }).repo;
+    return grammarFamilyFor(declaration.grammar ?? declaration.sides?.fe?.grammar).id;
 }
-
 /** The one declared presentation owner, following only explicit inheritance and rejecting cycles. */
 function presentationOwner(family, name, seen = new Set()) {
-  if (seen.has(family)) throw new Error(`Grammar ${name} inheritance cycles at ${family}`);
-  seen.add(family);
-  const entry = grammarFamilyFor(family);
-  if (typeof entry.productComposition !== 'string' || !entry.productComposition) {
-    throw new Error(`Grammar family ${family} has no presentation playbook`);
-  }
-  const file = path.resolve(GRAMMARS, entry.productComposition);
-  const relative = path.relative(GRAMMARS, file);
-  if (relative.startsWith('..') || path.isAbsolute(relative)) throw new Error(`Grammar family ${family} has an invalid presentation path`);
-  const doc = parseYaml(fs.readFileSync(file, 'utf8'));
-  const data = doc?.presentation?.[name];
-  if (!data || typeof data !== 'object') throw new Error(`Grammar family ${family} has no ${name} presentation data`);
-  if (Object.hasOwn(data, 'inherits')) {
-    if (Object.keys(data).some(key => !['inherits', 'ownership', 'contract'].includes(key))) {
-      throw new Error(`Grammar family ${family} mixes inherited and replacement ${name} data`);
+    if (seen.has(family))
+        throw new Error(`Grammar ${name} inheritance cycles at ${family}`);
+    seen.add(family);
+    const entry = grammarFamilyFor(family);
+    if (typeof entry.productComposition !== 'string' || !entry.productComposition) {
+        throw new Error(`Grammar family ${family} has no presentation playbook`);
+    }
+    const file = path.resolve(GRAMMARS, entry.productComposition);
+    const relative = path.relative(GRAMMARS, file);
+    if (relative.startsWith('..') || path.isAbsolute(relative))
+        throw new Error(`Grammar family ${family} has an invalid presentation path`);
+    const doc = parseYaml(fs.readFileSync(file, 'utf8'));
+    const data = doc?.presentation?.[name]; // reason: parsed YAML from disk, validated below
+    if (!data || typeof data !== 'object')
+        throw new Error(`Grammar family ${family} has no ${name} presentation data`);
+    if (Object.hasOwn(data, 'inherits')) {
+        if (Object.keys(data).some((key) => !['inherits', 'ownership', 'contract'].includes(key))) {
+            throw new Error(`Grammar family ${family} mixes inherited and replacement ${name} data`);
+        }
+        return presentationOwner(data.inherits, name, seen);
+    }
+    if (!Array.isArray(data.scale?.steps) || !data.scale.steps.length
+        || !Array.isArray(data.componentOwnership?.rows) || !data.componentOwnership.rows.length
+        || !Array.isArray(data.recipes) || !data.recipes.length) {
+        throw new Error(`Grammar family ${family} has incomplete ${name} presentation data`);
+    }
+    const steps = new Map(data.scale.steps.map((step) => [step.id, step]));
+    if (steps.size !== data.scale.steps.length || data.scale.steps.some((step) => typeof step.id !== 'string'
+        || !step.id || (name === 'padding' && (remPx(step.value) === null || remPx(step.value) < 0)))) {
+        throw new Error(`Grammar family ${family} has duplicate or unusable ${name} scale steps`);
     }
-    return presentationOwner(data.inherits, name, seen);
-  }
-  if (!Array.isArray(data.scale?.steps) || !data.scale.steps.length
-    || !Array.isArray(data.componentOwnership?.rows) || !data.componentOwnership.rows.length
-    || !Array.isArray(data.recipes) || !data.recipes.length) {
-    throw new Error(`Grammar family ${family} has incomplete ${name} presentation data`);
-  }
-  const steps = new Map(data.scale.steps.map(step => [step.id, step]));
-  if (steps.size !== data.scale.steps.length || data.scale.steps.some(step => typeof step.id !== 'string'
-    || !step.id || (name === 'padding' && (remPx(step.value) === null || remPx(step.value) < 0)))) {
-    throw new Error(`Grammar family ${family} has duplicate or unusable ${name} scale steps`);
-  }
-  if (data.componentOwnership.rows.some(row => !steps.has(row.rule))) {
-    throw new Error(`Grammar family ${family} has a component ${name === 'padding' ? 'inset' : 'font rank'} without a scale value`);
-  }
-  if (data.recipes.some(recipe => typeof recipe.title !== 'string' || !recipe.title.trim())) {
-    throw new Error(`Grammar family ${family} has a ${name} recipe without its concrete title`);
-  }
-  if (name === 'font') validateFontGuidance(data);
-  return { data, source: `knowledge/grammars/${relative.split(path.sep).join('/')}#presentation.${name}` };
+    if (data.componentOwnership.rows.some((row) => !steps.has(row.rule))) {
+        throw new Error(`Grammar family ${family} has a component ${name === 'padding' ? 'inset' : 'font rank'} without a scale value`);
+    }
+    if (data.recipes.some((recipe) => typeof recipe.title !== 'string' || !recipe.title.trim())) {
+        throw new Error(`Grammar family ${family} has a ${name} recipe without its concrete title`);
+    }
+    if (name === 'font')
+        validateFontGuidance(data);
+    return { data, source: `knowledge/grammars/${relative.split(path.sep).join('/')}#presentation.${name}` };
 }
-
 /** Preserve every universal case while attaching the exact renderer recipe and its numerical owner. */
 function presentationTopic(topic, owner, name) {
-  const { data, source } = owner;
-  const recipes = new Map(data.recipes.map(recipe => [recipe.rule, recipe]));
-  const rules = topic.doc.rules ?? [];
-  if (recipes.size !== data.recipes.length || recipes.size !== rules.length) {
-    throw new Error(`Grammar ${name} recipes do not cover the universal rule identities exactly once`);
-  }
-  const attached = rules.map(rule => {
-    const recipe = recipes.get(rule.id);
-    const byCase = new Map((recipe?.cases ?? []).map(item => [item.id, item]));
-    if (!recipe || byCase.size !== recipe.cases.length || byCase.size !== (rule.cases ?? []).length) {
-      throw new Error(`Grammar ${name} recipe ${rule.id} does not cover its universal cases exactly once`);
+    const { data, source } = owner;
+    const recipes = new Map(data.recipes.map((recipe) => [recipe.rule, recipe]));
+    const rules = topic.doc.rules ?? [];
+    if (recipes.size !== data.recipes.length || recipes.size !== rules.length) {
+        throw new Error(`Grammar ${name} recipes do not cover the universal rule identities exactly once`);
     }
-    const cases = rule.cases.map(item => {
-      const concrete = byCase.get(item.id);
-      if (!concrete || typeof concrete.render !== 'string' || typeof concrete.owner !== 'string') {
-        throw new Error(`Grammar ${name} recipe ${rule.id}/${item.id} has no renderer contract`);
-      }
-      return { ...item, owner: concrete.owner, render: concrete.render, recipeSource: source };
+    const attached = rules.map((rule) => {
+        const recipe = recipes.get(rule.id);
+        const byCase = new Map((recipe?.cases ?? []).map((item) => [item.id, item]));
+        if (!recipe || byCase.size !== recipe.cases.length || byCase.size !== (rule.cases ?? []).length) {
+            throw new Error(`Grammar ${name} recipe ${rule.id} does not cover its universal cases exactly once`);
+        }
+        const cases = rule.cases.map((item) => {
+            const concrete = byCase.get(item.id);
+            if (!concrete || typeof concrete.render !== 'string' || typeof concrete.owner !== 'string') {
+                throw new Error(`Grammar ${name} recipe ${rule.id}/${item.id} has no renderer contract`);
+            }
+            return { ...item, owner: concrete.owner, render: concrete.render, recipeSource: source };
+        });
+        return { ...rule, familyTitle: recipe.title, cases };
     });
-    return { ...rule, familyTitle: recipe.title, cases };
-  });
-  const guidance = new Map((topic.doc.guidance ?? []).map(item => [item.id, item]));
-  for (const concrete of data.guidance ?? []) {
-    const semantic = guidance.get(concrete.id);
-    guidance.set(concrete.id, semantic ? { ...semantic, familyRequirement: concrete.requirement, familySource: source }
-      : { ...concrete, familySource: source });
-  }
-  return {
-    ...topic,
-    familySource: source,
-    doc: { ...topic.doc, scale: data.scale, componentOwnership: data.componentOwnership,
-      guidance: [...guidance.values()], rules: attached },
-  };
+    const guidance = new Map((topic.doc.guidance ?? []).map((item) => [item.id, item]));
+    for (const concrete of data.guidance ?? []) {
+        const semantic = guidance.get(concrete.id);
+        guidance.set(concrete.id, semantic ? { ...semantic, familyRequirement: concrete.requirement, familySource: source }
+            : { ...concrete, familySource: source });
+    }
+    return {
+        ...topic,
+        familySource: source,
+        doc: { ...topic.doc, scale: data.scale, componentOwnership: data.componentOwnership,
+            guidance: [...guidance.values()], rules: attached },
+    };
 }
-
 /**
  * Bind supported universal presentation cases to the selected family's numerical recipes without mutation.
  * Missing family data and incomplete coverage fail visibly rather than selecting another family.
@@ -139,14 +139,17 @@ function presentationTopic(topic, owner, name) {
  * @returns {{ family: string, knowledge: object[] }} Selected family and proof-ready topics with owner provenance.
  */
 export function familyPresentationKnowledge(knowledge, { family = null, repo = null } = {}) {
-  const selected = selectedFamily(family, repo);
-  const topics = knowledge.filter(topic => topic.rel.endsWith(PADDING_TOPIC));
-  if (topics.length !== 1) throw new Error('Presentation proof needs exactly one universal padding topic');
-  const decorated = new Map();
-  for (const name of TOPIC_NAMES) {
-    const matches = knowledge.filter(topic => topic.rel.endsWith(`presentation/${name}.yaml`));
-    if (matches.length > 1) throw new Error(`Presentation proof has duplicate universal ${name} topics`);
-    if (matches.length) decorated.set(matches[0], presentationTopic(matches[0], presentationOwner(selected, name), name));
-  }
-  return { family: selected, knowledge: knowledge.map(topic => decorated.get(topic) ?? topic) };
+    const selected = selectedFamily(family, repo);
+    const topics = knowledge.filter((topic) => topic.rel.endsWith(PADDING_TOPIC));
+    if (topics.length !== 1)
+        throw new Error('Presentation proof needs exactly one universal padding topic');
+    const decorated = new Map();
+    for (const name of TOPIC_NAMES) {
+        const matches = knowledge.filter((topic) => topic.rel.endsWith(`presentation/${name}.yaml`));
+        if (matches.length > 1)
+            throw new Error(`Presentation proof has duplicate universal ${name} topics`);
+        if (matches.length)
+            decorated.set(matches[0], presentationTopic(matches[0], presentationOwner(selected, name), name));
+    }
+    return { family: selected, knowledge: knowledge.map((topic) => decorated.get(topic) ?? topic) };
 }

package/runtime/scripts/hfs/linear-text.d.mts

@@ -0,0 +1,6 @@
+/** `text` without its trailing characters that are in `chars`. */
+export declare function trimTrailingChars(text: string, chars: string): string;
+/** `text` with every `<name>` placeholder (a `<`, one or more characters other than `>`, a `>`) replaced by `replacement`. */
+export declare function replacePlaceholders(text: string, replacement: string): string;
+/** Whether `text` holds a `<name>` placeholder. */
+export declare const hasPlaceholder: (text: string) => boolean;

package/runtime/scripts/hfs/linear-text.mjs

@@ -1,30 +1,30 @@
 // Linear-time text trimming and `<placeholder>` replacement for the HFS path and prose checks.
-
 /** `text` without its trailing characters that are in `chars`. */
 export function trimTrailingChars(text, chars) {
-  let last = text.length - 1;
-  while (last >= 0 && chars.includes(text[last])) last -= 1;
-  return text.slice(0, last + 1);
+    let last = text.length - 1;
+    while (last >= 0 && chars.includes(text[last]))
+        last -= 1;
+    return text.slice(0, last + 1);
 }
-
 /** `text` with every `<name>` placeholder (a `<`, one or more characters other than `>`, a `>`) replaced by `replacement`. */
 export function replacePlaceholders(text, replacement) {
-  let out = '';
-  let from = 0;
-  let open = text.indexOf('<');
-  while (open >= 0) {
-    const close = text.indexOf('>', open + 1);
-    if (close < 0) break;
-    if (close === open + 1) {
-      open = text.indexOf('<', close);
-    } else {
-      out += text.slice(from, open) + replacement;
-      from = close + 1;
-      open = text.indexOf('<', from);
+    let out = '';
+    let from = 0;
+    let open = text.indexOf('<');
+    while (open >= 0) {
+        const close = text.indexOf('>', open + 1);
+        if (close < 0)
+            break;
+        if (close === open + 1) {
+            open = text.indexOf('<', close);
+        }
+        else {
+            out += text.slice(from, open) + replacement;
+            from = close + 1;
+            open = text.indexOf('<', from);
+        }
     }
-  }
-  return out + text.slice(from);
+    return out + text.slice(from);
 }
-
 /** Whether `text` holds a `<name>` placeholder. */
 export const hasPlaceholder = (text) => replacePlaceholders(text, '') !== text;

package/runtime/scripts/hfs/manifest-shape.d.mts

@@ -0,0 +1,216 @@
+export type Parsed = any;
+export type SlotPresence = 'required' | 'optional' | 'opt-in' | 'forbidden';
+export type SlotTracking = 'tracked' | 'ignored' | 'external' | 'generated';
+export type SlotTests = 'unit-beside' | 'e2e' | 'none';
+export type SlotCoverage = 'required' | 'none';
+/** A reference to the file that exemplifies a slot: a path, or a path limited to one edition or a few. */
+export type SlotEvidenceRef = string | {
+    path: string;
+    edition?: string;
+    editions?: string[];
+};
+/** The fields a slot's `lite` overlay may hold: the same keys it would carry in the slot body, resolved under edition lite. */
+export interface SlotLiteOverlay {
+    path?: string;
+    requires?: string[];
+    allows?: string[];
+    forbids?: string[];
+    minInstances?: number;
+    requiredInstances?: Record<string, string[]>;
+    why?: string;
+}
+/** One slot of the manifest (knowledge/hfs/slots.yaml, or runtime-slots.yaml for kind runtime), as the loader validated it. */
+export interface Slot {
+    id: string;
+    profiles: string[];
+    path: string;
+    presence: SlotPresence;
+    tracked: SlotTracking;
+    tier: string;
+    tests: SlotTests;
+    owner?: boolean;
+    appKind?: string;
+    minInstances?: number;
+    requiredWhen?: string;
+    requiredInstances?: Record<string, string[]>;
+    requires?: string[];
+    pattern?: string;
+    trigger?: string;
+    allows?: string[];
+    forbids?: string[];
+    layers?: string[];
+    kinds?: string[];
+    roles?: Record<string, string>;
+    composedBy?: string[];
+    budget?: Record<string, number>;
+    managedBy?: string;
+    liteManagedBy?: string;
+    rules?: string[];
+    goesTo?: string;
+    why?: string;
+    since?: string;
+    perConnection?: string[];
+    parent?: string;
+    editions?: string[];
+    editionWhy?: string;
+    litePresence?: SlotPresence | Record<string, SlotPresence>;
+    lite?: SlotLiteOverlay;
+    provider?: string;
+    coverage?: SlotCoverage;
+    entries?: string[];
+    outcomeHome?: boolean;
+    templateNa?: string;
+    exemplifiedBy?: SlotEvidenceRef[];
+    role?: string;
+    importedBy?: string[];
+    rewrittenBy?: string;
+    logic?: string[];
+    generatedBy?: string;
+}
+/** One tier of the direction matrix of a profile. */
+export interface TierDef {
+    mayImport: string[];
+    mayImportKinds?: Record<string, {
+        from: string[];
+        to: string[];
+    }>;
+    mayImportSlots?: Record<string, {
+        from: string[];
+    }>;
+    acyclic?: boolean;
+    lowerLayerOnly?: boolean;
+}
+/** A unit-tested role of a back end (ruleParams.be.unitRoles). */
+export interface UnitRole {
+    role: string;
+    spec: string;
+    slot?: string;
+    exempt?: string[];
+}
+/** A database function an app or the canon lists (ruleParams.be.dbFunctions, hfs.json sides.be.dbFunctions). */
+export interface DbFunction {
+    name: string;
+    reason: string;
+}
+/** The rule parameters of one profile (ruleParams.common merged with ruleParams.<profile>); the keys not named here are parsed manifest data. */
+export interface RuleParams {
+    [key: string]: Parsed;
+    fileLines?: {
+        soft: number;
+        hardGrowth: boolean;
+    };
+    duplicateBlock?: {
+        lines: number;
+        tokens: number;
+    };
+    logicRoles?: string[];
+    suffixes?: string[];
+    bannedSuffixes?: string[];
+    dbFunctions?: DbFunction[];
+}
+/** ruleParams.be: the back end's own parameters, which the validators of this folder require. */
+export interface BeRuleParams extends RuleParams {
+    unitRoles: UnitRole[];
+    logicRoles: string[];
+    suffixes: string[];
+    bannedSuffixes: string[];
+}
+/** The `ruleParams` of a manifest, by profile; `common` is shared and `lite` overrides live inside each profile. */
+export interface ManifestRuleParams {
+    [profile: string]: RuleParams | undefined;
+    common: RuleParams;
+    be: BeRuleParams;
+}
+/** The parsed and validated slot manifest of loadSlotManifest, with the numeric parts of `version` added. */
+export interface SlotManifest {
+    schema: string;
+    kind?: string;
+    version: string;
+    major: number;
+    minor: number;
+    patch: number;
+    editions?: string[];
+    sides: Record<string, {
+        reads: string[];
+    }>;
+    appKinds: Record<string, string[]>;
+    triggerKinds?: string[];
+    tiers: Record<string, Record<string, TierDef>>;
+    ruleParams: ManifestRuleParams;
+    slots: Slot[];
+    consumers?: string[];
+    crossOwner?: string;
+    crossApp?: string;
+}
+export declare const SEMVER: RegExp;
+export declare const NAME: RegExp;
+/** An npm package name, scoped or not. */
+export declare const PACKAGE_NAME: RegExp;
+/** The editions an app repository may declare in hfs.json (`full` when absent): the filter slots.mjs applies. */
+export declare const EDITIONS: readonly string[];
+/** What decides where schema changes live (ruleParams.<side>.schemaAuthority): TypeORM migrations under persistence/, or the SQL migration tree db/migrations. */
+export declare const SCHEMA_AUTHORITIES: readonly string[];
+/**
+ * The shape problems of the `connections` of one side: a list of {name, envPrefix, owner, isolation}, the owner an api or worker app
+ * of the same side (a connection is a bounded context and one service owns it), isolation `database` or `schema`.
+ *
+ * @param {unknown} list - The declared connections (null when it is not an array).
+ * @param {unknown} apps - The declared apps of the same side.
+ * @returns {string[]} The problems, none when the shape is right.
+ */
+export declare function connectionShapeProblems(list: Parsed, apps: Parsed): string[];
+export declare const SLOT_ID: RegExp;
+export declare const PRESENCE: string[];
+export declare const TRACKED: string[];
+export declare const TESTS: string[];
+/** The coverage mode of a tracked slot of the be profile or of a runtime manifest (scripts/hfs/coverage-scope.mjs and scripts/hfs/runtime-coverage-scope.mjs derive the coverage consumers from it). */
+export declare const COVERAGE: string[];
+export declare const APP_KIND = "app";
+/**
+ * The unit-tested roles of a back end whose spec is required (ruleParams.be.unitRoles of the slot manifest): [{ role, spec, slot?, exempt? }].
+ * THE one list: every check that asks "is this file unit-tested, and where is its spec" asks it here. What the unit run MEASURES is
+ * logicRoles over the coverage-required slots (coverage-scope.mjs), not this list.
+ */
+export declare const unitRolesOf: (manifest: SlotManifest) => UnitRole[];
+/** The roles that carry logic (ruleParams.be.logicRoles): measured at 100 per file inside a coverage-required slot. */
+export declare const logicRolesOf: (manifest: SlotManifest) => string[];
+/** The role suffix of a file name (`passport.tokens.ts` gives `tokens`). */
+export declare const suffixOf: (file: string) => string | null;
+/**
+ * The files a slot declares as logic (`logic`, names relative to the slot path): a file that carries logic without a logic-role suffix.
+ * Each is measured at 100 per file like a logic-role file (scripts/hfs/coverage-scope.mjs), and its `<stem>.spec.ts` beside it is a
+ * legitimate unit spec its slot admits (scripts/hfs/allows.mjs, eslint-canon-be unit-test-colocated). No role name is added for it.
+ */
+export declare const declaredLogicOf: (slot: Pick<Slot, "logic"> | null | undefined) => string[];
+/** The unit spec beside a declared logic file: `passport.tokens.ts` gives `passport.tokens.spec.ts`. */
+export declare const declaredLogicSpecOf: (file: string) => string;
+/**
+ * Shape problems of a slot's `logic`: a non-empty list of unique `<name>.<part>.ts` files, each one the slot requires or allows by that
+ * exact name, on a tracked directory slot of profile be that is coverage: required and unit-beside, and (given the logic roles) none
+ * already of a logic role, which its role measures.
+ */
+export declare function slotLogicProblems(slot: Parsed, at: string, logicRoles?: readonly unknown[]): string[];
+/** Shape problems of ruleParams.be.unitRoles: unique roles of the suffix vocabulary, each spec `<role>.spec`. */
+export declare function unitRolesProblems(be: Parsed): string[];
+/** Shape problems of ruleParams.be.logicRoles, valueRoles and thinRoles: each a non-empty list of unique roles of the suffix vocabulary; every unit role is a logic role. */
+export declare function roleListProblems(be: Parsed): string[];
+/** The kind of a manifest and of a declaration that describes the StarCi runtime repository; also its one profile. */
+export declare const RUNTIME_KIND = "runtime";
+export declare const MANIFEST_KINDS: string[];
+/** The kind of a parsed manifest: `kind`, or app when absent (knowledge/hfs/slots.yaml carries none). */
+export declare const manifestKind: (m: Parsed) => string;
+export declare function slotProblems(slot: Parsed, index: number, kind: string, { appScope, scopes, logicRoles }?: {
+    appScope?: string;
+    scopes?: string[];
+    logicRoles?: readonly unknown[];
+}): string[];
+/** Shape problems of a parsed manifest of kind runtime (knowledge/hfs/runtime-slots.yaml), in the words of modules/schemas/hfs-slots.schema.yaml. */
+export declare function runtimeShapeProblems(m: Parsed): string[];
+/** A non-empty map whose every key is a name and every value satisfies `valid`. */
+export declare const namedMapValid: (map: Parsed, valid: Parsed) => boolean;
+/** Shape problems of the tier map of one profile. */
+export declare function tierMapProblems(profile: string, tiers: Parsed): string[];
+/** Kind and slot restrictions narrow allowed tier edges and name declared source and target roles. */
+export declare function tierKindProblems(manifest: SlotManifest, profile: string): string[];
+/** The semantic rules of a runtime manifest beyond the slot rules both kinds share: tier names and the schema major. */
+export declare function runtimeSemanticProblems(m: Parsed): string[];