@cosyte/synth 0.0.2 → 0.0.4

package/dist/hl7/index.cjs

@@ -31,6 +31,57 @@ function sfc32Next(s) {
   return t >>> 0;
 }
 
+// src/codes.ts
+var SYNTH_FATAL_CODES = {
+  /**
+   * A vendor quirk was requested that the target format's profile system does not support. Fatal —
+   * never a silent no-op and never a fabricated quirk.
+   */
+  SYNTH_UNSUPPORTED_QUIRK: "SYNTH_UNSUPPORTED_QUIRK",
+  /**
+   * A bare parse of a freshly-generated quirk artifact did not produce exactly the declared intended
+   * warning code(s). Fatal — never emit a mislabeled fixture.
+   */
+  SYNTH_INTENDED_WARNING_MISMATCH: "SYNTH_INTENDED_WARNING_MISMATCH",
+  /** An integer range was requested with its maximum below its minimum. Fatal. */
+  SYNTH_INVALID_RANGE: "SYNTH_INVALID_RANGE",
+  /** A value was drawn from an empty pool. Fatal — never a fabricated substitute. */
+  SYNTH_EMPTY_POOL: "SYNTH_EMPTY_POOL",
+  /** A `defineSynthProfile` spec was not usable (a missing or blank `name`). Fatal. */
+  SYNTH_INVALID_PROFILE: "SYNTH_INVALID_PROFILE",
+  /**
+   * A caller-supplied selector (a message kind, a document type, a corpus mix entry, a claim
+   * variant, a Bundle type, a resource profile) is not in the closed set that governs it. Fatal —
+   * see `resolveKind`: a selector union is erased at run time, and a selector that falls through
+   * either mislabels the fixture or hands the value to a peer builder that quotes it back.
+   */
+  SYNTH_UNSUPPORTED_KIND: "SYNTH_UNSUPPORTED_KIND"
+};
+var SYNTH_FATAL_MESSAGES = Object.freeze({
+  SYNTH_UNSUPPORTED_FORMAT: "The requested format is not generable by this build. A generator has no byte fallback: it builds through a parser's own serializer or it refuses.",
+  SYNTH_UNSUPPORTED_QUIRK: "The requested vendor quirk is not in the target format's quirk registry. Compare the request against that format's exported registry (HL7_QUIRKS, CCDA_QUIRKS, ASTM_QUIRKS).",
+  SYNTH_QUIRK_ANCHOR_ABSENT: "The quirk transform found no structural anchor to mutate, so the fixture would not carry the deviation it is labelled with. Refusing to emit a mislabeled fixture.",
+  SYNTH_INTENDED_WARNING_MISMATCH: "A bare parse of the generated quirk artifact did not produce exactly the declared intended warning code(s). Refusing to emit a mislabeled fixture.",
+  SYNTH_UNMAPPED_CODE_SYSTEM: "The concept's code-system URI has no OID mapping in the C-CDA example-code table.",
+  SYNTH_INVALID_DECIMAL: "The value could not be read as an X12 decimal.",
+  SYNTH_INVALID_RANGE: "An integer range was requested with its maximum below its minimum.",
+  SYNTH_EMPTY_POOL: "A value was drawn from an empty pool.",
+  SYNTH_INVALID_PROFILE: "defineSynthProfile requires a non-empty string name.",
+  SYNTH_UNSUPPORTED_KIND: "The requested kind, document type, corpus mix entry, variant or profile is not one this generator supports. The supported set is the exported union for that option."
+});
+var SynthError = class extends Error {
+  /** The stable fatal code. */
+  code;
+  /**
+   * @param code - The stable {@link SynthFatalCode}. The message comes from the frozen registry.
+   */
+  constructor(code) {
+    super(SYNTH_FATAL_MESSAGES[code]);
+    this.name = "SynthError";
+    this.code = code;
+  }
+};
+
 // src/rng/rng.ts
 var Sfc32Rng = class {
   seed;
@@ -48,7 +99,7 @@ var Sfc32Rng = class {
     return this.nextUint32() / 4294967296;
   }
   int(min, max) {
-    if (max < min) throw new RangeError(`Rng.int: max (${String(max)}) < min (${String(min)})`);
+    if (max < min) throw new SynthError(SYNTH_FATAL_CODES.SYNTH_INVALID_RANGE);
     const span = max - min + 1;
     return min + Math.floor(this.float() * span);
   }
@@ -56,7 +107,7 @@ var Sfc32Rng = class {
     return this.float() < p;
   }
   pick(items) {
-    if (items.length === 0) throw new RangeError("Rng.pick: empty array");
+    if (items.length === 0) throw new SynthError(SYNTH_FATAL_CODES.SYNTH_EMPTY_POOL);
     return items[this.int(0, items.length - 1)];
   }
   digits(n) {
@@ -447,10 +498,22 @@ function pidSegment(id) {
   ];
 }
 
+// src/select.ts
+function resolveKind(allowed, requested) {
+  const match = allowed.find((value) => value === requested);
+  if (match === void 0) throw new SynthError(SYNTH_FATAL_CODES.SYNTH_UNSUPPORTED_KIND);
+  return match;
+}
+function resolveMix(allowed, requested, fallback) {
+  if (requested === void 0) return fallback;
+  return requested.map((entry) => resolveKind(allowed, entry));
+}
+
 // src/hl7/adt.ts
+var ADT_TRIGGERS = Object.freeze(["A01", "A04", "A08"]);
 function generateAdt(options = {}) {
   const seed = options.seed ?? 0;
-  const trigger = options.trigger ?? "A01";
+  const trigger = resolveKind(ADT_TRIGGERS, options.trigger ?? "A01");
   const rng = createRng(seed);
   const { message, timestamp } = mshScaffold(rng, `ADT^${trigger}`);
   message.addSegment("EVN", [trigger, timestamp]);
@@ -737,7 +800,7 @@ function roundTrip(message) {
 // src/profile.ts
 function defineSynthProfile(spec) {
   if (typeof spec.name !== "string" || spec.name.trim().length === 0) {
-    throw new TypeError("defineSynthProfile: `name` is required and must be a non-empty string.");
+    throw new SynthError(SYNTH_FATAL_CODES.SYNTH_INVALID_PROFILE);
   }
   return Object.freeze({
     name: spec.name,
@@ -747,28 +810,6 @@ function defineSynthProfile(spec) {
   });
 }
 
-// src/codes.ts
-var SYNTH_FATAL_CODES = {
-  /**
-   * A vendor quirk was requested that the target format's profile system does not support. Fatal —
-   * never a silent no-op and never a fabricated quirk.
-   */
-  SYNTH_UNSUPPORTED_QUIRK: "SYNTH_UNSUPPORTED_QUIRK"
-};
-var SynthError = class extends Error {
-  /** The stable fatal code. */
-  code;
-  /**
-   * @param code - The stable {@link SynthFatalCode}.
-   * @param message - A human-readable detail (never contains PHI — there is none).
-   */
-  constructor(code, message) {
-    super(message);
-    this.name = "SynthError";
-    this.code = code;
-  }
-};
-
 // src/quirk.ts
 var PROFILE_QUIRK_APPLIED = "PROFILE_QUIRK_APPLIED";
 function sameCodeSet(a, b) {
@@ -785,12 +826,8 @@ function sameCodeSet(a, b) {
 }
 function resolveQuirk(registry, format, name2) {
   const descriptor = registry[name2];
-  if (descriptor === void 0) {
-    const supported = Object.keys(registry).sort().join(", ");
-    throw new SynthError(
-      SYNTH_FATAL_CODES.SYNTH_UNSUPPORTED_QUIRK,
-      `${format}: unsupported quirk "${name2}". The ${format} profile system supports: ${supported}.`
-    );
+  if (descriptor === void 0 || descriptor.format !== format) {
+    throw new SynthError(SYNTH_FATAL_CODES.SYNTH_UNSUPPORTED_QUIRK);
   }
   return descriptor;
 }
@@ -805,11 +842,9 @@ function profileTolerated(disposition, intendedWarnings, warningsUnderProfile) {
       return false;
   }
 }
-function assertIntendedWarnings(quirk, intendedWarnings, bareWarnings) {
+function assertIntendedWarnings(intendedWarnings, bareWarnings) {
   if (!sameCodeSet(bareWarnings, intendedWarnings)) {
-    throw new Error(
-      `quirk "${quirk}": the intended-warning contract does not hold \u2014 expected exactly [${intendedWarnings.join(", ")}] but a bare parse produced [${bareWarnings.join(", ")}]. Refusing to emit a mislabeled fixture.`
-    );
+    throw new SynthError(SYNTH_FATAL_CODES.SYNTH_INTENDED_WARNING_MISMATCH);
   }
 }
 function validateProfileQuirks(profile, registry, format) {
@@ -850,6 +885,15 @@ function applyQuirk(quirk, wire) {
       return [...segments, "NTE|1||\\Zff\\"].join("\r");
   }
 }
+var ALL_QUIRK_KINDS = Object.freeze([
+  "ADT^A01",
+  "ADT^A04",
+  "ADT^A08",
+  "ORU^R01",
+  "ORM^O01",
+  "SIU^S12",
+  "VXU^V04"
+]);
 function baseMessage(kind, seed) {
   switch (kind) {
     case "ADT^A01":
@@ -870,11 +914,10 @@ function baseMessage(kind, seed) {
 }
 function generateHl7Quirk(options) {
   const seed = options.seed ?? 0;
-  const kind = options.kind ?? "ORU^R01";
+  const kind = resolveKind(ALL_QUIRK_KINDS, options.kind ?? "ORU^R01");
   const descriptor = resolveQuirk(HL7_QUIRKS, "hl7v2", options.quirk);
   const content = applyQuirk(options.quirk, baseMessage(kind, seed).toString());
   assertIntendedWarnings(
-    descriptor.name,
     descriptor.intendedWarnings,
     hl7.parseHL7(content).warnings.map((w) => String(w.code))
   );
@@ -920,6 +963,7 @@ var ALL_HL7_QUIRKS = Object.freeze(
 function hl7QuirkCorpus(options) {
   const quirks = options.profile ? validateProfileQuirks(options.profile, HL7_QUIRKS, "hl7v2") : options.quirks ?? ALL_HL7_QUIRKS;
   const names = quirks.length > 0 ? quirks : ALL_HL7_QUIRKS;
+  for (const name2 of names) resolveQuirk(HL7_QUIRKS, "hl7v2", name2);
   const kind = options.kind ?? "ORU^R01";
   const count = options.count ?? names.length;
   const seedStream = createRng(options.seed);
@@ -942,7 +986,7 @@ var hl7QuirkProfile = defineSynthProfile({
 });
 
 // src/hl7/index.ts
-var DEFAULT_MIX = Object.freeze([
+var ALL_KINDS = Object.freeze([
   "ADT^A01",
   "ADT^A04",
   "ADT^A08",
@@ -951,8 +995,10 @@ var DEFAULT_MIX = Object.freeze([
   "SIU^S12",
   "VXU^V04"
 ]);
+var DEFAULT_MIX = ALL_KINDS;
+var ADT_TRIGGERS2 = Object.freeze(["A01", "A04", "A08"]);
 function generateHl7(kind, seed) {
-  switch (kind) {
+  switch (resolveKind(ALL_KINDS, kind)) {
     case "ADT^A01":
       return generateAdt({ seed, trigger: "A01" });
     case "ADT^A04":
@@ -971,7 +1017,9 @@ function generateHl7(kind, seed) {
 }
 function hl7Corpus(options) {
   const { seed, count = 1 } = options;
-  const kinds = options.triggers !== void 0 ? options.triggers.map((t) => `ADT^${t}`) : options.mix ?? DEFAULT_MIX;
+  const kinds = options.triggers !== void 0 ? options.triggers.map(
+    (t) => `ADT^${resolveKind(ADT_TRIGGERS2, t)}`
+  ) : resolveMix(ALL_KINDS, options.mix, DEFAULT_MIX);
   const seedStream = createRng(seed);
   const artifacts = Array.from({ length: count }, (_unused, i) => {
     const kind = kinds[i % kinds.length] ?? "ADT^A01";