@starci/hfs 4.4.0 → 4.4.1

package/runtime/scripts/hfs/coverage-scope.mjs

@@ -17,7 +17,7 @@ import { byCodeUnit } from '../lib/list.mjs';
 import { trimTrailingSlashes } from './trailing-slashes.mjs';
 
 /** The component that holds the shared infrastructure: the platform tier and every capability more than one service app composes. */
-export const PLATFORM_COMPONENT = 'platform';
+const PLATFORM_COMPONENT = 'platform';
 const SERVICE_APP_KINDS = new Set(['api', 'worker']);
 /** `text` with every `<placeholder>` (a `<`, at least one character, the next `>`) replaced by `*`; a `<` with no closing `>` stays. */
 export const star = (text) => {

package/runtime/scripts/hfs/example-secrets.mjs

@@ -135,7 +135,7 @@ function commandEnvironment() {
 }
 
 /** Run an installed app command in a sealed temporary copy, returning its exit code and preserving report artifacts. */
-export async function runMaterializedCommand(repoRoot, command, args = [], { run = runProgram } = {}) {
+async function runMaterializedCommand(repoRoot, command, args = [], { run = runProgram } = {}) {
   return withMaterializedExample(repoRoot, '.', (app) => {
     const launch = commandLaunch(command, args);
     const result = run(launch.file, launch.args, { cwd: app, env: commandEnvironment(), stdio: 'inherit', windowsHide: true });

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

@@ -56,8 +56,6 @@ export const unitRolesOf = (manifest) => manifest.ruleParams.be.unitRoles;
 /** The roles that carry logic (ruleParams.be.logicRoles): measured at 100 per file inside a coverage-required slot. */
 export const logicRolesOf = (manifest) => manifest.ruleParams.be.logicRoles;
 
-/** The roles a feature-tier file is judged thin by (ruleParams.be.thinRoles, R203 BE_FEATURE_THIN). */
-export const thinRolesOf = (manifest) => manifest.ruleParams.be.thinRoles;
 
 /** Shape problems of ruleParams.be.unitRoles: unique roles of the suffix vocabulary, each spec `<role>.spec`. */
 export function unitRolesProblems(be) {
@@ -86,7 +84,7 @@ export const MANIFEST_KINDS = [APP_KIND, RUNTIME_KIND];
 export const manifestKind = (m) => (isPlainObject(m) && m.kind !== undefined ? m.kind : APP_KIND);
 const strList = (v) => stringList(v);
 
-const APP_SLOT_KEYS = ['id', 'profiles', 'path', 'presence', 'tracked', 'tier', 'tests', 'owner', 'appKind', 'minInstances', 'requiredWhen', 'requiredInstances', 'requires', 'pattern', 'trigger', 'allows', 'forbids', 'layers', 'kinds', 'roles', 'composedBy', 'budget', 'managedBy', 'liteManagedBy', 'rules', 'goesTo', 'why', 'since', 'perConnection', 'parent', 'editions', 'editionWhy', 'litePresence', 'lite', 'provider', 'coverage', 'entries', 'outcomeHome', 'templateNa', 'exemplifiedBy'];
+const APP_SLOT_KEYS = ['id', 'profiles', 'path', 'presence', 'tracked', 'tier', 'tests', 'owner', 'appKind', 'minInstances', 'requiredWhen', 'requiredInstances', 'requires', 'pattern', 'trigger', 'allows', 'forbids', 'layers', 'kinds', 'roles', 'composedBy', 'budget', 'managedBy', 'liteManagedBy', 'rules', 'goesTo', 'why', 'since', 'perConnection', 'parent', 'editions', 'editionWhy', 'litePresence', 'lite', 'provider', 'coverage', 'entries', 'outcomeHome', 'templateNa', 'exampleNa', 'exemplifiedBy'];
 /** The fields a slot's `lite` overlay may hold: the same keys it would carry in the slot body, resolved under edition lite. */
 const LITE_OVERLAY_KEYS = ['path', 'requires', 'allows', 'forbids', 'minInstances', 'requiredInstances', 'why'];
 /** A runtime slot has no app kind, side composition, layer or managed template; it may name the generator of a generated copy. */
@@ -220,6 +218,8 @@ function slotCoverageEvidenceProblems(slot, at) {
   const bad = [];
   if (slot.templateNa !== undefined && !(typeof slot.templateNa === 'string' && slot.templateNa.trim()))
     bad.push(`${at}: templateNa must be non-empty text`);
+  if (slot.exampleNa !== undefined && !(typeof slot.exampleNa === 'string' && slot.exampleNa.trim()))
+    bad.push(`${at}: exampleNa must be non-empty text`);
   if (slot.exemplifiedBy === undefined) return bad;
   const refs = slot.exemplifiedBy;
   const valid = Array.isArray(refs) && refs.length > 0 && refs.every(slotEvidenceRefValid)

package/runtime/scripts/hfs/param-names.mjs

@@ -1,6 +1,6 @@
 // param-names.mjs - the one shape of `ruleParams.be.paramNames` of knowledge/hfs/slots.yaml (R85 injected-param-name): a non-empty list of unique
 // entries `{type | typeSuffix, names, nameSuffix?}`. The loader of scripts/hfs/slots.mjs calls it; the schema (modules/schemas/hfs-slots.schema.yaml)
-// states the same shape and tests/hfs/hfs-slots.spec.mjs proves the two agree.
+// states the same shape.
 import { isPlainObject } from '../../engine/plain-object.mjs';
 
 const UPPER = /^[A-Z][A-Za-z0-9]*$/u;

package/runtime/scripts/hfs/rule-catalog.mjs

@@ -16,7 +16,7 @@ const RULE_KINDS = Object.freeze(['codemod', 'lint', 'check', 'design']);
 const FINDING_CODE = /^[A-Z][A-Z0-9]*(_[A-Z0-9]+)+$/;
 const ENFORCER_ID = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
 const FILE_ENFORCERS = new Set(['machine', 'hfs', 'work-validate', 'sonar', 'runtime']);
-const RULE_KEYS = new Set(['id', 'code', 'law', 'scope', 'kinds', 'gates', 'failureCodes', 'editions', 'codeEditions', 'enforcers', 'cases', 'docs', 'exemplifiedBy', 'proves', 'witness', 'editionWhy', 'amendedBy', 'templateNa']);
+const RULE_KEYS = new Set(['id', 'code', 'law', 'scope', 'kinds', 'gates', 'failureCodes', 'editions', 'codeEditions', 'enforcers', 'cases', 'docs', 'exemplifiedBy', 'proves', 'witness', 'editionWhy', 'amendedBy', 'templateNa', 'specNa', 'exampleNa']);
 const CASE_KEYS = new Set(['id', 'date', 'source', 'ruling', 'quote', 'supersedes', 'status', 'staleWhen', 'amendedBy']);
 const CASE_DATE = /^\d{4}-\d{2}-\d{2}$/;
 const ENFORCER_KEYS = new Set(['kind', 'id', 'status', 'at', 'editions', 'editionWhy']);
@@ -279,6 +279,8 @@ function checkRule(rule, index, catalog, codeOwner, bad) {
   if (rule.amendedBy !== undefined) caseReferenceProblems(rule.amendedBy, `${label}.amendedBy`, bad);
   optionalText(rule, 'editionWhy', label, bad);
   optionalText(rule, 'templateNa', label, bad);
+  optionalText(rule, 'specNa', label, bad);
+  optionalText(rule, 'exampleNa', label, bad);
   for (const key of ['docs', 'exemplifiedBy', 'proves']) evidenceProblems(rule, key, label, bad);
   witnessProblems(rule, label, bad);
   enumListProblems(rule, label, 'kinds', RULE_KINDS, bad);

package/runtime/scripts/hfs/rules/a15-findings.mjs

@@ -41,7 +41,7 @@ export const A15_CODES = [
   // codes-end
 ];
 
-export const FINDERS = [
+const FINDERS = [
   // finders-begin
   featureFileFindings,
   lexiconFindings,

package/runtime/scripts/hfs/rules/assets.mjs

@@ -8,7 +8,7 @@ import { found } from './read.mjs';
 
 export const HFS_ASSET_OVERSIZE = 'HFS_ASSET_OVERSIZE';
 export const HFS_ASSET_KIND = 'HFS_ASSET_KIND';
-export const DEFAULT_ASSET_BYTES = 512000;
+const DEFAULT_ASSET_BYTES = 512000;
 const BUILD_EXTENSIONS = ['.ttf', '.otf', '.woff', '.woff2', '.eot', '.png', '.svg', '.webp', '.jpg', '.jpeg', '.gif', '.ico', '.avif', '.bmp', '.tif', '.tiff'];
 const MEDIA_EXTENSIONS = new Set(['.mp3', '.mp4', '.wav', '.ogg', '.oga', '.opus', '.flac', '.aac', '.m4a', '.wma', '.aiff', '.aif', '.mid', '.midi', '.mov', '.m4v', '.webm', '.avi', '.mkv', '.mpeg', '.mpg', '.wmv', '.flv', '.3gp']);
 const IMAGE_EXTENSIONS = new Set(BUILD_EXTENSIONS.filter((ext) => !['.ttf', '.otf', '.woff', '.woff2', '.eot'].includes(ext)));

package/runtime/scripts/hfs/rules/cli.mjs

@@ -10,7 +10,7 @@ import { found } from './read.mjs';
 const CLI_REQUIRED = 'BE_CLI_REQUIRED';
 
 /** The one name of the cli app, its kind, and what its image is called below it. */
-export const CLI_APP = 'cli';
+const CLI_APP = 'cli';
 const CLI_KIND = 'cli';
 const IMAGE = 'Dockerfile';
 const CLI_FEATURE_SLOT = 'be.cli';

package/runtime/scripts/hfs/rules/contract-compat.mjs

@@ -14,7 +14,7 @@ import { isPlainObject } from '../../../engine/plain-object.mjs';
 import { found, readJson } from './read.mjs';
 import { byCodeUnit } from '../../lib/list.mjs';
 
-export const CONTRACT_BREAKING = 'BE_CONTRACT_BREAKING';
+const CONTRACT_BREAKING = 'BE_CONTRACT_BREAKING';
 
 const CONTRACTS = /^be\/contracts\/([^/]+)\/events\.pin\.json$/;
 

package/runtime/scripts/hfs/rules/contract.mjs

@@ -15,7 +15,7 @@ import { safeRemove } from '../../api/fs/safe-remove.mjs';
 import { makeTempDir } from '../../api/fs/make-temp-dir.mjs';
 import { loadTypescript } from '../../lib/package-at.mjs';
 
-export const CONTRACT_SNAPSHOT_DRIFT = 'HFS_CONTRACT_SNAPSHOT_DRIFT';
+const CONTRACT_SNAPSHOT_DRIFT = 'HFS_CONTRACT_SNAPSHOT_DRIFT';
 const GRAPHQL_TRANSPORT_SLOT = 'be.transport.graphql';
 const SNAPSHOT_OF = { graphql: 'schema.graphql', json: 'openapi.json' };
 const GRAPHQL_PLATFORM = /^src\/modules\/platform\/graphql(?:\/|\.ts$|$)/;

package/runtime/scripts/hfs/rules/frontend-tree.mjs

@@ -22,7 +22,7 @@ const I18N_CATALOG = 'FE_I18N_CATALOG';
 export const DEFAULT_LOCALE = 'vi';
 const ROUTE_FILE = /\/(?:page|layout|template|loading|error|not-found)\.[jt]sx?$/;
 const LOCALE = /^[a-z]{2,3}(?:-[A-Za-z0-9]+)*$/;
-export const WIRE_SCHEMA_STAMP = '.schema-sha256';
+const WIRE_SCHEMA_STAMP = '.schema-sha256';
 
 /** Every leaf key of a parsed catalog as a dotted path. */
 function catalogKeys(value, prefix = '') {
@@ -32,7 +32,7 @@ function catalogKeys(value, prefix = '') {
 }
 
 /** Digest protocol for codegen: sorted app-relative schema path, NUL, LF-normalized source, NUL. */
-export function wireSchemaDigest(repoRoot, snapshots) {
+function wireSchemaDigest(repoRoot, snapshots) {
   const hash = createHash('sha256');
   for (const snapshot of [...snapshots].sort(byCodeUnit)) {
     let source;

package/runtime/scripts/hfs/rules/supabase-secrets.mjs

@@ -77,7 +77,7 @@ function providerSecretFindings(repoRoot, file, repo, findings) {
 }
 
 /** Raw L17 findings. The catalog-driven findings filter decides which editions judge them. */
-export function liteSecretCustodyFindings({ repoRoot, files, repo }) {
+function liteSecretCustodyFindings({ repoRoot, files, repo }) {
   const findings = [];
   for (const file of files) {
     if (custodyPathFinding(file, repo, findings)) continue;

package/runtime/scripts/hfs/runtime-rules/workflow-source.mjs

@@ -4,8 +4,8 @@ import { parseYaml } from '../../../engine/yaml.mjs';
 
 const WORKFLOW = /(?:^|\/)\.?(?:github\/)?workflows\/[^/]+\.ya?ml$/;
 
-/** The tracked workflow files of the runtime, its examples and the hfs templates (never a spec fixture under tests/). */
-const workflowFiles = (files) => files.filter((file) => WORKFLOW.test(file) && !file.startsWith('tests/'));
+/** The tracked workflow files of the runtime, its examples and the hfs templates. */
+const workflowFiles = (files) => files.filter((file) => WORKFLOW.test(file));
 
 /** The parsed workflow, or null when the text is not YAML (the other checks name that). */
 export function parseWorkflow(text) {

package/runtime/scripts/hfs/slots.mjs

@@ -5,7 +5,7 @@
 //   is this path tracked             isTracked(P) / trackingOf(P); the rule catalog (knowledge/hfs/rules.yaml, modules/schemas/hfs-rules.schema.yaml) loads through loadRuleCatalog / rules().
 // Every check and lint rule of HFS reads knowledge/hfs/slots.yaml through this module; none keeps its own path
 // list. The manifest shape is modules/schemas/hfs-slots.schema.yaml and hfs.json is modules/schemas/hfs-repo.schema.yaml;
-// the installed runtime carries no npm dependency, so this file re-states those shapes instead of loading ajv (tests/hfs/hfs-slots.spec.mjs proves the two agree).
+// the installed runtime carries no npm dependency, so this file re-states those shapes instead of loading ajv.
 //
 // A product is ONE app repository: hfs.json at the app root has kind `app` and declares its two sides, `be` and `fe`, each in
 // the folder of that name. The resolver of the app answers for the whole tree: a root path with the slots of profile `app`,
@@ -41,7 +41,7 @@ export { HfsSlotsError } from './slot-errors.mjs';
 export { loadRuleCatalog };
 export { rules } from './rule-catalog.mjs';
 export { APP_SCOPE };
-export const HFS_MANIFEST_FILE = 'knowledge/hfs/slots.yaml';
+const HFS_MANIFEST_FILE = 'knowledge/hfs/slots.yaml';
 /** The manifest of kind runtime: the standard tree of the StarCi runtime repository (judged by scripts/hfs/runtime-check.mjs). */
 export const RUNTIME_MANIFEST_FILE = 'knowledge/hfs/runtime-slots.yaml';
 export const HFS_DECLARATION_FILE = 'hfs.json';

package/runtime/scripts/hfs/typescript-programs.mjs

@@ -9,14 +9,6 @@ import { byCodeUnit } from '../lib/list.mjs';
 // builds afresh.
 const runs = new AsyncLocalStorage();
 
-/** A program run: run(fn) shares what is built inside fn; release() drops it. */
-export function typeScriptProgramRun() {
-  const values = new Map();
-  return {
-    run: fn => runs.run(values, fn),
-    release: () => values.clear(),
-  };
-}
 
 function keyOf(value) {
   if (value === undefined) return 'u';

package/runtime/scripts/lib/env.mjs

@@ -11,8 +11,8 @@ export const isSpecRun = (env = process.env) => Boolean(env.NODE_TEST_CONTEXT);
 
 /**
  * The environment for a child that is itself a test runner: `env` without the mark of an enclosing spec run. A `node --test` that inherits NODE_TEST_CONTEXT believes it is a
- * subtest of that run: it reports to its parent and exits 0 whatever its tests did, so a verb that runs specs as a child (starci test affected, the land gate, the release cut, the
- * suite) would pass red specs from inside a test process. The runner marks the spec files it starts itself, so isSpecRun stays true inside them.
+ * subtest of that run: it reports to its parent and exits 0 whatever its tests did, so a verb that runs specs as a child (the package clean-test, the scaffold e2e, the release cut)
+ * would pass red specs from inside a test process. The runner marks the spec files it starts itself, so isSpecRun stays true inside them.
  */
 export function withoutTestRunner(env = process.env) {
   const { NODE_TEST_CONTEXT: _enclosing, ...rest } = env;

package/runtime/scripts/lib/git.mjs

@@ -12,7 +12,7 @@ export const unquoteDiffPath = (value) =>
 
 // git's repository-local variables (git rev-parse --local-env-vars). A hook or alias run in a linked worktree exports
 // GIT_DIR=<main>/.git/worktrees/<wt>; a spec inheriting it pointed every fixture git at the LIVE .claude repo and re-inited
-// it core.bare=true (2026-09-29, a6f60352c). tests/setup/isolated-registry.mjs drops the same list.
+// it core.bare=true (2026-09-29, a6f60352c). e2e/setup/isolated-registry.mjs drops the same list.
 export const GIT_LOCAL_ENV_VARS = ['GIT_DIR', 'GIT_COMMON_DIR', 'GIT_WORK_TREE', 'GIT_INDEX_FILE', 'GIT_OBJECT_DIRECTORY', 'GIT_ALTERNATE_OBJECT_DIRECTORIES', 'GIT_IMPLICIT_WORK_TREE', 'GIT_PREFIX', 'GIT_CONFIG', 'GIT_CONFIG_PARAMETERS', 'GIT_CONFIG_COUNT', 'GIT_GRAFT_FILE', 'GIT_NO_REPLACE_OBJECTS', 'GIT_REPLACE_REF_BASE', 'GIT_SHALLOW_FILE', 'GIT_INTERNAL_SUPER_PREFIX'];
 /** `parent` (the caller's env) without git's repository-local variables (GIT_CONFIG_KEY_n/VALUE_n go with GIT_CONFIG_COUNT). Pure. */
 export function withoutGitLocalEnv(parent) {

package/runtime/scripts/lib/i18n.mjs

@@ -49,8 +49,6 @@ export function loadCatalog(root = skillRoot, { scope = 'runtime' } = {}) {
   return cache.get(key);
 }
 
-/** Forget the cached catalogs (a spec that rewrites a catalog file). */
-export const resetCatalogCache = () => cache.clear();
 
 /** The names each `pattern` match captures (group 1) in `text`, in match order (`sort` sorts them). */
 export const captureNames = (text, pattern, { sort = false } = {}) => {

package/runtime/scripts/lib/language.mjs

@@ -76,7 +76,7 @@ const I18N_CATALOG_DIR = 'modules/i18n/messages/';
 const OP_MANIFEST_VIETNAMESE_FIELDS = Object.freeze({ fields: Object.freeze(['vi']) });
 const OP_MANIFEST_DIR = 'modules/ops/ops/';
 /** The declared Vietnamese fields of `rel`: its own entry, or the op-manifest text field for a manifest of modules/ops/ops. */
-export const declaredVietnameseFieldsOf = (rel) => DECLARED_VIETNAMESE_FIELDS[rel]
+const declaredVietnameseFieldsOf = (rel) => DECLARED_VIETNAMESE_FIELDS[rel]
   ?? (rel.startsWith(I18N_CATALOG_DIR) && !rel.slice(I18N_CATALOG_DIR.length).includes('/') && /\.ya?ml$/.test(rel) ? I18N_CATALOG_VIETNAMESE_FIELDS : null)
   ?? (rel.startsWith(OP_MANIFEST_DIR) && !rel.slice(OP_MANIFEST_DIR.length).includes('/') && /\.ya?ml$/.test(rel) ? OP_MANIFEST_VIETNAMESE_FIELDS : null);
 

package/runtime/scripts/lib/roots.mjs

@@ -17,16 +17,14 @@
 // directory or from the Work directory name outside this module.
 import fs from 'node:fs';
 import path from 'node:path';
-import { skillRoot, runtimeStateDir, starciLocalRoot, starciSourceRoot } from '../../engine/runtime-root.mjs';
+import { skillRoot, starciLocalRoot, starciSourceRoot } from '../../engine/runtime-root.mjs';
 import { tempRoot } from '../../engine/temp-root.mjs';
 
 export { tempRoot, starciLocalRoot, starciSourceRoot };
 
 /** The runtime tree this code runs from. */
-export const runtimeTree = skillRoot;
+const runtimeTree = skillRoot;
 
-/** The state directory of a runtime tree (default: this one). */
-export const runtimeState = (tree = runtimeTree) => runtimeStateDir(tree);
 
 /** The name of the Work records directory inside a product tree. */
 export const WORK_DIR_NAME = '.starciwork';

package/scaffold/add-fe-overlay.mjs

@@ -1,122 +1 @@
-import { createRequire } from "node:module";
-import path from "node:path";
-import { ScaffoldError, pascalOf } from "./service.mjs";
-import { feName, readFeContext, readFeFile, requireNewFeOwner, planFeCatalogs, writeFePlan } from "./add-fe-page.mjs";
 
-function loadTypeScript(root) {
-  try { return createRequire(path.join(root, "package.json"))("typescript"); } catch {
-    throw new ScaffoldError("HFS_ADD_TYPESCRIPT_MISSING", "add overlay reads the host page with its installed TypeScript compiler");
-  }
-}
-
-function pageArrow(ts, source, symbol) {
-  for (const statement of source.statements) {
-    if (!ts.isVariableStatement(statement) || !statement.modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)) continue;
-    const candidate = statement.declarationList.declarations.find((declaration) => declaration.name.getText(source) === symbol);
-    if (candidate?.initializer && ts.isArrowFunction(candidate.initializer)) return candidate.initializer;
-  }
-  return null;
-}
-
-function pageRender(ts, arrow) {
-  if (!arrow) return null;
-  if (!ts.isBlock(arrow.body)) {
-    let body = arrow.body;
-    while (ts.isParenthesizedExpression(body)) body = body.expression;
-    return body;
-  }
-  const returns = arrow.body.statements.filter(ts.isReturnStatement);
-  const unconditional = arrow.body.statements.every((statement) => ts.isVariableStatement(statement) || ts.isExpressionStatement(statement) || ts.isReturnStatement(statement));
-  if (!unconditional || returns.length !== 1) return null;
-  let render = returns[0].expression;
-  while (render && ts.isParenthesizedExpression(render)) render = render.expression;
-  return render;
-}
-
-function mountOverlay({ ts, before, relative, pageSymbol, symbol }) {
-  const source = ts.createSourceFile(relative, before, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
-  const client = source.statements.some((statement) => ts.isExpressionStatement(statement) && ts.isStringLiteral(statement.expression) && statement.expression.text === "use client");
-  const render = pageRender(ts, pageArrow(ts, source, pageSymbol));
-  const isJsx = render && (ts.isJsxElement(render) || ts.isJsxSelfClosingElement(render) || ts.isJsxFragment(render));
-  if (source.parseDiagnostics.length || client || !isJsx) {
-    throw new ScaffoldError("HFS_ADD_WIRE_INVALID", `${relative} must export the server ${pageSymbol} arrow with one unconditional JSX return`);
-  }
-  if (before.split(/[^A-Za-z0-9_]/).includes(symbol)) {
-    throw new ScaffoldError("HFS_ADD_EXISTS", `${relative} already references ${symbol}`);
-  }
-  const from = render.getStart(source);
-  const wrapped = ["(", "        <>", `            ${before.slice(from, render.end)}`, `            <${symbol} />`, "        </>", "    )"].join("\n");
-  const body = before.slice(0, from) + wrapped + before.slice(render.end);
-  const imports = source.statements.filter(ts.isImportDeclaration);
-  const last = imports.at(-1)?.end ?? 0;
-  const importLine = `import { ${symbol} } from "@/features/overlays/${symbol}"`;
-  return `${body.slice(0, last)}\n${importLine}${body.slice(last)}`;
-}
-
-function overlaySources(symbol, namespace) {
-  return {
-    entry: `"use client"
-
-import { useTranslations } from "next-intl"
-import { ${symbol}Base } from "./component"
-
-/** Resolve the overlay's copy at its client interaction boundary. */
-export const ${symbol} = () => {
-    const t = useTranslations(${JSON.stringify(namespace)})
-    return <${symbol}Base props={{ title: t("title"), open: t("open"), close: t("close"), description: t("description") }} />
-}
-`,
-    component: `import { Button, Dialog, Text } from "@starci/grammar/common"
-
-/** Settled labels and content for the overlay's accessible dialog. */
-export interface ${symbol}BaseProps {
-    readonly props: {
-        readonly title: string
-        readonly open: string
-        readonly close: string
-        readonly description: string
-    }
-}
-
-/** Draw an accessible dialog with an intrinsic trigger and dismissal. */
-export const ${symbol}Base = (props: ${symbol}BaseProps) => (
-    <Dialog
-        title={props.props.title}
-        closeLabel={props.props.close}
-        trigger={<Button>{props.props.open}</Button>}
-    >
-        <Text>{props.props.description}</Text>
-    </Dialog>
-)
-`,
-  };
-}
-
-/** Add a localized client overlay and mount its public entry in a server feature page. */
-export function addFeOverlay({ root, app, name, page, messages, ts }) {
-  feName(name, "overlay name");
-  if (page === undefined) throw new ScaffoldError("HFS_ADD_OPTION_MISSING", "add overlay needs --page naming its server feature page");
-  feName(page, "host page name");
-  const context = readFeContext({ root, app });
-  const symbol = `${pascalOf(name)}Overlay`;
-  const owner = `${context.source}/features/overlays/${symbol}`;
-  requireNewFeOwner(context, owner);
-  const pageSymbol = `${pascalOf(page)}Page`;
-  const relative = `${context.source}/features/pages/${pageSymbol}/index.tsx`;
-  const before = readFeFile(context, relative);
-  const body = mountOverlay({ ts: ts ?? loadTypeScript(context.root), before, relative, pageSymbol, symbol });
-  const catalogs = planFeCatalogs(context, {
-    group: "overlays", name, messages,
-    defaults: {
-      vi: { title: "Th\u00f4ng tin", open: "M\u1edf th\u00f4ng tin", close: "\u0110\u00f3ng", description: "Xem th\u00f4ng tin c\u1ee7a trang n\u00e0y." },
-      en: { title: "Information", open: "Open information", close: "Close", description: "View information about this page." },
-    },
-  });
-  const sources = overlaySources(symbol, catalogs.namespace);
-  const created = [
-    { relative: `${owner}/index.tsx`, body: sources.entry },
-    { relative: `${owner}/component.tsx`, body: sources.component },
-  ];
-  const updates = [...catalogs.updates, { relative, before, body }];
-  return { ...writeFePlan(context, created, updates), registered: { app: context.app, overlay: symbol, page: pageSymbol } };
-}