@cosyte/terminology 0.0.11 → 0.0.12

package/dist/index.d.cts

@@ -5,15 +5,15 @@
  * These mirror the FHIR R4 datatypes of the same names (the interchange lingua franca the whole
  * ecosystem speaks), reduced to the fields the terminology operations need. Every instance the
  * engine hands back is deep-frozen, so a translated result is safe to share across a pipeline
- * without defensive copying — the immutability discipline the parsers follow.
+ * without defensive copying: the immutability discipline the parsers follow.
  *
  * @packageDocumentation
  */
 /**
- * A single coded value — a `code` drawn from a code `system`, optionally versioned and displayed.
+ * A single coded value: a `code` drawn from a code `system`, optionally versioned and displayed.
  *
  * Models FHIR R4 `Coding`. `system` is the code system's **canonical URI** (e.g.
- * `http://loinc.org`), not a mnemonic or OID — use {@link ../systems/resolve.resolveSystem} to
+ * `http://loinc.org`), not a mnemonic or OID: use {@link ../systems/resolve.resolveSystem} to
  * canonicalize before constructing one. `system` is optional because a raw wire code sometimes
  * arrives without one; the engine surfaces that rather than inventing a system.
  *
@@ -28,7 +28,7 @@
 interface Coding {
     /** The code system's canonical URI (e.g. `http://snomed.info/sct`). Optional when unknown. */
     readonly system?: string;
-    /** The symbol in the code system's syntax. Required — a coding without a code is meaningless. */
+    /** The symbol in the code system's syntax. Required: a coding without a code is meaningless. */
     readonly code: string;
     /** The code system version this code is drawn from, when known (mappings are release-scoped). */
     readonly version?: string;
@@ -36,7 +36,7 @@ interface Coding {
     readonly display?: string;
 }
 /**
- * A concept described by one or more {@link Coding}s plus optional free text — FHIR R4
+ * A concept described by one or more {@link Coding}s plus optional free text: FHIR R4
  * `CodeableConcept`. Included so the value layer is complete for downstream consumers even though
  * {@link ../conceptmap/translate.translate} operates on a single {@link Coding}.
  *
@@ -60,7 +60,7 @@ interface CodeableConcept {
 /**
  * Construct a deep-frozen {@link Coding}.
  *
- * The returned object is `Object.freeze`d so it cannot be mutated in place — parsed/translated
+ * The returned object is `Object.freeze`d so it cannot be mutated in place: parsed/translated
  * values are immutable by default. Optional fields are only present when supplied (no `undefined`
  * keys), so structural equality checks stay clean.
  *
@@ -96,14 +96,14 @@ declare function codeableConcept(init: CodeableConcept): CodeableConcept;
  * `@cosyte/terminology` is an engine, not a lenient wire-format parser, so its stable codes are
  * **diagnostics** (typed, surfaced outcomes a consumer branches on) and **fatals** (thrown on
  * structurally unusable input), rather than the parsers' "Tier-2 tolerance warnings". The
- * discipline is identical: the code strings are part of the public contract — consumers narrow on
+ * discipline is identical: the code strings are part of the public contract, consumers narrow on
  * them, so renaming or removing one is a **breaking change**, and the full set is snapshotted via
  * `sortedCodeSet` (`@cosyte/test-utils`) as a reviewable tripwire.
  *
  * **Value-free by construction**, and the property is stated as what it actually is: every string a
  * diagnostic or fatal message is assembled from is **owned by the engine**. Three kinds, and no
  * fourth: a string literal; an entry in a frozen table keyed on the engine's own vocabulary; and a
- * **locus this package built** — a 1-based `line`, a column count, or an index path over the
+ * **locus this package built**: a 1-based `line`, a column count, or an index path over the
  * caller's own resource made of integers and FHIR field names (`ConceptMap group[0].element[0].target[0]`,
  * `compose.include[2]`). Nothing a caller configured and nothing their release or resource contained
  * is ever one of them, so no such string reaches a `message`, a `stack`, or a `detail`, at any
@@ -112,16 +112,16 @@ declare function codeableConcept(init: CodeableConcept): CodeableConcept;
  * Read that as the rule, and note what it does **not** say. It does not say no factory takes a
  * `string` parameter. Several do: `malformed(path, fault)` in `conceptmap/load.ts` and
  * `valueset/load.ts`, and `cannotExpand(detail, path)`, `truncated(detail, path)` and
- * `underPath(d, prefix)` in `valueset/` — where `expand.ts` and `validate.ts` each carry their own
+ * `underPath(d, prefix)` in `valueset/`, where `expand.ts` and `validate.ts` each carry their own
  * copy. It says every **argument** reaching them is engine-owned: each `fault` and `detail` is a
  * literal at the call site, each `path` and `prefix` is built from indices by the loader that
- * raises it. That distinction is the thing to preserve — an absolute "no factory takes a value
+ * raises it. That distinction is the thing to preserve: an absolute "no factory takes a value
  * parameter" reads as a stronger guarantee than the one the code makes, and those factories are the
  * counter-example to it. Do not write the count down; derive it.
  *
  * Positional context is value-free the same way: a `line` integer, an `ExpansionDiagnostic.path`
  * index path into the caller's own resource (`compose.include[2]`), or a closed-set token
- * (`RXNCONSO` / `RXNREL` / `RXNSAT`) — never a URI, a column name, or a field the file supplied.
+ * (`RXNCONSO` / `RXNREL` / `RXNSAT`): never a URI, a column name, or a field the file supplied.
  * This matters because a code *in patient context* can be PHI, and a thrown error is the one surface
  * that reaches a log or an error reporter without the consumer choosing to put it there.
  *
@@ -134,20 +134,20 @@ declare function codeableConcept(init: CodeableConcept): CodeableConcept;
  * The **objects** these codes appear on are a different matter, and they carry verbatim text from
  * two *different* provenances, which decide differently:
  *
- * - **Your query, echoed back** — `LookupUnknown.input`, `LookupResult.code`, `UnknownSystem.input`,
+ * - **Your query, echoed back**: `LookupUnknown.input`, `LookupResult.code`, `UnknownSystem.input`,
  *   `TranslateUnmapped.source`, `CrosswalkUnmapped.source`, `CrosswalkNoMap.source`,
  *   `RxNormUnknown.rxcui`, `RxNormRelated.predicates`, `NdcUnmapped.ndc`,
- *   `ValueSetMembership.coding`, and **`MapProvenance.sourceSystem`** — which is the `system` off
+ *   `ValueSetMembership.coding`, and **`MapProvenance.sourceSystem`**, which is the `system` off
  *   the `Coding` you passed to `translate`, verbatim and unbounded, whenever that coding
  *   carries one; the map's own `group.source` is only the fallback for a coding that does not. The
  *   query is the one genuinely **patient-derived** input this engine takes (a code off a parsed
  *   message, a unit off an observation, an NDC off a prescription), so this is the class that
  *   decides a PHI question.
- * - **Your loaded artifact, carried through** — `ComplexMapContextRequired.rules` (the map
+ * - **Your loaded artifact, carried through**: `ComplexMapContextRequired.rules` (the map
  *   document's own `rule` / `advice` text) and `MapProvenance.targetSystem` / `.conceptMapUrl` /
  *   `.conceptMapVersion`, which are read off the loaded map (`group.target`, `map.url`,
  *   `map.version`). These are *reference data*, bounded by the map or release you loaded, not by
- *   anything a patient supplied. **`MapProvenance` straddles the two lists** — do not read the whole
+ *   anything a patient supplied. **`MapProvenance` straddles the two lists**: do not read the whole
  *   record as reference data on the strength of the fields that are.
  *
  * Read both lists as illustrative, not closed: **assume any result field may hold what you passed
@@ -161,7 +161,7 @@ declare function codeableConcept(init: CodeableConcept): CodeableConcept;
  * @packageDocumentation
  */
 /**
- * Stable **diagnostic codes** — typed, surfaced, non-throwing outcomes.
+ * Stable **diagnostic codes**: typed, surfaced, non-throwing outcomes.
  *
  * These are not errors: they are first-class results a caller inspects (an unmapped translation,
  * an unrecognized code system). `key === value` so `Object.values(...)` yields the snapshot set.
@@ -175,7 +175,7 @@ declare function codeableConcept(init: CodeableConcept): CodeableConcept;
  */
 declare const DIAGNOSTIC_CODES: {
     /**
-     * A `$translate` found no target for the source code. A **first-class outcome, never an error** —
+     * A `$translate` found no target for the source code. A **first-class outcome, never an error**:
      * the source is surfaced as `unmapped`, never replaced with a guessed target (the never-fabricate
      * invariant).
      */
@@ -186,30 +186,30 @@ declare const DIAGNOSTIC_CODES: {
      */
     readonly TERM_SYSTEM_UNRECOGNIZED: "TERM_SYSTEM_UNRECOGNIZED";
     /**
-     * An RRF (pipe-delimited RxNorm/UMLS release) row was structurally unusable — too few columns to
+     * An RRF (pipe-delimited RxNorm/UMLS release) row was structurally unusable: too few columns to
      * reach a configured field, or a missing code. The row is **skipped and surfaced** as a load
      * warning (liberal on load), never kept as a partially-parsed concept.
      */
     readonly TERM_RRF_MALFORMED_ROW: "TERM_RRF_MALFORMED_ROW";
     /**
-     * A CSV (RFC-4180, e.g. LOINC `Loinc.csv`) row was structurally unusable — too few fields to reach
+     * A CSV (RFC-4180, e.g. LOINC `Loinc.csv`) row was structurally unusable: too few fields to reach
      * a configured column. The row is **skipped and surfaced** as a load warning, never partial.
      */
     readonly TERM_CSV_MALFORMED: "TERM_CSV_MALFORMED";
     /**
-     * A fixed-width (e.g. ICD-10-CM order file) row was structurally unusable — too short to contain
+     * A fixed-width (e.g. ICD-10-CM order file) row was structurally unusable: too short to contain
      * the configured code field, or a missing code. Skipped and surfaced, never partial.
      */
     readonly TERM_FIXED_WIDTH_MALFORMED: "TERM_FIXED_WIDTH_MALFORMED";
     /**
-     * A concept inside a FHIR `CodeSystem` resource was unusable — not an object, or missing its
+     * A concept inside a FHIR `CodeSystem` resource was unusable: not an object, or missing its
      * required `code`. Skipped and surfaced (the whole resource still loads); `line` is `0` since a
      * JSON concept is not line-addressable.
      */
     readonly TERM_FHIR_CONCEPT_MALFORMED: "TERM_FHIR_CONCEPT_MALFORMED";
     /**
      * A `$lookup`/`$validate-code` found no concept for the code in the loaded release. A **first-class
-     * typed outcome, never a guess** — the engine returns `unknown`/`valid: false`, never a fabricated
+     * typed outcome, never a guess**: the engine returns `unknown`/`valid: false`, never a fabricated
      * display or a coerced `valid: true` (the never-fabricate invariant, applied to code identity).
      */
     readonly TERM_CODE_UNKNOWN: "TERM_CODE_UNKNOWN";
@@ -226,7 +226,7 @@ declare const DIAGNOSTIC_CODES: {
      */
     readonly TERM_CONCEPT_HEADER_NOT_BILLABLE: "TERM_CONCEPT_HEADER_NOT_BILLABLE";
     /**
-     * A ValueSet `compose` part could **not be expanded** — an intensional `include`/`exclude` whose
+     * A ValueSet `compose` part could **not be expanded**: an intensional `include`/`exclude` whose
      * code system was not supplied, an unresolvable referenced value set, or a `filter` operator the
      * engine does not implement. Surfaced as a typed outcome that marks the expansion **incomplete**;
      * the engine **never** fabricates a member and **never** returns a silently-empty "no members"
@@ -234,14 +234,14 @@ declare const DIAGNOSTIC_CODES: {
      */
     readonly TERM_VALUESET_CANNOT_EXPAND: "TERM_VALUESET_CANNOT_EXPAND";
     /**
-     * A **pre-computed** `ValueSet.expansion` is **incomplete** — its `total` exceeds the number of
+     * A **pre-computed** `ValueSet.expansion` is **incomplete**: its `total` exceeds the number of
      * `contains` entries, or it is flagged too-costly (the VSAC `$expand` >1200-code truncation
      * hazard). The engine **never treats a truncated expansion as complete membership**: a code
      * absent from a truncated expansion is `undetermined`, never a confident "not a member".
      */
     readonly TERM_VALUESET_EXPANSION_TRUNCATED: "TERM_VALUESET_EXPANSION_TRUNCATED";
     /**
-     * A UCUM unit expression is **not valid** — it does not parse against the UCUM grammar, or it
+     * A UCUM unit expression is **not valid**: it does not parse against the UCUM grammar, or it
      * names an atom absent from the vendored UCUM table. A **first-class typed outcome, never an
      * error and never a guess**: {@link validateUcum} returns `{ valid: false, reason }`, never a
      * coerced or "nearest" unit (the never-fabricate invariant, applied to units). The
@@ -249,7 +249,7 @@ declare const DIAGNOSTIC_CODES: {
      */
     readonly TERM_UCUM_INVALID: "TERM_UCUM_INVALID";
     /**
-     * A crosswalk source code has an **authored No-Map** — the steward declares it has no valid target
+     * A crosswalk source code has an **authored No-Map**: the steward declares it has no valid target
      * in the other classification (a GEM `NoDx`/`NoPCS` sentinel, or a SNOMED complex-map `447638001`
      * "cannot be classified" category). A **first-class typed outcome, never an error and never a
      * guess** (the never-fabricate invariant, applied to crosswalks). Distinct from
@@ -257,7 +257,7 @@ declare const DIAGNOSTIC_CODES: {
      */
     readonly TERM_CROSSWALK_NO_MAP: "TERM_CROSSWALK_NO_MAP";
     /**
-     * A crosswalk source code is **absent from the map entirely** — not an authored No-Map, simply not
+     * A crosswalk source code is **absent from the map entirely**: not an authored No-Map, simply not
      * present. Surfaced as a typed outcome (never a fabricated target, never a silent success), and
      * kept distinct from {@link TERM_CROSSWALK_NO_MAP} so a caller can tell "the steward said no target"
      * from "this code was not in the file".
@@ -266,26 +266,26 @@ declare const DIAGNOSTIC_CODES: {
     /**
      * A SNOMED→ICD-10-CM complex-map group's decision needs **patient context** (an `IFA` age band or
      * gender) the caller did not supply. The engine surfaces the candidate rules + advice and **refuses
-     * to pick a branch** it lacks the data for — never a silently-chosen target.
+     * to pick a branch** it lacks the data for: never a silently-chosen target.
      */
     readonly TERM_CROSSWALK_CONTEXT_REQUIRED: "TERM_CROSSWALK_CONTEXT_REQUIRED";
     /**
-     * A GEM file line was structurally unusable — not three whitespace-delimited fields, or a flag
+     * A GEM file line was structurally unusable: not three whitespace-delimited fields, or a flag
      * field that is not a 5-digit code. The row is **skipped and surfaced** as a load warning (liberal
      * on load), never kept as a partially-parsed entry.
      */
     readonly TERM_GEM_MALFORMED_ROW: "TERM_GEM_MALFORMED_ROW";
     /**
-     * A SNOMED complex-map RF2 refset row was structurally unusable — missing its
+     * A SNOMED complex-map RF2 refset row was structurally unusable: missing its
      * `referencedComponentId`/`mapGroup`/`mapPriority`. Skipped and surfaced, never partial.
      */
     readonly TERM_COMPLEX_MAP_MALFORMED_ROW: "TERM_COMPLEX_MAP_MALFORMED_ROW";
     /**
-     * A RxNorm RRF row (`RXNCONSO` / `RXNREL` / `RXNSAT`) was structurally unusable — too few columns to
+     * A RxNorm RRF row (`RXNCONSO` / `RXNREL` / `RXNSAT`) was structurally unusable: too few columns to
      * reach a required field, or a missing `RXCUI`/NDC value. The row is **skipped and surfaced** as a
      * load warning (liberal on load), never kept as a partial concept/edge. Rows that are simply *not of
      * interest* (a non-`RXNORM` atom, an atom-level relationship, a non-`NDC` attribute) are skipped
-     * **silently** — they are expected, not faults.
+     * **silently**: they are expected, not faults.
      */
     readonly TERM_RXNORM_MALFORMED_ROW: "TERM_RXNORM_MALFORMED_ROW";
     /**
@@ -299,7 +299,7 @@ declare const DIAGNOSTIC_CODES: {
      */
     readonly TERM_RXNORM_UNTYPED_CONCEPT: "TERM_RXNORM_UNTYPED_CONCEPT";
     /**
-     * A RxNorm graph navigation was asked about an `RXCUI` **absent from the loaded release** — a
+     * A RxNorm graph navigation was asked about an `RXCUI` **absent from the loaded release**: a
      * first-class typed outcome, never a fabricated concept and never an empty "success" (the
      * never-fabricate invariant, applied to the drug graph). Distinct from a *present*
      * concept that simply has no edge of the requested relationship (that is a found result with empty
@@ -307,18 +307,18 @@ declare const DIAGNOSTIC_CODES: {
      */
     readonly TERM_RXNORM_UNKNOWN_RXCUI: "TERM_RXNORM_UNKNOWN_RXCUI";
     /**
-     * An NDC could **not be resolved** to any `RXCUI` in the loaded RxNorm release — a typed, surfaced
+     * An NDC could **not be resolved** to any `RXCUI` in the loaded RxNorm release: a typed, surfaced
      * absence, never a guessed `RXCUI`. NDC↔RXCUI is many:1 and temporal, so a resolution
      * is always release-scoped; an NDC not present in the loaded release is this diagnostic.
      */
     readonly TERM_RXNORM_NDC_UNMAPPED: "TERM_RXNORM_NDC_UNMAPPED";
 };
 /**
- * A value from {@link DIAGNOSTIC_CODES} — the type consumers narrow a diagnostic's `code` against.
+ * A value from {@link DIAGNOSTIC_CODES}: the type consumers narrow a diagnostic's `code` against.
  */
 type DiagnosticCode = (typeof DIAGNOSTIC_CODES)[keyof typeof DIAGNOSTIC_CODES];
 /**
- * Stable **fatal codes** — thrown (as a {@link TerminologyError}) when input cannot be loaded into
+ * Stable **fatal codes**: thrown (as a {@link TerminologyError}) when input cannot be loaded into
  * a usable model at all. Always thrown, never swallowed. `key === value`, part of the contract.
  *
  * @example
@@ -330,33 +330,33 @@ type DiagnosticCode = (typeof DIAGNOSTIC_CODES)[keyof typeof DIAGNOSTIC_CODES];
  */
 declare const FATAL_CODES: {
     /**
-     * A `ConceptMap` resource was structurally unusable — wrong `resourceType`, or a group/element
+     * A `ConceptMap` resource was structurally unusable: wrong `resourceType`, or a group/element
      * missing a required field. Thrown rather than silently loading a partial, misleading map.
      */
     readonly TERM_CONCEPTMAP_MALFORMED: "TERM_CONCEPTMAP_MALFORMED";
     /**
-     * A CodeSystem *source* was structurally unusable — a FHIR resource with the wrong `resourceType`,
+     * A CodeSystem *source* was structurally unusable: a FHIR resource with the wrong `resourceType`,
      * or a delimited source whose configured code/display column is absent from the header. Thrown
      * rather than silently loading an empty or mis-keyed release. (Malformed individual **rows** are
-     * skipped-and-surfaced load warnings, not fatals — only an unusable *source* is fatal.)
+     * skipped-and-surfaced load warnings, not fatals: only an unusable *source* is fatal.)
      */
     readonly TERM_CODESYSTEM_MALFORMED: "TERM_CODESYSTEM_MALFORMED";
     /**
-     * A `ValueSet` resource was structurally unusable — wrong `resourceType`, or a `compose`/`expansion`
+     * A `ValueSet` resource was structurally unusable: wrong `resourceType`, or a `compose`/`expansion`
      * whose required shape (an `include` that is not an object, a `contains` entry missing its `code`)
      * is corrupt. Thrown rather than silently loading a partial value set that would bind *some* codes
-     * and quietly drop others. (A `filter` operator the engine does not implement is **not** fatal — it
+     * and quietly drop others. (A `filter` operator the engine does not implement is **not** fatal; it
      * is the surfaced `TERM_VALUESET_CANNOT_EXPAND` diagnostic at expansion time.)
      */
     readonly TERM_VALUESET_MALFORMED: "TERM_VALUESET_MALFORMED";
     /**
-     * A crosswalk map *source* was structurally unusable — e.g. a SNOMED complex-map RF2 refset with
+     * A crosswalk map *source* was structurally unusable: e.g. a SNOMED complex-map RF2 refset with
      * empty content or a header missing a required column. Thrown rather than silently loading an empty
      * or mis-keyed map. (Malformed individual **rows** are skipped-and-surfaced warnings, not fatals.)
      */
     readonly TERM_CROSSWALK_MALFORMED: "TERM_CROSSWALK_MALFORMED";
     /**
-     * An **inversion** of a directional crosswalk was requested — a forbidden operation. The GEMs and
+     * An **inversion** of a directional crosswalk was requested: a forbidden operation. The GEMs and
      * the SNOMED→ICD-10-CM map are authoritative in **one direction only**; a forward map is not the
      * inverse of the backward map. Thrown by {@link ../crosswalk/gems.invertGem} so the
      * never-invert refusal is a first-class, discoverable contract rather than a silent absence.
@@ -364,7 +364,7 @@ declare const FATAL_CODES: {
     readonly TERM_MAP_NOT_INVERTIBLE: "TERM_MAP_NOT_INVERTIBLE";
 };
 /**
- * A value from {@link FATAL_CODES} — the type carried by a thrown {@link TerminologyError}.
+ * A value from {@link FATAL_CODES}: the type carried by a thrown {@link TerminologyError}.
  */
 type FatalCode = (typeof FATAL_CODES)[keyof typeof FATAL_CODES];
 /**
@@ -372,7 +372,7 @@ type FatalCode = (typeof FATAL_CODES)[keyof typeof FATAL_CODES];
  * without string-matching the message. Thrown only for {@link FATAL_CODES} conditions.
  *
  * The `message` is **value-free**: it names the structural fault (a resource path, a missing field,
- * the *role* of a configured column) and never echoes an input value — so it is safe to log, and
+ * the *role* of a configured column) and never echoes an input value, so it is safe to log, and
  * safe in an `err.stack` that reaches an error reporter. The rule the strings are built by is in
  * this module's docblock above.
  *
@@ -393,7 +393,7 @@ declare class TerminologyError extends Error {
     /**
      * @param code - The stable {@link FatalCode} describing the fault.
      * @param message - A **value-free** structural description (path + fault; never an input value).
-     *   Every piece of it must be engine-owned — a literal, a frozen-table entry, or a locus this
+     *   Every piece of it must be engine-owned: a literal, a frozen-table entry, or a locus this
      *   package built. This string reaches `err.stack`, so interpolating a caller-supplied or
      *   document-derived value into it is how a diagnostic becomes a leak.
      */
@@ -407,7 +407,7 @@ declare class TerminologyError extends Error {
  * The engine never trusts the shape of its inputs: every accessor here narrows an `unknown`
  * to a concrete type or returns `undefined`, so a malformed resource degrades to a typed
  * diagnostic (see {@link ../conceptmap/load}) rather than a `TypeError` deep in a getter. This
- * is the terminology-engine analogue of a parser's lenient tokenizer — liberal on load.
+ * is the terminology-engine analogue of a parser's lenient tokenizer: liberal on load.
  *
  * These helpers are **value-free**: they read structure, never log or echo field *values*, so a
  * code-in-context (which can be PHI) never flows into a message.
@@ -444,7 +444,7 @@ declare function getString(obj: unknown, key: string): string | undefined;
 /**
  * Read an **array** property from an untrusted object as a `readonly unknown[]`, or `undefined`.
  *
- * The elements are left as `unknown` — callers narrow each one. A non-array (including a missing
+ * The elements are left as `unknown`: callers narrow each one. A non-array (including a missing
  * key) yields `undefined`, which callers treat as "no entries" rather than an error.
  *
  * @param obj - The source object (may be any `unknown`).
@@ -461,7 +461,7 @@ declare function getArray(obj: unknown, key: string): readonly unknown[] | undef
 /**
  * Read a **boolean** property from an untrusted object, or `undefined` if absent/not a boolean.
  *
- * A non-boolean (including a missing key, or the strings `"true"`/`"false"`) yields `undefined` —
+ * A non-boolean (including a missing key, or the strings `"true"`/`"false"`) yields `undefined`:
  * the accessor never coerces, so a caller can distinguish "explicitly `false`" from "absent".
  *
  * @param obj - The source object (may be any `unknown`).
@@ -491,41 +491,41 @@ declare function getBoolean(obj: unknown, key: string): boolean | undefined;
 declare function getNumber(obj: unknown, key: string): number | undefined;
 
 /**
- * The **code-system identity registry** — the grounded OID ↔ canonical-URI ↔ mnemonic facts the
+ * The **code-system identity registry**: the grounded OID ↔ canonical-URI ↔ mnemonic facts the
  * ecosystem uses.
  *
  * A code-system *identity* (the triple of canonical URI, OID, and HL7 v2 mnemonic that all name
- * the same terminology) is a **published identifier** for the system, not the system's code list — so
+ * the same terminology) is a **published identifier** for the system, not the system's code list, so
  * it is encoded here, cited firsthand. That is where the line falls: identities are encoded; the code
  * *lists themselves* (SNOMED CT / CPT / LOINC content) are BYO and never bundled.
  *
  * **Every identity below is grounded firsthand against a primary source** (verified 2026-07-21):
  *
- * - The FHIR R4 terminology-systems registry — `https://hl7.org/fhir/R4/terminologies-systems.html`
- *   — for LOINC, SNOMED CT, RxNorm, UCUM, CPT, NDC, CVX (canonical URI + OID), and for the HL7 v2
+ * - The FHIR R4 terminology-systems registry (`https://hl7.org/fhir/R4/terminologies-systems.html`)
+ *   for LOINC, SNOMED CT, RxNorm, UCUM, CPT, NDC, CVX (canonical URI + OID), and for the HL7 v2
  *   table URI/OID patterns (`http://terminology.hl7.org/CodeSystem/v2-[X]` ↔
  *   `2.16.840.1.113883.12.[X]`).
- * - The FHIR R4 ICD page — `https://hl7.org/fhir/R4/icd.html` — for ICD-10-CM
+ * - The FHIR R4 ICD page (`https://hl7.org/fhir/R4/icd.html`) for ICD-10-CM
  *   (`http://hl7.org/fhir/sid/icd-10-cm` ↔ `2.16.840.1.113883.6.90`).
- * - HL7 Table 0396 (coding-system mnemonics) — the THO `v2-0396` code system — for the mnemonics
+ * - HL7 Table 0396 (coding-system mnemonics), the THO `v2-0396` code system, for the mnemonics
  *   (`LN`, `SCT`, `I10C`, `RXNORM`, `UCUM`, `C4`, `NDC`, `CVX`).
  *
  * Identities that could not be pinned to a primary source firsthand are **omitted**, not
- * guessed — notably ICD-9-CM and ICD-10-PCS, whose OID
+ * guessed: notably ICD-9-CM and ICD-10-PCS, whose OID
  * assignments were ambiguous across sources.
  *
  * @packageDocumentation
  */
 /**
- * A resolved code-system identity — the canonical URI plus the alternate identifiers that name the
+ * A resolved code-system identity: the canonical URI plus the alternate identifiers that name the
  * same system.
  */
 interface SystemIdentity {
-    /** The canonical URI — the single value the engine treats as the system's identity. */
+    /** The canonical URI: the single value the engine treats as the system's identity. */
     readonly url: string;
     /** The registered OID (bare, no `urn:oid:` prefix), when the system has one. */
     readonly oid?: string;
-    /** A short human-readable name for diagnostics/logs (value-free — a system name, never a value). */
+    /** A short human-readable name for diagnostics/logs (value-free, a system name, never a value). */
     readonly name: string;
     /** HL7 v2 Table 0396 mnemonic(s) and other accepted short aliases for this system. */
     readonly mnemonics: readonly string[];
@@ -537,33 +537,33 @@ interface SystemIdentity {
 declare const SYSTEM_IDENTITIES: readonly SystemIdentity[];
 /**
  * The OID root under which every HL7 v2 table code system is registered:
- * `2.16.840.1.113883.12.[table]` — grounded against the FHIR R4 terminology-systems registry.
+ * `2.16.840.1.113883.12.[table]`: grounded against the FHIR R4 terminology-systems registry.
  * The table number is appended with no leading zeros (e.g. table 0203 → `…12.203`).
  */
 declare const HL7_V2_OID_ROOT = "2.16.840.1.113883.12";
 /**
  * The canonical URI prefix for HL7 v2 table code systems in HL7 Terminology (THO):
  * `http://terminology.hl7.org/CodeSystem/v2-[XXXX]`, where `[XXXX]` is the zero-padded 4-digit
- * table id — grounded against the FHIR R4 terminology-systems registry.
+ * table id: grounded against the FHIR R4 terminology-systems registry.
  */
 declare const HL7_V2_URL_PREFIX = "http://terminology.hl7.org/CodeSystem/v2-";
 
 /**
- * The **code-system identity / canonical-URI resolver** — `resolveSystem`.
+ * The **code-system identity / canonical-URI resolver**: `resolveSystem`.
  *
- * Given a code system named any of the ways the ecosystem names it — a canonical URI, an OID (bare
- * or `urn:oid:`-prefixed), or an HL7 v2 mnemonic (`LN`, `SCT`, …) — it returns the one canonical
+ * Given a code system named any of the ways the ecosystem names it, whether a canonical URI, an OID
+ * (bare or `urn:oid:`-prefixed), or an HL7 v2 mnemonic (`LN`, `SCT`, …), it returns the one canonical
  * {@link SystemIdentity}. This is the piece `@cosyte/transform` pins so a `Coding` off any parser
  * (HL7 v2 CE/CWE, C-CDA, FHIR) can be canonicalized to a single system URI before translation.
  *
  * **Never guesses.** An identifier that matches nothing known returns a typed
- * `{ unknown: true, input }` — never a fabricated URI (the never-fabricate invariant, applied to
+ * `{ unknown: true, input }`: never a fabricated URI (the never-fabricate invariant, applied to
  * system identity).
  *
  * @packageDocumentation
  */
 
-/** The typed "not recognized" outcome from {@link resolveSystem} — surfaced, never a guess. */
+/** The typed "not recognized" outcome from {@link resolveSystem}: surfaced, never a guess. */
 interface UnknownSystem {
     /** Discriminant: the identifier was not recognized. */
     readonly unknown: true;
@@ -578,7 +578,7 @@ type ResolveSystemResult = SystemIdentity | UnknownSystem;
  * Accepts, in order of attempt: a canonical URI (case-insensitive), a `v2-XXXX` mnemonic or a
  * v2 table URI/OID (resolved structurally), a bare or `urn:oid:`-prefixed OID, or an HL7 v2
  * Table 0396 mnemonic. Whitespace is trimmed. An empty or unrecognized identifier yields a typed
- * {@link UnknownSystem} — the resolver **never** invents a URI.
+ * {@link UnknownSystem}: the resolver **never** invents a URI.
  *
  * @param id - The identifier (canonical URI, OID, `urn:oid:` OID, or mnemonic).
  * @returns The resolved {@link SystemIdentity}, or `{ unknown: true, input }`.
@@ -607,7 +607,7 @@ declare function resolveSystem(id: string): ResolveSystemResult;
 declare function isUnknownSystem(result: ResolveSystemResult): result is UnknownSystem;
 
 /**
- * The types for the ConceptMap `$translate` engine — the loaded {@link ConceptMap} model, the
+ * The types for the ConceptMap `$translate` engine: the loaded {@link ConceptMap} model, the
  * normalized {@link Relationship} enum, and the fail-safe {@link TranslateResult}.
  *
  * The engine targets **FHIR R4** ConceptMap input (`element.target.equivalence`), but carries an
@@ -627,7 +627,7 @@ declare function isUnknownSystem(result: ResolveSystemResult): result is Unknown
  */
 type R4Equivalence = "relatedto" | "equivalent" | "equal" | "wider" | "subsumes" | "narrower" | "specializes" | "inexact" | "unmatched" | "disjoint";
 /**
- * The engine's **normalized, version-neutral relationship** between a source and a target concept —
+ * The engine's **normalized, version-neutral relationship** between a source and a target concept:
  * the FHIR **R5** vocabulary, which the R4 `equivalence` tokens fold into cleanly. Surfaced on every
  * match alongside the verbatim R4 token.
  *
@@ -640,7 +640,7 @@ type R4Equivalence = "relatedto" | "equivalent" | "equal" | "wider" | "subsumes"
 type Relationship = "equivalent" | "source-is-narrower-than-target" | "source-is-broader-than-target" | "related-to" | "not-related-to";
 /**
  * One target concept a {@link translate} call produced, with its relationship to the source and
- * the verbatim R4 equivalence token. Never fabricated — every field is drawn from the loaded map.
+ * the verbatim R4 equivalence token. Never fabricated: every field is drawn from the loaded map.
  */
 interface TranslateMatch {
     /** The target {@link Coding} exactly as declared in the map (frozen). */
@@ -653,17 +653,17 @@ interface TranslateMatch {
     readonly comment?: string;
 }
 /**
- * The FHIR R4 `group.unmapped.mode` an unmapped source fell through to — the map author's declared
+ * The FHIR R4 `group.unmapped.mode` an unmapped source fell through to: the map author's declared
  * fallback behavior. Surfaced (never silently acted on): the caller decides whether to trust a
  * fallback.
  *
- * - `provided` — echo the source code as the target (the map declares no real mapping).
- * - `fixed` — a single fixed fallback code the map declares for *all* unmapped sources.
- * - `other-map` — consult the referenced ConceptMap (which this engine does not auto-follow).
- * - `none` — no `group.unmapped` directive applied (plain no-match, or an explicit `unmatched`).
+ * - `provided`: echo the source code as the target (the map declares no real mapping).
+ * - `fixed`: a single fixed fallback code the map declares for *all* unmapped sources.
+ * - `other-map`: consult the referenced ConceptMap (which this engine does not auto-follow).
+ * - `none`: no `group.unmapped` directive applied (plain no-match, or an explicit `unmatched`).
  */
 type UnmappedMode = "provided" | "fixed" | "other-map" | "none";
-/** Provenance of a translation — which map (and which group's systems) produced it. */
+/** Provenance of a translation, which map (and which group's systems) produced it. */
 interface MapProvenance {
     /** The ConceptMap's canonical `url`, when declared. */
     readonly conceptMapUrl?: string;
@@ -690,9 +690,9 @@ interface TranslateMatched {
     readonly provenance: MapProvenance;
 }
 /**
- * A **fail-safe unmapped** translation — the never-fabricate outcome. The source is surfaced as-is;
+ * A **fail-safe unmapped** translation: the never-fabricate outcome. The source is surfaced as-is;
  * **no target is ever guessed**. Any `group.unmapped` fallback the author declared is reported via
- * {@link UnmappedMode} (and `fixedTarget`/`otherMapUrl`) for the caller to accept or reject — the
+ * {@link UnmappedMode} (and `fixedTarget`/`otherMapUrl`) for the caller to accept or reject: the
  * engine does not silently substitute it.
  */
 interface TranslateUnmapped {
@@ -704,9 +704,9 @@ interface TranslateUnmapped {
     readonly mode: UnmappedMode;
     /** The original source {@link Coding}, surfaced untouched. */
     readonly source: Coding;
-    /** For `mode: "fixed"`, the author's fixed fallback coding — reported, not auto-applied. */
+    /** For `mode: "fixed"`, the author's fixed fallback coding: reported, not auto-applied. */
     readonly fixedTarget?: Coding;
-    /** For `mode: "other-map"`, the referenced map's URL — reported, not auto-followed. */
+    /** For `mode: "other-map"`, the referenced map's URL: reported, not auto-followed. */
     readonly otherMapUrl?: string;
     /** Where the (failed) translation was attempted. */
     readonly provenance: MapProvenance;
@@ -726,7 +726,7 @@ interface ConceptMapUnmapped {
     /** For `other-map`, the canonical URL of the map to consult. */
     readonly url?: string;
 }
-/** One `group.element.target` — a candidate target for a source concept (FHIR R4). */
+/** One `group.element.target`: a candidate target for a source concept (FHIR R4). */
 interface ConceptMapTarget {
     /** The target code (absent for a pure `unmatched` assertion). */
     readonly code?: string;
@@ -737,7 +737,7 @@ interface ConceptMapTarget {
     /** Author's comment (e.g. steward map advice), carried verbatim. */
     readonly comment?: string;
 }
-/** One `group.element` — a source concept and its candidate targets (FHIR R4). */
+/** One `group.element`: a source concept and its candidate targets (FHIR R4). */
 interface ConceptMapElement {
     /** The source code. */
     readonly code?: string;
@@ -746,7 +746,7 @@ interface ConceptMapElement {
     /** The candidate targets. */
     readonly target: readonly ConceptMapTarget[];
 }
-/** One `group` — a source-system/target-system pair with its element mappings (FHIR R4). */
+/** One `group`: a source-system/target-system pair with its element mappings (FHIR R4). */
 interface ConceptMapGroup {
     /** The group's source code system (canonical URI), when declared. */
     readonly source?: string;
@@ -762,7 +762,7 @@ interface ConceptMapGroup {
     readonly unmapped?: ConceptMapUnmapped;
 }
 /**
- * A loaded, immutable ConceptMap — the subset of the FHIR R4 `ConceptMap` resource the
+ * A loaded, immutable ConceptMap: the subset of the FHIR R4 `ConceptMap` resource the
  * `$translate` engine needs. Produced by {@link loadConceptMap}; every field frozen.
  */
 interface ConceptMap {
@@ -779,13 +779,13 @@ interface ConceptMap {
 }
 
 /**
- * {@link loadConceptMap} — validate and normalize an untrusted FHIR R4 `ConceptMap` JSON resource
+ * {@link loadConceptMap}: validate and normalize an untrusted FHIR R4 `ConceptMap` JSON resource
  * into the immutable {@link ConceptMap} model the `$translate` engine runs over.
  *
  * **Conservative on load** (unlike a wire parser's lenient posture): a ConceptMap drives a clinical
  * translation, so a structurally unusable map is a typed **fatal**
  * ({@link FATAL_CODES.TERM_CONCEPTMAP_MALFORMED}), never a silently partial map that would translate
- * *some* codes and quietly drop others. Fault messages are **value-free** — they name the resource
+ * *some* codes and quietly drop others. Fault messages are **value-free**: they name the resource
  * *path* and the fault, never echo a code or display *value*.
  *
  * @packageDocumentation
@@ -799,7 +799,7 @@ interface ConceptMap {
  * variant. The result is deep-frozen. Anything structurally unusable throws a
  * {@link TerminologyError} carrying {@link FATAL_CODES.TERM_CONCEPTMAP_MALFORMED}.
  *
- * @param json - The untrusted resource (typically `JSON.parse` output — hence `unknown`).
+ * @param json - The untrusted resource (typically `JSON.parse` output, hence `unknown`).
  * @returns The immutable, validated {@link ConceptMap}.
  * @throws {TerminologyError} `TERM_CONCEPTMAP_MALFORMED` when the resource is not a usable ConceptMap.
  * @example
@@ -823,18 +823,18 @@ interface ConceptMap {
 declare function loadConceptMap(json: unknown): ConceptMap;
 
 /**
- * {@link translate} — the ConceptMap `$translate` engine, modeled on the FHIR
+ * {@link translate}: the ConceptMap `$translate` engine, modeled on the FHIR
  * `ConceptMap/$translate` operation.
  *
  * Given a source {@link Coding} and a loaded {@link ConceptMap}, it returns the declared target
- * code(s) with their FHIR relationship and the map's provenance — or, when the source does not map,
+ * code(s) with their FHIR relationship and the map's provenance, or, when the source does not map,
  * a **typed {@link TranslateUnmapped}**. Two invariants govern it:
  *
- * 1. **Never fabricate.** An unmapped source yields a surfaced `unmapped` result — never a guessed
+ * 1. **Never fabricate.** An unmapped source yields a surfaced `unmapped` result: never a guessed
  *    target. Every target returned is drawn verbatim from the map; the engine invents nothing.
  * 2. **Never invert.** Translation reads the map in its authored direction only: a source coding is
  *    matched against `group.element.code` (the source side) and **never** against target codes. A
- *    directional map therefore cannot be run backwards — reverse translation requires an explicit
+ *    directional map therefore cannot be run backwards: reverse translation requires an explicit
  *    inverse map; it is never synthesized here.
  *
  * @packageDocumentation
@@ -843,16 +843,16 @@ declare function loadConceptMap(json: unknown): ConceptMap;
 /**
  * Translate a source {@link Coding} through a loaded {@link ConceptMap}.
  *
- * Matches the coding's `code` against each applicable group's `element.code` (the **source** side —
+ * Matches the coding's `code` against each applicable group's `element.code` (the **source** side,
  * never targets, so the map is never inverted) and returns every declared target for it. A target
- * with an `unmatched` equivalence, or with no `code`, is treated as "no target" — the FHIR way of
- * asserting a non-mapping — and does not count as a match. When nothing matches, the map author's
+ * with an `unmatched` equivalence, or with no `code`, is treated as "no target" (the FHIR way of
+ * asserting a non-mapping), and does not count as a match. When nothing matches, the map author's
  * `group.unmapped` directive (if any) is *reported* via the result's {@link UnmappedMode} but never
  * silently applied.
  *
  * @param sourceCoding - The source concept to translate.
  * @param map - A {@link ConceptMap} from {@link loadConceptMap}.
- * @returns A {@link TranslateResult} — matched targets, or a typed unmapped outcome.
+ * @returns A {@link TranslateResult}: matched targets, or a typed unmapped outcome.
  * @example
  * ```ts
  * import { loadConceptMap, translate } from "@cosyte/terminology";
@@ -883,7 +883,7 @@ declare function translate(sourceCoding: Coding, map: ConceptMap): TranslateResu
  *
  * The model is **content-agnostic**: it is fed a code system's *release* (a consumer-supplied RRF,
  * CSV, fixed-width file, or FHIR `CodeSystem` JSON) and answers the two identity questions. It ships
- * **no code-system release** — every concept comes from the caller's data (the BYO-data posture).
+ * **no code-system release**: every concept comes from the caller's data (the BYO-data posture).
  * The FHIR operation shapes are grounded firsthand on the FHIR R4 Terminology Module
  * (`https://hl7.org/fhir/R4/codesystem-operation-lookup.html`,
  * `https://hl7.org/fhir/R4/codesystem-operation-validate-code.html`).
@@ -892,20 +892,20 @@ declare function translate(sourceCoding: Coding, map: ConceptMap): TranslateResu
  */
 
 /**
- * A concept's normalized activity — whether it is a clean, current, usable code, or carries a
+ * A concept's normalized activity: whether it is a clean, current, usable code, or carries a
  * steward status that a caller must not ignore. `active` is the boolean convenience derived from it.
  *
- * - `active` — current and usable.
- * - `deprecated` — no longer current (LOINC `DEPRECATED`; a FHIR `inactive`/`deprecated` concept).
- * - `discouraged` / `trial` — LOINC lifecycle states (usable, but not settled).
- * - `obsolete` — withdrawn (RxNorm `SUPPRESS = O`).
- * - `suppressed` — editor-suppressed (RxNorm/UMLS `SUPPRESS = Y`/`E`).
- * - `header` — a classification header, **not a billable/valid leaf** (ICD-10-CM flag `0`).
- * - `unknown` — a status token the mapper did not recognize; carried verbatim, never guessed clean.
+ * - `active`: current and usable.
+ * - `deprecated`: no longer current (LOINC `DEPRECATED`; a FHIR `inactive`/`deprecated` concept).
+ * - `discouraged` / `trial`: LOINC lifecycle states (usable, but not settled).
+ * - `obsolete`: withdrawn (RxNorm `SUPPRESS = O`).
+ * - `suppressed`: editor-suppressed (RxNorm/UMLS `SUPPRESS = Y`/`E`).
+ * - `header`: a classification header, **not a billable/valid leaf** (ICD-10-CM flag `0`).
+ * - `unknown`: a status token the mapper did not recognize; carried verbatim, never guessed clean.
  */
 type ConceptActivity = "active" | "deprecated" | "discouraged" | "trial" | "obsolete" | "suppressed" | "header" | "unknown";
 /**
- * The status flags a `$lookup`/`$validate-code` carries on a concept — the safety surface that stops
+ * The status flags a `$lookup`/`$validate-code` carries on a concept: the safety surface that stops
  * a non-current or non-billable code from being presented as clean. Present only when
  * the loaded release supplied status information; the engine never fabricates a status.
  */
@@ -922,7 +922,7 @@ interface ConceptStatus {
     readonly code?: DiagnosticCode;
 }
 /**
- * One property value on a concept — models FHIR R4 `$lookup` `property` ("one or more properties
+ * One property value on a concept: models FHIR R4 `$lookup` `property` ("one or more properties
  * that contain additional information about the code, including status"). Carried verbatim from the
  * release; never fabricated.
  */
@@ -935,7 +935,7 @@ interface Property {
     readonly description?: string;
 }
 /**
- * One loaded, immutable concept — the subset of a `CodeSystem.concept` the operations need.
+ * One loaded, immutable concept: the subset of a `CodeSystem.concept` the operations need.
  */
 interface Concept {
     /** The code, exactly as it appears in the release. */
@@ -950,7 +950,7 @@ interface Concept {
     readonly properties: readonly Property[];
 }
 /**
- * A surfaced, non-fatal load warning — a malformed row that was **skipped**, reported with its line
+ * A surfaced, non-fatal load warning: a malformed row that was **skipped**, reported with its line
  * number and a **value-free** structural reason (never the row's content). Liberal on load.
  */
 interface LoadWarning {
@@ -962,14 +962,14 @@ interface LoadWarning {
     readonly detail: string;
 }
 /**
- * A loaded, immutable code-system release — the queryable model {@link loadCodeSystem} produces and
+ * A loaded, immutable code-system release: the queryable model {@link loadCodeSystem} produces and
  * {@link lookup} / {@link validateCode} run over. Concepts are keyed by code for O(1) identity, and
  * every concept is frozen.
  */
 interface CodeSystem {
     /** The code system's canonical URI, when supplied by the source. */
     readonly url?: string;
-    /** The release version, when supplied — mappings and displays are release-scoped. */
+    /** The release version, when supplied: mappings and displays are release-scoped. */
     readonly version?: string;
     /** A short human-readable name, when supplied. */
     readonly name?: string;
@@ -980,7 +980,7 @@ interface CodeSystem {
      * iteration behave as a `Map`'s do, adding / deleting / clearing is refused however it is
      * attempted, and every value is frozen.
      *
-     * A view is not a `Map` instance — `instanceof Map` is `false` and this model cannot be
+     * A view is not a `Map` instance: `instanceof Map` is `false` and this model cannot be
      * `structuredClone`d or posted to a worker; copy out what you need (`new Map(…)`).
      */
     readonly concepts: ReadonlyMap<string, Concept>;
@@ -1006,7 +1006,7 @@ interface LookupResult {
     /** The release version, when known. */
     readonly version?: string;
 }
-/** A **fail-safe unknown** {@link lookup} — the never-fabricate outcome; no display is ever guessed. */
+/** A **fail-safe unknown** {@link lookup}: the never-fabricate outcome; no display is ever guessed. */
 interface LookupUnknown {
     /** Discriminant: the code was not found. */
     readonly found: false;
@@ -1018,7 +1018,7 @@ interface LookupUnknown {
 /** The result of {@link lookup}: a found concept or a typed {@link LookupUnknown}. */
 type LookupOutcome = LookupResult | LookupUnknown;
 /**
- * The result of {@link validateCode} — models FHIR R4 `$validate-code`'s `result` boolean. A found
+ * The result of {@link validateCode}: models FHIR R4 `$validate-code`'s `result` boolean. A found
  * concept is `valid: true` **carrying its status** (a deprecated or header code validates as present
  * but is flagged, never presented clean); an absent code is `valid: false`, never a guessed `true`.
  */
@@ -1058,9 +1058,9 @@ interface RrfColumnMap {
     readonly properties?: readonly RrfPropertyColumn[];
 }
 /**
- * An **RRF** (Rich Release Format — pipe-delimited RxNorm/UMLS release) source. One parameterized
+ * An **RRF** (Rich Release Format, pipe-delimited RxNorm/UMLS release) source. One parameterized
  * reader serves both: RxNorm `RXNCONSO`/`RXNSAT` and UMLS `MRCONSO`/`MRSAT` share the RRF shape
- * (pipe-delimited, one trailing pipe per line). BYO — the consumer supplies the file.
+ * (pipe-delimited, one trailing pipe per line). BYO: the consumer supplies the file.
  */
 interface RrfSource {
     /** Discriminant. */
@@ -1073,7 +1073,7 @@ interface RrfSource {
     readonly url?: string;
     /** A human-readable name. */
     readonly name?: string;
-    /** The release version (RRF carries none inline — supply it so displays stay release-scoped). */
+    /** The release version (RRF carries none inline, supply it so displays stay release-scoped). */
     readonly version?: string;
     /** Override the default status interpretation of the `status` column's raw token. */
     readonly statusMap?: StatusMapper;
@@ -1090,7 +1090,7 @@ interface CsvColumnMap {
     readonly properties?: readonly string[];
 }
 /**
- * An **RFC-4180 CSV** source (quoted fields, embedded commas/quotes/newlines) — e.g. LOINC's
+ * An **RFC-4180 CSV** source (quoted fields, embedded commas/quotes/newlines): e.g. LOINC's
  * `Loinc.csv`. The one release format that needs real quote handling; hand-rolled, zero-dep. BYO.
  */
 interface CsvSource {
@@ -1137,7 +1137,7 @@ interface FixedWidthFieldMap {
     readonly properties?: readonly FixedWidthPropertyField[];
 }
 /**
- * A **fixed-width** source (slice by column) — e.g. the ICD-10-CM order file. Fully parameterized:
+ * A **fixed-width** source (slice by column): e.g. the ICD-10-CM order file. Fully parameterized:
  * the consumer supplies the field slices (see {@link ICD10CM_ORDER_FILE_FIELDS} for the documented
  * ICD-10-CM preset, which they confirm against their release's README, since the byte offsets are
  * not confirmed against an authoritative machine-readable source). BYO.
@@ -1166,14 +1166,14 @@ interface FixedWidthSource {
 interface FhirCodeSystemSource {
     /** Discriminant. */
     readonly format: "fhir";
-    /** The untrusted FHIR `CodeSystem` resource (typically `JSON.parse` output — hence `unknown`). */
+    /** The untrusted FHIR `CodeSystem` resource (typically `JSON.parse` output, hence `unknown`). */
     readonly resource: unknown;
 }
 /** The discriminated union {@link loadCodeSystem} accepts. */
 type CodeSystemSource = RrfSource | CsvSource | FixedWidthSource | FhirCodeSystemSource;
 
 /**
- * {@link loadCodeSystem} — the single entry point that dispatches a {@link CodeSystemSource} to the
+ * {@link loadCodeSystem}: the single entry point that dispatches a {@link CodeSystemSource} to the
  * right reader (RRF / CSV / fixed-width / FHIR) and assembles the immutable {@link CodeSystem}.
  *
  * The engine is **content-agnostic**: it loads a *consumer-supplied* release and ships
@@ -1187,10 +1187,10 @@ type CodeSystemSource = RrfSource | CsvSource | FixedWidthSource | FhirCodeSyste
  * Load a consumer-supplied code-system release into an immutable, queryable {@link CodeSystem}.
  *
  * Dispatches on `source.format`:
- * - `"rrf"` — pipe-delimited RxNorm/UMLS release (one parameterized reader for both).
- * - `"csv"` — RFC-4180 CSV (e.g. LOINC `Loinc.csv`), with real quote handling.
- * - `"fixed-width"` — slice-by-column order files (e.g. ICD-10-CM; see `ICD10CM_ORDER_FILE_FIELDS`).
- * - `"fhir"` — a native FHIR R4 `CodeSystem` JSON resource.
+ * - `"rrf"`: pipe-delimited RxNorm/UMLS release (one parameterized reader for both).
+ * - `"csv"`: RFC-4180 CSV (e.g. LOINC `Loinc.csv`), with real quote handling.
+ * - `"fixed-width"`: slice-by-column order files (e.g. ICD-10-CM; see `ICD10CM_ORDER_FILE_FIELDS`).
+ * - `"fhir"`: a native FHIR R4 `CodeSystem` JSON resource.
  *
  * **Liberal on load:** a malformed *row* is skipped and surfaced in `warnings` (never a crash, never a
  * partial concept). **Conservative on structure:** an unusable *source* (wrong FHIR `resourceType`, or
@@ -1218,7 +1218,7 @@ type CodeSystemSource = RrfSource | CsvSource | FixedWidthSource | FhirCodeSyste
 declare function loadCodeSystem(source: CodeSystemSource): CodeSystem;
 
 /**
- * {@link lookup} and {@link validateCode} — the FHIR R4 CodeSystem `$lookup` and `$validate-code`
+ * {@link lookup} and {@link validateCode}: the FHIR R4 CodeSystem `$lookup` and `$validate-code`
  * operations over a loaded {@link CodeSystem}.
  *
  * Grounded firsthand on FHIR R4 (`https://hl7.org/fhir/R4/codesystem-operation-lookup.html`,
@@ -1229,7 +1229,7 @@ declare function loadCodeSystem(source: CodeSystemSource): CodeSystem;
  * - `$validate-code` returns `result` (*"True if the concept details supplied are valid"*).
  *
  * Both honor the **never-fabricate invariant**, applied here to code identity: an
- * unknown code yields a typed `unknown` / `valid: false` — **never** a fabricated display and
+ * unknown code yields a typed `unknown` / `valid: false`: **never** a fabricated display and
  * **never** a guessed `valid: true`. A found-but-non-current concept (deprecated, or an ICD-10-CM
  * header) validates as present **but carries its status flag**, so a caller never treats it as clean.
  *
@@ -1241,7 +1241,7 @@ declare function loadCodeSystem(source: CodeSystemSource): CodeSystem;
  *
  * @param cs - The loaded {@link CodeSystem}.
  * @param code - The code to look up.
- * @returns A {@link LookupResult} when found, or a typed {@link LookupUnknown} — never a guess.
+ * @returns A {@link LookupResult} when found, or a typed {@link LookupUnknown}: never a guess.
  * @example
  * ```ts
  * import { loadCodeSystem, lookup } from "@cosyte/terminology";
@@ -1259,7 +1259,7 @@ declare function lookup(cs: CodeSystem, code: string): LookupOutcome;
  * `$validate-code`: is `code` a valid member of the loaded code system?
  *
  * A found code is `valid: true`, **carrying its status** (a deprecated or header code is present but
- * flagged — never silently clean). An absent code is `valid: false` with `TERM_CODE_UNKNOWN`, never a
+ * flagged: never silently clean). An absent code is `valid: false` with `TERM_CODE_UNKNOWN`, never a
  * guessed `true`.
  *
  * @param cs - The loaded {@link CodeSystem}.
@@ -1280,14 +1280,14 @@ declare function lookup(cs: CodeSystem, code: string): LookupOutcome;
 declare function validateCode(cs: CodeSystem, code: string): ValidateCodeResult;
 
 /**
- * The **RRF** (Rich Release Format) reader — the pipe-delimited layer shared by RxNorm (`RXNCONSO`/
+ * The **RRF** (Rich Release Format) reader: the pipe-delimited layer shared by RxNorm (`RXNCONSO`/
  * `RXNSAT`) and UMLS (`MRCONSO`/`MRSAT`). One parameterized reader serves both: they share the RRF
- * shape — fields separated by `|`, with **one trailing pipe per line** (grounded firsthand on the
+ * shape: fields separated by `|`, with **one trailing pipe per line** (grounded firsthand on the
  * UMLS Reference Manual, `https://www.ncbi.nlm.nih.gov/books/NBK9685/`: *"values … are separated by
  * vertical bars (|)"* and each row ends with *"a vertical bar and line termination"*).
  *
  * **Liberal on load**: a row too short to reach a configured column, or with an empty
- * code, is **skipped and surfaced** as a `TERM_RRF_MALFORMED_ROW` warning — never kept as a partial
+ * code, is **skipped and surfaced** as a `TERM_RRF_MALFORMED_ROW` warning: never kept as a partial
  * concept, never a crash. RRF reserves `|` as the delimiter (fields never contain a literal pipe), so
  * a plain split is exact.
  *
@@ -1311,7 +1311,7 @@ declare function parseRrfLine(line: string): readonly string[];
  * Parse an {@link RrfSource} into concepts (first row per code wins) and skipped-row warnings.
  *
  * A code that recurs across rows (RRF repeats a code once per atom/attribute) keeps its **first**
- * occurrence — a documented v1 limitation: preferred-atom selection (`TS`/`STT`/`ISPREF`) and
+ * occurrence, a documented v1 limitation: preferred-atom selection (`TS`/`STT`/`ISPREF`) and
  * attribute merging are later work. The result is data only; {@link loadCodeSystem} freezes it.
  *
  * @param source - The RRF source.
@@ -1334,17 +1334,17 @@ declare function parseRrf(source: RrfSource): {
 };
 
 /**
- * The **RFC-4180 CSV** reader — the one release format that needs real quote handling (LOINC's
+ * The **RFC-4180 CSV** reader: the one release format that needs real quote handling (LOINC's
  * `Loinc.csv`). Fields may be quoted with `"`; inside a quoted field a literal quote is escaped as
  * `""`, and commas and newlines are data. Hand-rolled, zero-dep (the CSV surface is small and
  * well-specified enough to hand-roll rather than pull a dependency).
  *
  * **Liberal on load:** a data row with too few fields to reach a configured column is **skipped and
- * surfaced** as a `TERM_CSV_MALFORMED` warning; an unterminated final quote is surfaced too — never a
+ * surfaced** as a `TERM_CSV_MALFORMED` warning; an unterminated final quote is surfaced too: never a
  * crash. A configured code/display header that is **absent from the header row** is a *fatal*
  * (`TERM_CODESYSTEM_MALFORMED`): the source config does not match the file, so nothing loads cleanly.
  * That fatal names the missing column's **role** (`code`, `display`, `status`, a property column)
- * from a frozen table, never the column name you configured — the message reaches `err.stack`, and a
+ * from a frozen table, never the column name you configured: the message reaches `err.stack`, and a
  * column name is consumer-supplied text of unbounded length.
  *
  * @packageDocumentation
@@ -1390,14 +1390,14 @@ declare function parseCsvSource(source: CsvSource): {
 };
 
 /**
- * The **fixed-width** reader — slice a line by column, for order-file layouts like the ICD-10-CM
+ * The **fixed-width** reader: slice a line by column, for order-file layouts like the ICD-10-CM
  * order file (`icd10cm_order_YYYY.txt`). Fully parameterized: the consumer supplies the field slices,
  * so the *engine* is content-agnostic and the byte offsets live in the caller's config, not baked in.
  *
- * The documented ICD-10-CM preset is {@link ICD10CM_ORDER_FILE_FIELDS} — the position-15 flag
+ * The documented ICD-10-CM preset is {@link ICD10CM_ORDER_FILE_FIELDS}: the position-15 flag
  * (0-based char index 14) is `1` for a **billable/valid** code and `0` for a **header** (grounded on
  * the CMS/CDC order-file layout). Confirm the exact offsets against your release's README before
- * relying on the preset — which is exactly why the reader takes the slices as a parameter.
+ * relying on the preset, which is exactly why the reader takes the slices as a parameter.
  *
  * **Liberal on load:** a line too short to contain the code slice, or with an empty code, is skipped
  * and surfaced as a `TERM_FIXED_WIDTH_MALFORMED` warning.
@@ -1422,10 +1422,10 @@ declare function sliceField(line: string, slice: FieldSlice): string;
 /**
  * The documented **ICD-10-CM order file** field layout (0-based char indices).
  *
- * - `code` — the ICD-10-CM code (no decimal point).
- * - `billable` — position-15 flag at index 14: `"1"` = billable/valid leaf, `"0"` = header.
- * - `display` — the long description (to end of line).
- * - property `shortDescription` — the 60-char short description.
+ * - `code`: the ICD-10-CM code (no decimal point).
+ * - `billable`, position-15 flag at index 14: `"1"` = billable/valid leaf, `"0"` = header.
+ * - `display`: the long description (to end of line).
+ * - property `shortDescription`: the 60-char short description.
  *
  * Grounded on the CMS/CDC order-file layout; **verify against your release's README** before relying
  * on the exact offsets, which are not confirmed against an authoritative machine-readable source.
@@ -1456,14 +1456,14 @@ declare function parseFixedWidth(source: FixedWidthSource): {
 };
 
 /**
- * The **FHIR R4 `CodeSystem`** JSON loader — the native, consumer-supplied model. Reads the untrusted
+ * The **FHIR R4 `CodeSystem`** JSON loader: the native, consumer-supplied model. Reads the untrusted
  * resource into the engine's {@link Concept} map, flattening nested `concept` hierarchies and mapping
  * the standard concept properties to {@link ConceptStatus}.
  *
  * Grounded firsthand on FHIR R4 (`https://hl7.org/fhir/R4/codesystem.html` and the concept-properties
  * code system, `https://hl7.org/fhir/R4/codesystem-concept-properties.html`): a concept has
  * `code`/`display`/`definition`/`designation`/`property`/nested `concept`; the base property
- * **`inactive`** (boolean) is *"True if the concept is not considered active — e.g. not a valid
+ * **`inactive`** (boolean) is *"True if the concept is not considered active: e.g. not a valid
  * concept any more"*, **`deprecated`** (dateTime) marks a deprecation, and a `status` string property
  * is common in real systems.
  *
@@ -1500,14 +1500,14 @@ declare function parseFhirCodeSystem(source: FhirCodeSystemSource): {
 };
 
 /**
- * Status interpretation shared by the loaders — the {@link defaultStatusMapper} that turns a raw
+ * Status interpretation shared by the loaders: the {@link defaultStatusMapper} that turns a raw
  * steward status token into a normalized {@link ConceptActivity}, and {@link makeStatus} which
  * assembles the frozen {@link ConceptStatus} (attaching the stable diagnostic code for the two
  * concerns it distinguishes: deprecated and header-not-billable).
  *
  * The mapper is deliberately **conservative**: it recognizes only the tokens grounded in the format
  * docs (LOINC `STATUS` lifecycle values and RxNorm/UMLS `SUPPRESS` values), and maps
- * everything else to `unknown` — a non-active state carrying the raw token, **never** a guessed
+ * everything else to `unknown`: a non-active state carrying the raw token, **never** a guessed
  * clean-active. Every loader lets the consumer override it for a release with bespoke semantics.
  *
  * @packageDocumentation
@@ -1534,7 +1534,7 @@ declare const defaultStatusMapper: StatusMapper;
 /**
  * Assemble a frozen {@link ConceptStatus} from a normalized activity, carrying the raw token and (for
  * classification systems) the billable flag, and attaching the stable diagnostic code for the two
- * concerns it distinguishes — `TERM_CONCEPT_DEPRECATED` and `TERM_CONCEPT_HEADER_NOT_BILLABLE`.
+ * concerns it distinguishes: `TERM_CONCEPT_DEPRECATED` and `TERM_CONCEPT_HEADER_NOT_BILLABLE`.
  *
  * @param activity - The normalized activity.
  * @param raw - The verbatim steward token, if any (omitted from the result when empty).
@@ -1556,7 +1556,7 @@ declare function makeStatus(activity: ConceptActivity, raw?: string, billable?:
  * {@link ValueSetMembership} outcomes.
  *
  * The model is **content-agnostic**: a `ValueSet` names codes by system URI and is expanded over
- * **consumer-supplied** {@link CodeSystem} releases — the engine ships **zero** encoded value-set
+ * **consumer-supplied** {@link CodeSystem} releases: the engine ships **zero** encoded value-set
  * content (SNOMED CT / CPT / LOINC / UMLS / VSAC value sets are strictly BYO). The FHIR
  * operation shapes are grounded firsthand on the FHIR R4 Terminology Module
  * (`https://hl7.org/fhir/R4/valueset.html`, `https://hl7.org/fhir/R4/valueset-operation-expand.html`,
@@ -1566,17 +1566,17 @@ declare function makeStatus(activity: ConceptActivity, raw?: string, billable?:
  */
 
 /**
- * A FHIR R4 `ValueSet.compose.include.filter` operator — the subset the engine implements plus the
+ * A FHIR R4 `ValueSet.compose.include.filter` operator: the subset the engine implements plus the
  * ones it explicitly does not. Grounded on the FHIR `filter-operator` code system
  * (`https://hl7.org/fhir/R4/valueset-filter-operator.html`).
  *
  * **Implemented:** `is-a` / `descendent-of` / `is-not-a` (subsumption over the loaded release's
  * hierarchy), `=` / `in` / `not-in` / `exists` (property predicates). **Not implemented** (surfaced as
  * a typed {@link DiagnosticCode.TERM_VALUESET_CANNOT_EXPAND}, never silently mis-expanded): `regex`,
- * `generalizes`. Anything unrecognized is treated as not-implemented — never as "matches nothing".
+ * `generalizes`. Anything unrecognized is treated as not-implemented: never as "matches nothing".
  */
 type FilterOperator = "=" | "is-a" | "descendent-of" | "is-not-a" | "regex" | "in" | "not-in" | "generalizes" | "exists";
-/** One `ValueSet.compose.include.filter` — a `property op value` predicate over a code system. */
+/** One `ValueSet.compose.include.filter`: a `property op value` predicate over a code system. */
 interface ConceptSetFilter {
     /** The concept property the predicate is on (e.g. `"concept"` for the code hierarchy, or a code). */
     readonly property: string;
@@ -1585,7 +1585,7 @@ interface ConceptSetFilter {
     /** The comparison value (for `in`/`not-in`, a comma-separated list; for `is-a`, an anchor code). */
     readonly value: string;
 }
-/** One explicit `ValueSet.compose.include.concept` — an enumerated code (extensional). */
+/** One explicit `ValueSet.compose.include.concept`: an enumerated code (extensional). */
 interface ConceptRef {
     /** The code, drawn verbatim from the value set. */
     readonly code: string;
@@ -1593,7 +1593,7 @@ interface ConceptRef {
     readonly display?: string;
 }
 /**
- * One `ValueSet.compose.include` / `.exclude` component — a `ConceptSet`. Selects codes by an explicit
+ * One `ValueSet.compose.include` / `.exclude` component: a `ConceptSet`. Selects codes by an explicit
  * `concept` list, by `filter`s over a `system`, by referencing other value sets (`valueSet`), or a
  * combination (the combination is an **intersection**, per FHIR).
  */
@@ -1609,18 +1609,18 @@ interface ConceptSetComponent {
     /** Canonical URLs of other value sets; a code must be a member of **every** one (intersection). */
     readonly valueSet?: readonly string[];
 }
-/** A `ValueSet.compose` — the intensional/extensional definition of membership. */
+/** A `ValueSet.compose`: the intensional/extensional definition of membership. */
 interface ValueSetCompose {
     /** The `include` components (their union, minus every {@link exclude}, is the membership). */
     readonly include: readonly ConceptSetComponent[];
-    /** The `exclude` components — codes removed from the include union. */
+    /** The `exclude` components: codes removed from the include union. */
     readonly exclude: readonly ConceptSetComponent[];
 }
 /** One `ValueSet.expansion.contains` entry from a **pre-computed** expansion. */
 interface ExpansionContains {
     /** The code system URI, when the entry names one. */
     readonly system?: string;
-    /** The code. Required — a `contains` entry without a code is a malformed expansion. */
+    /** The code. Required: a `contains` entry without a code is a malformed expansion. */
     readonly code: string;
     /** The display, carried verbatim when present. */
     readonly display?: string;
@@ -1628,7 +1628,7 @@ interface ExpansionContains {
     readonly version?: string;
 }
 /**
- * A **pre-computed** `ValueSet.expansion` — a cached membership snapshot, used as-is (extensional).
+ * A **pre-computed** `ValueSet.expansion`: a cached membership snapshot, used as-is (extensional).
  * The engine never re-derives it; it only checks whether it is **complete** (a truncated
  * expansion must never read as full membership).
  */
@@ -1645,7 +1645,7 @@ interface ValueSetExpansion {
     readonly truncated: boolean;
 }
 /**
- * A loaded, immutable `ValueSet` — the subset of the FHIR R4 `ValueSet` resource the binding layer
+ * A loaded, immutable `ValueSet`: the subset of the FHIR R4 `ValueSet` resource the binding layer
  * needs. Produced by {@link loadValueSet}; every field deep-frozen.
  */
 interface ValueSet {
@@ -1676,14 +1676,14 @@ interface ExpansionContext {
     /** Referenced value sets, keyed by canonical URL, for `compose.include.valueSet`. */
     readonly valueSets?: ReadonlyMap<string, ValueSet>;
 }
-/** A surfaced expansion concern — a part that could not be expanded, or a truncated snapshot. */
+/** A surfaced expansion concern: a part that could not be expanded, or a truncated snapshot. */
 interface ExpansionDiagnostic {
     /** The stable code (`TERM_VALUESET_CANNOT_EXPAND` / `TERM_VALUESET_EXPANSION_TRUNCATED`). */
     readonly code: DiagnosticCode;
     /** A **value-free** structural description of the concern (never echoes a patient value). */
     readonly detail: string;
     /**
-     * A **value-free structural locus** into the caller's own resource — `"expansion"`, or a
+     * A **value-free structural locus** into the caller's own resource: `"expansion"`, or a
      * `compose`-relative index path such as `"compose.include[2]"` or
      * `"compose.include[0].valueSet[1]"`. A diagnostic raised while expanding a *referenced* value set
      * is prefixed with the reference that reached it (`"compose.include[0].valueSet[1]/compose.include[3]"`).
@@ -1713,7 +1713,7 @@ interface ExpandResult {
     /** The surfaced concerns, in encounter order (frozen; may be empty). */
     readonly diagnostics: readonly ExpansionDiagnostic[];
 }
-/** A definitive membership answer — the code is (or is not) a member of the value set. */
+/** A definitive membership answer: the code is (or is not) a member of the value set. */
 interface ValueSetMemberDecided {
     /** Discriminant: membership was decided. */
     readonly undetermined: false;
@@ -1723,7 +1723,7 @@ interface ValueSetMemberDecided {
     readonly coding: Coding;
 }
 /**
- * A **fail-safe undetermined** membership — the never-fabricate outcome for a value set that could
+ * A **fail-safe undetermined** membership: the never-fabricate outcome for a value set that could
  * not be fully evaluated (a missing code system, a truncated expansion). The engine refuses to guess:
  * it returns neither `true` nor `false`, so a caller can never mistake "we could not check" for "not a
  * member" (a false "not a member" is a clinical error).
@@ -1742,14 +1742,14 @@ interface ValueSetMemberUndetermined {
 type ValueSetMembership = ValueSetMemberDecided | ValueSetMemberUndetermined;
 
 /**
- * {@link loadValueSet} — validate and normalize an untrusted FHIR R4 `ValueSet` JSON resource into
+ * {@link loadValueSet}: validate and normalize an untrusted FHIR R4 `ValueSet` JSON resource into
  * the immutable {@link ValueSet} model the `$expand` / `$validate-code` binding operations run over.
  *
  * **Conservative on load** (like {@link ../conceptmap/load.loadConceptMap}, unlike a lenient wire
  * parser): a value set *binds* whether a code is allowed in a clinical slot, so a structurally
  * unusable resource is a typed **fatal** ({@link FATAL_CODES.TERM_VALUESET_MALFORMED}) rather than a
  * silently partial value set that would admit *some* codes and quietly drop others. A `filter`
- * operator the engine does not implement is **not** fatal — the value set loads, and the gap surfaces
+ * operator the engine does not implement is **not** fatal: the value set loads, and the gap surfaces
  * at expansion time as a {@link DIAGNOSTIC_CODES.TERM_VALUESET_CANNOT_EXPAND} diagnostic. Fault
  * messages are **value-free**: they name the resource *path* and the fault, never echo a code value.
  *
@@ -1765,7 +1765,7 @@ type ValueSetMembership = ValueSetMemberDecided | ValueSetMemberUndetermined;
  * `truncated` flag). The result is deep-frozen. Anything structurally unusable throws a
  * {@link TerminologyError} carrying {@link FATAL_CODES.TERM_VALUESET_MALFORMED}.
  *
- * @param json - The untrusted resource (typically `JSON.parse` output — hence `unknown`).
+ * @param json - The untrusted resource (typically `JSON.parse` output, hence `unknown`).
  * @returns The immutable, validated {@link ValueSet}.
  * @throws {TerminologyError} `TERM_VALUESET_MALFORMED` when the resource is not a usable ValueSet.
  * @example
@@ -1785,20 +1785,20 @@ type ValueSetMembership = ValueSetMemberDecided | ValueSetMemberUndetermined;
 declare function loadValueSet(json: unknown): ValueSet;
 
 /**
- * {@link expand} — the FHIR R4 ValueSet `$expand` operation over a loaded {@link ValueSet}.
+ * {@link expand}: the FHIR R4 ValueSet `$expand` operation over a loaded {@link ValueSet}.
  *
  * Grounded firsthand on FHIR R4 (`https://hl7.org/fhir/R4/valueset-operation-expand.html`,
  * `https://hl7.org/fhir/R4/valueset.html#compose`):
  *
- * - A **pre-computed** `expansion` is used as-is (extensional), and its completeness is checked — a
+ * - A **pre-computed** `expansion` is used as-is (extensional), and its completeness is checked: a
  *   truncated snapshot is flagged, never treated as full membership.
  * - An intensional `compose` is expanded over **consumer-supplied** {@link ../codesystem/types.CodeSystem}
  *   releases: the union of `include` components minus the union of `exclude` components. Each component
  *   selects by explicit `concept`, by `filter` (subsumption + property predicates), by the whole
  *   `system`, and/or by intersecting referenced value sets.
  *
- * **Never fabricate.** A part that cannot be computed — a missing code system, an unresolved
- * referenced value set, an unimplemented `filter` operator — yields a typed
+ * **Never fabricate.** A part that cannot be computed (a missing code system, an unresolved
+ * referenced value set, an unimplemented `filter` operator) yields a typed
  * {@link ../common/diagnostics.DIAGNOSTIC_CODES.TERM_VALUESET_CANNOT_EXPAND} and marks the result
  * `complete: false`, so the `contains` set is an explicit **lower bound**, never a silently-empty or
  * fabricated membership.
@@ -1811,7 +1811,7 @@ declare function loadValueSet(json: unknown): ValueSet;
  *
  * @param vs - The loaded value set.
  * @param ctx - The loaded code systems / referenced value sets the intensional parts resolve against.
- * @returns An {@link ExpandResult} — the `contains` members plus an honest `complete` flag. When
+ * @returns An {@link ExpandResult}: the `contains` members plus an honest `complete` flag. When
  *   `complete` is `false`, `contains` is a lower bound (never treat it as exhaustive membership).
  * @example
  * ```ts
@@ -1837,16 +1837,16 @@ declare function loadValueSet(json: unknown): ValueSet;
 declare function expand(vs: ValueSet, ctx?: ExpansionContext): ExpandResult;
 
 /**
- * {@link validateCodeInValueSet} — the FHIR R4 ValueSet `$validate-code` operation (value-set
+ * {@link validateCodeInValueSet}: the FHIR R4 ValueSet `$validate-code` operation (value-set
  * binding): is a {@link Coding} a member of a {@link ValueSet}?
  *
  * Grounded firsthand on FHIR R4 (`https://hl7.org/fhir/R4/valueset-operation-validate-code.html`): a
  * binding decides whether a code is *allowed* in a slot. The engine returns a **decided** membership
- * (`result: true`/`false`) **only when it can prove it** — a code found in a computable `include` and
+ * (`result: true`/`false`) **only when it can prove it**: a code found in a computable `include` and
  * not removed by any computable `exclude` is a definite member; a code absent from a fully-evaluated
  * value set is a definite non-member. When any relevant part cannot be evaluated (a missing code
  * system, a truncated pre-computed expansion, an unimplemented `filter`), the answer is a typed
- * {@link ValueSetMemberUndetermined} — **never** a fabricated `false` (a false "not a member" is a
+ * {@link ValueSetMemberUndetermined}: **never** a fabricated `false` (a false "not a member" is a
  * clinical error).
  *
  * @packageDocumentation
@@ -1859,7 +1859,7 @@ declare function expand(vs: ValueSet, ctx?: ExpansionContext): ExpandResult;
  * @param valueSet - The loaded value set.
  * @param ctx - The loaded code systems / referenced value sets the intensional parts resolve against.
  * @returns A decided {@link ValueSetMembership} (`result: true`/`false`), or a typed
- *   {@link ValueSetMemberUndetermined} when membership could not be proven — never a fabricated `false`.
+ *   {@link ValueSetMemberUndetermined} when membership could not be proven: never a fabricated `false`.
  * @example
  * ```ts
  * import { loadValueSet, validateCodeInValueSet } from "@cosyte/terminology";
@@ -1875,15 +1875,15 @@ declare function expand(vs: ValueSet, ctx?: ExpansionContext): ExpandResult;
 declare function validateCodeInValueSet(coding: Coding, valueSet: ValueSet, ctx?: ExpansionContext): ValueSetMembership;
 
 /**
- * Subsumption + `compose.include.filter` evaluation — the shared machinery {@link ./expand.expand}
+ * Subsumption + `compose.include.filter` evaluation: the shared machinery {@link ./expand.expand}
  * and {@link ./validate.validateCodeInValueSet} both draw on.
  *
  * **Subsumption** is read from the loaded {@link CodeSystem}'s **`parent`** concept-properties
- * (`http://hl7.org/fhir/concept-properties#parent`) — which the FHIR loader synthesizes from a nested
+ * (`http://hl7.org/fhir/concept-properties#parent`), which the FHIR loader synthesizes from a nested
  * `concept` hierarchy and carries verbatim from an explicit `parent` property. This is deliberately
  * the release's **own** hierarchy: subsumption across two separate releases is not computed, and a
  * code system that encodes no parent edges has no descendants beyond identity, which is treated as
- * complete — not guessed deeper.
+ * complete: not guessed deeper.
  *
  * **Filter support is explicit.** `is-a` / `descendent-of` / `is-not-a` / `=` / `in` / `not-in` /
  * `exists` are implemented; `regex` / `generalizes` / anything unrecognized report `supported: false`
@@ -1894,7 +1894,7 @@ declare function validateCodeInValueSet(coding: Coding, valueSet: ValueSet, ctx?
  */
 
 /**
- * The filters whose operator the engine does **not** implement (`regex` / `generalizes` / unknown) —
+ * The filters whose operator the engine does **not** implement (`regex` / `generalizes` / unknown):
  * a non-empty result means the caller must surface a typed cannot-expand, never mis-expand.
  *
  * @param filters - The component's filters.
@@ -1930,7 +1930,7 @@ interface Subsumption {
  */
 declare function buildSubsumption(cs: CodeSystem): Subsumption;
 /**
- * True when `code` is-a `anchor` — the same code, or a (transitive) descendant of it.
+ * True when `code` is-a `anchor`: the same code, or a (transitive) descendant of it.
  *
  * @param sub - The subsumption index (from {@link buildSubsumption}).
  * @param code - The candidate code.
@@ -1960,7 +1960,7 @@ interface FilterMatch {
  *
  * The `concept` filter property (and the hierarchy operators regardless of property) reads the code
  * itself / its subsumption; other properties read the concept's `property` values. An unimplemented
- * operator returns `{ supported: false }` — never a coerced `matched`.
+ * operator returns `{ supported: false }`: never a coerced `matched`.
  *
  * @param concept - The concept under test.
  * @param filter - The filter predicate.
@@ -1984,12 +1984,12 @@ declare function matchesFilter(concept: Concept, filter: ConceptSetFilter, sub:
  * Types for the **UCUM unit layer**: the parsed unit AST, the reduced
  * (canonical) dimensional form, and the public {@link UcumValidation} result.
  *
- * The layer is **recognition + validation + representation canonicalization only** — it answers
+ * The layer is **recognition + validation + representation canonicalization only**: it answers
  * "is this a valid UCUM expression" and "are these two expressions the same unit", and it
  * canonicalizes a unit's *representation*. It performs **no magnitude conversion** (`mg/dL` →
- * `mmol/L` needs an analyte's molar mass — a clinical computation the engine refuses). The tables
+ * `mmol/L` needs an analyte's molar mass: a clinical computation the engine refuses). The tables
  * are the UCUM `ucum-essence.xml`, **bundled verbatim** in this package (copyright © Regenstrief
- * Institute, Inc. — see `vendor/ucum/NOTICE.md`) and transformed to an in-memory model at runtime;
+ * Institute, Inc.: see `vendor/ucum/NOTICE.md`) and transformed to an in-memory model at runtime;
  * the engine ships **no derivative** of the UCUM table.
  *
  * @packageDocumentation
@@ -2010,18 +2010,18 @@ interface UcumAtom {
     readonly code: string;
     /** Whether a metric prefix may attach to this atom (essence `isMetric`). Only metric atoms prefix. */
     readonly metric: boolean;
-    /** A **base** unit (one of the 7: `m s g rad K C cd`) — its own dimension, factor 1. */
+    /** A **base** unit (one of the 7: `m s g rad K C cd`), its own dimension, factor 1. */
     readonly base: boolean;
     /** A base unit's dimension key (its own `code`), or `undefined` for derived atoms. */
     readonly dim?: string;
     /**
-     * A **special** unit (essence `isSpecial`, e.g. `Cel`, `B`, `[pH]`) — defined by a non-linear
+     * A **special** unit (essence `isSpecial`, e.g. `Cel`, `B`, `[pH]`): defined by a non-linear
      * function, so it has **no** linear factor/dimension and is never reduced to one. Compared only by
      * identity of its normalized representation (never claimed equal to a linear unit).
      */
     readonly special: boolean;
     /**
-     * An **arbitrary** unit (essence `isArbitrary`, e.g. `[IU]`, `[arb'U]`) — not commensurable with
+     * An **arbitrary** unit (essence `isArbitrary`, e.g. `[IU]`, `[arb'U]`): not commensurable with
      * any other unit. Modeled as its own dimension axis keyed by the atom `code`, so `[IU]/[IU]`
      * reduces to unity but `[IU]` is never equated with a mass or another arbitrary unit.
      */
@@ -2035,7 +2035,7 @@ interface UcumAtom {
         readonly unit: string;
     };
 }
-/** The parsed UCUM essence table — the engine's in-memory unit model, built lazily and cached. */
+/** The parsed UCUM essence table: the engine's in-memory unit model, built lazily and cached. */
 interface UcumEssence {
     /** Prefix symbols → prefix, longest symbols first (for greedy matching). */
     readonly prefixes: readonly UcumPrefix[];
@@ -2072,7 +2072,7 @@ interface GroupNode {
 interface AnnotationNode {
     readonly kind: "annotation";
 }
-/** A component: a simple unit, a factor, a group, or an annotation — each optionally exponentiated. */
+/** A component: a simple unit, a factor, a group, or an annotation, each optionally exponentiated. */
 type ComponentNode = SimpleUnitNode | FactorNode | GroupNode | AnnotationNode;
 /**
  * A parsed UCUM term: an ordered list of components, each combined into the product with the given
@@ -2099,10 +2099,10 @@ interface LinearReduction {
     readonly dims: Readonly<Record<string, number>>;
 }
 /**
- * A **non-linear** (special) reduction — the expression involves a special unit (`Cel`, `B`, …) and
+ * A **non-linear** (special) reduction: the expression involves a special unit (`Cel`, `B`, …) and
  * cannot be reduced to a scalar×dimension form. Carried by its normalized representation `form`;
  * two special reductions are the same unit iff their `form`s are identical (never equated with a
- * linear unit — the never-fabricate posture applied to units).
+ * linear unit: the never-fabricate posture applied to units).
  */
 interface SpecialReduction {
     readonly kind: "special";
@@ -2119,7 +2119,7 @@ type UcumValidation = {
     /** The expression is a well-formed UCUM unit over known atoms. */
     readonly valid: true;
     /**
-     * A stable, normalized **descriptor** of the unit's canonical form — equal iff the units are
+     * A stable, normalized **descriptor** of the unit's canonical form: equal iff the units are
      * the same (see {@link ucumEqual}). Note: this is a comparison/debug descriptor, **not**
      * guaranteed to be a re-parseable UCUM expression (UCUM cannot express arbitrary numeric
      * factors as literals).
@@ -2128,7 +2128,7 @@ type UcumValidation = {
 } | {
     /** The expression is not a valid UCUM unit. */
     readonly valid: false;
-    /** The stable diagnostic code — never a guessed "nearest" unit (the never-fabricate rule). */
+    /** The stable diagnostic code: never a guessed "nearest" unit (the never-fabricate rule). */
     readonly code: "TERM_UCUM_INVALID";
     /** A **value-free** structural reason (a grammar fault or an unknown atom; never PHI). */
     readonly reason: string;
@@ -2138,7 +2138,7 @@ type UcumValidation = {
  * The public **UCUM** surface: {@link validateUcum} (recognition + a canonical
  * descriptor) and {@link ucumEqual} (are two expressions the *same unit*).
  *
- * Both are **recognition / validation / representation-canonicalization only** — never magnitude
+ * Both are **recognition / validation / representation-canonicalization only**: never magnitude
  * conversion. The never-fabricate posture holds: an unparseable or unknown unit is
  * a typed {@link TERM_UCUM_INVALID} outcome carrying a value-free reason, **never** a guessed
  * "nearest" unit; and a special (non-linear) unit is never claimed equal to a linear one.
@@ -2151,7 +2151,7 @@ type UcumValidation = {
  *
  * Validation **is** parsing against the UCUM grammar over the known atom table: an expression is
  * valid iff it parses completely. An invalid expression returns a typed {@link TERM_UCUM_INVALID}
- * with a value-free reason — never a coerced or guessed unit.
+ * with a value-free reason: never a coerced or guessed unit.
  *
  * @param unit - The UCUM unit expression (e.g. `"mmol/L"`, `"kg.m/s2"`, `"Cel"`).
  * @returns `{ valid: true, canonical }` or `{ valid: false, code: "TERM_UCUM_INVALID", reason }`.
@@ -2166,13 +2166,13 @@ type UcumValidation = {
  */
 declare function validateUcum(unit: string): UcumValidation;
 /**
- * Whether two UCUM expressions denote the **same unit** — i.e. they reduce to the same canonical
+ * Whether two UCUM expressions denote the **same unit**: i.e. they reduce to the same canonical
  * form (equal base dimensions *and* equal scale). This recognizes representational equivalences
  * (`N` ≡ `kg.m/s2`, `mmol/L` ≡ `mmol.L-1`, annotations inert) but is **not** magnitude conversion:
  * `mg` and `g` are different units and compare unequal.
  *
  * A unit is never equal to an invalid expression, and a special (non-linear) unit (`Cel`, `[pH]`) is
- * equal only to a structurally identical special unit — never to a linear unit (the never-fabricate
+ * equal only to a structurally identical special unit: never to a linear unit (the never-fabricate
  * posture: the engine will not assert an equivalence it cannot prove).
  *
  * @param a - The first UCUM unit expression.
@@ -2195,7 +2195,7 @@ declare function ucumEqual(a: string, b: string): boolean;
  * specification's syntax (base units, metric prefixes attached with no delimiter and resolved by
  * longest-match, `.` multiply / `/` divide, signed integer exponents, `{…}` inert annotations, and
  * the `10*` / `10^` powers-of-ten). Validation **is** parsing: an expression is valid iff it parses
- * completely over **known** atoms — an unknown atom yields no match and fails, never a guessed unit.
+ * completely over **known** atoms: an unknown atom yields no match and fails, never a guessed unit.
  *
  * @packageDocumentation
  */
@@ -2228,13 +2228,13 @@ declare function parseUcum(unit: string): ParseResult;
 
 /**
  * **Dimensional reduction** of a parsed UCUM unit: reduce an expression to its
- * canonical base-unit form — a scalar factor times a map of the seven UCUM base dimensions
+ * canonical base-unit form: a scalar factor times a map of the seven UCUM base dimensions
  * (`m s g rad K C cd`), recursively substituting each atom's essence definition down to base units.
  *
  * This is **representation** canonicalization, not magnitude *conversion*: it answers "are these two
  * expressions the same unit" (`N` ≡ `kg.m/s2`, `mmol/L` ≡ `mmol.L-1`), never "what is 5 mg/dL in
  * mmol/L" (that needs an analyte's molar mass, which the engine refuses). **Special** units (`Cel`,
- * `B`, `[pH]`) are non-linear and carry no factor/dimension — they reduce to an opaque normalized
+ * `B`, `[pH]`) are non-linear and carry no factor/dimension: they reduce to an opaque normalized
  * form and are never equated with a linear unit. **Arbitrary** units (`[IU]`, `[arb'U]`) are modeled
  * as their own dimension axis, so they cancel with themselves but convert to nothing else.
  *
@@ -2242,7 +2242,7 @@ declare function parseUcum(unit: string): ParseResult;
  */
 
 /**
- * Reduce a parsed UCUM unit to its canonical {@link Reduction} — a linear scalar×dimension form, or
+ * Reduce a parsed UCUM unit to its canonical {@link Reduction}: a linear scalar×dimension form, or
  * an opaque `special` form for expressions involving a non-linear special unit.
  *
  * The reduction of one atom is cached against **that atom object**, so a `UnitNode` you assembled
@@ -2255,8 +2255,8 @@ declare function parseUcum(unit: string): ParseResult;
  *   definition does not parse. **No expression {@link parseUcum} accepts reaches either**; a node
  *   you assemble yourself can, including by defining an atom in terms of a special unit such as
  *   `Cel`, which lands on the table's own `Cel`. A third guard catches a definition that leads back
- *   to itself. Naming a table atom does not reach it — a definition is resolved against the loaded
- *   table, so your atom can name one but never be one — and neither does the table itself, which is
+ *   to itself. Naming a table atom does not reach it (a definition is resolved against the loaded
+ *   table, so your atom can name one but never be one), and neither does the table itself, which is
  *   frozen; what reaches it is a `value` accessor that re-enters `reduce` for the same atom while
  *   that atom is still being reduced. The message names the fault, never the atom.
  * @example
@@ -2274,13 +2274,13 @@ declare function reduce(node: UnitNode): Reduction;
 
 /**
  * Parse the vendored, verbatim UCUM `ucum-essence.xml` (embedded as {@link UCUM_ESSENCE_XML}) into
- * the engine's in-memory unit model — the {@link UcumEssence} table of prefixes and atoms.
+ * the engine's in-memory unit model: the {@link UcumEssence} table of prefixes and atoms.
  *
  * Hand-rolled, **zero-dependency** scanning of a known-well-formed document (not a general XML
  * parser): the essence file is a flat, regular list of `<prefix>` / `<base-unit>` / `<unit>`
- * elements. Parsed **once**, lazily, and cached — the engine reads no file at runtime; the table is
+ * elements. Parsed **once**, lazily, and cached: the engine reads no file at runtime; the table is
  * a pure in-process transform of the embedded verbatim content, never serialized or distributed. The
- * UCUM table is copyright © Regenstrief Institute, Inc. and is bundled verbatim — see
+ * UCUM table is copyright © Regenstrief Institute, Inc. and is bundled verbatim: see
  * `vendor/ucum/NOTICE.md`, which ships with this package.
  *
  * @packageDocumentation
@@ -2292,7 +2292,7 @@ declare function reduce(node: UnitNode): Reduction;
  * One table is shared by every caller and by the engine itself, so it is handed out **frozen**: an
  * atom's definition cannot be rewritten in place, and neither can the `atoms` array the parser
  * scans. It used to be, and doing so before that atom's first reduction poisoned the
- * reduction memo for the life of the process — a fabricated unit equivalence that survived putting
+ * reduction memo for the life of the process: a fabricated unit equivalence that survived putting
  * the table back. A write is refused, which in strict mode means a `TypeError`.
  *
  * @returns The shared, frozen in-memory {@link UcumEssence} model.
@@ -2307,19 +2307,19 @@ declare function reduce(node: UnitNode): Reduction;
 declare function loadUcumEssence(): UcumEssence;
 
 /**
- * The types for the **crosswalk resolvers** — the CMS ICD-9↔ICD-10 **GEMs**
+ * The types for the **crosswalk resolvers**: the CMS ICD-9↔ICD-10 **GEMs**
  * (General Equivalence Mappings) and the NLM **SNOMED CT → ICD-10-CM complex map**.
  *
  * Both are the library's highest-risk surface, and their types are built around the stewards' own
- * warnings: these maps are **approximate, 1:many, context-dependent, and non-invertible** — *"not
+ * warnings: these maps are **approximate, 1:many, context-dependent, and non-invertible**, *"not
  * crosswalks… reference mappings"* (CMS on the GEMs), *"semi-automated"* (NLM on the SNOMED map). So
  * every result type here is a **discriminated, fail-safe outcome** carrying the steward's flags,
  * never a single collapsed target:
  *
- * - a No-Map is a typed {@link CrosswalkNoMap} — the steward said "cannot be classified", surfaced,
+ * - a No-Map is a typed {@link CrosswalkNoMap}: the steward said "cannot be classified", surfaced,
  *   never a guessed code;
  * - a 1:many source yields the **whole** ordered candidate set, never one confident pick;
- * - a context-dependent rule with no runtime context is a typed {@link ComplexMapContextRequired} —
+ * - a context-dependent rule with no runtime context is a typed {@link ComplexMapContextRequired}:
  *   the rule + advice ride through, the engine never picks a branch it wasn't given the data for;
  * - all Map Advice / GEM flags ride through **verbatim** (advice flags must not be swallowed);
  * - a directional map is **never inverted** (see {@link ../crosswalk/gems.invertGem}).
@@ -2329,7 +2329,7 @@ declare function loadUcumEssence(): UcumEssence;
 
 /**
  * The **direction** of a loaded GEM file. CMS ships the forward (ICD-9→ICD-10, `…_I9gem.txt`) and
- * backward (ICD-10→ICD-9, `…_I10gem.txt`) maps as **separate, non-inverse artifacts** — a forward map
+ * backward (ICD-10→ICD-9, `…_I10gem.txt`) maps as **separate, non-inverse artifacts**: a forward map
  * composed with a backward map is *"not a mirror image"*. A `GemMap` therefore records
  * which direction it is and is only ever applied in that direction.
  */
@@ -2342,31 +2342,31 @@ type GemDirection = "9-to-10" | "10-to-9";
  */
 interface GemFlags {
     /**
-     * Position 1 — **approximate** flag. `true` when the mapping is approximate (the common case: the
+     * Position 1: **approximate** flag. `true` when the mapping is approximate (the common case: the
      * source and target are not identical in meaning); `false` when the entry is an exact identity. A
-     * GEM entry is a *reference* mapping either way — never an assertion of clinical equivalence.
+     * GEM entry is a *reference* mapping either way: never an assertion of clinical equivalence.
      */
     readonly approximate: boolean;
     /**
-     * Position 2 — **no-map** flag. `true` when the source code has **no valid target** in the other
-     * classification (the target field is the `NoDx`/`NoPCS` sentinel). A first-class typed outcome —
+     * Position 2: **no-map** flag. `true` when the source code has **no valid target** in the other
+     * classification (the target field is the `NoDx`/`NoPCS` sentinel). A first-class typed outcome:
      * surfaced as a {@link CrosswalkNoMap}, never a fabricated target.
      */
     readonly noMap: boolean;
     /**
-     * Position 3 — **combination** flag. `true` when the source requires a **combination** of target
+     * Position 3: **combination** flag. `true` when the source requires a **combination** of target
      * codes to be fully represented; the entry is one candidate within a scenario/choice-list cluster
      * (see {@link scenario} / {@link choiceList}), never a standalone 1:1 target.
      */
     readonly combination: boolean;
     /**
-     * Position 4 — **scenario** number (`0` for a non-combination entry). Within a combination, all
+     * Position 4: **scenario** number (`0` for a non-combination entry). Within a combination, all
      * entries sharing a scenario describe **one** valid way to represent the source; distinct scenarios
      * are alternative representations.
      */
     readonly scenario: number;
     /**
-     * Position 5 — **choice-list** number (`0` for a non-combination entry). Within a scenario, a valid
+     * Position 5: **choice-list** number (`0` for a non-combination entry). Within a scenario, a valid
      * cluster is built by taking **one** target from each distinct choice list.
      */
     readonly choiceList: number;
@@ -2374,33 +2374,33 @@ interface GemFlags {
     readonly raw: string;
 }
 /**
- * One loaded GEM entry — a source code, its (optional) target, and the decoded {@link GemFlags}. A
+ * One loaded GEM entry: a source code, its (optional) target, and the decoded {@link GemFlags}. A
  * No-Map entry ({@link GemFlags.noMap}) carries **no** {@link target}: the source has no equivalent,
  * and the engine never invents one.
  */
 interface GemEntry {
     /** The source code (in the map's source classification), verbatim. */
     readonly source: string;
-    /** The target code (in the map's target classification), verbatim — **absent** for a No-Map entry. */
+    /** The target code (in the map's target classification), verbatim: **absent** for a No-Map entry. */
     readonly target?: string;
     /** The decoded steward flags. */
     readonly flags: GemFlags;
 }
 /**
- * A loaded, immutable GEM map. Entries are keyed by source code (a source may have many entries — the
+ * A loaded, immutable GEM map. Entries are keyed by source code (a source may have many entries, the
  * maps are 1:many). Applied **only** in its {@link direction}; never inverted.
  *
  * {@link entries} is a **read-only view**, not a `Map` you were handed, and each source's candidate
  * list is frozen: nothing that holds a loaded map can delete a source's mapping, or add a target the
  * steward's file never authored, and have {@link applyGem} answer from it.
  *
- * A view is not a `Map` instance — `instanceof Map` is `false` and this model cannot be
+ * A view is not a `Map` instance: `instanceof Map` is `false` and this model cannot be
  * `structuredClone`d or posted to a worker; copy out what you need (`new Map(…)`).
  */
 interface GemMap {
     /** Which direction this file maps. Applied only this way. */
     readonly direction: GemDirection;
-    /** The GEM version/release (e.g. `"2018"`), when supplied — mappings are release-scoped. */
+    /** The GEM version/release (e.g. `"2018"`), when supplied: mappings are release-scoped. */
     readonly version?: string;
     /** The number of loaded entries. */
     readonly count: number;
@@ -2410,7 +2410,7 @@ interface GemMap {
     readonly warnings: readonly GemLoadWarning[];
 }
 /**
- * A surfaced, non-fatal GEM load warning — a malformed line that was **skipped**, reported with its
+ * A surfaced, non-fatal GEM load warning: a malformed line that was **skipped**, reported with its
  * line number and a value-free structural reason. Liberal on load (the parsers' posture).
  */
 interface GemLoadWarning {
@@ -2421,7 +2421,7 @@ interface GemLoadWarning {
     /** A value-free description of the structural fault (never echoes a field value). */
     readonly detail: string;
 }
-/** One choice list within a combination scenario — pick **one** of its targets to build a cluster. */
+/** One choice list within a combination scenario: pick **one** of its targets to build a cluster. */
 interface GemChoiceList {
     /** The choice-list number ({@link GemFlags.choiceList}). */
     readonly choiceList: number;
@@ -2429,7 +2429,7 @@ interface GemChoiceList {
     readonly targets: readonly string[];
 }
 /**
- * One combination **scenario** — a single valid way to represent the source as a combination of
+ * One combination **scenario**: a single valid way to represent the source as a combination of
  * target codes. A valid **cluster** is one target taken from each of its {@link choiceLists}.
  */
 interface GemScenario {
@@ -2439,7 +2439,7 @@ interface GemScenario {
     readonly choiceLists: readonly GemChoiceList[];
 }
 /**
- * A successful GEM application — one or more candidate targets for the source. The **full** candidate
+ * A successful GEM application: one or more candidate targets for the source. The **full** candidate
  * set is surfaced (never collapsed to one); when the source is a combination, {@link combinations}
  * carries the scenario/choice-list structure needed to build valid clusters.
  */
@@ -2456,7 +2456,7 @@ interface GemMatched {
     readonly combinations?: readonly GemScenario[];
 }
 /**
- * One row of the SNOMED CT → ICD-10-CM **complex/extended map** refset — the caller-supplied,
+ * One row of the SNOMED CT → ICD-10-CM **complex/extended map** refset: the caller-supplied,
  * SNOMED-licensed content the resolver runs over (**no SNOMED CT refset is bundled**). The field
  * names paraphrase the SNOMED RF2 extended-map refset columns.
  */
@@ -2464,7 +2464,7 @@ interface ComplexMapEntry {
     /** The SNOMED CT source concept id (`referencedComponentId`), verbatim. */
     readonly source: string;
     /**
-     * The **map group** (1-based). Distinct groups on one source are an **AND** — the source needs a
+     * The **map group** (1-based). Distinct groups on one source are an **AND**: the source needs a
      * target from *each* group (e.g. a manifestation code plus an etiology code). Every group resolves
      * independently.
      */
@@ -2475,17 +2475,17 @@ interface ComplexMapEntry {
      */
     readonly priority: number;
     /**
-     * The **map rule**, verbatim — `"TRUE"` / `"OTHERWISE TRUE"` (unconditional fall-through), or an
+     * The **map rule**, verbatim: `"TRUE"` / `"OTHERWISE TRUE"` (unconditional fall-through), or an
      * `IFA` predicate (e.g. an age-band or gender test) evaluated against caller-supplied context.
      */
     readonly rule: string;
     /**
-     * The **map advice**, verbatim (pipe-delimited in the source) — steward instructions to a human
+     * The **map advice**, verbatim (pipe-delimited in the source): steward instructions to a human
      * (`CONSIDER LATERALITY`, `EPISODE OF CARE INFORMATION NEEDED`, `THIS IS A MANIFESTATION CODE…`).
      * Carried through untouched: advice flags must **never** be swallowed.
      */
     readonly advice: string;
-    /** The ICD-10-CM **map target** code, verbatim — **absent** for a No-Map / empty-target row. */
+    /** The ICD-10-CM **map target** code, verbatim: **absent** for a No-Map / empty-target row. */
     readonly target?: string;
     /** The steward **map category** id (a `MAP_CATEGORIES` value, e.g. `447638001`), when supplied. */
     readonly category?: string;
@@ -2500,11 +2500,11 @@ interface ComplexMapEntry {
  * is frozen: nothing that holds a loaded map can delete a source concept's rules, or add one your
  * refset never carried, and have {@link applyComplexMap} resolve from it.
  *
- * A view is not a `Map` instance — `instanceof Map` is `false` and this model cannot be
+ * A view is not a `Map` instance: `instanceof Map` is `false` and this model cannot be
  * `structuredClone`d or posted to a worker; copy out what you need (`new Map(…)`).
  */
 interface ComplexMap {
-    /** The map version/release, when supplied — mappings are release-scoped. */
+    /** The map version/release, when supplied: mappings are release-scoped. */
     readonly version?: string;
     /** The number of loaded rows. */
     readonly count: number;
@@ -2513,7 +2513,7 @@ interface ComplexMap {
     /** The skipped-row warnings surfaced during load, in line order. Frozen; may be empty. */
     readonly warnings: readonly ComplexMapLoadWarning[];
 }
-/** A surfaced, non-fatal complex-map load warning — a malformed refset row that was skipped. */
+/** A surfaced, non-fatal complex-map load warning: a malformed refset row that was skipped. */
 interface ComplexMapLoadWarning {
     /** The stable diagnostic code for a skipped complex-map row. */
     readonly code: "TERM_COMPLEX_MAP_MALFORMED_ROW";
@@ -2534,7 +2534,7 @@ interface PatientContext {
     readonly gender?: "male" | "female";
 }
 /**
- * One map group's resolution — a discriminated outcome. A group resolves to a target, a No-Map, an
+ * One map group's resolution: a discriminated outcome. A group resolves to a target, a No-Map, an
  * ambiguity (candidates surfaced), or a context-required stall; it is **never** a silently-picked
  * single target when the steward flagged otherwise.
  */
@@ -2555,7 +2555,7 @@ interface ComplexMapGroupResolved {
     readonly rule: string;
 }
 /**
- * A group the steward marked **No-Map** (`447638001` "cannot be classified", or an empty target) — a
+ * A group the steward marked **No-Map** (`447638001` "cannot be classified", or an empty target): a
  * typed, surfaced outcome, never a fabricated target.
  */
 interface ComplexMapGroupNoMap {
@@ -2573,7 +2573,7 @@ interface ComplexMapGroupNoMap {
 /**
  * A group whose winning path is a **context-dependent** `IFA` rule (or `447639009`/`447640006`
  * category) for which the caller supplied **no** matching context. The engine surfaces the rules +
- * advice and refuses to pick a branch — the never-fabricate rule for runtime context.
+ * advice and refuses to pick a branch: the never-fabricate rule for runtime context.
  */
 interface ComplexMapContextRequired {
     /** Discriminant. */
@@ -2585,7 +2585,7 @@ interface ComplexMapContextRequired {
     /** The unresolved candidate rules in this group (priority order), each with its target + advice. */
     readonly rules: readonly ComplexMapEntry[];
 }
-/** A successful complex-map application — one resolution **per map group**, in group order. */
+/** A successful complex-map application: one resolution **per map group**, in group order. */
 interface ComplexMapMatched {
     /** Discriminant: the source concept is present in the map. */
     readonly mapped: true;
@@ -2595,7 +2595,7 @@ interface ComplexMapMatched {
     readonly groups: readonly ComplexMapGroupResult[];
 }
 /**
- * A **No-Map** outcome — the source is present in the map but the steward declares it has no valid
+ * A **No-Map** outcome: the source is present in the map but the steward declares it has no valid
  * target ("cannot be classified with available data"). A first-class typed result, **never** a
  * fabricated target. Distinct from {@link CrosswalkUnmapped} (source absent entirely).
  */
@@ -2612,7 +2612,7 @@ interface CrosswalkNoMap {
     readonly entries: readonly GemEntry[];
 }
 /**
- * An **unmapped** outcome — the source code is **not present in the map at all** (distinct from an
+ * An **unmapped** outcome: the source code is **not present in the map at all** (distinct from an
  * authored No-Map). Surfaced as a typed result, never a guessed target and never a silent success.
  */
 interface CrosswalkUnmapped {
@@ -2637,9 +2637,9 @@ type ComplexMapApplyResult = ComplexMapMatched | CrosswalkUnmapped;
  * The CMS **ICD-9 ↔ ICD-10 GEMs** (General Equivalence Mappings) loader + applier.
  *
  * The GEMs are **CMS/NCHS public-domain** (US-government work) reference mappings between the ICD-9-CM
- * and ICD-10-CM diagnosis classifications. CMS is emphatic about what they are — *"GEMs are not
+ * and ICD-10-CM diagnosis classifications. CMS is emphatic about what they are: *"GEMs are not
  * crosswalks. They are reference mappings… the raw material from which providers… derive specific
- * applied mappings"* — so this resolver treats a GEM hit as a **candidate**, never an equivalence:
+ * applied mappings"*, so this resolver treats a GEM hit as a **candidate**, never an equivalence:
  *
  * - **Approximate by default.** Position-1 flag: most entries are approximate (source and target are
  *   not identical in meaning). The flag rides through; the engine asserts nothing beyond it.
@@ -2658,7 +2658,7 @@ type ComplexMapApplyResult = ComplexMapMatched | CrosswalkUnmapped;
  */
 
 /**
- * A raw GEM source file, plus the direction it maps and its release version. BYO — the caller
+ * A raw GEM source file, plus the direction it maps and its release version. BYO: the caller
  * supplies the public-domain CMS GEM file content.
  */
 interface GemSource {
@@ -2666,7 +2666,7 @@ interface GemSource {
     readonly content: string;
     /** Which direction this file maps (`"9-to-10"` for `…_I9gem.txt`, `"10-to-9"` for `…_I10gem.txt`). */
     readonly direction: GemDirection;
-    /** The GEM release/version (e.g. `"2018"`), when known — mappings are release-scoped. */
+    /** The GEM release/version (e.g. `"2018"`), when known: mappings are release-scoped. */
     readonly version?: string;
 }
 /**
@@ -2675,7 +2675,7 @@ interface GemSource {
  * Liberal on load: a structurally unusable *line* (not three whitespace-delimited fields, or a
  * malformed 5-digit flag) is **skipped and surfaced** as a {@link GemLoadWarning}, never a
  * partially-parsed entry. An unusable *source* is not possible here (an all-malformed file loads to an
- * empty map with warnings) — there is no fatal for GEM load. Ships **no** GEM content: the entries are
+ * empty map with warnings): there is no fatal for GEM load. Ships **no** GEM content: the entries are
  * the caller's public-domain file.
  *
  * @param source - The {@link GemSource} (raw content + direction + version).
@@ -2700,7 +2700,7 @@ declare function loadGems(source: GemSource): GemMap;
  * Returns the **full** candidate set (never collapsed to one), with each entry's steward flags; a
  * combination source additionally surfaces its scenario/choice-list structure. A source the steward
  * marked No-Map (`NoDx` sentinel) is a typed {@link CrosswalkNoMap}; a source **absent** from the map
- * is a typed {@link CrosswalkUnmapped} — the two are distinct, and neither is ever a fabricated code.
+ * is a typed {@link CrosswalkUnmapped}: the two are distinct, and neither is ever a fabricated code.
  *
  * @param map - A {@link GemMap} from {@link loadGems}.
  * @param source - The source code (in the map's source classification).
@@ -2719,12 +2719,12 @@ declare function applyGem(map: GemMap, source: string): GemApplyResult;
  * Refuse to invert a directional GEM map. **Always throws** {@link FATAL_CODES.TERM_MAP_NOT_INVERTIBLE}.
  *
  * The never-invert invariant made explicit and discoverable: a forward GEM (9→10) is **not** the
- * inverse of the backward GEM (10→9) — CMS ships them as separate artifacts and *"forward and
+ * inverse of the backward GEM (10→9): CMS ships them as separate artifacts and *"forward and
  * backward mappings are not simply the reverse"*. To resolve the other direction, load
  * the other file with {@link loadGems}; the engine never synthesizes an inverse.
  *
  * @param map - The map an inversion was (incorrectly) requested for.
- * @returns Never — always throws.
+ * @returns Never: always throws.
  * @throws {TerminologyError} `TERM_MAP_NOT_INVERTIBLE`, always.
  * @example
  * ```ts runnable throws
@@ -2737,15 +2737,15 @@ declare function applyGem(map: GemMap, source: string): GemApplyResult;
 declare function invertGem(map: GemMap): never;
 
 /**
- * The **SNOMED CT → ICD-10-CM complex-map** resolver — a rule-based, **BYO**
+ * The **SNOMED CT → ICD-10-CM complex-map** resolver: a rule-based, **BYO**
  * resolver over the caller-supplied complex/extended-map refset. **No SNOMED CT refset or release is
  * bundled**: the engine ships the rule machinery; the caller supplies the map rows from their own
  * SNOMED CT release. (Individual SNOMED CT concepts this resolver *names* are bundled: the
- * map-category concepts a row's `mapCategoryId` refers to — see
- * {@link ../crosswalk/categories.MAP_CATEGORIES} — and the two gender findings a gender `IFA` rule
+ * map-category concepts a row's `mapCategoryId` refers to (see
+ * {@link ../crosswalk/categories.MAP_CATEGORIES}), and the two gender findings a gender `IFA` rule
  * is written against.)
  *
- * The map is *"semi-automated"* by the steward's own statement — 1:many, context-dependent, with
+ * The map is *"semi-automated"* by the steward's own statement, 1:many, context-dependent, with
  * first-class No-Map states. The resolver honours that:
  *
  * - **Map groups are an AND.** A source needing a manifestation *and* an etiology code has two groups;
@@ -2754,19 +2754,19 @@ declare function invertGem(map: GemMap): never;
  *   whose `IFA` predicate the caller's context satisfies wins.
  * - **Context it wasn't given, it never guesses.** If deciding a group requires an `IFA` predicate
  *   (an age band, a gender) the caller left unspecified, the group is a typed
- *   {@link ComplexMapContextRequired} carrying the candidate rules + advice — never a silently-picked
+ *   {@link ComplexMapContextRequired} carrying the candidate rules + advice: never a silently-picked
  *   branch.
  * - **No-Map is typed.** A `447638001` "cannot be classified" row (or an empty target) is a typed
  *   No-Map, never a fabricated code.
  * - **Advice rides through verbatim.** `CONSIDER LATERALITY`, `EPISODE OF CARE INFORMATION NEEDED`,
- *   manifestation-code advice — carried untouched to the caller.
+ *   manifestation-code advice: carried untouched to the caller.
  * - **Never inverted.** The map is applied SNOMED→ICD-10-CM only; the reverse is a separate artifact.
  *
  * @packageDocumentation
  */
 
 /**
- * The discriminated input {@link loadComplexMap} accepts — already-structured refset rows, or a raw
+ * The discriminated input {@link loadComplexMap} accepts: already-structured refset rows, or a raw
  * RF2 tab-delimited extended-map refset the caller exported from their SNOMED release.
  */
 type ComplexMapInput = {
@@ -2784,7 +2784,7 @@ type ComplexMapInput = {
  *
  * Liberal on load: a structurally unusable RF2 *row* is skipped and surfaced as a warning; only an
  * unusable *source* (empty content, header missing required columns) is a fatal
- * {@link FATAL_CODES.TERM_CROSSWALK_MALFORMED}. Ships **no** SNOMED CT release or refset — the rows
+ * {@link FATAL_CODES.TERM_CROSSWALK_MALFORMED}. Ships **no** SNOMED CT release or refset: the rows
  * are the caller's, under their own licence.
  *
  * @param input - Structured `rows`, or a raw RF2 extended-map refset `content`.
@@ -2807,7 +2807,7 @@ declare function loadComplexMap(input: ComplexMapInput): ComplexMap;
 /**
  * Apply a loaded SNOMED→ICD-10-CM complex map to a source concept and patient context.
  *
- * Resolves **each map group** independently (groups are an AND — a source needing multiple ICD-10-CM
+ * Resolves **each map group** independently (groups are an AND, a source needing multiple ICD-10-CM
  * codes has multiple groups) by running its rules in priority order against `context`. A group whose
  * decision needs `IFA` context the caller did not supply is a typed
  * {@link ComplexMapContextRequired}; a `447638001` row is a typed No-Map; every result carries the
@@ -2817,7 +2817,7 @@ declare function loadComplexMap(input: ComplexMapInput): ComplexMap;
  * @param source - The SNOMED CT source concept id.
  * @param context - The caller-supplied {@link PatientContext} (age / gender). Optional; a missing
  *   field that a rule needs yields a `context-required` group, never a guessed branch.
- * @returns A {@link ComplexMapApplyResult} — per-group resolutions, or a typed absence.
+ * @returns A {@link ComplexMapApplyResult}: per-group resolutions, or a typed absence.
  * @example
  * ```ts
  * import { loadComplexMap, applyComplexMap } from "@cosyte/terminology";
@@ -2839,10 +2839,10 @@ declare const COMPLEX_MAP_SOURCE_SYSTEM = "http://snomed.info/sct";
 
 /**
  * Steward-defined **map category** and **map-relationship** identifiers the crosswalk resolvers carry
- * through verbatim — the SNOMED CT complex-map `mapCategoryId` concepts and the map-correlation
+ * through verbatim: the SNOMED CT complex-map `mapCategoryId` concepts and the map-correlation
  * concepts. These are SNOMED CT metadata concepts, and **they are bundled**: the four ids below and
  * their steward descriptions ship inside this package. SNOMED CT is copyright © International Health
- * Terminology Standards Development Organisation. **No SNOMED CT refset or release is bundled** — a
+ * Terminology Standards Development Organisation. **No SNOMED CT refset or release is bundled**: a
  * caller still supplies the map refset itself under their own SNOMED CT licence (the BYO posture).
  *
  * The category on a resolved SNOMED→ICD-10-CM map row is the steward telling the caller *how much to
@@ -2854,8 +2854,8 @@ declare const COMPLEX_MAP_SOURCE_SYSTEM = "http://snomed.info/sct";
  * @packageDocumentation
  */
 /**
- * The SNOMED CT complex-map **map category** concept ids — the `mapCategoryId` column of the
- * SNOMED→ICD-10-CM extended-map refset. These four SNOMED CT concepts — id and steward description —
+ * The SNOMED CT complex-map **map category** concept ids: the `mapCategoryId` column of the
+ * SNOMED→ICD-10-CM extended-map refset. These four SNOMED CT concepts (id and steward description)
  * are **bundled** in this package (SNOMED CT is copyright © International Health Terminology
  * Standards Development Organisation); carried through a resolution verbatim so a caller sees the
  * steward's own trust signal.
@@ -2868,16 +2868,16 @@ declare const COMPLEX_MAP_SOURCE_SYSTEM = "http://snomed.info/sct";
  * ```
  */
 declare const MAP_CATEGORIES: {
-    /** `447637006` — "Map source concept is properly classified" (a normal, usable target). */
+    /** `447637006`: "Map source concept is properly classified" (a normal, usable target). */
     readonly PROPERLY_CLASSIFIED: "447637006";
-    /** `447638001` — "Map source concept cannot be classified with available data" — a **No-Map**. */
+    /** `447638001`: "Map source concept cannot be classified with available data" (a **No-Map**). */
     readonly NO_MAP: "447638001";
-    /** `447639009` — "Map of source concept is context dependent" (needs runtime patient context). */
+    /** `447639009`: "Map of source concept is context dependent" (needs runtime patient context). */
     readonly CONTEXT_DEPENDENT: "447639009";
-    /** `447640006` — "Source concept is ambiguous" — surface candidates, never pick one. */
+    /** `447640006`: "Source concept is ambiguous" (surface candidates, never pick one). */
     readonly AMBIGUOUS: "447640006";
 };
-/** A value from {@link MAP_CATEGORIES} — the SNOMED map-category id carried on a resolution. */
+/** A value from {@link MAP_CATEGORIES}: the SNOMED map-category id carried on a resolution. */
 type MapCategoryId = (typeof MAP_CATEGORIES)[keyof typeof MAP_CATEGORIES];
 /**
  * The set of {@link MAP_CATEGORIES} ids the resolver treats as a **No-Map** (a typed, surfaced
@@ -2885,7 +2885,7 @@ type MapCategoryId = (typeof MAP_CATEGORIES)[keyof typeof MAP_CATEGORIES];
  */
 declare const NO_MAP_CATEGORIES: ReadonlySet<string>;
 /**
- * The canonical code-system URI for **ICD-10-CM** — the target system of both crosswalks. A published
+ * The canonical code-system URI for **ICD-10-CM**: the target system of both crosswalks. A published
  * identity fact (mirrors {@link ../systems/registry.SYSTEM_IDENTITIES}); attached to a resolved
  * target {@link ../common/coding.Coding} so a translation is self-describing.
  */
@@ -2896,13 +2896,13 @@ declare const ICD10CM_SYSTEM = "http://hl7.org/fhir/sid/icd-10-cm";
  */
 declare const ICD9CM_SYSTEM = "http://hl7.org/fhir/sid/icd-9-cm";
 /**
- * The canonical code-system URI for **SNOMED CT** — the source system of the SNOMED→ICD-10-CM complex
+ * The canonical code-system URI for **SNOMED CT**: the source system of the SNOMED→ICD-10-CM complex
  * map. Recognised by URI only; **no SNOMED CT refset or release is bundled**.
  */
 declare const SNOMEDCT_SYSTEM = "http://snomed.info/sct";
 
 /**
- * The types for the **RxNorm drug relationship graph** — the ingredient / brand /
+ * The types for the **RxNorm drug relationship graph**: the ingredient / brand /
  * clinical-drug / dose-form graph navigated over a **caller-supplied** RxNorm RRF release.
  *
  * RxNorm is the US NLM's normalized drug nomenclature. Its concepts (`RXCUI`s) are typed by **term
@@ -2916,13 +2916,13 @@ declare const SNOMEDCT_SYSTEM = "http://snomed.info/sct";
  *
  * **The direction convention is a documented medication-safety trap**, and it
  * is grounded here firsthand on the NLM RxNorm Technical Documentation (§12.7) and the UMLS Reference
- * Manual: *"the direction of REL — the relationship which the SECOND concept or atom (with … RXCUI2
+ * Manual: *"the direction of REL, the relationship which the SECOND concept or atom (with … RXCUI2
  * …) HAS TO the FIRST concept or atom (with … RXCUI1 …)."* So every `RXNREL` row `(RXCUI1, …, RELA,
  * RXCUI2, …)` is read **`RXCUI2 ⟶RELA⟶ RXCUI1`** and normalized at load into a
  * {@link RxNormEdge} with `subject = RXCUI2`, `predicate = RELA`, `object = RXCUI1`. Navigation only
  * ever follows **authored** edges by their predicate; the engine **never synthesizes an inverse edge**
  * (RxNorm already ships both directions of an asymmetric relationship as separate rows) and **never
- * fabricates** an `RXCUI` or a relationship absent from the loaded data — an absent concept is a typed
+ * fabricates** an `RXCUI` or a relationship absent from the loaded data: an absent concept is a typed
  * {@link RxNormUnknown}, an unresolvable NDC a typed {@link NdcUnmapped}, never a guess.
  *
  * **No RxNorm release is bundled**: the engine ships the graph *machinery*, and RxNorm's
@@ -2933,7 +2933,7 @@ declare const SNOMEDCT_SYSTEM = "http://snomed.info/sct";
  * @packageDocumentation
  */
 /**
- * A RxNorm **term type** (`TTY`) — the kind of drug concept an `RXCUI` names. These are the
+ * A RxNorm **term type** (`TTY`): the kind of drug concept an `RXCUI` names. These are the
  * `RXNCONSO.RRF` `TTY` values relevant to the drug graph, grounded on the NLM RxNorm Technical
  * Documentation (Appendix 5). Carried verbatim on a {@link RxNormConcept}; the engine classifies but
  * never re-labels a concept.
@@ -2945,7 +2945,7 @@ declare const SNOMEDCT_SYSTEM = "http://snomed.info/sct";
  */
 type TermType = "IN" | "PIN" | "MIN" | "BN" | "SCDC" | "SBDC" | "SCDF" | "SBDF" | "SCDFP" | "SBDFP" | "SCD" | "SBD" | "SCDG" | "SBDG" | "SCDGP" | "GPCK" | "BPCK" | "DF" | "DFG" | "PSN" | "SY" | "TMSY" | "ET";
 /**
- * One RxNorm concept (`RXCUI`) as loaded from `RXNCONSO.RRF` — its normalized name and term type.
+ * One RxNorm concept (`RXCUI`) as loaded from `RXNCONSO.RRF`: its normalized name and term type.
  * Built from the concept's `SAB=RXNORM` atom (the normalized form); the verbatim `RXCUI`, `TTY`, and
  * `STR` (name) ride through untouched.
  */
@@ -2959,26 +2959,26 @@ interface RxNormConcept {
     readonly tty: TermType;
     /** The concept's normalized name (`RXNCONSO.STR`), verbatim. */
     readonly name: string;
-    /** `true` when the source atom is suppressed (`RXNCONSO.SUPPRESS` ≠ `N`) — surfaced, never hidden. */
+    /** `true` when the source atom is suppressed (`RXNCONSO.SUPPRESS` ≠ `N`): surfaced, never hidden. */
     readonly suppressed: boolean;
 }
 /**
  * One directed relationship edge, normalized from an `RXNREL.RRF` row under the documented direction
  * convention (see the module doc): the row `(RXCUI1, …, RELA, RXCUI2, …)` becomes
- * `subject = RXCUI2`, `predicate = RELA`, `object = RXCUI1` — read **`subject ⟶predicate⟶ object`**.
+ * `subject = RXCUI2`, `predicate = RELA`, `object = RXCUI1`: read **`subject ⟶predicate⟶ object`**.
  */
 interface RxNormEdge {
-    /** The subject `RXCUI` — `RXCUI2` in the source row. The concept the relationship is *from*. */
+    /** The subject `RXCUI`: `RXCUI2` in the source row. The concept the relationship is *from*. */
     readonly subject: string;
     /** The relationship label (`RXNREL.RELA`, e.g. `has_ingredient`), verbatim. */
     readonly predicate: string;
-    /** The object `RXCUI` — `RXCUI1` in the source row. The concept the relationship is *to*. */
+    /** The object `RXCUI`: `RXCUI1` in the source row. The concept the relationship is *to*. */
     readonly object: string;
 }
 /**
  * A resolved **NDC → RXCUI** mapping (from an `RXNSAT.RRF` `ATN=NDC` attribute), carrying the
  * temporal {@link NdcStatus} and the **as-of release** it is valid for. NDC↔RXCUI is many:1 and
- * changes across releases, so a resolution is never timeless — the release rides
+ * changes across releases, so a resolution is never timeless: the release rides
  * through on {@link asOf}.
  */
 interface NdcResolution {
@@ -2997,11 +2997,11 @@ interface NdcResolution {
  * The temporal status of an NDC↔RXCUI mapping (RxNav `getNDCStatus`: `ACTIVE` / `OBSOLETE` / `ALIEN`
  * / `UNKNOWN`). An NDC found in the loaded release's `RXNSAT` attributes is `active` **as of that
  * release**; `obsolete` / `alien` come from the RxNav NDC-history data (a differential / BYO source,
- * not the base RRF concept files) and are surfaced only when the caller supplies them — the engine
+ * not the base RRF concept files) and are surfaced only when the caller supplies them: the engine
  * **never fabricates** a non-current status.
  */
 type NdcStatus = "active" | "obsolete" | "alien" | "unknown";
-/** An NDC that could not be resolved to any `RXCUI` in the loaded release — a typed absence. */
+/** An NDC that could not be resolved to any `RXCUI` in the loaded release: a typed absence. */
 interface NdcUnmapped {
     /** Discriminant: the NDC is not present in the loaded release. */
     readonly resolved: false;
@@ -3013,7 +3013,7 @@ interface NdcUnmapped {
 /** The result of {@link ../rxnorm/navigate.resolveNdc}: a resolution or a typed absence. */
 type NdcResult = NdcResolution | NdcUnmapped;
 /**
- * A successful graph-navigation result — the concept, the predicate followed, and the **full** set of
+ * A successful graph-navigation result: the concept, the predicate followed, and the **full** set of
  * related concepts drawn verbatim from the loaded edges. `targets` may be **empty**: that is an
  * honest, data-grounded "the release has no such edge for this concept", never a fabricated relation.
  */
@@ -3028,7 +3028,7 @@ interface RxNormRelated {
     readonly targets: readonly RxNormConcept[];
 }
 /**
- * A typed **unknown** navigation result — the queried `RXCUI` is **absent from the loaded graph**. A
+ * A typed **unknown** navigation result: the queried `RXCUI` is **absent from the loaded graph**. A
  * first-class outcome, never a fabricated concept or an empty success (the never-fabricate
  * invariant, applied to the drug graph). Distinct from a {@link RxNormRelated} with empty
  * `targets`, which means "present, but no such relationship".
@@ -3050,7 +3050,7 @@ type RxNormNavResult = RxNormRelated | RxNormUnknown;
  * loaded release.
  */
 interface RxNormApproximateMatch {
-    /** Always `true` — this is a similarity match, never an exact code resolution. */
+    /** Always `true`: this is a similarity match, never an exact code resolution. */
     readonly approximate: true;
     /** The matched concept, verbatim from the loaded release. */
     readonly concept: RxNormConcept;
@@ -3082,15 +3082,15 @@ interface RxNormLoadWarning {
  *
  * Its three indexes are **read-only views**, not `Map`s you were handed: reads and iteration behave
  * as a `Map`'s do, and adding / deleting / clearing is refused however it is attempted. What that
- * buys is the never-fabricate invariant surviving the handover — nothing that holds a loaded graph
+ * buys is the never-fabricate invariant surviving the handover: nothing that holds a loaded graph
  * can empty a medication's ingredient edges, or add an edge or concept the release never authored,
  * and leave {@link conceptCount} / {@link edgeCount} still reporting the loaded figures.
  *
- * A view is not a `Map` instance — `instanceof Map` is `false` and this model cannot be
+ * A view is not a `Map` instance: `instanceof Map` is `false` and this model cannot be
  * `structuredClone`d or posted to a worker; copy out what you need (`new Map(…)`).
  */
 interface RxNormGraph {
-    /** The release version (e.g. `"RXNORM_2026AA"`), when supplied — mappings are release-scoped. */
+    /** The release version (e.g. `"RXNORM_2026AA"`), when supplied: mappings are release-scoped. */
     readonly version?: string;
     /** Concepts keyed by `RXCUI` (first `SAB=RXNORM` atom per `RXCUI` wins). Each frozen. */
     readonly concepts: ReadonlyMap<string, RxNormConcept>;
@@ -3110,10 +3110,10 @@ interface RxNormGraph {
 }
 
 /**
- * The **RxNorm drug graph loader** — build an immutable {@link RxNormGraph} from a
+ * The **RxNorm drug graph loader**: build an immutable {@link RxNormGraph} from a
  * **caller-supplied** RxNorm RRF release (`RXNCONSO.RRF` + `RXNREL.RRF`, and optionally `RXNSAT.RRF`
  * for NDC attributes). Reuses the shared, zero-dep {@link ../codesystem/rrf.parseRrfLine} (pipe split,
- * reserved trailing pipe) — the same RRF reader the CodeSystem layer uses.
+ * reserved trailing pipe): the same RRF reader the CodeSystem layer uses.
  *
  * **Column layouts, grounded firsthand** on the NLM RxNorm Technical Documentation (§ file
  * descriptions):
@@ -3124,7 +3124,7 @@ interface RxNormGraph {
  * - `RXNREL.RRF` (16 cols): `RXCUI1`(0) `RXAUI1`(1) `STYPE1`(2) `REL`(3) `RXCUI2`(4) `RXAUI2`(5)
  *   `STYPE2`(6) `RELA`(7) `RUI`(8) `SRUI`(9) `SAB`(10) `SL`(11) `RG`(12) `DIR`(13) `SUPPRESS`(14)
  *   `CVF`(15). Read `subject = RXCUI2`, `predicate = RELA`, `object = RXCUI1` (the direction
- *   convention — see {@link ../rxnorm/rela}). Only concept-level rows (both `RXCUI`s present) with a
+ *   convention: see {@link ../rxnorm/rela}). Only concept-level rows (both `RXCUI`s present) with a
  *   non-empty `RELA` become edges; atom-level (`RXAUI`) rows are not part of the concept graph.
  * - `RXNSAT.RRF` (13 cols): `RXCUI`(0) … `ATN`(8) `SAB`(9) `ATV`(10) `SUPPRESS`(11) `CVF`(12). Rows
  *   with `ATN=NDC` index `ATV`(the NDC) → `RXCUI`, marked `active` **as of** the loaded release.
@@ -3144,7 +3144,7 @@ interface RxNormGraph {
  * **Liberal on load**: a structurally unusable *row* (too few columns, missing a required
  * value) is **skipped and surfaced** as a `TERM_RXNORM_MALFORMED_ROW` warning, never a partial
  * concept/edge, never a crash. Rows that are simply *not of interest* (a non-`RXNORM` atom, an
- * atom-level relationship, a non-`NDC` attribute) are skipped **silently** — they are expected, not
+ * atom-level relationship, a non-`NDC` attribute) are skipped **silently**: they are expected, not
  * faults. Ships **no** RxNorm release: every concept/edge is the caller's.
  *
  * @packageDocumentation
@@ -3159,17 +3159,17 @@ interface RxNormGraphSource {
     readonly conso: string;
     /** The raw `RXNREL.RRF` content (pipe-delimited relationships). */
     readonly rel: string;
-    /** The raw `RXNSAT.RRF` content (pipe-delimited attributes) — supply to resolve NDCs. Optional. */
+    /** The raw `RXNSAT.RRF` content (pipe-delimited attributes): supply to resolve NDCs. Optional. */
     readonly sat?: string;
-    /** The release version (e.g. `"RXNORM_2026AA"`), when known — mappings are release-scoped. */
+    /** The release version (e.g. `"RXNORM_2026AA"`), when known: mappings are release-scoped. */
     readonly version?: string;
 }
 /**
  * Load a **caller-supplied** RxNorm RRF release into an immutable {@link RxNormGraph}.
  *
  * Parses `RXNCONSO` (concepts), `RXNREL` (directed edges, normalized to the documented direction), and
- * — when supplied — `RXNSAT` (NDC attributes). Liberal on load: a structurally unusable row is a
- * skipped, surfaced {@link RxNormLoadWarning}, never partial. Ships **no** RxNorm release — the graph
+ * (when supplied) `RXNSAT` (NDC attributes). Liberal on load: a structurally unusable row is a
+ * skipped, surfaced {@link RxNormLoadWarning}, never partial. Ships **no** RxNorm release: the graph
  * is entirely the caller's release.
  *
  * A concept is typed only by a **defining** atom, never by a synonym-class one and never by file
@@ -3199,7 +3199,7 @@ declare function loadRxNormGraph(source: RxNormGraphSource): RxNormGraph;
  * a loaded {@link RxNormGraph}. Every query is **fail-safe and never-fabricate**:
  *
  * - a queried `RXCUI` absent from the graph is a typed {@link RxNormUnknown}, never a guessed concept;
- * - a present concept with no such relationship is a {@link RxNormRelated} with **empty** `targets` —
+ * - a present concept with no such relationship is a {@link RxNormRelated} with **empty** `targets`:
  *   an honest, data-grounded "no such edge", distinct from "unknown concept";
  * - navigation follows only **authored** edges by their predicate; the engine **never synthesizes an
  *   inverse** (RxNorm ships both directions as separate rows, so brand→generic follows the authored
@@ -3250,7 +3250,7 @@ declare function getConcept(graph: RxNormGraph, rxcui: string): RxNormConcept |
  */
 declare function relatedByRela(graph: RxNormGraph, rxcui: string, predicate: string | readonly string[]): RxNormNavResult;
 /**
- * The **ingredients** of a concept — the concepts it links to by a **direct** `has_ingredient` /
+ * The **ingredients** of a concept: the concepts it links to by a **direct** `has_ingredient` /
  * `has_precise_ingredient` edge in the loaded release.
  *
  * This follows the *authored, direct* edge only (never-fabricate, never a synthesized path), and
@@ -3300,7 +3300,7 @@ declare function relatedByRela(graph: RxNormGraph, rxcui: string, predicate: str
  */
 declare function ingredientsOf(graph: RxNormGraph, rxcui: string): RxNormNavResult;
 /**
- * The **generic** form(s) of a branded concept — an `SBD`/`BN`/`BPCK` `tradename_of` its generic. The
+ * The **generic** form(s) of a branded concept: an `SBD`/`BN`/`BPCK` `tradename_of` its generic. The
  * authored forward edge; the engine never inverts a `has_tradename` edge to synthesize this.
  *
  * @param graph - A loaded {@link RxNormGraph}.
@@ -3320,7 +3320,7 @@ declare function ingredientsOf(graph: RxNormGraph, rxcui: string): RxNormNavResu
  */
 declare function genericFor(graph: RxNormGraph, rxcui: string): RxNormNavResult;
 /**
- * The **branded** form(s) of a generic concept — an `SCD`/`IN`/`GPCK` that `has_tradename` a brand.
+ * The **branded** form(s) of a generic concept: an `SCD`/`IN`/`GPCK` that `has_tradename` a brand.
  * The authored forward edge; not a synthesized inverse of `tradename_of`.
  *
  * @param graph - A loaded {@link RxNormGraph}.
@@ -3339,7 +3339,7 @@ declare function genericFor(graph: RxNormGraph, rxcui: string): RxNormNavResult;
  */
 declare function brandsFor(graph: RxNormGraph, rxcui: string): RxNormNavResult;
 /**
- * The **dose form(s)** of a drug — the `DF`/`DFG` concepts it `has_dose_form` / `has_doseformgroup`.
+ * The **dose form(s)** of a drug: the `DF`/`DFG` concepts it `has_dose_form` / `has_doseformgroup`.
  *
  * @param graph - A loaded {@link RxNormGraph}.
  * @param rxcui - The drug concept.
@@ -3357,7 +3357,7 @@ declare function brandsFor(graph: RxNormGraph, rxcui: string): RxNormNavResult;
  */
 declare function doseFormsOf(graph: RxNormGraph, rxcui: string): RxNormNavResult;
 /**
- * The **components** a drug `consists_of` — an `SCD`/`SBD` → its `SCDC`/`SBDC` dose-form components.
+ * The **components** a drug `consists_of`: an `SCD`/`SBD` → its `SCDC`/`SBDC` dose-form components.
  *
  * @param graph - A loaded {@link RxNormGraph}.
  * @param rxcui - The drug concept.
@@ -3382,7 +3382,7 @@ declare function consistsOf(graph: RxNormGraph, rxcui: string): RxNormNavResult;
  *
  * @param graph - A loaded {@link RxNormGraph} (load with `sat` supplied to populate NDC attributes).
  * @param ndc - The NDC (as it appears in the release, e.g. 11-digit).
- * @returns An {@link NdcResult} — a resolution with status + `asOf`, or a typed absence.
+ * @returns An {@link NdcResult}: a resolution with status + `asOf`, or a typed absence.
  * @example
  * ```ts
  * import { loadRxNormGraph, resolveNdc } from "@cosyte/terminology";
@@ -3406,7 +3406,7 @@ interface ApproximateMatchOptions {
     readonly limit?: number;
 }
 /**
- * **Opt-in, explicitly labeled** approximate name matching — find loaded concepts whose
+ * **Opt-in, explicitly labeled** approximate name matching: find loaded concepts whose
  * names are token-similar to `query`. This is **never** the default resolution path and its results
  * are **never** an exact code assertion: every candidate is marked `approximate: true` with a derived
  * {@link RxNormApproximateMatch.score}. A caller opts in by calling this function explicitly.
@@ -3434,16 +3434,16 @@ declare function approximateMatch(graph: RxNormGraph, query: string, options?: A
 
 /**
  * The RxNorm **relationship (`RELA`) vocabulary** and the **direction convention** the drug graph is
- * built on — encoded here as published identity facts (like the code-system OID↔URI facts in
+ * built on: encoded here as published identity facts (like the code-system OID↔URI facts in
  * {@link ../systems/registry}), grounded firsthand on the NLM RxNorm Technical Documentation and the
- * UMLS Reference Manual. **No RxNorm release is bundled** — what ships is the relationship *names*
+ * UMLS Reference Manual. **No RxNorm release is bundled**: what ships is the relationship *names*
  * and the *rule* for reading a row's direction.
  *
  * **The direction rule (a documented medication-safety trap).** From the
  * RxNorm Technical Documentation (§12.7) and the UMLS Reference Manual, verbatim: *"the direction of
- * REL — the relationship which the SECOND concept or atom (with … RXCUI2 …) HAS TO the FIRST concept
- * or atom (with … RXCUI1 …)."* The doc's worked example — a row with `RXCUI1=1155862`, `RELA=isa`,
- * `RXCUI2=197589` — reads *"197589 **isa** 1155862"* (the second concept is-a the first).
+ * REL: the relationship which the SECOND concept or atom (with … RXCUI2 …) HAS TO the FIRST concept
+ * or atom (with … RXCUI1 …)."* The doc's worked example (a row with `RXCUI1=1155862`, `RELA=isa`,
+ * `RXCUI2=197589`) reads *"197589 **isa** 1155862"* (the second concept is-a the first).
  *
  * So an `RXNREL.RRF` row is read **`RXCUI2 ⟶RELA⟶ RXCUI1`**, and {@link ../rxnorm/load.loadRxNormGraph}
  * normalizes every row to `subject = RXCUI2`, `predicate = RELA`, `object = RXCUI1`. Concretely, a
@@ -3469,7 +3469,7 @@ declare function approximateMatch(graph: RxNormGraph, query: string, options?: A
  * The drug-graph `RELA` relationship names, grounded on the NLM RxNorm Technical Documentation
  * (Appendix 1). Each is directional and read `subject ⟶RELA⟶ object` after normalization (see the
  * module doc). RxNorm ships both members of an inverse pair as **separate rows**, so the graph
- * traverses the authored predicate for the direction it wants — it **never synthesizes an inverse**.
+ * traverses the authored predicate for the direction it wants: it **never synthesizes an inverse**.
  *
  * @example
  * ```ts
@@ -3491,43 +3491,43 @@ declare const RELA: {
      * Neither reaches an `SCD`.
      */
     readonly INGREDIENT_OF: "ingredient_of";
-    /** `has_precise_ingredient` — subject *has precise ingredient* object (a `PIN`). */
+    /** `has_precise_ingredient`: subject *has precise ingredient* object (a `PIN`). */
     readonly HAS_PRECISE_INGREDIENT: "has_precise_ingredient";
-    /** `precise_ingredient_of` — inverse of `has_precise_ingredient`. */
+    /** `precise_ingredient_of`: inverse of `has_precise_ingredient`. */
     readonly PRECISE_INGREDIENT_OF: "precise_ingredient_of";
-    /** `tradename_of` — subject (a branded concept) *is a tradename of* object (its generic). */
+    /** `tradename_of`: subject (a branded concept) *is a tradename of* object (its generic). */
     readonly TRADENAME_OF: "tradename_of";
-    /** `has_tradename` — subject (a generic concept) *has tradename* object (a branded concept). */
+    /** `has_tradename`: subject (a generic concept) *has tradename* object (a branded concept). */
     readonly HAS_TRADENAME: "has_tradename";
-    /** `has_dose_form` — subject (a drug) *has dose form* object (a `DF`). */
+    /** `has_dose_form`: subject (a drug) *has dose form* object (a `DF`). */
     readonly HAS_DOSE_FORM: "has_dose_form";
-    /** `dose_form_of` — subject (a `DF`) *is the dose form of* object (a drug). */
+    /** `dose_form_of`: subject (a `DF`) *is the dose form of* object (a drug). */
     readonly DOSE_FORM_OF: "dose_form_of";
-    /** `has_doseformgroup` — subject *has dose-form group* object (a `DFG`). */
+    /** `has_doseformgroup`: subject *has dose-form group* object (a `DFG`). */
     readonly HAS_DOSE_FORM_GROUP: "has_doseformgroup";
-    /** `doseformgroup_of` — inverse of `has_doseformgroup`. */
+    /** `doseformgroup_of`: inverse of `has_doseformgroup`. */
     readonly DOSE_FORM_GROUP_OF: "doseformgroup_of";
-    /** `consists_of` — subject (an `SCD`/`SBD`) *consists of* object (its `SCDC`/`SBDC` component(s)). */
+    /** `consists_of`: subject (an `SCD`/`SBD`) *consists of* object (its `SCDC`/`SBDC` component(s)). */
     readonly CONSISTS_OF: "consists_of";
-    /** `constitutes` — subject (a component) *constitutes* object (the drug). Inverse of `consists_of`. */
+    /** `constitutes`: subject (a component) *constitutes* object (the drug). Inverse of `consists_of`. */
     readonly CONSTITUTES: "constitutes";
-    /** `contains` — subject (a pack) *contains* object (a member drug). */
+    /** `contains`: subject (a pack) *contains* object (a member drug). */
     readonly CONTAINS: "contains";
-    /** `contained_in` — subject (a drug) *is contained in* object (a pack). Inverse of `contains`. */
+    /** `contained_in`: subject (a drug) *is contained in* object (a pack). Inverse of `contains`. */
     readonly CONTAINED_IN: "contained_in";
-    /** `has_quantified_form` — subject *has quantified form* object. */
+    /** `has_quantified_form`: subject *has quantified form* object. */
     readonly HAS_QUANTIFIED_FORM: "has_quantified_form";
-    /** `quantified_form_of` — inverse of `has_quantified_form`. */
+    /** `quantified_form_of`: inverse of `has_quantified_form`. */
     readonly QUANTIFIED_FORM_OF: "quantified_form_of";
-    /** `isa` — subject *is a* object (hierarchical, e.g. `SCD isa SCDG`). */
+    /** `isa`: subject *is a* object (hierarchical, e.g. `SCD isa SCDG`). */
     readonly ISA: "isa";
-    /** `inverse_isa` — subject *is a parent of* object. Inverse of `isa`. */
+    /** `inverse_isa`: subject *is a parent of* object. Inverse of `isa`. */
     readonly INVERSE_ISA: "inverse_isa";
 };
-/** A value from {@link RELA} — a drug-graph relationship name. */
+/** A value from {@link RELA}: a drug-graph relationship name. */
 type RelaName = (typeof RELA)[keyof typeof RELA];
 /**
- * The authored **inverse pairs** of the drug-graph `RELA`s — a published fact (RxNorm Appendix 1),
+ * The authored **inverse pairs** of the drug-graph `RELA`s: a published fact (RxNorm Appendix 1),
  * used only to *document* and *validate* that a caller is traversing a real relationship. The graph
  * **never** uses this to synthesize a missing edge: RxNorm ships both directions, so
  * {@link ../rxnorm/navigate} follows whichever authored predicate points the way it wants to go.
@@ -3540,12 +3540,12 @@ type RelaName = (typeof RELA)[keyof typeof RELA];
  * ```
  */
 declare const RELA_INVERSE: Readonly<Record<string, string>>;
-/** The canonical code-system URI for **RxNorm** — a published identity fact, attached to graph codings. */
+/** The canonical code-system URI for **RxNorm**: a published identity fact, attached to graph codings. */
 declare const RXNORM_SYSTEM = "http://www.nlm.nih.gov/research/umls/rxnorm";
 
 /**
- * The RxNorm **term-type (`TTY`) vocabulary** relevant to the drug graph — the normal-form ladder and
- * the cross-link kinds — encoded as published identity facts (grounded firsthand on the NLM RxNorm
+ * The RxNorm **term-type (`TTY`) vocabulary** relevant to the drug graph (the normal-form ladder and
+ * the cross-link kinds), encoded as published identity facts (grounded firsthand on the NLM RxNorm
  * Technical Documentation, Appendix 5). **No RxNorm release is bundled**: what ships is these
  * *labels*, not the drug list.
  *
@@ -3620,7 +3620,7 @@ declare function asTermType(tty: string): TermType | undefined;
 declare function isSynonymTermType(tty: TermType): boolean;
 
 /**
- * Public entry point for **`@cosyte/terminology`** — a zero-dependency, developer-focused
+ * Public entry point for **`@cosyte/terminology`**: a zero-dependency, developer-focused
  * **terminology engine** for US healthcare code systems.
  *
  * Unlike its sibling `@cosyte/*` packages, this is **not a wire-format parser**: it mirrors the
@@ -3633,78 +3633,78 @@ declare function isSynonymTermType(tty: TermType): boolean;
  *
  * **Code-system identity and ConceptMap translation:**
  *
- * - {@link resolveSystem} — the code-system identity / canonical-URI resolver (mnemonic | OID → URI).
- * - {@link loadConceptMap} + {@link translate} — the ConceptMap `$translate` engine, with the
+ * - {@link resolveSystem}: the code-system identity / canonical-URI resolver (mnemonic | OID → URI).
+ * - {@link loadConceptMap} + {@link translate}: the ConceptMap `$translate` engine, with the
  *   **never-fabricate / never-invert** invariants: an unmapped source is a typed
  *   {@link TranslateUnmapped}, never a guessed target; a directional map is never run backwards.
  *
  * **The CodeSystem load layer**, with the FHIR `$lookup` / `$validate-code` operations:
  *
- * - {@link loadCodeSystem} — load a **consumer-supplied** release (RRF / CSV / fixed-width / FHIR
+ * - {@link loadCodeSystem}: load a **consumer-supplied** release (RRF / CSV / fixed-width / FHIR
  *   `CodeSystem` JSON) into an immutable model. Ships the loader; **no code-system release**.
- * - {@link lookup} — code → display + properties, carrying status (deprecated / header-not-billable).
- * - {@link validateCode} — is a code a valid member of the system, with its status flags.
+ * - {@link lookup}: code → display + properties, carrying status (deprecated / header-not-billable).
+ * - {@link validateCode}: is a code a valid member of the system, with its status flags.
  *
  * The never-fabricate invariant holds here too: an unknown code is a typed `unknown` / `valid: false`,
  * never a fabricated display or a guessed `valid: true`.
  *
- * **The ValueSet binding layer** — FHIR `$expand` / `$validate-code` over a `compose`:
+ * **The ValueSet binding layer**, FHIR `$expand` / `$validate-code` over a `compose`:
  *
- * - {@link loadValueSet} — load a **consumer-supplied** FHIR `ValueSet` (intensional `compose` and/or
+ * - {@link loadValueSet}: load a **consumer-supplied** FHIR `ValueSet` (intensional `compose` and/or
  *   a pre-computed `expansion`) into an immutable model.
- * - {@link expand} — flatten membership over the supplied {@link CodeSystem}s (`include`/`exclude`,
+ * - {@link expand}: flatten membership over the supplied {@link CodeSystem}s (`include`/`exclude`,
  *   explicit `concept` lists, `is-a`/property `filter`s, referenced value sets), with an honest
  *   `complete` flag: an unresolvable part is a typed `TERM_VALUESET_CANNOT_EXPAND`, never a guess.
- * - {@link validateCodeInValueSet} — binding membership, returning a **decided** `result` only when
+ * - {@link validateCodeInValueSet}: binding membership, returning a **decided** `result` only when
  *   proven and a typed `undetermined` otherwise (a truncated expansion never reads as complete).
  *
- * **The UCUM unit layer** — a hand-rolled UCUM grammar parser + validation + representation
+ * **The UCUM unit layer**: a hand-rolled UCUM grammar parser + validation + representation
  * canonicalization (recognition only, **no** magnitude conversion):
  *
- * - {@link validateUcum} — is a string a valid UCUM unit; if so, its canonical descriptor. An
+ * - {@link validateUcum}: is a string a valid UCUM unit; if so, its canonical descriptor. An
  *   invalid unit is a typed `TERM_UCUM_INVALID`, never a guessed "nearest" unit.
- * - {@link ucumEqual} — do two expressions denote the *same unit* (`N` ≡ `kg.m/s2`), by reducing
+ * - {@link ucumEqual}: do two expressions denote the *same unit* (`N` ≡ `kg.m/s2`), by reducing
  *   both to base dimensions. Not magnitude conversion (`mg/dL` → `mmol/L` is refused).
- * - {@link parseUcum} / {@link reduce} / {@link loadUcumEssence} — the underlying grammar parser,
+ * - {@link parseUcum} / {@link reduce} / {@link loadUcumEssence}: the underlying grammar parser,
  *   dimensional reducer, and the in-memory model of the vendored, verbatim UCUM table.
  *
- * **The crosswalk resolvers** — the never-fabricate/never-invert invariant applied to the
+ * **The crosswalk resolvers**: the never-fabricate/never-invert invariant applied to the
  * published, directional reference maps:
  *
- * - {@link loadGems} + {@link applyGem} — the CMS **ICD-9↔ICD-10 GEMs** (public-domain reference
+ * - {@link loadGems} + {@link applyGem}: the CMS **ICD-9↔ICD-10 GEMs** (public-domain reference
  *   mappings), honoring the steward's Approximate / No-Map / Combination (scenario→choice-list) flags.
  *   A No-Map source is a typed {@link CrosswalkNoMap}; a 1:many source returns the full candidate set.
- * - {@link loadComplexMap} + {@link applyComplexMap} — the NLM **SNOMED CT → ICD-10-CM complex map**
- *   (BYO — **no SNOMED CT refset bundled**), evaluating Map Group / Priority / `IFA` Rule /
+ * - {@link loadComplexMap} + {@link applyComplexMap}: the NLM **SNOMED CT → ICD-10-CM complex map**
+ *   (BYO, **no SNOMED CT refset bundled**), evaluating Map Group / Priority / `IFA` Rule /
  *   Advice / Category against caller-supplied {@link PatientContext}; a rule needing context the
  *   caller lacks is a typed {@link ComplexMapContextRequired}, never a guessed branch.
- * - {@link invertGem} — the never-invert refusal made a first-class, thrown contract
+ * - {@link invertGem}: the never-invert refusal made a first-class, thrown contract
  *   ({@link FATAL_CODES.TERM_MAP_NOT_INVERTIBLE}).
  *
- * **The RxNorm drug relationship graph** — ingredient / brand / clinical-drug / dose-form
+ * **The RxNorm drug relationship graph**: ingredient / brand / clinical-drug / dose-form
  * navigation over a **caller-supplied** RxNorm RRF release:
  *
- * - {@link loadRxNormGraph} — load `RXNCONSO` (concepts, typed by `TTY`), `RXNREL` (directed `RELA`
+ * - {@link loadRxNormGraph}: load `RXNCONSO` (concepts, typed by `TTY`), `RXNREL` (directed `RELA`
  *   edges, normalized to the documented `RXCUI2 ⟶RELA⟶ RXCUI1` direction), and optionally `RXNSAT`
- *   (NDC attributes) into an immutable graph. Ships **no** RxNorm release — BYO.
+ *   (NDC attributes) into an immutable graph. Ships **no** RxNorm release: BYO.
  * - {@link ingredientsOf} / {@link genericFor} / {@link brandsFor} / {@link doseFormsOf} /
- *   {@link consistsOf} / {@link relatedByRela} — graph navigation following **authored** edges only
+ *   {@link consistsOf} / {@link relatedByRela}: graph navigation following **authored** edges only
  *   (the engine never synthesizes an inverse). An absent `RXCUI` is a typed {@link RxNormUnknown}.
- * - {@link resolveNdc} — NDC → `RXCUI` carrying the temporal status and the as-of release; an absent
+ * - {@link resolveNdc}: NDC → `RXCUI` carrying the temporal status and the as-of release; an absent
  *   NDC is a typed {@link NdcUnmapped}, never a guess.
- * - {@link approximateMatch} — the **opt-in, explicitly labeled** similarity path (never the default,
+ * - {@link approximateMatch}: the **opt-in, explicitly labeled** similarity path (never the default,
  *   never an exact code assertion).
  *
  * **What is bundled.** No code-system release is. What is bundled includes the following, named with
  * its copyright:
  *
- * - the **UCUM unit table** (`ucum-essence.xml`, version 2.2, revision-date 2024-06-17) — copyright
+ * - the **UCUM unit table** (`ucum-essence.xml`, version 2.2, revision-date 2024-06-17): copyright
  *   ©1999–2024 Regenstrief Institute, Inc., all rights reserved, reproduced **verbatim** under the
  *   UCUM Copyright Notice and License (https://ucum.org/license), embedded byte-for-byte in the
  *   published build and parsed at runtime; no modified or derivative copy is distributed. The UCUM
- *   Specification is provided "as is" **without warranty of any kind** — see the License for the
+ *   Specification is provided "as is" **without warranty of any kind**: see the License for the
  *   full disclaimer. The complete notice ships with this package at `vendor/ucum/NOTICE.md`.
- * - the **code-system identity facts** ({@link SYSTEM_IDENTITIES}) — OID ↔ canonical-URI pairings,
+ * - the **code-system identity facts** ({@link SYSTEM_IDENTITIES}): OID ↔ canonical-URI pairings,
  *   which identify the systems rather than listing any system's codes.
  * - the **SNOMED CT concepts the crosswalk resolver names**, each with its description: the four
  *   map-category concepts ({@link MAP_CATEGORIES}) a complex-map row's `mapCategoryId` refers to, and