@starci/hfs 4.0.10 → 4.2.0

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

@@ -13,18 +13,38 @@
 // and `starci app check` compares the files with this derivation. Nothing here lists a path of a product: it all comes from slots.yaml.
 import { braceVariants, globExpression } from '../lib/glob.mjs';
 import { logicRolesOf } from './manifest-shape.mjs';
+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 SERVICE_APP_KINDS = new Set(['api', 'worker']);
-const star = (text) => String(text).replace(/<[^>]+>/g, '*');
-const segments = (dir) => dir.replace(/\/+$/, '').split('/').filter(Boolean);
+/** `text` with every `<placeholder>` (a `<`, at least one character, the next `>`) replaced by `*`; a `<` with no closing `>` stays. */
+export const star = (text) => {
+  const source = String(text);
+  let result = '';
+  let copied = 0;
+  let open = source.indexOf('<');
+  while (open !== -1) {
+    const close = source.indexOf('>', open + 1);
+    if (close === -1) break;
+    if (close === open + 1) {
+      open = source.indexOf('<', close);
+      continue;
+    }
+    result += `${source.slice(copied, open)}*`;
+    copied = close + 1;
+    open = source.indexOf('<', copied);
+  }
+  return result + source.slice(copied);
+};
+export const segments = (dir, trimSlashes = false) => (trimSlashes ? trimTrailingSlashes(dir) : dir).split('/').filter(Boolean);
 const isDir = (path) => path.endsWith('/');
 
 /** True when directory pattern `inner` lies inside `outer` (an outer `*` segment matches any one inner segment) or is the same. */
-function nested(inner, outer) {
-  const a = segments(inner);
-  const b = segments(outer);
+export function nested(inner, outer) {
+  const a = segments(inner, true);
+  const b = segments(outer, true);
   return a.length >= b.length && b.every((segment, index) => segment === '*' ? true : segment === a[index]);
 }
 
@@ -37,6 +57,24 @@ const variantsOf = (slot) => braceVariants(slot.path).map(star);
  */
 const beSlots = (manifest, providers) => manifest.slots.filter((slot) => slot.profiles.includes('be') && slot.tracked === 'tracked' && (slot.provider === undefined || providers.includes(slot.provider)));
 
+function addRequiredPatterns(sonar, required, suffixes) {
+  const escapedSuffixes = suffixes.map((suffix) => suffix.replaceAll('-', String.raw`\-`)).join('|');
+  const isRole = new RegExp(String.raw`\.(?:${escapedSuffixes})\.ts$`);
+  for (const slot of required) {
+    for (const entry of [...(slot.requires ?? []), ...(slot.allows ?? [])]) {
+      addEntryPatterns(sonar, slot, entry, isRole);
+    }
+  }
+}
+
+function addEntryPatterns(sonar, slot, entry, isRole) {
+  if (!entry.endsWith('.ts') || entry.includes('<role>')) return;
+  for (const name of braceVariants(entry)) {
+    if (isRole.test(star(name).replaceAll('*', 'x'))) continue;
+    for (const dir of variantsOf(slot)) sonar.add(`be/${dir}${star(name)}`.replace(/\/\/+/g, '/'));
+  }
+}
+
 /** The directory a path pattern lives in (itself when it is one). */
 const dirOf = (path) => (isDir(path) ? path : path.slice(0, path.lastIndexOf('/') + 1));
 
@@ -64,31 +102,26 @@ export function coverageScope(manifest, providers = []) {
     if (!isDir(dir)) throw new Error(`slot ${slot.id} is coverage: required but its path ${slot.path} is not a directory`);
     return dir;
   }));
-  const roots = minimal(requiredDirs).sort();
+  const roots = minimal(requiredDirs).sort(byCodeUnit);
   const nonePaths = none.flatMap((slot) => variantsOf(slot));
   for (const dir of nonePaths.filter(isDir)) if (requiredDirs.some((other) => nested(other, dir))) throw new Error(`a coverage: none directory ${dir} contains a coverage: required slot`);
   const noneUnique = [...new Set(nonePaths)];
   const noneMinimal = noneUnique.filter((path) => !noneUnique.some((other) => other !== path && isDir(other) && nested(dirOf(path), other)));
-  const excludes = noneMinimal.filter((path) => isDir(path) && roots.some((root) => nested(path, root))).sort();
+  const excludes = noneMinimal.filter((path) => isDir(path) && roots.some((root) => nested(path, root))).sort(byCodeUnit);
   const suffixes = manifest.ruleParams.be.suffixes;
-  const isRole = new RegExp(`\\.(?:${suffixes.map((s) => s.replace(/-/g, '\\-')).join('|')})\\.ts$`);
   const sonar = new Set(noneMinimal.map((path) => `be/${path}${isDir(path) ? '**' : ''}`));
   for (const role of suffixes.filter((suffix) => !roles.includes(suffix))) sonar.add(`be/**/*.${role}.ts`);
-  for (const slot of required) {
-    for (const entry of [...(slot.requires ?? []), ...(slot.allows ?? [])]) {
-      if (!/\.ts$/.test(entry) || entry.includes('<role>')) continue;
-      for (const name of braceVariants(entry)) {
-        if (isRole.test(star(name).replace(/\*/g, 'x'))) continue;
-        for (const dir of variantsOf(slot)) sonar.add(`be/${dir}${star(name)}`.replace(/\/\/+/g, '/'));
-      }
-    }
-  }
+  addRequiredPatterns(sonar, required, suffixes);
   sonar.add('fe/**');
-  return { roles, roots, excludes, none: noneMinimal.sort(), sonar: [...sonar].sort(), codecovPaths: roots.map((root) => `be/${root}**`) };
+  noneMinimal.sort(byCodeUnit);
+  return { roles, roots, excludes, none: noneMinimal, sonar: [...sonar].sort(byCodeUnit), codecovPaths: roots.map((root) => `be/${root}**`) };
 }
 
 /** The glob a root measures: every file of a logic role below it (`src/modules/domain/*\/**\/*.{service,policy}.ts`). */
-export const rootGlob = (root, roles) => `${root}**/*.${roles.length === 1 ? roles[0] : `{${roles.join(',')}}`}.ts`;
+export const rootGlob = (root, roles) => {
+  const roleGlob = roles.length === 1 ? roles[0] : `{${roles.join(',')}}`;
+  return `${root}**/*.${roleGlob}.ts`;
+};
 
 /** The jest coverage options of the rendered be/jest.config.js: { roots, roles, excludes }. */
 export function jestCoverage(manifest, providers = []) {
@@ -107,13 +140,17 @@ export const codecovPaths = (manifest, providers = []) => coverageScope(manifest
  * (`src/modules/domain/*\/` and `src/modules/domain/order/order.service.ts` give `order`).
  */
 function capabilityOf(root, file) {
-  const parts = segments(root);
+  const parts = segments(root, true);
   const at = parts.length - 1;
   if (parts[at] !== '*') return null;
   const own = file.split('/');
   return parts.slice(0, at).every((part, index) => part === own[index]) && own.length > at + 1 ? own[at] : null;
 }
 
+function escapeImportPart(part) {
+  return part.replace(/[/.]/g, String.raw`\$&`);
+}
+
 /**
  * The Codecov components of an app, [{ id, name, paths }] (paths repository-relative from the app root): one per service app (api or worker)
  * that composes the capabilities nothing else composes, then `platform`. A capability of a root whose last segment is a placeholder
@@ -130,28 +167,37 @@ export function coverageComponents(manifest, { files, read, apps, providers = []
   const imports = new Map(services.map((app) => [app.name, files.filter((file) => file.startsWith(`apps/${app.name}/`) && /\.[cm]?ts$/.test(file)).map((file) => read(file)).join('\n')]));
   const platformPaths = [];
   const ownedBy = new Map(services.map((app) => [app.name, []]));
-  for (const root of roots) {
-    const module = /^src\/modules\/(.+)\/\*\/$/.exec(root)?.[1] ?? null;
-    const capabilities = [...new Set(files.map((file) => capabilityOf(root, file)).filter(Boolean))].sort();
-    const base = root.slice(0, -2);
-    if (module === null || module === 'platform' || !capabilities.length) {
-      platformPaths.push(`be/${root}**`);
-      continue;
-    }
-    for (const capability of capabilities) {
-      const spec = new RegExp(`from\\s+["']@modules/${module.replace(/[/.]/g, '\\$&')}/${capability.replace(/[/.]/g, '\\$&')}["']`);
-      const importers = services.filter((app) => spec.test(imports.get(app.name)));
-      const owners = importers.length === 1 ? importers : importers.filter((app) => app.name === capability);
-      if (owners.length === 1) ownedBy.get(owners[0].name).push(`be/${base}${capability}/**`);
-      else platformPaths.push(`be/${base}${capability}/**`);
-    }
-  }
+  for (const root of roots) assignRoot({ root, files, services, imports, platformPaths, ownedBy });
+  const components = services.filter((app) => ownedBy.get(app.name).length).map((app) => {
+    const paths = ownedBy.get(app.name);
+    paths.sort(byCodeUnit);
+    return { id: app.name, name: app.name, paths };
+  });
+  if (platformPaths.length) platformPaths.sort(byCodeUnit);
   return [
-    ...services.filter((app) => ownedBy.get(app.name).length).map((app) => ({ id: app.name, name: app.name, paths: ownedBy.get(app.name).sort() })),
-    ...(platformPaths.length ? [{ id: PLATFORM_COMPONENT, name: PLATFORM_COMPONENT, paths: platformPaths.sort() }] : []),
+    ...components,
+    ...(platformPaths.length ? [{ id: PLATFORM_COMPONENT, name: PLATFORM_COMPONENT, paths: platformPaths }] : []),
   ];
 }
 
+/** Puts the measured root, or each capability below it, into the platform paths or the paths of the one service app that composes it. */
+function assignRoot({ root, files, services, imports, platformPaths, ownedBy }) {
+  const module = /^src\/modules\/(.+)\/\*\/$/.exec(root)?.[1] ?? null;
+  const capabilities = [...new Set(files.map((file) => capabilityOf(root, file)).filter(Boolean))].sort(byCodeUnit);
+  const base = root.slice(0, -2);
+  if (module === null || module === 'platform' || !capabilities.length) {
+    platformPaths.push(`be/${root}**`);
+    return;
+  }
+  for (const capability of capabilities) {
+    const spec = new RegExp(String.raw`from\s+["']@modules/${escapeImportPart(module)}/${escapeImportPart(capability)}["']`);
+    const importers = services.filter((app) => spec.test(imports.get(app.name)));
+    const owners = importers.length === 1 ? importers : importers.filter((app) => app.name === capability);
+    if (owners.length === 1) ownedBy.get(owners[0].name).push(`be/${base}${capability}/**`);
+    else platformPaths.push(`be/${base}${capability}/**`);
+  }
+}
+
 /** True when the be-relative `file` is measured: it is `<name>.<role>.ts` of a logic role below a measured root and inside no none directory of it. */
 export function isMeasured(manifest, file) {
   const { roots, roles, excludes } = coverageScope(manifest);

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

@@ -3,17 +3,88 @@
 import { isPlainObject } from '../../engine/plain-object.mjs';
 import { APP_KIND, connectionShapeProblems, NAME, RUNTIME_KIND, SLOT_ID } from './manifest-shape.mjs';
 import { kindShapeProblems, patternShapeProblems } from './declaration-slots.mjs';
+import { byCodeUnit } from '../lib/list.mjs';
 
 /** Shape problems of the optional hfs.json `supabase` block whose auth posture DB_CONFIG_POLICY checks. */
+const isSupabaseStringList = (value) => Array.isArray(value) && value.every((entry) => typeof entry === 'string' && entry.trim());
+
+function supabaseValueProblems(block) {
+  const bad = [];
+  if (block.enableSignup !== undefined && typeof block.enableSignup !== 'boolean') bad.push('supabase.enableSignup must be true or false');
+  if (block.jwtExpiry !== undefined && !(Number.isInteger(block.jwtExpiry) && block.jwtExpiry > 0 && block.jwtExpiry <= 3600)) bad.push('supabase.jwtExpiry must be an integer of seconds, 3600 at most');
+  if (block.siteUrl !== undefined && (typeof block.siteUrl !== 'string' || !block.siteUrl.trim())) bad.push('supabase.siteUrl must be a URL string');
+  for (const key of ['redirectUrls', 'forceRls']) if (block[key] !== undefined && !isSupabaseStringList(block[key])) bad.push(`supabase.${key} must be a list of strings`);
+  return bad;
+}
+
 function supabaseBlockProblems(block) {
   if (block === undefined) return [];
   if (!isPlainObject(block)) return ['supabase must be an object'];
   const bad = [];
   for (const key of Object.keys(block)) if (!['enableSignup', 'jwtExpiry', 'siteUrl', 'redirectUrls', 'forceRls'].includes(key)) bad.push(`supabase has unknown key ${key}`);
-  if (block.enableSignup !== undefined && typeof block.enableSignup !== 'boolean') bad.push('supabase.enableSignup must be true or false');
-  if (block.jwtExpiry !== undefined && !(Number.isInteger(block.jwtExpiry) && block.jwtExpiry > 0 && block.jwtExpiry <= 3600)) bad.push('supabase.jwtExpiry must be an integer of seconds, 3600 at most');
-  if (block.siteUrl !== undefined && (typeof block.siteUrl !== 'string' || !block.siteUrl.trim())) bad.push('supabase.siteUrl must be a URL string');
-  for (const key of ['redirectUrls', 'forceRls']) if (block[key] !== undefined && !(Array.isArray(block[key]) && block[key].every((value) => typeof value === 'string' && value.trim()))) bad.push(`supabase.${key} must be a list of strings`);
+  bad.push(...supabaseValueProblems(block));
+  return bad;
+}
+
+function appShapeProblems(apps, at, side, names) {
+  const bad = [];
+  if (!Array.isArray(apps) || !apps.length) {
+    bad.push(`${at}.apps must list every ${side}/apps/<name> with its kind`);
+    return bad;
+  }
+  apps.forEach((app, index) => {
+    if (!isPlainObject(app) || !NAME.test(String(app.name)) || !NAME.test(String(app.kind)) || Object.keys(app).some((key) => key !== 'name' && key !== 'kind')) bad.push(`${at}.apps[${index}] must be {name, kind}`);
+    else if (names.has(app.name)) bad.push(`app ${app.name} is declared twice (${names.get(app.name)} and ${side})`);
+    else names.set(app.name, side);
+  });
+  return bad;
+}
+
+function connectionProblems(side, value) {
+  const bad = [];
+  if (side !== 'be') {
+    bad.push('connections belong to the be side');
+    return bad;
+  }
+  const list = Array.isArray(value.connections) ? value.connections : null;
+  const shape = connectionShapeProblems(list, value.apps);
+  if (shape.length) {
+    bad.push(...shape);
+    return bad;
+  }
+  if (new Set(list.map((connection) => connection.name)).size !== list.length) bad.push('connections names must be unique');
+  for (const a of list) for (const b of list) if (a !== b && `${b.envPrefix}_`.startsWith(`${a.envPrefix}_`)) bad.push(`connections ${a.name} and ${b.name} share env keys (${a.envPrefix}_ covers ${b.envPrefix}_)`);
+  return bad;
+}
+
+/** Whether a declared list is present but not a list of distinct entries that all satisfy `valid`. */
+const isBadUniqueList = (list, valid) => list !== undefined && (!Array.isArray(list) || !list.every((entry) => valid(entry)) || new Set(list).size !== list.length);
+
+function declarationSideProblems(side, value, names) {
+  const bad = [];
+  const at = `sides.${side}`;
+  if (!isPlainObject(value)) return [`${at} must be an object`];
+  for (const key of Object.keys(value)) if (!['apps', 'optionalSlots', 'patterns', 'kinds', 'connections', 'reads'].includes(key)) bad.push(`${at} has unknown key ${key}`);
+  bad.push(...appShapeProblems(value.apps, at, side, names));
+  if (isBadUniqueList(value.optionalSlots, (slot) => SLOT_ID.test(String(slot)))) bad.push(`${at}.optionalSlots must be a unique list of slot ids`);
+  bad.push(...patternShapeProblems(value, at, NAME), ...kindShapeProblems(value, at, NAME));
+  if (isBadUniqueList(value.reads, (read) => typeof read === 'string' && read.length > 0)) bad.push(`${at}.reads must be a unique list of paths`);
+  if (value.connections !== undefined) bad.push(...connectionProblems(side, value));
+  return bad;
+}
+
+const DECLARATION_KEYS = new Set(['hfs', 'kind', 'project', 'edition', 'supabase', 'sides', 'browser']);
+const RUNTIME_DECLARATION_KEYS = new Set(['hfs', 'kind', 'project']);
+
+function productDeclarationProblems(declaration, profiles) {
+  const bad = [];
+  for (const key of Object.keys(declaration)) if (!DECLARATION_KEYS.has(key)) bad.push(`unknown key ${key}`);
+  bad.push(...supabaseBlockProblems(declaration.supabase));
+  if (declaration.browser !== undefined && declaration.browser !== true) bad.push('browser is `true` when the app has a browser journey (slot app.browser), and is left out otherwise');
+  if (declaration.kind !== APP_KIND) bad.push(`kind must be ${APP_KIND} (a product is one app repository with a be and an fe side) or ${RUNTIME_KIND} (the StarCi runtime repository)`);
+  if (!isPlainObject(declaration.sides) || Object.keys(declaration.sides).sort(byCodeUnit).join() !== profiles.join()) { bad.push('sides must declare exactly be and fe'); return bad; }
+  const names = new Map();
+  for (const side of profiles) bad.push(...declarationSideProblems(side, declaration.sides[side], names));
   return bad;
 }
 
@@ -24,39 +95,9 @@ export function declarationShapeProblems(declaration, profiles) {
   if (!(Number.isInteger(declaration.hfs) && declaration.hfs >= 1)) bad.push('hfs must be the pinned manifest major (an integer, 1 or more)');
   if (!NAME.test(String(declaration.project))) bad.push('project must be a project name');
   if (declaration.kind === RUNTIME_KIND) {
-    for (const key of Object.keys(declaration)) if (!['hfs', 'kind', 'project'].includes(key)) bad.push(`unknown key ${key} (a runtime declaration is {hfs, kind, project})`);
+    for (const key of Object.keys(declaration)) if (!RUNTIME_DECLARATION_KEYS.has(key)) bad.push(`unknown key ${key} (a runtime declaration is {hfs, kind, project})`);
     return bad;
   }
-  for (const key of Object.keys(declaration)) if (!['hfs', 'kind', 'project', 'edition', 'supabase', 'sides', 'browser'].includes(key)) bad.push(`unknown key ${key}`);
-  bad.push(...supabaseBlockProblems(declaration.supabase));
-  if (declaration.browser !== undefined && declaration.browser !== true) bad.push('browser is `true` when the app has a browser journey (slot app.browser), and is left out otherwise');
-  if (declaration.kind !== APP_KIND) bad.push(`kind must be ${APP_KIND} (a product is one app repository with a be and an fe side) or ${RUNTIME_KIND} (the StarCi runtime repository)`);
-  if (!isPlainObject(declaration.sides) || Object.keys(declaration.sides).sort().join() !== profiles.join()) { bad.push('sides must declare exactly be and fe'); return bad; }
-  const names = new Map();
-  for (const side of profiles) {
-    const value = declaration.sides[side];
-    const at = `sides.${side}`;
-    if (!isPlainObject(value)) { bad.push(`${at} must be an object`); continue; }
-    for (const key of Object.keys(value)) if (!['apps', 'optionalSlots', 'patterns', 'kinds', 'connections', 'reads'].includes(key)) bad.push(`${at} has unknown key ${key}`);
-    if (!Array.isArray(value.apps) || !value.apps.length) bad.push(`${at}.apps must list every ${side}/apps/<name> with its kind`);
-    else value.apps.forEach((app, index) => {
-      if (!isPlainObject(app) || !NAME.test(String(app.name)) || !NAME.test(String(app.kind)) || Object.keys(app).some((key) => key !== 'name' && key !== 'kind')) bad.push(`${at}.apps[${index}] must be {name, kind}`);
-      else if (names.has(app.name)) bad.push(`app ${app.name} is declared twice (${names.get(app.name)} and ${side})`);
-      else names.set(app.name, side);
-    });
-    if (value.optionalSlots !== undefined && (!Array.isArray(value.optionalSlots) || !value.optionalSlots.every((slot) => SLOT_ID.test(String(slot))) || new Set(value.optionalSlots).size !== value.optionalSlots.length)) bad.push(`${at}.optionalSlots must be a unique list of slot ids`);
-    bad.push(...patternShapeProblems(value, at, NAME), ...kindShapeProblems(value, at, NAME));
-    if (value.reads !== undefined && (!Array.isArray(value.reads) || !value.reads.every((read) => typeof read === 'string' && read.length > 0) || new Set(value.reads).size !== value.reads.length)) bad.push(`${at}.reads must be a unique list of paths`);
-    if (value.connections !== undefined) {
-      if (side !== 'be') { bad.push('connections belong to the be side'); continue; }
-      const list = Array.isArray(value.connections) ? value.connections : null;
-      const shape = connectionShapeProblems(list, value.apps);
-      if (shape.length) bad.push(...shape);
-      else {
-        if (new Set(list.map((connection) => connection.name)).size !== list.length) bad.push('connections names must be unique');
-        for (const a of list) for (const b of list) if (a !== b && `${b.envPrefix}_`.startsWith(`${a.envPrefix}_`)) bad.push(`connections ${a.name} and ${b.name} share env keys (${a.envPrefix}_ covers ${b.envPrefix}_)`);
-      }
-    }
-  }
+  bad.push(...productDeclarationProblems(declaration, profiles));
   return bad;
 }

package/runtime/scripts/hfs/declaration-slots.mjs

@@ -8,7 +8,7 @@ export function optionalSlotProblems(manifest, side, s) {
   const bad = [];
   for (const id of s.optionalSlots ?? []) {
     const slot = manifest.slots.find((candidate) => candidate.id === id);
-    if (!slot || !slot.profiles.includes(side)) bad.push(`sides.${side}.optionalSlots names ${id}, which is not a ${side} slot`);
+    if (!slot?.profiles.includes(side)) bad.push(`sides.${side}.optionalSlots names ${id}, which is not a ${side} slot`);
     else if (slot.presence !== 'opt-in') bad.push(`sides.${side}.optionalSlots names ${id}, which is ${slot.presence}, not opt-in`);
     else if (slot.appKind !== undefined) bad.push(`sides.${side}.optionalSlots names ${id}; an app of kind ${slot.appKind} enables it`);
   }

package/runtime/scripts/hfs/edition-slots.mjs

@@ -20,8 +20,10 @@ export function effectiveSlot(slot, profile, edition) {
   if (edition !== 'lite') return slot;
   const { lite, litePresence, ...base } = slot;
   const presence = litePresenceOf(slot, profile);
-  const tracked = presence === 'forbidden' ? 'external' : (slot.tracked === 'external' ? 'tracked' : slot.tracked);
-  return { ...base, ...(lite ?? {}), presence, tracked, tests: 'none' };
+  let tracked = slot.tracked;
+  if (presence === 'forbidden') tracked = 'external';
+  else if (tracked === 'external') tracked = 'tracked';
+  return { ...base, ...lite, presence, tracked, tests: 'none' };
 }
 
 /** The template group starci app sync renders `slot` from under `edition`: `liteManagedBy` (else `managedBy`) in lite, `managedBy` otherwise; undefined when unmanaged. */
@@ -61,6 +63,6 @@ export function enforcerJudgedInEdition(rules, kind, id, edition = 'full') {
 export function editionRuleParams(params, edition) {
   const { lite, ...base } = params;
   const merged = edition === 'lite' && lite ? { ...base, ...lite } : base;
-  const deepFreeze = (value) => { if (value && typeof value === 'object') Object.values(value).forEach(deepFreeze); return Object.freeze(value); };
+  const deepFreeze = (value) => { if (value && typeof value === 'object') { Object.values(value).forEach(deepFreeze); } return Object.freeze(value); };
   return deepFreeze(structuredClone(merged));
 }

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

@@ -0,0 +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);
+}
+
+/** `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);
+    }
+  }
+  return out + text.slice(from);
+}
+
+/** Whether `text` holds a `<name>` placeholder. */
+export const hasPlaceholder = (text) => replacePlaceholders(text, '') !== text;