@cosyte/synth 0.1.5 → 0.1.6

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 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) {
@@ -640,7 +672,7 @@ function buildResultInput(options) {
   };
 }
 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 +680,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 +711,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 +803,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 +847,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 +860,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 +913,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,