@cosyte/terminology 0.0.7 → 0.0.9

package/CHANGELOG.md

@@ -23,8 +23,244 @@ this file is maintained by hand (Changesets handles the version bump and publish
   without evaluating a part expansion still has to report. Reading `d.system` is now a type error.
   The rationale, and the other three sites, are under **Fixed** below.
 
+- **The test suite no longer sets a global timeout, and its one repeated start-up tax is gone**
+  (`PARSER-TESTTIMEOUT-ASSERTS-AN-IDLE-BOX`). Development tooling only — `vitest.config.ts` and the
+  test suite. No source file, no build output and no part of the public surface is touched.
+
+  **The trim came first, and it was the larger win.** `test/scripts/phi-scan.test.ts` spawns the
+  scanner at twenty call sites, and the cost of each spawn was start-up, not scanning — the fixtures
+  are a few hundred bytes. Measured on a 12-CPU cgroup quota, warmed runs of each against the same
+  scanner and argv: a `tsx` start had a median around **470–500 ms** against **141–200 ms** for
+  `node` running the same TypeScript through its native type stripping — roughly 300 ms a spawn.
+  That roughly halved the file: a plain base run measured **13,925 ms** over 21 cases, and plain runs
+  after the change measured **5,657 ms and 6,853 ms** over 22. Both runners were checked to produce
+  byte-identical stdout and stderr and the same exit code, on a clean file and on a violator, before
+  the change; several cases assert on stderr exactly.
+
+  `pnpm phi-scan` still runs `tsx`, so one case still spawns it and asserts the two runners **agree**
+  on exit code, stdout and stderr — a parity assertion, so a divergence reds rather than letting the
+  sweep quietly test something the gate does not run. Node's type stripping is on by default from
+  **22.18** while `engines.node` is `>=22.0.0`; the CI matrix is 22 + 24 and both resolve above that,
+  but a developer on 22.0–22.17 would need a newer 22 to run the suite.
+
+  **`testTimeout: 10_000` and `hookTimeout: 10_000` are removed**; the shared `@cosyte/vitest-config`
+  sets no timeout at all. A global timeout asserts the **machine**, not the code: sized for the
+  slowest test in the repo and then inherited by every other test, so a genuinely hung fast test
+  looks merely slow instead of broken. `hookTimeout` was pure noise — Vitest's default hook timeout
+  is **exactly** 10,000 ms, so the literal restated it. Both defaults were established by measuring a
+  deliberately over-running test and hook, not by reading the documentation.
+
+  **Per-test, never global.** Every test whose cost is not fixed now declares its own budget beside
+  the work. The `attw-gate` cases that run a real `npm pack` have carried an explicit 60 s one all
+  along; three groups were added — the two 200,000-row bulk cases in
+  `test/rxnorm/term-types.test.ts`, the single `tsx`-parity case, and **all of `test/property/**`**,
+  whose runtime varies with the fast-check draw as well as with the box, since this package pins no
+  seed by design. With those declared, every remaining test peaked at **689 ms\*\*, a ~7x margin
+  against the 5 s default the config now inherits.
+
+  **The method is part of the claim.** Ten full runs on a contended box (12-CPU cgroup quota,
+  fourteen-worker fleet), of which **six were `vitest run --coverage`**. That is not optional: CI
+  gates on `pnpm test` _and_ `pnpm test:coverage`, and the instrumented run is materially slower,
+  roughly doubling the property-suite peaks. An earlier draft of this change measured only the plain
+  run, recorded 499 ms, and was refuted for it.
+
+  **Two things measurement corrected.** The argument-refusal cases in `attw-gate` look like they
+  belong with the slow ones and do not: the wrapper rejects the flag before invoking `attw`, so they
+  run no `npm pack` and finish in ~200 ms. And the case that actually approached the old ceiling —
+  **9,318 ms against 10,000 ms** under load, a 682 ms margin on correct code — was an `attw` case
+  that already had its own 60 s budget, so the global was never what stood between it and a false
+  red. The `attw` cost itself is genuine work (a real `npm pack` runs ~1,550 ms), so it is bounded
+  rather than trimmed. These figures describe one box on one day and are recorded so the next reader
+  re-measures rather than inherits them.
+
 ### Fixed
 
+- **The publish gate's argument guard refused a fixed LIST of blinding spellings, and `-fjson` was
+  not on it — a value fused to a short flag hid the one sentence the gate reads, and it handed back a
+  pass over a tarball carrying no types** (`ATTW-GUARD-ALLOWLIST`). Development tooling only —
+  `scripts/attw.mjs` ships in no tarball, and the public surface, build output and runtime behaviour
+  are unchanged.
+
+  **The rules of the gate are stated once, in `scripts/attw.mjs`'s docblock. This entry points at it
+  rather than repeating them**, and `CLAUDE.md`'s paragraph now does the same. The guard was
+  described in several committed files at once and the copies drifted: `CLAUDE.md` claimed a refusal "by
+  option name, wholesale" that a fused short option walked past, and called `--config-path` refused
+  "by inference, not measurement" when the real-file half takes one command to measure.
+
+  **The remedy is an ALLOW-LIST, so no spelling is enumerated.** The gate forwards `--profile` and
+  `--no-definitely-typed` and refuses everything else, including options that blind nothing:
+  "harmless" is not a judgement a script can make from an option name. Measured on `7bdd5f5` against
+  this repo's pinned `@arethetypeswrong/cli@0.18.4`, on a fixture whose tarball carries no types —
+  `-fjson`, `-Pf json` and `-Pfjson` each exited **0** with the untyped sentence absent and a
+  non-empty transcript, so the empty-output net could not backstop them; `--help`, `-h`, `--version`
+  and `-V` did the same. `--config-path` naming a real file that sets `format` blinded identically,
+  while the nonexistent path the old test named blinds **nothing** — `readConfig()` swallows the
+  `ENOENT` and the sentence is still printed, so that test asserted a refusal over a case that could
+  not have hurt the gate. Both halves are pinned now.
+
+  **The preflight walks two promises it used to skip**, each measured to leave bare `attw` at exit 0:
+  `bin`, which `attw` does not look at at all, so a manifest could promise a command absent from the
+  tarball; and a path written without a leading `./`, which is legal and is the spelling npm's own
+  documentation uses, so `"main": "dist/index.js"` was dropped silently while the gate reported it
+  had checked. This package declares no `bin` — that half is pinned on a fixture that does, because
+  every sibling copies this file.
+
+  **A false explanation of a correct red is deleted rather than reworded.** The preflight used to
+  name the exit code `attw` "would have" produced. It reads the manifest and never the tarball, and
+  the tarball decides: `analysis.types` is `containsTypes()` in `@arethetypeswrong/core`, which is
+  `listFiles(directory).some(ts.hasTSFileExtension)` — any TypeScript-extension file in the packed
+  tarball, computed before an entrypoint is resolved. A package packing a whole `dist/` can lose
+  every declared declaration and still hand `attw` an undeclared chunk declaration, at which point it
+  exits 1 and the sentence is false. The failure now says what it checked and that it cannot speak
+  for `attw`.
+
+  **A limit found while grading this, filed rather than closed.** The `.attw.json` refusal names
+  `quiet` and `format`, but `readConfig()` sets an option value for **every** key except
+  `configPath`, `help` and `version` — so a committed config reaches options this gate does not name,
+  `definitelyTyped` pointed at a `.tgz` among them, which merges those types in and can make an
+  untyped tarball analyse as typed. It predates this change, and the allow-list closes only its argv
+  half — `--definitely-typed` on argv is now refused, where the deny-list forwarded it — while the
+  config route is untouched. Adding a key would rebuild, on the config side, the deny-list this
+  change retires on the argument side.
+
+- **A symbolic link under a scan root read CLEAN on BOTH of the PHI scanner's enumerating routes, so
+  a link pointing at a file full of real identifiers passed the gate twice over**
+  (`PHI-SCAN-SYMLINK-BLIND-ON-BOTH-ROUTES`). Development tooling only — `scripts/phi-scan.ts` ships in
+  no tarball and the package's public surface is unchanged.
+
+  Reproduced on `80a8cc7` before any fix, with a synthetic name-bearing payload (a person name, a
+  DOB, a dashed SSN and an email at a non-test domain) placed outside the walk roots and a link to it
+  at `src/leak.ts`. `pnpm phi-scan` printed `OK — no hits` and exited **0**; `pnpm phi-scan --staged`,
+  after `git add`, printed `OK — no hits` and exited **0**. Naming the link's target explicitly on the
+  command line found both shapes and exited 1, so the payload was always detectable — the two routes
+  simply never looked at it.
+
+  The two blindnesses are separate mechanisms and needed separate fixes. The walk enumerates
+  `Dirent.isFile()`, which is an **lstat** answer, so a link is neither a file nor a directory and
+  fell out of the loop with no record that anything had been skipped — and `isDirectory()` answers
+  false for a linked directory too, so a whole subtree could disappear the same way. The `--staged`
+  route reads content with `git show :<path>`, and **git stores a symbolic link as its target path
+  under mode `120000`**, so it was handed the target's path text and scanned that. That second route
+  is this repo's `pre-commit` hook, which is exactly where the claim that `--staged` covers a link
+  would have been trusted.
+
+  **Neither route is made to follow the link.** Following would read bytes the enumeration does not
+  control — outside the repo, a loop, a device, a FIFO that blocks the gate forever — and git does not
+  carry those bytes anyway, so a hit on them would be a claim about something no commit contains.
+  Instead the enumeration is narrowed: an entry under a scan root that is not a regular file **refuses
+  the scan** (exit 2, the existing "could not complete" code), naming every offender rather than the
+  first. The walk classifies by `Dirent` (symbolic link, FIFO, socket, block device, character
+  device); `--staged` now reads `git diff --cached --raw -z` instead of `--name-only` so the
+  destination mode is visible, and refuses mode `120000` and `160000` (a gitlink) wherever that
+  route's own path scope reaches them. A `--raw` record that does not parse refuses as well, rather
+  than being skipped into a silently shortened list.
+
+  **`T` (typechange) is in the `--diff-filter`, and leaving it out made the mode check unreachable
+  whenever the file being replaced was already tracked.** Replacing a **tracked** regular file with a link is neither an add nor a
+  modify: git raises `:100644 120000 <sha> <sha> T`, so `--diff-filter=AM` deleted the record before
+  any mode could be read and the hook passed the link green. Measured on git 2.39.5: with `AM` the
+  raw output for that stage is empty. Typechange carries a single path, exactly like `A` and `M`, so
+  admitting it costs the record stride nothing — and it means the reverse typechange, a link replaced
+  by a real file, is now scanned as the ordinary file it became.
+
+  **A refusal names the entry's own repo-relative path and an engine-owned token for its kind, and
+  never the link target** — a target path is text off the working tree and can itself carry PHI. That
+  is asserted, not asserted-in-prose: the pinning payload and the target's own filename both carry a
+  synthetic person name, and every refusal message is checked to contain none of it.
+
+  **What this does not cover, stated narrowly, each measured.** Explicit-path mode already read
+  through a link and reported the target's hits; it is unchanged. The `--staged` path scope is
+  unchanged — still `test/fixtures/**` and `src/**.ts` — so a staged link outside it is still not
+  looked at; narrowing what a scope admits is not widening the scope. That scope also bounds the
+  gitlink half: a submodule staged at `test/fixtures/nested` is refused, while one at `src/nested` is
+  a directory name that fails the `.ts` suffix and is not looked at. `R` (rename) and `C` (copy) are
+  still **not** enumerated by `--staged` at all, so a staged rename that also appends PHI passes that
+  route — pre-existing, unchanged here, and admitting it needs the two-path record shape handled,
+  which is a scope decision rather than this one; CI's all-mode sweep does read the resulting
+  worktree file. A tracked file **absent from the worktree** is still caught at `git add` time only.
+  And the scanner still has no tolerance for a file that vanishes between enumeration and read, so an
+  untracked transient appearing under a walk root can still refuse a whole sweep; that is a different
+  defect, it fails closed, and it is not addressed here.
+
+- **A loaded GEM map, complex map and RxNorm drug graph froze their wrapper and handed out plain
+  `Map`s inside it, so whoever held one could delete a diagnosis mapping, add a target the steward's
+  file never authored, or empty a medication's ingredient edges** (`TERMINOLOGY-INNER-MAPS-UNSEALED`).
+  `Object.freeze` cannot reach a `Map` — its entries live in an internal slot rather than in
+  properties — so freezing the model left `set` / `delete` / `clear` working on every index it points
+  at, and the `readonly` on those fields was a compile-time claim only.
+
+  Measured on `dd8465b`, before any fix: one `push` into `loadGems(…).entries.get("0010")` made
+  `applyGem` answer with a target that is in no GEM file; `entries.delete("0010")` turned the same
+  source into a typed `TERM_CROSSWALK_UNMAPPED`; `graph.edges.clear()` left `ingredientsOf` answering
+  `targets: []` for every drug while `edgeCount` still reported the loaded figure; and
+  `graph.concepts.set(…)` put a concept the caller's release never shipped where navigation would
+  return it. The candidate and rule lists were nominally `readonly` in the same way — writing over
+  element `0` landed too.
+
+  A code system's `concepts`, a GEM's and a complex map's `entries`, and a drug graph's `concepts` /
+  `edges` / `ndcs` are each now a **read-only view** of a map rather than the map itself — those six
+  indexes, not every field this package types `ReadonlyMap` — and every list, entry and warning
+  reachable from one of those models is frozen. Reads are exactly a `Map`'s: `get`, `has`, `size`,
+  `keys`, `values`, `entries`, `forEach`, iteration, `new Map(view)`.
+
+  **Two behaviour changes to know before you write against one.** A view is not a `Map` instance, so
+  `instanceof Map` is now `false` on `CodeSystem.concepts`, a `GemMap`'s and a `ComplexMap`'s
+  `entries`, and a graph's `concepts` / `edges` / `ndcs`; it prints as a plain object, `Object.keys`
+  lists its own methods, and `JSON.stringify` renders it as `{"size":2}` where a `Map` rendered `{}`.
+  And a model carrying one therefore **cannot be structured-cloned** — `structuredClone` and
+  `worker.postMessage` raise a `DataCloneError`, `v8.serialize` a plain `Error`, where before each
+  produced a working copy. Clone what the other side needs instead: `new Map(cs.concepts)`. A loaded
+  `ConceptMap`, `ValueSet` or unit table carries no view and clones as it always did. That refusal is
+  deliberate rather than incidental. Hiding the view's methods would make the clone _succeed_ and
+  hand back a model
+  whose indexes were empty while `count` / `conceptCount` / `edgeCount` still reported the loaded
+  figures — this defect's own shape, arriving silently. It is pinned as a test, not left as prose.
+
+  Not being a `Map` is also what closes the second route rather than only the first: replacing a
+  `Map`'s three mutators leaves `Map.prototype.set.call(theMap, …)` reaching the internal slot
+  directly, and a view has no slot to reach. `CodeSystem.concepts` was sealed that weaker way — a
+  fabricated concept could be forced into a loaded release and `lookup` would return it — and is a
+  view now too.
+
+  **The bundled UCUM table is deliberately not part of this and is unchanged.** `atomByCode` and
+  `prefixByCode` stay real `Map`s whose `set` / `delete` / `clear` are replaced by a refusal, so an
+  entry forced through `Map.prototype` still lands there. That residual is bounded and stays
+  documented: `parseUcum` resolves an atom by scanning the frozen `atoms` array, never through a
+  lookup map, so a forced entry changes no validation, reduction or `ucumEqual` answer — only the
+  caller's own `get` is lied to.
+
+  The guarantee is that the loaded model does not change, not that a write throws: a named mutator
+  raises a `TypeError` in either mode, while a frozen list or entry throws in strict mode and is
+  silently ignored in sloppy mode, which the CJS build lets a caller observe. Every route is
+  therefore asserted by the **reading** it would have changed as well as by the refusal, and a
+  reachability sweep walks **all seven** `load*` models for anything still writable, so a field added
+  later is covered without anyone maintaining a list of routes. The UCUM table is pinned in that
+  sweep as the named exception rather than skipped, so converting it later has to be deliberate. The
+  sweep carries its own negative controls: a planted mutable object and a raw `Map` behind a frozen
+  wrapper both have to be reported.
+
+- **`parseEssence`'s example imported it from `@cosyte/terminology/ucum/essence`, a subpath the
+  package's `exports` does not declare.** It is package-internal and not re-exported from the entry
+  point; the example says so and imports it the way this package's own code does. Consumers reach the
+  table through `loadUcumEssence()`, which is unchanged.
+
+- **Three `/* v8 ignore */` hints in `src/ucum/essence.ts` were inert, and are now plain comments.**
+  The branches they claimed to exclude were reported uncovered either way — measured with and
+  without a `--` reason suffix and under `--coverage.experimentalAstAwareRemapping` — so the hints
+  stated a coverage exclusion that no run performed. The package's posture is the one
+  `vitest.config.ts` already records for `rxnorm/`: an unreachable `noUncheckedIndexedAccess`
+  fallback stays visibly uncovered under a directory floor of 90, rather than being hidden by an
+  assertion about reachability that the next reader inherits with no way to check it. No coverage
+  figure moved, which is what proves they were inert.
+
+- **A GEM source with more than one combination scenario had no deterministic test**, so the
+  comparator that orders them was reached only when a `fast-check` draw happened to generate a second
+  scenario — `Array.prototype.sort` never calls one for a single-element array. Scenarios are
+  alternative valid representations of the same source, so their order is part of the answer. Covered
+  now by a fixture whose file order is deliberately scenario 2 first. Found while measuring this
+  slice; `vitest run --coverage --exclude 'test/property/**'` reports `crosswalk/` at 100% functions
+  with it and 95.45% without.
+
 - **The UCUM unit table `loadUcumEssence()` hands out was `readonly` to TypeScript only, so a unit's
   definition could be rewritten in place — and doing so fabricated a unit equivalence that outlived
   putting the table back** (`TERMINOLOGY-MUTABLE-ESSENCE-TABLE`). One table is shared by every caller

package/README.md

@@ -208,8 +208,15 @@ _names_, listed under [What is bundled](#what-is-bundled).
   NDC you asked about, so log the `code` and the locus rather than the whole result — a code _in
   patient context_ can be PHI.
 - **Zero runtime dependencies. Dual ESM + CJS.** Node stdlib only; built with `tsup`, validated with
-  `attw`. The models the engine loads for you are frozen — the bundled unit table deeply so, atom by
-  atom and definition by definition, because it is shared with the engine's own reducer. The AST and
+  `attw`. A release you load is frozen, its indexes included: a code system's concepts, a GEM's or a
+  complex map's entries and a drug graph's concepts, edges and NDCs are each a read-only **view** of a
+  map rather than the map itself, so nothing holding one can add, delete or clear an entry, whichever
+  way it tries. A view is not a `Map` instance, so a model carrying one cannot be `structuredClone`d
+  or posted to a worker — copy out what you need (`new Map(cs.concepts)`). The bundled unit table is frozen deeply, atom by atom and definition by
+  definition, because it is shared with the engine's own reducer; its two lookup maps refuse `set`,
+  `delete` and `clear` by name, and an entry forced past that through `Map.prototype` changes nothing
+  the engine reads, because `parseUcum` resolves an atom by scanning the frozen atom array rather than
+  through a lookup map. The AST and
   the reduction that `parseUcum` and `reduce` hand back are per-call values you own, and mutating one
   changes nothing for anyone else.
 

package/dist/index.cjs

@@ -567,6 +567,31 @@ function translate(sourceCoding, map) {
   );
 }
 
+// src/common/frozen-map.ts
+function frozenMap(source, what) {
+  const refuse = () => {
+    throw new TypeError(`Cannot mutate ${what} (it is immutable)`);
+  };
+  const view = {
+    get size() {
+      return source.size;
+    },
+    get: (key) => source.get(key),
+    has: (key) => source.has(key),
+    keys: () => source.keys(),
+    values: () => source.values(),
+    entries: () => source.entries(),
+    forEach: (callback, thisArg) => {
+      for (const [key, value] of source) callback.call(thisArg, value, key, view);
+    },
+    [Symbol.iterator]: () => source[Symbol.iterator](),
+    set: refuse,
+    delete: refuse,
+    clear: refuse
+  };
+  return Object.freeze(view);
+}
+
 // src/codesystem/status.ts
 var defaultStatusMapper = (raw) => {
   switch (raw.trim().toUpperCase()) {
@@ -973,15 +998,6 @@ function parseRrf(source) {
 }
 
 // src/codesystem/load.ts
-function sealConceptMap(map) {
-  const guard = () => {
-    throw new TypeError("Cannot mutate a loaded CodeSystem's concepts map (it is immutable)");
-  };
-  for (const method of ["set", "delete", "clear"]) {
-    Object.defineProperty(map, method, { value: guard, writable: false, configurable: false });
-  }
-  return map;
-}
 function loadCodeSystem(source) {
   let concepts;
   let warnings;
@@ -1019,7 +1035,7 @@ function loadCodeSystem(source) {
     }
   }
   out.count = concepts.size;
-  out.concepts = sealConceptMap(concepts);
+  out.concepts = frozenMap(concepts, "a loaded CodeSystem's concepts map");
   out.warnings = Object.freeze(warnings);
   return Object.freeze(out);
 }
@@ -4069,21 +4085,25 @@ function loadGems(source) {
     if (trimmed === "") continue;
     const fields = trimmed.split(/\s+/);
     if (fields.length !== 3) {
-      warnings.push({
-        code: "TERM_GEM_MALFORMED_ROW",
-        line: i + 1,
-        detail: `expected 3 whitespace-delimited fields, found ${String(fields.length)}`
-      });
+      warnings.push(
+        Object.freeze({
+          code: "TERM_GEM_MALFORMED_ROW",
+          line: i + 1,
+          detail: `expected 3 whitespace-delimited fields, found ${String(fields.length)}`
+        })
+      );
       continue;
     }
     const [src, tgt, flagStr] = fields;
     const flags = decodeFlags(flagStr);
     if (flags === void 0) {
-      warnings.push({
-        code: "TERM_GEM_MALFORMED_ROW",
-        line: i + 1,
-        detail: "flag field is not a 5-digit code"
-      });
+      warnings.push(
+        Object.freeze({
+          code: "TERM_GEM_MALFORMED_ROW",
+          line: i + 1,
+          detail: "flag field is not a 5-digit code"
+        })
+      );
       continue;
     }
     const entry = { source: src, flags };
@@ -4094,11 +4114,12 @@ function loadGems(source) {
     else entries.set(src, [frozen]);
     count++;
   }
+  for (const list of entries.values()) Object.freeze(list);
   return Object.freeze({
     direction: source.direction,
     ...source.version !== void 0 ? { version: source.version } : {},
     count,
-    entries,
+    entries: frozenMap(entries, "a loaded GEM map's entries"),
     warnings: Object.freeze(warnings)
   });
 }
@@ -4246,11 +4267,13 @@ function parseRf2(content) {
     const groupN = Number(at(f, iGroup));
     const priorityN = Number(at(f, iPriority));
     if (source === "" || !Number.isFinite(groupN) || !Number.isFinite(priorityN)) {
-      warnings.push({
-        code: "TERM_COMPLEX_MAP_MALFORMED_ROW",
-        line: i + 1,
-        detail: "row is missing referencedComponentId / mapGroup / mapPriority"
-      });
+      warnings.push(
+        Object.freeze({
+          code: "TERM_COMPLEX_MAP_MALFORMED_ROW",
+          line: i + 1,
+          detail: "row is missing referencedComponentId / mapGroup / mapPriority"
+        })
+      );
       continue;
     }
     rows.push({
@@ -4293,7 +4316,7 @@ function loadComplexMap(input) {
   }
   const out = {
     count,
-    entries,
+    entries: frozenMap(entries, "a loaded complex map's entries"),
     warnings
   };
   if (input.version !== void 0) out.version = input.version;
@@ -4587,9 +4610,9 @@ function loadRxNormGraph(source) {
   const ndcs = source.sat !== void 0 ? parseNdcs(source.sat, warnings) : /* @__PURE__ */ new Map();
   for (const list of edges.values()) Object.freeze(list);
   const out = {
-    concepts,
-    edges,
-    ndcs,
+    concepts: frozenMap(concepts, "a loaded RxNorm graph's concepts"),
+    edges: frozenMap(edges, "a loaded RxNorm graph's edges"),
+    ndcs: frozenMap(ndcs, "a loaded RxNorm graph's NDC index"),
     conceptCount: concepts.size,
     edgeCount,
     warnings: Object.freeze(warnings)
@@ -4753,7 +4776,7 @@ function approximateMatch(graph, query, options = {}) {
 }
 
 // src/index.ts
-var VERSION = "0.0.7";
+var VERSION = "0.0.9";
 
 exports.COMPLEX_MAP_SOURCE_SYSTEM = COMPLEX_MAP_SOURCE_SYSTEM;
 exports.DIAGNOSTIC_CODES = DIAGNOSTIC_CODES;