@cosyte/synth 0.0.3 → 0.0.4

package/dist/{quirk-DmkgoZdh.d.cts → quirk-DYMDojVw.d.cts}

@@ -39,7 +39,7 @@ interface SynthProfile {
  *
  * @param spec - The profile spec; `name` is required and non-empty.
  * @returns A deep-frozen {@link SynthProfile}.
- * @throws TypeError when `name` is missing or blank.
+ * @throws SynthError `SYNTH_INVALID_PROFILE` when `name` is missing or blank.
  * @example
  * ```ts
  * import { defineSynthProfile } from "@cosyte/synth";
@@ -167,8 +167,14 @@ declare function sameCodeSet(a: readonly string[], b: readonly string[]): boolea
  * profile system does not support is a fatal `SYNTH_UNSUPPORTED_QUIRK` — never a silent no-op and never
  * a fabricated quirk with a made-up warning.
  *
+ * The refusal names neither the request nor the registry. `registry`, `format` and `name` are all
+ * caller-supplied, and a diagnostic that quotes its input is a diagnostic that can be made to carry
+ * anything the caller was holding — which for a fixture generator wired into someone else's pipeline
+ * is not a hypothetical. Branch on `err.code`; the supported set is the registry you passed
+ * (`HL7_QUIRKS`, `CCDA_QUIRKS`, `ASTM_QUIRKS`), which you can enumerate directly.
+ *
  * @param registry - The format's quirk descriptors, keyed by name.
- * @param format - The format being generated (for the error message).
+ * @param format - The format being generated.
  * @param name - The requested quirk name.
  * @returns The matching {@link QuirkDescriptor}.
  * @throws SynthError with code `SYNTH_UNSUPPORTED_QUIRK` when `name` is not a supported quirk.
@@ -205,17 +211,22 @@ declare function profileTolerated(disposition: QuirkProfileDisposition, intended
  * warning. Every format's `generate*Quirk` calls this after transforming, so the contract is enforced at
  * generation time, not merely at round-trip time.
  *
- * @param quirk - The quirk name (for the error message).
+ * It no longer takes the quirk name. That parameter existed for one reason — to be interpolated into
+ * the refusal — and a parameter whose only job is to reach a message is the exact shape this package
+ * is removing, so it is gone rather than merely unused. The refusal names neither code list either;
+ * both are caller-supplied, and the caller reads the comparison back off the arguments it holds.
+ *
  * @param intendedWarnings - The declared intended code(s).
  * @param bareWarnings - The code(s) a bare parse of the generated artifact actually produced.
- * @throws Error when the bare parse did not produce exactly the intended code(s).
+ * @throws SynthError `SYNTH_INTENDED_WARNING_MISMATCH` when the bare parse did not produce exactly
+ *   the intended code(s).
  * @example
  * ```ts
  * import { assertIntendedWarnings } from "@cosyte/synth";
- * assertIntendedWarnings("unknown-zsegment", ["UNKNOWN_SEGMENT"], ["UNKNOWN_SEGMENT"]); // ok
+ * assertIntendedWarnings(["UNKNOWN_SEGMENT"], ["UNKNOWN_SEGMENT"]); // ok
  * ```
  */
-declare function assertIntendedWarnings(quirk: string, intendedWarnings: readonly string[], bareWarnings: readonly string[]): void;
+declare function assertIntendedWarnings(intendedWarnings: readonly string[], bareWarnings: readonly string[]): void;
 /**
  * Validate the quirk names carried by a {@link SynthProfile} against a format's registry, failing closed
  * on the first unsupported one. Lets a consumer author a fixture recipe with `defineSynthProfile` and

package/dist/x12/index.cjs

@@ -31,6 +31,47 @@ function sfc32Next(s) {
   return t >>> 0;
 }
 
+// src/codes.ts
+var SYNTH_FATAL_CODES = {
+  /** A money value could not be read as an X12 decimal. Fatal — a generator never rounds to a float. */
+  SYNTH_INVALID_DECIMAL: "SYNTH_INVALID_DECIMAL",
+  /** 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 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 +89,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 +97,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) {
@@ -91,7 +132,7 @@ function makeCorpus(seed, artifacts, quirks = []) {
 }
 function dec(value) {
   const d = x12.X12Decimal.fromString(value);
-  if (d === void 0) throw new Error(`invalid synthetic decimal: ${value}`);
+  if (d === void 0) throw new SynthError(SYNTH_FATAL_CODES.SYNTH_INVALID_DECIMAL);
   return d;
 }
 function money(n) {
@@ -469,7 +510,19 @@ var TOOTH_SURFACES = Object.freeze(["M", "O", "D", "B", "L"]);
 var CARC_CODES = Object.freeze(["1", "2", "3", "45", "96", "197"]);
 var SERVICE_TYPE_CODES = Object.freeze(["30", "1", "35", "88", "98"]);
 
+// 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/x12/claim-837.ts
+var CLAIM_837_VARIANTS = Object.freeze(["P", "I", "D"]);
 function serviceDtp(serviceDate) {
   return { qualifier: "472", formatQualifier: "D8", value: serviceDate };
 }
@@ -652,11 +705,17 @@ function specOf(rng, variant) {
   };
 }
 function generate837(variant, options) {
+  const resolved = resolveKind(CLAIM_837_VARIANTS, variant);
   const rng = createRng(options.seed);
-  const spec = specOf(rng, variant);
-  if (variant === "P") return x12.build837P(spec);
-  if (variant === "I") return x12.build837I(spec);
-  return x12.build837D(spec);
+  const spec = specOf(rng, resolved);
+  switch (resolved) {
+    case "P":
+      return x12.build837P(spec);
+    case "I":
+      return x12.build837I(spec);
+    case "D":
+      return x12.build837D(spec);
+  }
 }
 function generate837P(options) {
   return generate837("P", options);
@@ -864,15 +923,25 @@ function roundTrip(interchange) {
 }
 
 // src/x12/index.ts
-var DEFAULT_MIX = Object.freeze(["837P", "837I", "837D", "835", "271"]);
+var ALL_KINDS = Object.freeze(["837P", "837I", "837D", "835", "271"]);
+var DEFAULT_MIX = ALL_KINDS;
 function generateKind(kind, seed) {
-  if (kind === "835") return roundTrip(generate835({ seed }));
-  if (kind === "271") return roundTrip(generate271({ seed }));
-  const variant = kind === "837I" ? "I" : kind === "837D" ? "D" : "P";
-  return roundTrip(generate837(variant, { seed }));
+  switch (kind) {
+    case "835":
+      return roundTrip(generate835({ seed }));
+    case "271":
+      return roundTrip(generate271({ seed }));
+    case "837P":
+      return roundTrip(generate837("P", { seed }));
+    case "837I":
+      return roundTrip(generate837("I", { seed }));
+    case "837D":
+      return roundTrip(generate837("D", { seed }));
+  }
 }
 function x12Corpus(options) {
-  const { seed, mix = DEFAULT_MIX } = options;
+  const { seed } = 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) => {