@cosyte/script-utils 0.1.2 → 0.1.4

package/catalog.js

@@ -0,0 +1,251 @@
+// @cosyte/script-utils/catalog
+//
+// THE CATALOG OF COSYTE'S LIBRARIES (ST13, ST14). One record per library, generated from that
+// library's own package.json, with the tier it belongs to; and one for Pathways, our integration
+// engine, which is in development and not on npm. The tiers and Pathways' status come from a small
+// hand-kept file in cosyte/config (`catalog/tiers.json`); everything else is read out of each
+// package.json by `scripts/catalog.mjs` there, and written beside this module as `catalog.json`.
+// A site, the org profile, a deck or a knowledgebase page reads that one list instead of keeping
+// its own roster.
+//
+// IT ALSO CARRIES THE CHECK EVERY LIBRARY RUNS. Each package.json description is that library's one
+// canonical line (ST14), so the description in a library's package.json must be the catalog's.
+// When a library changes its description, its check fails until the catalog is regenerated and a
+// script-utils release carries it: the catalog and the package cannot quietly disagree.
+//
+//   node node_modules/@cosyte/script-utils/catalog.js              # the package in this directory
+//   node node_modules/@cosyte/script-utils/catalog.js --dir <path> # another package directory
+//
+// EXIT CODES, the contract every gate here keeps: 0 the description agrees, 1 it does not, 2 the
+// check could not run (no package.json, or a package the catalog does not list).
+//
+// ZERO DEPENDENCIES AND NO BUILD STEP, like the rest of this package.
+
+import { readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+import { isCliEntrypoint } from "./index.js";
+
+/** The three tiers, in the order ST13 names them. */
+export const TIERS = Object.freeze(["standard", "built-on", "engine"]);
+
+/** Deep-freeze a parsed JSON value, so no consumer can edit the shared catalog in place. */
+function freeze(value) {
+  if (value !== null && typeof value === "object") {
+    for (const child of Object.values(value)) freeze(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+/** The catalog, as `catalog.json` beside this module carries it. */
+export const CATALOG = freeze(
+  JSON.parse(readFileSync(new URL("./catalog.json", import.meta.url), "utf8")),
+);
+
+/**
+ * The release line a version is on: `0.<minor>` below 1.0.0, where a minor may break, and the
+ * major from 1.0.0 on. `0.1.2` is the 0.1 line (ST16).
+ *
+ * @param {string} version A `major.minor.patch` version.
+ * @returns {string} The line, for example `0.1`.
+ */
+export function releaseLine(version) {
+  const match = /^(\d+)\.(\d+)\.\d+(?:[-+].*)?$/.exec(String(version));
+  if (match === null) throw new TypeError(`${JSON.stringify(version)} is not a semver version.`);
+  return match[1] === "0" ? `0.${match[2]}` : match[1];
+}
+
+/** The `https://github.com/cosyte/<repo>` a package.json's repository names, or `null`. */
+function repositoryUrl(manifest) {
+  const raw =
+    typeof manifest.repository === "string" ? manifest.repository : manifest.repository?.url;
+  if (typeof raw !== "string") return null;
+  const match = /github\.com[/:]cosyte\/([A-Za-z0-9._-]+?)(?:\.git)?\/?$/.exec(raw);
+  return match === null ? null : `https://github.com/cosyte/${match[1]}`;
+}
+
+/** The slug a `@cosyte/<slug>` name carries. */
+function slugOf(name) {
+  const match = /^@cosyte\/([a-z0-9][a-z0-9.-]*)$/.exec(String(name));
+  if (match === null)
+    throw new TypeError(`${JSON.stringify(name)} is not a @cosyte/<name> package.`);
+  return match[1];
+}
+
+/** The fields every record takes from its package.json, refusing a manifest that lacks one. */
+function fromManifest(name, manifest) {
+  if (manifest === undefined || manifest === null || typeof manifest !== "object") {
+    throw new TypeError(`no package.json was read for ${name}.`);
+  }
+  if (manifest.name !== name) {
+    throw new TypeError(
+      `the package.json read for ${name} names ${JSON.stringify(manifest.name)}.`,
+    );
+  }
+  const slug = slugOf(name);
+  const problems = [];
+  if (typeof manifest.description !== "string" || manifest.description.trim() === "") {
+    problems.push("no description");
+  }
+  if (typeof manifest.version !== "string") problems.push("no version");
+  if (typeof manifest.engines?.node !== "string") problems.push("no engines.node");
+  const repository = repositoryUrl(manifest);
+  if (repository === null) problems.push("no github.com/cosyte repository");
+  if (problems.length > 0)
+    throw new TypeError(`${name}'s package.json has ${problems.join(", ")}.`);
+  return {
+    name,
+    slug,
+    description: manifest.description,
+    line: releaseLine(manifest.version),
+    engines: { node: manifest.engines.node },
+    repository,
+    docs: `https://docs.cosyte.com/${slug}`,
+  };
+}
+
+/**
+ * Build the catalog from the hand-kept tiers file and each package's package.json. Pure: it reads
+ * nothing, so the generator decides where the manifests come from.
+ *
+ * @param {{ standards: { package: string, standard: string }[], builtOn: string[],
+ *   engine: { package: string, name: string, status: string, onNpm: boolean } }} tiers
+ * @param {Map<string, Record<string, any>> | Record<string, Record<string, any>>} manifests
+ *   Each package's parsed package.json, keyed by package name.
+ * @returns {{ libraries: object[], engine: object }} The catalog.
+ * @throws {TypeError} When a tier names a package with no usable manifest, or names one twice.
+ */
+export function buildCatalog(tiers, manifests) {
+  const get = (name) => (manifests instanceof Map ? manifests.get(name) : manifests[name]);
+  const seen = new Set();
+  const claim = (name) => {
+    if (seen.has(name)) throw new TypeError(`${name} is listed twice in the tiers.`);
+    seen.add(name);
+  };
+  const libraries = [];
+  for (const { package: name, standard } of tiers.standards) {
+    claim(name);
+    libraries.push({
+      ...fromManifest(name, get(name)),
+      npm: `https://www.npmjs.com/package/${name}`,
+      tier: "standard",
+      standard,
+    });
+  }
+  for (const name of tiers.builtOn) {
+    claim(name);
+    libraries.push({
+      ...fromManifest(name, get(name)),
+      npm: `https://www.npmjs.com/package/${name}`,
+      tier: "built-on",
+    });
+  }
+  const { package: enginePackage, name: engineName, status, onNpm } = tiers.engine;
+  claim(enginePackage);
+  const engine = {
+    ...fromManifest(enginePackage, get(enginePackage)),
+    tier: "engine",
+    displayName: engineName,
+    status,
+    onNpm,
+  };
+  return { libraries, engine };
+}
+
+/**
+ * The catalog record for a package name: a library or the engine, or `undefined`.
+ *
+ * @param {string} name A package name, for example `@cosyte/hl7`.
+ * @param {{ libraries: object[], engine: object }} [catalog] Defaults to `CATALOG`.
+ */
+export function catalogEntry(name, catalog = CATALOG) {
+  if (catalog.engine?.name === name) return catalog.engine;
+  return catalog.libraries.find((entry) => entry.name === name);
+}
+
+/**
+ * Compare a package.json with its catalog record. Only the description is compared: it is the line
+ * ST14 makes canonical, and the other generated fields move with a release (the version line) or
+ * cannot drift without the package moving (the name and repository).
+ *
+ * @param {Record<string, any>} manifest The package's parsed package.json.
+ * @param {{ libraries: object[], engine: object }} [catalog] Defaults to `CATALOG`.
+ * @returns {{ field: string, catalog: string, packageJson: string }[]} The disagreements.
+ * @throws {TypeError} When the catalog does not list the package.
+ */
+export function compareWithCatalog(manifest, catalog = CATALOG) {
+  const entry = catalogEntry(manifest?.name, catalog);
+  if (entry === undefined) {
+    throw new TypeError(`the catalog does not list ${JSON.stringify(manifest?.name ?? null)}.`);
+  }
+  if (manifest.description === entry.description) return [];
+  return [
+    {
+      field: "description",
+      catalog: entry.description,
+      packageJson: String(manifest.description ?? ""),
+    },
+  ];
+}
+
+/**
+ * Run the check over one package directory and return the exit code. It never exits the process.
+ *
+ * @param {{ dir?: string, argv?: string[] }} [options] `dir` is the package directory (default:
+ *   the working directory). `argv` is the CLI arguments, read only for `--dir <path>`.
+ * @returns {0 | 1 | 2} 0 agree, 1 disagree, 2 the check could not run.
+ */
+export function runCatalogCheck(options = {}) {
+  let dir = options.dir ?? process.cwd();
+  const argv = options.argv ?? [];
+  for (let i = 0; i < argv.length; i += 1) {
+    if (argv[i] === "--dir" && typeof argv[i + 1] === "string") {
+      dir = argv[i + 1];
+      i += 1;
+    } else if (argv[i] !== "--") {
+      process.stderr.write(
+        `catalog check: ${JSON.stringify(argv[i])} is not an argument this check accepts (only ` +
+          `--dir <package directory>). Nothing was checked.\n`,
+      );
+      return 2;
+    }
+  }
+  dir = resolve(dir);
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+  } catch (err) {
+    process.stderr.write(`catalog check: could not read package.json in ${dir}: ${err.message}\n`);
+    return 2;
+  }
+  let differences;
+  try {
+    differences = compareWithCatalog(manifest);
+  } catch (err) {
+    process.stderr.write(`catalog check: ${err.message} Nothing was checked.\n`);
+    return 2;
+  }
+  if (differences.length === 0) {
+    process.stdout.write(`catalog check: ${manifest.name}'s description is the catalog's.\n`);
+    return 0;
+  }
+  const report = differences
+    .map(
+      (d) =>
+        `  ${d.field}\n    package.json: ${JSON.stringify(d.packageJson)}\n` +
+        `    catalog:      ${JSON.stringify(d.catalog)}`,
+    )
+    .join("\n");
+  process.stderr.write(
+    `catalog check: ${manifest.name}'s package.json and the catalog disagree.\n${report}\n` +
+      `The catalog is generated from package.json in cosyte/config (scripts/catalog.mjs) and ` +
+      `ships in @cosyte/script-utils. Change both together: regenerate the catalog, release ` +
+      `script-utils, then move this package to that release.\n`,
+  );
+  return 1;
+}
+
+if (isCliEntrypoint(import.meta.url)) {
+  process.exitCode = runCatalogCheck({ argv: process.argv.slice(2) });
+}

package/catalog.json

@@ -0,0 +1,210 @@
+{
+  "$comment": "GENERATED by cosyte/config scripts/catalog.mjs from each package's package.json and catalog/tiers.json. Do not edit by hand: change the package.json or the tiers file, then run `node scripts/catalog.mjs write` from the umbrella.",
+  "libraries": [
+    {
+      "name": "@cosyte/hl7",
+      "slug": "hl7",
+      "description": "Developer-focused HL7 v2 toolkit for Node.js and TypeScript, message parsing and building, mutation and serialization, and one-line helpers.",
+      "line": "0.1",
+      "engines": {
+        "node": ">=22.0.0"
+      },
+      "repository": "https://github.com/cosyte/hl7",
+      "docs": "https://docs.cosyte.com/hl7",
+      "npm": "https://www.npmjs.com/package/@cosyte/hl7",
+      "tier": "standard",
+      "standard": "HL7 v2"
+    },
+    {
+      "name": "@cosyte/mllp",
+      "slug": "mllp",
+      "description": "MLLP transport for HL7 v2 in Node.js and TypeScript: client and server, framing, ACK correlation, auto-reconnect, TLS, and an in-memory transport for tests.",
+      "line": "0.1",
+      "engines": {
+        "node": ">=22.0.0"
+      },
+      "repository": "https://github.com/cosyte/mllp",
+      "docs": "https://docs.cosyte.com/mllp",
+      "npm": "https://www.npmjs.com/package/@cosyte/mllp",
+      "tier": "standard",
+      "standard": "MLLP"
+    },
+    {
+      "name": "@cosyte/fhir",
+      "slug": "fhir",
+      "description": "FHIR R4 for Node.js and TypeScript: a resource model that keeps every value exactly as written, JSON and XML codecs, layered validation, and a safety readout for status and negation.",
+      "line": "0.1",
+      "engines": {
+        "node": ">=22.0.0"
+      },
+      "repository": "https://github.com/cosyte/fhir",
+      "docs": "https://docs.cosyte.com/fhir",
+      "npm": "https://www.npmjs.com/package/@cosyte/fhir",
+      "tier": "standard",
+      "standard": "FHIR"
+    },
+    {
+      "name": "@cosyte/ccda",
+      "slug": "ccda",
+      "description": "C-CDA parser, serializer, and builder for Node.js and TypeScript: lenient on parse, spec-clean on emit.",
+      "line": "0.1",
+      "engines": {
+        "node": ">=22.0.0"
+      },
+      "repository": "https://github.com/cosyte/ccda",
+      "docs": "https://docs.cosyte.com/ccda",
+      "npm": "https://www.npmjs.com/package/@cosyte/ccda",
+      "tier": "standard",
+      "standard": "C-CDA"
+    },
+    {
+      "name": "@cosyte/x12",
+      "slug": "x12",
+      "description": "Developer-focused ASC X12 healthcare EDI parser, serializer, and builder for Node.js and TypeScript: lenient on parse, spec-clean on emit.",
+      "line": "0.1",
+      "engines": {
+        "node": ">=22.0.0"
+      },
+      "repository": "https://github.com/cosyte/x12",
+      "docs": "https://docs.cosyte.com/x12",
+      "npm": "https://www.npmjs.com/package/@cosyte/x12",
+      "tier": "standard",
+      "standard": "X12"
+    },
+    {
+      "name": "@cosyte/ncpdp",
+      "slug": "ncpdp",
+      "description": "NCPDP parser, serializer, and builder for Node.js and TypeScript: SCRIPT ePrescribing and Telecom pharmacy claims, lenient on parse, spec-clean on emit.",
+      "line": "0.1",
+      "engines": {
+        "node": ">=22.0.0"
+      },
+      "repository": "https://github.com/cosyte/ncpdp",
+      "docs": "https://docs.cosyte.com/ncpdp",
+      "npm": "https://www.npmjs.com/package/@cosyte/ncpdp",
+      "tier": "standard",
+      "standard": "NCPDP"
+    },
+    {
+      "name": "@cosyte/astm",
+      "slug": "astm",
+      "description": "ASTM parser, serializer, and builder for Node.js and TypeScript: lenient on parse, spec-clean on emit.",
+      "line": "0.1",
+      "engines": {
+        "node": ">=22.0.0"
+      },
+      "repository": "https://github.com/cosyte/astm",
+      "docs": "https://docs.cosyte.com/astm",
+      "npm": "https://www.npmjs.com/package/@cosyte/astm",
+      "tier": "standard",
+      "standard": "ASTM"
+    },
+    {
+      "name": "@cosyte/dicom",
+      "slug": "dicom",
+      "description": "DICOM Part 10 parser + utility library for Node.js and TypeScript: metadata-first, vendor-quirky-tolerant, dual ESM/CJS.",
+      "line": "0.1",
+      "engines": {
+        "node": ">=22.0.0"
+      },
+      "repository": "https://github.com/cosyte/dicom",
+      "docs": "https://docs.cosyte.com/dicom",
+      "npm": "https://www.npmjs.com/package/@cosyte/dicom",
+      "tier": "standard",
+      "standard": "DICOM"
+    },
+    {
+      "name": "@cosyte/terminology",
+      "slug": "terminology",
+      "description": "Terminology engine for US healthcare code systems in Node.js and TypeScript: FHIR $translate, $lookup, $validate-code and $expand over code systems, value sets and maps you supply.",
+      "line": "0.1",
+      "engines": {
+        "node": ">=22.0.0"
+      },
+      "repository": "https://github.com/cosyte/terminology",
+      "docs": "https://docs.cosyte.com/terminology",
+      "npm": "https://www.npmjs.com/package/@cosyte/terminology",
+      "tier": "built-on"
+    },
+    {
+      "name": "@cosyte/transform",
+      "slug": "transform",
+      "description": "HL7 v2 → FHIR R4 transformation library for Node.js and TypeScript: IG-grounded, fail-safe, value-free diagnostics; never a confident wrong FHIR value.",
+      "line": "0.1",
+      "engines": {
+        "node": ">=22.0.0"
+      },
+      "repository": "https://github.com/cosyte/transform",
+      "docs": "https://docs.cosyte.com/transform",
+      "npm": "https://www.npmjs.com/package/@cosyte/transform",
+      "tier": "built-on"
+    },
+    {
+      "name": "@cosyte/deid",
+      "slug": "deid",
+      "description": "Healthcare de-identification for Node.js and TypeScript: applies a HIPAA Safe Harbor policy to HL7 v2, C-CDA, FHIR R4, X12, NCPDP Telecom and DICOM, fails closed, and emits a value-free manifest.",
+      "line": "0.1",
+      "engines": {
+        "node": ">=22.0.0"
+      },
+      "repository": "https://github.com/cosyte/deid",
+      "docs": "https://docs.cosyte.com/deid",
+      "npm": "https://www.npmjs.com/package/@cosyte/deid",
+      "tier": "built-on"
+    },
+    {
+      "name": "@cosyte/synth",
+      "slug": "synth",
+      "description": "Deterministic, seedable synthetic healthcare test fixtures for Node.js and TypeScript: HL7 v2, FHIR R4 and US Core, C-CDA, X12, NCPDP and ASTM, spec-clean by construction and never real PHI.",
+      "line": "0.1",
+      "engines": {
+        "node": ">=22.0.0"
+      },
+      "repository": "https://github.com/cosyte/synth",
+      "docs": "https://docs.cosyte.com/synth",
+      "npm": "https://www.npmjs.com/package/@cosyte/synth",
+      "tier": "built-on"
+    },
+    {
+      "name": "@cosyte/dates",
+      "slug": "dates",
+      "description": "Date and time utilities for the @cosyte/* healthcare parsers: precision-preserving conversion and validation that never guesses a timezone.",
+      "line": "0.1",
+      "engines": {
+        "node": ">=22.0.0"
+      },
+      "repository": "https://github.com/cosyte/dates",
+      "docs": "https://docs.cosyte.com/dates",
+      "npm": "https://www.npmjs.com/package/@cosyte/dates",
+      "tier": "built-on"
+    },
+    {
+      "name": "@cosyte/cli",
+      "slug": "cli",
+      "description": "The cosyte CLI: a PHI-safe developer front door over the @cosyte/* healthcare parsers. Parse HL7 v2 / FHIR from a file or stdin to typed JSON, with a documented exit-code contract.",
+      "line": "0.1",
+      "engines": {
+        "node": ">=22.0.0 <26.0.0"
+      },
+      "repository": "https://github.com/cosyte/cli",
+      "docs": "https://docs.cosyte.com/cli",
+      "npm": "https://www.npmjs.com/package/@cosyte/cli",
+      "tier": "built-on"
+    }
+  ],
+  "engine": {
+    "name": "@cosyte/pathways",
+    "slug": "pathways",
+    "description": "A code-first healthcare integration engine for Node.js: channels in YAML, transforms in TypeScript. Early and not yet released.",
+    "line": "0.0",
+    "engines": {
+      "node": ">=24.0.0"
+    },
+    "repository": "https://github.com/cosyte/pathways",
+    "docs": "https://docs.cosyte.com/pathways",
+    "tier": "engine",
+    "displayName": "Pathways",
+    "status": "in development",
+    "onNpm": false
+  }
+}

package/check-no-emdash.sh

@@ -228,19 +228,32 @@ unset -f grep xargs sed awk 2>/dev/null || true
 # refuse_if_incomplete reads. That branch only refines wording, never the red.
 export LC_ALL=C.UTF-8
 
-# Matches U+2014 as the literal character and as its encodings: %E2%80%94 (URL), the
-# JS backslash-u escape, and the — / — / — HTML entities. The
-# escape is not theoretical in this repo: it is what the parser-template manifest
-# carried, and a literal-only sweep passed straight over it. Matches U+2013 the same
-# way: %E2%80%93, the backslash-u escape, and the – / – / – HTML
-# entities.
-#
-# THE MATCH VOCABULARY IS FROZEN at these twelve forms, six for each dash. A consumer
-# may narrow WHAT IS SCANNED through the declaration above; nothing may narrow WHAT IS
-# MATCHED, and widening it is a change every consuming repo inherits at once and is
-# specced as one. The en dash's six were that change (operator decision, 2026-11-07).
-PATTERN='\x{2014}|%E2%80%94|\\u2014|—|—|—'
-PATTERN+='|\x{2013}|%E2%80%93|\\u2013|–|–|–'
+# What counts as a dash, for U+2014 and U+2013 alike. Case never matters, so `—`
+# and `%e2%80%94` count too (D56: the forms the marketing and consulting scanner caught,
+# which this gate now matches so those repos lose nothing by moving to it):
+#
+#   the characters                       U+2014 U+2013
+#   HTML named entities, ; optional      — –
+#   HTML decimal references              — –    leading zeros and a missing ; too
+#   HTML hex references                  — –  leading zeros and a missing ; too
+#   URL encoding of the UTF-8 bytes      %E2%80%94 %E2%80%93
+#   backslash-u escapes (JS, JSON, Java, \u2014 \u{2014} \U00002014
+#     C#, Python, Rust, Swift)
+#   backslash-x escapes (PCRE, Perl)     \x{2014}
+#   CSS escapes                          \2014 \002014
+#   Unicode names (Python, Perl)         \N{EM DASH} \N{EN DASH}
+#
+# The lookaheads keep the near misses out: 𔃈 and the CSS escape \20140 name other
+# characters, and &mdashboard is not an entity. The escape forms are not theoretical: the
+# parser-template manifest once carried a backslash-u em dash, and a literal-only sweep
+# passed straight over it.
+#
+# A consumer may narrow WHAT IS SCANNED through the declaration above; nothing may narrow
+# WHAT IS MATCHED, and widening it is a change every consuming repo inherits at once. The
+# en dash's forms (operator decision, 2026-11-07) and these (D56) were such changes.
+PATTERN='(?i)\x{2014}|\x{2013}|&[mn]dash(?![a-z])|&#0*821[12](?![0-9])|&#x0*201[34](?![0-9a-f])'
+PATTERN+='|%E2%80%9[34]|\\u(?:0000)?201[34]|\\u\{0*201[34]\}|\\x\{0*201[34]\}'
+PATTERN+='|\\0{0,2}201[34](?![0-9a-f])|\\N\{E[MN] DASH\}'
 
 # The declaration's path, relative to the top level of the repo under scan. Deliberately
 # NOT relative to this file: in a consuming repo this file lives under `node_modules/`
@@ -281,10 +294,11 @@ SCAN_MODE=files
 
 refuse_arguments() {
   echo "ERROR: check-no-emdash - $1" >&2
-  echo "       The modes are: (no argument) to scan every tracked file; --stdin LABEL" >&2
-  echo "       to scan the text arriving on stdin; --list-scanned to write the paths the" >&2
-  echo "       default scan reads; --self-id to write the sha256 of the implementation" >&2
-  echo "       that is executing. Refusing to run rather than guess which was meant." >&2
+  echo "       The modes are: (no argument) to scan every tracked file and its name;" >&2
+  echo "       --stdin LABEL to scan the text arriving on stdin; --list-scanned to write the" >&2
+  echo "       paths the default scan reads; --self-id to write the sha256 of the" >&2
+  echo "       implementation that is executing; --help for this. Refusing to run rather" >&2
+  echo "       than guess which was meant." >&2
   exit 1
 }
 
@@ -324,6 +338,22 @@ case "${1:-}" in
       refuse_arguments "--self-id takes no further argument, and this was given: ${2}"
     fi
     ;;
+  --help | -h)
+    cat << 'USAGE'
+check-no-emdash: refuse the em dash (U+2014) and the en dash (U+2013), as the characters and
+in every encoded form, in the tracked files of the repository it runs in and in their names.
+
+  check-no-emdash.sh                 scan every tracked file and every tracked file name
+  check-no-emdash.sh --stdin LABEL   scan the text on stdin (a PR title, body, commit message)
+  check-no-emdash.sh --list-scanned  write the NUL-separated paths the default scan reads
+  check-no-emdash.sh --self-id       write the sha256 of the implementation that is executing
+
+A repository leaves paths out in scripts/check-no-emdash.exclude: one per line, an entry ending
+in / covers everything beneath it, # starts a comment. Exit 0 means the mode completed and found
+nothing banned; exit 1 means anything else.
+USAGE
+    exit 0
+    ;;
   *)
     refuse_arguments "unrecognised argument: ${1}"
     ;;
@@ -341,6 +371,7 @@ GITERR=$(mktemp)
 FILELIST=$(mktemp)
 SCANLIST=$(mktemp)
 PLAINLIST=$(mktemp)
+NAMELIST=$(mktemp)
 STDINBUF=$(mktemp)
 BINPROBE=$(mktemp)
 PROBEERR=$(mktemp)
@@ -353,8 +384,8 @@ PROBEERR=$(mktemp)
 # not lost with it.
 close_exit_vocabulary() {
   local code=$?
-  rm -f "$ERRLOG" "$GITERR" "$FILELIST" "$SCANLIST" "$PLAINLIST" "$STDINBUF" "$BINPROBE" \
-    "$PROBEERR"
+  rm -f "$ERRLOG" "$GITERR" "$FILELIST" "$SCANLIST" "$PLAINLIST" "$NAMELIST" "$STDINBUF" \
+    "$BINPROBE" "$PROBEERR"
   if [ "$code" -ne 0 ] && [ "$code" -ne 1 ]; then
     echo "ERROR: check-no-emdash - the run ended with status ${code}. This gate reports 0" >&2
     echo "       for a mode that completed clean and 1 for everything else, so it is" >&2
@@ -816,6 +847,7 @@ esac
 
 : > "$SCANLIST"
 : > "$PLAINLIST"
+: > "$NAMELIST"
 gitlinks=0
 scanned=0
 self_excluded=0
@@ -831,11 +863,16 @@ for i in "${!TRACKED[@]}"; do
 
   # What the repo declared it leaves out. Checked before the entry is opened, because an
   # excluded path is not read and its type on disk is therefore not this gate's business.
+  # It is not scanned at all, so its NAME is left out with its content.
   if is_excluded "$f"; then
     declared_excluded=$((declared_excluded + 1))
     continue
   fi
 
+  # A NAME IS COPY TOO (D56): every tracked path the declaration does not leave out has its
+  # name scanned, a gitlink's included, before any test of what is on disk.
+  printf '%s\0' "$f" >> "$NAMELIST"
+
   # `git ls-files` lists a submodule as a gitlink, which on disk is a REAL directory.
   # config has none today (checked: `git ls-files -s` lists no mode 160000 entry). The
   # skip is keyed on the INDEX MODE and never on the type on disk, because the two
@@ -886,12 +923,22 @@ if [ "$MODE" = list ]; then
   exit 0
 fi
 
+# File names first: NUL-separated in, one per line out. `-a` because a name is text whatever
+# bytes it holds, and the stderr capture refuses a name scan that could not complete.
+NAME_HITS=$(grep -z -a -P -e "$PATTERN" < "$NAMELIST" 2>> "$ERRLOG" | tr '\0' '\n' || true)
+refuse_if_incomplete
+
 HITS=$(xargs -0 -r grep -H -nP -e "$PATTERN" -- < "$SCANLIST" 2>> "$ERRLOG" || true)
 
 refuse_if_incomplete
 
+if [ -n "$NAME_HITS" ] && [ -n "$HITS" ]; then
+  fail_with_hits "the tracked file names and the tracked files listed above" \
+    "$NAME_HITS"$'\n'"$HITS"
+fi
+[ -n "$NAME_HITS" ] && fail_with_hits "the tracked file names listed above" "$NAME_HITS"
 [ -n "$HITS" ] && fail_with_hits "the tracked files listed above" "$HITS"
 
-echo "check-no-emdash: OK (no em or en dashes in ${scanned} of ${#TRACKED[@]} tracked file(s);" \
-  "${gitlinks} gitlink(s) skipped, ${self_excluded} excluded as the implementation under" \
-  "scan, ${declared_excluded} excluded by ${DECLARATION})"
+echo "check-no-emdash: OK (no em or en dashes in ${scanned} of ${#TRACKED[@]} tracked file(s)" \
+  "or their names; ${gitlinks} gitlink(s) skipped, ${self_excluded} excluded as the" \
+  "implementation under scan, ${declared_excluded} excluded by ${DECLARATION})"