@cosyte/synth 0.1.5 → 0.1.7

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 0.1.7
+
+### Patch Changes
+
+- 65399f9: `@cosyte/synth` now installs beside `@cosyte/deid` 0.2. The `@cosyte/deid` peer range is `^0.1.5 || ^0.2.0`, where it was `^0.1.5`, so npm no longer refuses the install with ERESOLVE when a project already has deid 0.2.3. The tests now run against `@cosyte/deid` 0.2.3, and a new workflow installs the lowest and the highest version the range admits and runs the de-identification loop against each.
+
+  Generated 837P, 837I and 837D claims now write each ICD-10-CM diagnosis code in `HI` without its decimal point (`HI*ABK:J209`, not `HI*ABK:J20.9`), as the 005010 claim guides transmit it. `@cosyte/deid` 0.2 removes a diagnosis code that has a decimal point, which made the X12 pairing loop report clinical codes as scrubbed. The exported `DIAGNOSES` pool (`@cosyte/synth/x12`) holds the same codes in that form: a caller that compared a generated code with `J20.9` must compare with `J209`, or remove the point first.
+
+  Output change: X12. Every generated 837P, 837I and 837D whose diagnosis code has a decimal point, and every X12 corpus that holds one, carries its diagnosis codes without the decimal point; nothing else in them moves. The X12 de-identification loop results move with it and with deid 0.2's X12 pass. An 837 golden file committed from an earlier release has to be regenerated. HL7 v2, FHIR R4 and US Core, C-CDA, NCPDP and ASTM output is byte for byte what it was for the same seed.
+
+- 7bb58a6: Three generated values now follow their standards: the X12 271 benefit percent, the NCPDP Telecom Quantity Dispensed and the ASTM header sender.
+
+  - X12 271: EB-08 (benefit percent) is a decimal fraction, so it is now written as `.8`, `.9` or `1` instead of `80`, `90` or `100`.
+  - NCPDP Telecom: 442-E7 (Quantity Dispensed) carries three implied decimals, so a quantity of 37 is now written as `37000` instead of `37`. It reads back through `@cosyte/ncpdp` as `37.000`.
+  - ASTM: the sender name now sits in H.5 (Sender Name or ID). Before, the sender went to H.3 (Message Control ID) and the analyzer string to H.4 (Access Password). H.3 and H.4 are now empty, and the analyzer string is no longer written to the header. `astmHeaderIdentity` still returns both strings.
+
+  Output change: X12, NCPDP and ASTM. For the same seed, every generated 271, every B1 and B3 Telecom claim, and every ASTM result, order, framed and quirk message changes in the values above, and so do the corpora and de-identification loop results built from them. Every other generated artifact is byte for byte what it was for the same seed. If you commit golden files from an earlier release, regenerate each 271, B1, B3 and ASTM golden file from its seed with this release and commit the new bytes.
+
+## 0.1.6
+
+### Patch Changes
+
+- d3c649c: Each format subpath now imports without loading its parser, and a corpus checks its artifacts in less time.
+
+  - Importing `@cosyte/synth/hl7`, `/fhir`, `/ccda`, `/x12`, `/ncpdp`, `/astm` or `/deid` no longer loads the sibling parser it builds through. The parser loads on the first call that needs it, synchronously, so every function keeps its signature. It is the same build an `import` or a `require` of the parser gives you, so a returned message, resource, document or interchange is an instance of the parser classes your own code imports. One thing moves: when an optional parser is not installed, the error that names it now comes from the first call that needs it, not from the import of the subpath. Install the parser for each format you generate, as before.
+  - Every corpus generator (`hl7Corpus`, `fhirCorpus`, `ccdaCorpus`, `x12Corpus`, `ncpdpCorpus`, `astmCorpus`) takes a new `verify` option. It defaults to `true`, which reads each artifact back through its parser and records the parser's findings as its `warnings`, as before. A corpus now reads each artifact back once and no longer serializes it a second time, since a corpus never reported byte stability; `roundTrip` and the other round-trip functions still check it. `verify: false` skips the read, a large share of a corpus's time, and leaves every artifact's `warnings` empty without checking it. Pass it when the corpus feeds a load test and the parser's verdict is not needed.
+  - The sibling parsers move to their latest releases: `@cosyte/hl7` 0.1.8, `@cosyte/fhir` 0.1.8, `@cosyte/ccda` 0.1.6, `@cosyte/x12` 0.1.10, `@cosyte/ncpdp` 0.1.6, `@cosyte/astm` 0.1.6 and `@cosyte/deid` 0.1.5, and each optional peer range now starts at that release.
+
+  Output change: X12. Every generated 271 now carries the BHT segment the 005010X279A1 guide requires right after its ST, because `@cosyte/x12` 0.1.10 writes it; its SE segment count is one higher, and the X12 271 de-identification loop result moves with it. A 271 golden file committed from an earlier release has to be regenerated. Every other generated artifact is byte for byte what it was for the same seed.
+
 ## 0.1.5
 
 ### Patch Changes

package/dist/astm/index.cjs

@@ -1,6 +1,15 @@
 'use strict';
 
-var astm = require('@cosyte/astm');
+var module$1 = require('module');
+var url = require('url');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/rng/splitmix32.ts
 function splitmix32(seed) {
@@ -150,6 +159,7 @@ function createRng(seed) {
 }
 
 // src/corpus.ts
+var UNCHECKED = Object.freeze([]);
 function makeCorpus(seed, artifacts, quirks = []) {
   const counts = {};
   const formats = /* @__PURE__ */ new Set();
@@ -586,6 +596,28 @@ var ASTM_COMMENT_TEXT = Object.freeze([
   "Sample generated by @cosyte/synth.",
   "Placeholder result comment for conformance testing."
 ]);
+function defaultHost() {
+  if (typeof undefined !== "function") return { require: __require, resolve: void 0 };
+  return { require: module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))), resolve: (s) => undefined(s) };
+}
+function isRequireEsmRefusal(error) {
+  return error?.code === "ERR_REQUIRE_ESM";
+}
+function loadPeer(specifier, host) {
+  if (host.resolve === void 0) return host.require(specifier);
+  const entry = url.fileURLToPath(host.resolve(specifier));
+  try {
+    return host.require(entry);
+  } catch (error) {
+    if (!isRequireEsmRefusal(error)) throw error;
+    return host.require(specifier);
+  }
+}
+function lazyPeer(specifier, host) {
+  let loaded;
+  return () => loaded ??= loadPeer(specifier, defaultHost());
+}
+var astmPeer = lazyPeer("@cosyte/astm");
 
 // src/astm/message.ts
 function resultValue(rng, low, high, decimals) {
@@ -634,13 +666,14 @@ function buildResultInput(options) {
     records.push({ type: "C", source: "L", text: rng.pick(ASTM_COMMENT_TEXT), commentType: "G" });
   }
   return {
-    header: { fields: [head.sender, head.analyzer] },
+    // H.3 (message control id) and H.4 (access password) stay empty; H.5 is the sender name.
+    header: { fields: ["", "", head.sender] },
     records,
     terminationCode: "N"
   };
 }
 function generateAstmResult(options) {
-  return astm.buildAstmMessage(buildResultInput(options));
+  return astmPeer().buildAstmMessage(buildResultInput(options));
 }
 function generateAstmOrder(options) {
   return generateAstmResult({ ...options, resultCount: 0, comment: false });
@@ -648,21 +681,23 @@ function generateAstmOrder(options) {
 function generateAstmResultFramed(options) {
   const raw = generateAstmResult(options);
   const recordLines = raw.split("\r").filter((line) => line.length > 0).map((line) => `${line}\r`);
-  return astm.composeAstmFrames(recordLines);
+  return astmPeer().composeAstmFrames(recordLines);
 }
+
+// src/astm/round-trip.ts
 function astmRoundTrip(raw) {
-  const message = astm.parseAstmRecords(raw);
+  const message = astmPeer().parseAstmRecords(raw);
   const warnings = message.warnings.map((w) => String(w.code));
-  const byteStable = astm.serializeAstmRecords(message) === raw;
+  const byteStable = astmPeer().serializeAstmRecords(message) === raw;
   return { content: raw, warnings, byteStable, specClean: warnings.length === 0 && byteStable };
 }
 function astmFramedRoundTrip(bytes) {
-  const { message, frameWarnings } = astm.parseFramedAstm(bytes);
+  const { message, frameWarnings } = astmPeer().parseFramedAstm(bytes);
   const warnings = [
     ...frameWarnings.map((w) => String(w.code)),
     ...message.warnings.map((w) => String(w.code))
   ];
-  const reframed = astm.serializeFramedAstm(message);
+  const reframed = astmPeer().serializeFramedAstm(message);
   const byteStable = bytesEqual(reframed, bytes);
   const content = latin1(bytes);
   return { content, warnings, byteStable, specClean: warnings.length === 0 && byteStable };
@@ -677,6 +712,11 @@ function latin1(bytes) {
   for (const b of bytes) out += String.fromCharCode(b);
   return out;
 }
+function astmCorpusArtifact(raw, verify) {
+  if (!verify) return { content: raw, warnings: UNCHECKED };
+  const warnings = astmPeer().parseAstmRecords(raw).warnings.map((w) => String(w.code));
+  return { content: raw, warnings };
+}
 
 // src/select.ts
 function resolveKind(allowed, requested) {
@@ -764,7 +804,7 @@ var ASTM_QUIRKS = Object.freeze({
   })
 });
 function toleratingProfile(quirk) {
-  return quirk === "unknown-escape" ? astm.astmProfiles.referenceCorpus : void 0;
+  return quirk === "unknown-escape" ? astmPeer().astmProfiles.referenceCorpus : void 0;
 }
 var CR = "\r";
 function applyQuirk(quirk, records) {
@@ -808,7 +848,7 @@ function generateAstmQuirk(options) {
   }
   assertIntendedWarnings(
     descriptor.intendedWarnings,
-    astm.parseAstmRecords(content).warnings.map((w) => String(w.code))
+    astmPeer().parseAstmRecords(content).warnings.map((w) => String(w.code))
   );
   return Object.freeze({
     format: "astm",
@@ -821,12 +861,10 @@ function generateAstmQuirk(options) {
 function astmQuirkRoundTrip(artifact) {
   const quirk = artifact.quirk;
   const descriptor = resolveQuirk(ASTM_QUIRKS, "astm", quirk);
-  const bare = astm.parseAstmRecords(artifact.content).warnings.map((w) => String(w.code));
+  const bare = astmPeer().parseAstmRecords(artifact.content).warnings.map((w) => String(w.code));
   const profile = toleratingProfile(quirk);
   const withProfile = profile !== void 0 && descriptor.toleratingProfile !== void 0 ? (() => {
-    const warnings = astm.parseAstmRecords(artifact.content, { profile }).warnings.map(
-      (w) => String(w.code)
-    );
+    const warnings = astmPeer().parseAstmRecords(artifact.content, { profile }).warnings.map((w) => String(w.code));
     return {
       profileName: descriptor.toleratingProfile,
       disposition: descriptor.disposition,
@@ -876,23 +914,23 @@ var astmQuirkProfile = defineSynthProfile({
 // src/astm/index.ts
 var ALL_KINDS = Object.freeze(["Result", "Order"]);
 var DEFAULT_MIX = ALL_KINDS;
-function generateKind(kind, seed) {
+function generateKind(kind, seed, verify) {
   switch (kind) {
     case "Result":
-      return astmRoundTrip(generateAstmResult({ seed }));
+      return astmCorpusArtifact(generateAstmResult({ seed }), verify);
     case "Order":
-      return astmRoundTrip(generateAstmOrder({ seed }));
+      return astmCorpusArtifact(generateAstmOrder({ seed }), verify);
   }
 }
 function astmCorpus(options) {
-  const { seed } = options;
+  const { seed, verify = true } = options;
   const mix = resolveMix(ALL_KINDS, options.mix, DEFAULT_MIX);
   const count = options.count ?? mix.length;
   const seedStream = createRng(seed);
   const artifacts = Array.from({ length: count }, (_unused, i) => {
     const kind = mix[i % mix.length] ?? "Result";
     const msgSeed = seedStream.nextUint32();
-    const rt = generateKind(kind, msgSeed);
+    const rt = generateKind(kind, msgSeed, verify);
     return {
       format: "astm",
       kind,