@cosyte/synth 0.0.2 → 0.0.4

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 import { s as ssn, p as phone, n as name, e as email, i as ipv4, c as ipv6, u as uuid, d as identifier, f as address, g as dateYmd, h as npi, j as dea } from './providers-OLz3zAc-.cjs';
 export { A as Artifact, C as Corpus, k as CorpusManifest, R as Rng, l as SsnBlock, m as SynthFormat, b as SyntheticAddress, a as SyntheticIdentifier, S as SyntheticName, o as createRng, q as makeCorpus } from './providers-OLz3zAc-.cjs';
-export { P as PROFILE_QUIRK_APPLIED, a as QuirkArtifact, Q as QuirkDescriptor, c as QuirkProfileDisposition, d as QuirkProfiledVerdict, b as QuirkRoundTripResult, S as SynthProfile, e as SynthProfileSpec, f as assertIntendedWarnings, g as defineSynthProfile, p as profileTolerated, r as resolveQuirk, s as sameCodeSet, v as validateProfileQuirks } from './quirk-DmkgoZdh.cjs';
+export { P as PROFILE_QUIRK_APPLIED, a as QuirkArtifact, Q as QuirkDescriptor, c as QuirkProfileDisposition, d as QuirkProfiledVerdict, b as QuirkRoundTripResult, S as SynthProfile, e as SynthProfileSpec, f as assertIntendedWarnings, g as defineSynthProfile, p as profileTolerated, r as resolveQuirk, s as sameCodeSet, v as validateProfileQuirks } from './quirk-DYMDojVw.cjs';
 
 /**
  * The reserved / never-collide identifier facts that make a `@cosyte/synth` value **provably
@@ -345,8 +345,12 @@ declare function sfc32Next(s: Sfc32State): number;
  */
 declare const SYNTH_FATAL_CODES: {
     /**
-     * A format was requested that this build cannot generate through a real parser builder/serializer
-     * (e.g. ASTM before `@cosyte/astm`'s serializer ships). Fatal — never a hand-written byte fallback.
+     * A format was requested that this build cannot generate through a real parser builder/serializer.
+     * Fatal — never a hand-written byte fallback.
+     *
+     * **No code path in this build raises it.** All six formats generate, so it is reserved for a
+     * future format that does not, and is kept because removing a published code is a breaking change.
+     * An unsupported *kind* within a format that does generate is `SYNTH_UNSUPPORTED_KIND`.
      */
     readonly SYNTH_UNSUPPORTED_FORMAT: "SYNTH_UNSUPPORTED_FORMAT";
     /**
@@ -354,31 +358,145 @@ declare const SYNTH_FATAL_CODES: {
      * never a silent no-op and never a fabricated quirk.
      */
     readonly SYNTH_UNSUPPORTED_QUIRK: "SYNTH_UNSUPPORTED_QUIRK";
+    /**
+     * A quirk transform found no structural anchor to mutate, so the fixture would not carry the
+     * deviation it is labelled with. Fatal — a golden file that lies about its parser verdict is worse
+     * than no golden file.
+     */
+    readonly SYNTH_QUIRK_ANCHOR_ABSENT: "SYNTH_QUIRK_ANCHOR_ABSENT";
+    /**
+     * 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.
+     */
+    readonly SYNTH_INTENDED_WARNING_MISMATCH: "SYNTH_INTENDED_WARNING_MISMATCH";
+    /** A concept's code-system URI has no OID mapping in the C-CDA example-code table. Fatal. */
+    readonly SYNTH_UNMAPPED_CODE_SYSTEM: "SYNTH_UNMAPPED_CODE_SYSTEM";
+    /** A money value could not be read as an X12 decimal. Fatal — a generator never rounds to a float. */
+    readonly SYNTH_INVALID_DECIMAL: "SYNTH_INVALID_DECIMAL";
+    /** An integer range was requested with its maximum below its minimum. Fatal. */
+    readonly SYNTH_INVALID_RANGE: "SYNTH_INVALID_RANGE";
+    /** A value was drawn from an empty pool. Fatal — never a fabricated substitute. */
+    readonly SYNTH_EMPTY_POOL: "SYNTH_EMPTY_POOL";
+    /** A `defineSynthProfile` spec was not usable (a missing or blank `name`). Fatal. */
+    readonly 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.
+     */
+    readonly SYNTH_UNSUPPORTED_KIND: "SYNTH_UNSUPPORTED_KIND";
 };
 /**
  * A value from {@link SYNTH_FATAL_CODES} — the type carried by a thrown {@link SynthError}.
  */
 type SynthFatalCode = (typeof SYNTH_FATAL_CODES)[keyof typeof SYNTH_FATAL_CODES];
+/**
+ * The **frozen message registry** — the only place a {@link SynthError} message can come from.
+ *
+ * A message here is a fixed string. It never quotes the request that produced it, and there is no
+ * parameter through which it could: {@link SynthError} takes a code and nothing else. That is the
+ * whole mechanism, and it is deliberately a mechanism rather than a habit. Every one of these
+ * messages used to be assembled by interpolating the caller's value into a template, and the reason
+ * that was safe was not the design — it was that the caller happened to be passing a quirk name.
+ *
+ * The trade is real and is accepted: a fatal no longer tells you *which* value it rejected. It tells
+ * you which rule refused, on `err.code`, and the stack frame tells you where. The caller already
+ * holds the value it passed.
+ *
+ * @example
+ * ```ts
+ * import { SYNTH_FATAL_CODES, SYNTH_FATAL_MESSAGES } from "@cosyte/synth";
+ * SYNTH_FATAL_MESSAGES[SYNTH_FATAL_CODES.SYNTH_EMPTY_POOL]; // => "A value was drawn from an empty pool."
+ * ```
+ */
+declare const SYNTH_FATAL_MESSAGES: Readonly<Record<SynthFatalCode, string>>;
 /**
  * The typed error every fatal `@cosyte/synth` condition throws. Carries a stable
  * {@link SynthFatalCode} so callers branch on `err.code` without matching message text.
  *
+ * It takes **no value parameter**. The message is whatever {@link SYNTH_FATAL_MESSAGES} holds for the
+ * code, so no caller-supplied string can reach a diagnostic surface by any route — not `message`, not
+ * `stack`, not a field on the thrown object.
+ *
  * @example
  * ```ts
  * import { SynthError, SYNTH_FATAL_CODES } from "@cosyte/synth";
- * throw new SynthError(SYNTH_FATAL_CODES.SYNTH_UNSUPPORTED_FORMAT, "astm is not yet generable");
+ * throw new SynthError(SYNTH_FATAL_CODES.SYNTH_UNSUPPORTED_FORMAT);
  * ```
  */
 declare class SynthError extends Error {
     /** The stable fatal code. */
     readonly code: SynthFatalCode;
     /**
-     * @param code - The stable {@link SynthFatalCode}.
-     * @param message - A human-readable detail (never contains PHI — there is none).
+     * @param code - The stable {@link SynthFatalCode}. The message comes from the frozen registry.
      */
-    constructor(code: SynthFatalCode, message: string);
+    constructor(code: SynthFatalCode);
 }
 
+/**
+ * The **selector chokepoint**. A generator's options are almost all *selectors*: a message kind, a
+ * document type, a corpus mix, a claim variant, a Bundle type, a profile. Each is typed as a closed
+ * union, and every one of those unions is **erased at run time**, so a JavaScript caller (or a
+ * `as never` in someone's test) reaches the branch with any string at all.
+ *
+ * Three things went wrong when that was left unchecked, and they are all the same bug:
+ *
+ * 1. **The value reached a diagnostic.** An unrecognised `documentType` travelled into
+ *    `@cosyte/ccda`'s `buildCcda`, which is entitled to quote it back in its own `TypeError` and
+ *    does. This package then has a caller-supplied string on an `err.message` and an `err.stack`,
+ *    through its own public entry point, having taken no care of it.
+ * 2. **The value reached the model.** A corpus mix entry becomes an `Artifact.kind` and a
+ *    `manifest.counts` key, which is precisely the structural-identifier position a downstream
+ *    package interpolates to describe a location.
+ * 3. **The fixture was silently mislabeled.** An exhaustive `switch` over an erased union takes no
+ *    branch and returns `undefined`, or a trailing `else` quietly generates something else. A corpus
+ *    whose manifest says it holds one transaction and holds another is a golden file that lies.
+ *
+ * So a selector is resolved against its own set, once, before anything is generated, and an
+ * unrecognised one is a fatal `SYNTH_UNSUPPORTED_KIND`. Like every fatal here it carries a code and a
+ * fixed message, and quotes neither the request nor the set.
+ *
+ * @module
+ */
+/**
+ * Resolve one caller-supplied selector against the closed set that governs it, or **fail closed**.
+ *
+ * @param allowed - Every value the selector may take.
+ * @param requested - The selector the caller supplied.
+ * @returns `requested`, narrowed to the union.
+ * @throws SynthError `SYNTH_UNSUPPORTED_KIND` when `requested` is not in `allowed`.
+ * @example
+ * ```ts
+ * import { resolveKind } from "@cosyte/synth";
+ * resolveKind(["ccd", "referralNote"] as const, "ccd"); // "ccd"
+ * ```
+ */
+declare function resolveKind<T extends string>(allowed: readonly T[], requested: string): T;
+/**
+ * Resolve every entry of a caller-supplied corpus mix, in order, or **fail closed** on the first
+ * unrecognised one.
+ *
+ * It substitutes the default **only** when the caller supplied nothing, which is exactly what the
+ * `??` it replaced did. An empty array is a supplied mix and is returned as one. An earlier version
+ * of this function also treated `[]` as "nothing supplied", on the stated grounds that it matched the
+ * previous behaviour; it did not — `??` fires on `undefined` and never on `[]` — and it changed the
+ * result of six published entry points, turning an explicit empty selection into "generate one of
+ * everything". A convenience that fails open is not a convenience.
+ *
+ * @param allowed - Every kind the corpus may generate.
+ * @param requested - The mix the caller supplied, or `undefined` for the default.
+ * @param fallback - The default mix, used only when `requested` is `undefined`.
+ * @returns The resolved mix.
+ * @throws SynthError `SYNTH_UNSUPPORTED_KIND` on the first unrecognised entry.
+ * @example
+ * ```ts
+ * import { resolveMix } from "@cosyte/synth";
+ * resolveMix(["Result", "Order"] as const, ["Order"], ["Result", "Order"]); // ["Order"]
+ * ```
+ */
+declare function resolveMix<T extends string>(allowed: readonly T[], requested: readonly string[] | undefined, fallback: readonly T[]): readonly T[];
+
 /**
  * `@cosyte/synth` — a deterministic, seedable **synthetic-data / test-fixture generator** for the
  * cosyte healthcare formats. A *consumer* of the parsers, not a parser: it builds artifacts **through
@@ -404,4 +522,4 @@ declare class SynthError extends Error {
  */
 declare const VERSION = "0.0.0";
 
-export { DEA_REGISTRANT_TYPES, DOC_V6_PREFIX, NPI_LUHN_PREFIX, RESERVED_EMAIL_DOMAINS, SYNTHETIC_ASSIGNING_AUTHORITY, SYNTHETIC_CITY_NAMES, SYNTHETIC_FAMILY_NAMES, SYNTHETIC_GIVEN_NAMES, SYNTHETIC_STREET_NAMES, SYNTH_FATAL_CODES, type Sfc32State, SynthError, type SynthFatalCode, TEST_NET_V4_PREFIXES, VERSION, address, dateYmd, dea, deaCheckDigit, email, identifier, ipv4, ipv6, isSyntheticDea, isSyntheticEmail, isSyntheticIp, isSyntheticNpi, isSyntheticPhone, isSyntheticSsn, luhnMod10, name, npi, npiCheckDigit, phone, safe, sfc32Next, splitmix32, ssn, uuid };
+export { DEA_REGISTRANT_TYPES, DOC_V6_PREFIX, NPI_LUHN_PREFIX, RESERVED_EMAIL_DOMAINS, SYNTHETIC_ASSIGNING_AUTHORITY, SYNTHETIC_CITY_NAMES, SYNTHETIC_FAMILY_NAMES, SYNTHETIC_GIVEN_NAMES, SYNTHETIC_STREET_NAMES, SYNTH_FATAL_CODES, SYNTH_FATAL_MESSAGES, type Sfc32State, SynthError, type SynthFatalCode, TEST_NET_V4_PREFIXES, VERSION, address, dateYmd, dea, deaCheckDigit, email, identifier, ipv4, ipv6, isSyntheticDea, isSyntheticEmail, isSyntheticIp, isSyntheticNpi, isSyntheticPhone, isSyntheticSsn, luhnMod10, name, npi, npiCheckDigit, phone, resolveKind, resolveMix, safe, sfc32Next, splitmix32, ssn, uuid };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { s as ssn, p as phone, n as name, e as email, i as ipv4, c as ipv6, u as uuid, d as identifier, f as address, g as dateYmd, h as npi, j as dea } from './providers-OLz3zAc-.js';
 export { A as Artifact, C as Corpus, k as CorpusManifest, R as Rng, l as SsnBlock, m as SynthFormat, b as SyntheticAddress, a as SyntheticIdentifier, S as SyntheticName, o as createRng, q as makeCorpus } from './providers-OLz3zAc-.js';
-export { P as PROFILE_QUIRK_APPLIED, a as QuirkArtifact, Q as QuirkDescriptor, c as QuirkProfileDisposition, d as QuirkProfiledVerdict, b as QuirkRoundTripResult, S as SynthProfile, e as SynthProfileSpec, f as assertIntendedWarnings, g as defineSynthProfile, p as profileTolerated, r as resolveQuirk, s as sameCodeSet, v as validateProfileQuirks } from './quirk-JLyO1Ncj.js';
+export { P as PROFILE_QUIRK_APPLIED, a as QuirkArtifact, Q as QuirkDescriptor, c as QuirkProfileDisposition, d as QuirkProfiledVerdict, b as QuirkRoundTripResult, S as SynthProfile, e as SynthProfileSpec, f as assertIntendedWarnings, g as defineSynthProfile, p as profileTolerated, r as resolveQuirk, s as sameCodeSet, v as validateProfileQuirks } from './quirk-C9t9CkPS.js';
 
 /**
  * The reserved / never-collide identifier facts that make a `@cosyte/synth` value **provably
@@ -345,8 +345,12 @@ declare function sfc32Next(s: Sfc32State): number;
  */
 declare const SYNTH_FATAL_CODES: {
     /**
-     * A format was requested that this build cannot generate through a real parser builder/serializer
-     * (e.g. ASTM before `@cosyte/astm`'s serializer ships). Fatal — never a hand-written byte fallback.
+     * A format was requested that this build cannot generate through a real parser builder/serializer.
+     * Fatal — never a hand-written byte fallback.
+     *
+     * **No code path in this build raises it.** All six formats generate, so it is reserved for a
+     * future format that does not, and is kept because removing a published code is a breaking change.
+     * An unsupported *kind* within a format that does generate is `SYNTH_UNSUPPORTED_KIND`.
      */
     readonly SYNTH_UNSUPPORTED_FORMAT: "SYNTH_UNSUPPORTED_FORMAT";
     /**
@@ -354,31 +358,145 @@ declare const SYNTH_FATAL_CODES: {
      * never a silent no-op and never a fabricated quirk.
      */
     readonly SYNTH_UNSUPPORTED_QUIRK: "SYNTH_UNSUPPORTED_QUIRK";
+    /**
+     * A quirk transform found no structural anchor to mutate, so the fixture would not carry the
+     * deviation it is labelled with. Fatal — a golden file that lies about its parser verdict is worse
+     * than no golden file.
+     */
+    readonly SYNTH_QUIRK_ANCHOR_ABSENT: "SYNTH_QUIRK_ANCHOR_ABSENT";
+    /**
+     * 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.
+     */
+    readonly SYNTH_INTENDED_WARNING_MISMATCH: "SYNTH_INTENDED_WARNING_MISMATCH";
+    /** A concept's code-system URI has no OID mapping in the C-CDA example-code table. Fatal. */
+    readonly SYNTH_UNMAPPED_CODE_SYSTEM: "SYNTH_UNMAPPED_CODE_SYSTEM";
+    /** A money value could not be read as an X12 decimal. Fatal — a generator never rounds to a float. */
+    readonly SYNTH_INVALID_DECIMAL: "SYNTH_INVALID_DECIMAL";
+    /** An integer range was requested with its maximum below its minimum. Fatal. */
+    readonly SYNTH_INVALID_RANGE: "SYNTH_INVALID_RANGE";
+    /** A value was drawn from an empty pool. Fatal — never a fabricated substitute. */
+    readonly SYNTH_EMPTY_POOL: "SYNTH_EMPTY_POOL";
+    /** A `defineSynthProfile` spec was not usable (a missing or blank `name`). Fatal. */
+    readonly 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.
+     */
+    readonly SYNTH_UNSUPPORTED_KIND: "SYNTH_UNSUPPORTED_KIND";
 };
 /**
  * A value from {@link SYNTH_FATAL_CODES} — the type carried by a thrown {@link SynthError}.
  */
 type SynthFatalCode = (typeof SYNTH_FATAL_CODES)[keyof typeof SYNTH_FATAL_CODES];
+/**
+ * The **frozen message registry** — the only place a {@link SynthError} message can come from.
+ *
+ * A message here is a fixed string. It never quotes the request that produced it, and there is no
+ * parameter through which it could: {@link SynthError} takes a code and nothing else. That is the
+ * whole mechanism, and it is deliberately a mechanism rather than a habit. Every one of these
+ * messages used to be assembled by interpolating the caller's value into a template, and the reason
+ * that was safe was not the design — it was that the caller happened to be passing a quirk name.
+ *
+ * The trade is real and is accepted: a fatal no longer tells you *which* value it rejected. It tells
+ * you which rule refused, on `err.code`, and the stack frame tells you where. The caller already
+ * holds the value it passed.
+ *
+ * @example
+ * ```ts
+ * import { SYNTH_FATAL_CODES, SYNTH_FATAL_MESSAGES } from "@cosyte/synth";
+ * SYNTH_FATAL_MESSAGES[SYNTH_FATAL_CODES.SYNTH_EMPTY_POOL]; // => "A value was drawn from an empty pool."
+ * ```
+ */
+declare const SYNTH_FATAL_MESSAGES: Readonly<Record<SynthFatalCode, string>>;
 /**
  * The typed error every fatal `@cosyte/synth` condition throws. Carries a stable
  * {@link SynthFatalCode} so callers branch on `err.code` without matching message text.
  *
+ * It takes **no value parameter**. The message is whatever {@link SYNTH_FATAL_MESSAGES} holds for the
+ * code, so no caller-supplied string can reach a diagnostic surface by any route — not `message`, not
+ * `stack`, not a field on the thrown object.
+ *
  * @example
  * ```ts
  * import { SynthError, SYNTH_FATAL_CODES } from "@cosyte/synth";
- * throw new SynthError(SYNTH_FATAL_CODES.SYNTH_UNSUPPORTED_FORMAT, "astm is not yet generable");
+ * throw new SynthError(SYNTH_FATAL_CODES.SYNTH_UNSUPPORTED_FORMAT);
  * ```
  */
 declare class SynthError extends Error {
     /** The stable fatal code. */
     readonly code: SynthFatalCode;
     /**
-     * @param code - The stable {@link SynthFatalCode}.
-     * @param message - A human-readable detail (never contains PHI — there is none).
+     * @param code - The stable {@link SynthFatalCode}. The message comes from the frozen registry.
      */
-    constructor(code: SynthFatalCode, message: string);
+    constructor(code: SynthFatalCode);
 }
 
+/**
+ * The **selector chokepoint**. A generator's options are almost all *selectors*: a message kind, a
+ * document type, a corpus mix, a claim variant, a Bundle type, a profile. Each is typed as a closed
+ * union, and every one of those unions is **erased at run time**, so a JavaScript caller (or a
+ * `as never` in someone's test) reaches the branch with any string at all.
+ *
+ * Three things went wrong when that was left unchecked, and they are all the same bug:
+ *
+ * 1. **The value reached a diagnostic.** An unrecognised `documentType` travelled into
+ *    `@cosyte/ccda`'s `buildCcda`, which is entitled to quote it back in its own `TypeError` and
+ *    does. This package then has a caller-supplied string on an `err.message` and an `err.stack`,
+ *    through its own public entry point, having taken no care of it.
+ * 2. **The value reached the model.** A corpus mix entry becomes an `Artifact.kind` and a
+ *    `manifest.counts` key, which is precisely the structural-identifier position a downstream
+ *    package interpolates to describe a location.
+ * 3. **The fixture was silently mislabeled.** An exhaustive `switch` over an erased union takes no
+ *    branch and returns `undefined`, or a trailing `else` quietly generates something else. A corpus
+ *    whose manifest says it holds one transaction and holds another is a golden file that lies.
+ *
+ * So a selector is resolved against its own set, once, before anything is generated, and an
+ * unrecognised one is a fatal `SYNTH_UNSUPPORTED_KIND`. Like every fatal here it carries a code and a
+ * fixed message, and quotes neither the request nor the set.
+ *
+ * @module
+ */
+/**
+ * Resolve one caller-supplied selector against the closed set that governs it, or **fail closed**.
+ *
+ * @param allowed - Every value the selector may take.
+ * @param requested - The selector the caller supplied.
+ * @returns `requested`, narrowed to the union.
+ * @throws SynthError `SYNTH_UNSUPPORTED_KIND` when `requested` is not in `allowed`.
+ * @example
+ * ```ts
+ * import { resolveKind } from "@cosyte/synth";
+ * resolveKind(["ccd", "referralNote"] as const, "ccd"); // "ccd"
+ * ```
+ */
+declare function resolveKind<T extends string>(allowed: readonly T[], requested: string): T;
+/**
+ * Resolve every entry of a caller-supplied corpus mix, in order, or **fail closed** on the first
+ * unrecognised one.
+ *
+ * It substitutes the default **only** when the caller supplied nothing, which is exactly what the
+ * `??` it replaced did. An empty array is a supplied mix and is returned as one. An earlier version
+ * of this function also treated `[]` as "nothing supplied", on the stated grounds that it matched the
+ * previous behaviour; it did not — `??` fires on `undefined` and never on `[]` — and it changed the
+ * result of six published entry points, turning an explicit empty selection into "generate one of
+ * everything". A convenience that fails open is not a convenience.
+ *
+ * @param allowed - Every kind the corpus may generate.
+ * @param requested - The mix the caller supplied, or `undefined` for the default.
+ * @param fallback - The default mix, used only when `requested` is `undefined`.
+ * @returns The resolved mix.
+ * @throws SynthError `SYNTH_UNSUPPORTED_KIND` on the first unrecognised entry.
+ * @example
+ * ```ts
+ * import { resolveMix } from "@cosyte/synth";
+ * resolveMix(["Result", "Order"] as const, ["Order"], ["Result", "Order"]); // ["Order"]
+ * ```
+ */
+declare function resolveMix<T extends string>(allowed: readonly T[], requested: readonly string[] | undefined, fallback: readonly T[]): readonly T[];
+
 /**
  * `@cosyte/synth` — a deterministic, seedable **synthetic-data / test-fixture generator** for the
  * cosyte healthcare formats. A *consumer* of the parsers, not a parser: it builds artifacts **through
@@ -404,4 +522,4 @@ declare class SynthError extends Error {
  */
 declare const VERSION = "0.0.0";
 
-export { DEA_REGISTRANT_TYPES, DOC_V6_PREFIX, NPI_LUHN_PREFIX, RESERVED_EMAIL_DOMAINS, SYNTHETIC_ASSIGNING_AUTHORITY, SYNTHETIC_CITY_NAMES, SYNTHETIC_FAMILY_NAMES, SYNTHETIC_GIVEN_NAMES, SYNTHETIC_STREET_NAMES, SYNTH_FATAL_CODES, type Sfc32State, SynthError, type SynthFatalCode, TEST_NET_V4_PREFIXES, VERSION, address, dateYmd, dea, deaCheckDigit, email, identifier, ipv4, ipv6, isSyntheticDea, isSyntheticEmail, isSyntheticIp, isSyntheticNpi, isSyntheticPhone, isSyntheticSsn, luhnMod10, name, npi, npiCheckDigit, phone, safe, sfc32Next, splitmix32, ssn, uuid };
+export { DEA_REGISTRANT_TYPES, DOC_V6_PREFIX, NPI_LUHN_PREFIX, RESERVED_EMAIL_DOMAINS, SYNTHETIC_ASSIGNING_AUTHORITY, SYNTHETIC_CITY_NAMES, SYNTHETIC_FAMILY_NAMES, SYNTHETIC_GIVEN_NAMES, SYNTHETIC_STREET_NAMES, SYNTH_FATAL_CODES, SYNTH_FATAL_MESSAGES, type Sfc32State, SynthError, type SynthFatalCode, TEST_NET_V4_PREFIXES, VERSION, address, dateYmd, dea, deaCheckDigit, email, identifier, ipv4, ipv6, isSyntheticDea, isSyntheticEmail, isSyntheticIp, isSyntheticNpi, isSyntheticPhone, isSyntheticSsn, luhnMod10, name, npi, npiCheckDigit, phone, resolveKind, resolveMix, safe, sfc32Next, splitmix32, ssn, uuid };

package/dist/index.mjs

@@ -27,6 +27,76 @@ function sfc32Next(s) {
   return t >>> 0;
 }
 
+// src/codes.ts
+var SYNTH_FATAL_CODES = {
+  /**
+   * A format was requested that this build cannot generate through a real parser builder/serializer.
+   * Fatal — never a hand-written byte fallback.
+   *
+   * **No code path in this build raises it.** All six formats generate, so it is reserved for a
+   * future format that does not, and is kept because removing a published code is a breaking change.
+   * An unsupported *kind* within a format that does generate is `SYNTH_UNSUPPORTED_KIND`.
+   */
+  SYNTH_UNSUPPORTED_FORMAT: "SYNTH_UNSUPPORTED_FORMAT",
+  /**
+   * 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 quirk transform found no structural anchor to mutate, so the fixture would not carry the
+   * deviation it is labelled with. Fatal — a golden file that lies about its parser verdict is worse
+   * than no golden file.
+   */
+  SYNTH_QUIRK_ANCHOR_ABSENT: "SYNTH_QUIRK_ANCHOR_ABSENT",
+  /**
+   * 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",
+  /** A concept's code-system URI has no OID mapping in the C-CDA example-code table. Fatal. */
+  SYNTH_UNMAPPED_CODE_SYSTEM: "SYNTH_UNMAPPED_CODE_SYSTEM",
+  /** 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 `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;
@@ -44,7 +114,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);
   }
@@ -52,7 +122,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) {
@@ -395,7 +465,7 @@ function makeCorpus(seed, artifacts, quirks = []) {
 // 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,
@@ -405,33 +475,6 @@ function defineSynthProfile(spec) {
   });
 }
 
-// src/codes.ts
-var SYNTH_FATAL_CODES = {
-  /**
-   * A format was requested that this build cannot generate through a real parser builder/serializer
-   * (e.g. ASTM before `@cosyte/astm`'s serializer ships). Fatal — never a hand-written byte fallback.
-   */
-  SYNTH_UNSUPPORTED_FORMAT: "SYNTH_UNSUPPORTED_FORMAT",
-  /**
-   * 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) {
@@ -448,12 +491,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;
 }
@@ -468,11 +507,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) {
@@ -480,9 +517,20 @@ function validateProfileQuirks(profile, registry, format) {
   return profile.quirks;
 }
 
+// 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/index.ts
 var VERSION = "0.0.0";
 
-export { DEA_REGISTRANT_TYPES, DOC_V6_PREFIX, NPI_LUHN_PREFIX, PROFILE_QUIRK_APPLIED, RESERVED_EMAIL_DOMAINS, SYNTHETIC_ASSIGNING_AUTHORITY, SYNTHETIC_CITY_NAMES, SYNTHETIC_FAMILY_NAMES, SYNTHETIC_GIVEN_NAMES, SYNTHETIC_STREET_NAMES, SYNTH_FATAL_CODES, SynthError, TEST_NET_V4_PREFIXES, VERSION, address, assertIntendedWarnings, createRng, dateYmd, dea, deaCheckDigit, defineSynthProfile, email, identifier, ipv4, ipv6, isSyntheticDea, isSyntheticEmail, isSyntheticIp, isSyntheticNpi, isSyntheticPhone, isSyntheticSsn, luhnMod10, makeCorpus, name, npi, npiCheckDigit, phone, profileTolerated, resolveQuirk, safe, sameCodeSet, sfc32Next, splitmix32, ssn, uuid, validateProfileQuirks };
+export { DEA_REGISTRANT_TYPES, DOC_V6_PREFIX, NPI_LUHN_PREFIX, PROFILE_QUIRK_APPLIED, RESERVED_EMAIL_DOMAINS, SYNTHETIC_ASSIGNING_AUTHORITY, SYNTHETIC_CITY_NAMES, SYNTHETIC_FAMILY_NAMES, SYNTHETIC_GIVEN_NAMES, SYNTHETIC_STREET_NAMES, SYNTH_FATAL_CODES, SYNTH_FATAL_MESSAGES, SynthError, TEST_NET_V4_PREFIXES, VERSION, address, assertIntendedWarnings, createRng, dateYmd, dea, deaCheckDigit, defineSynthProfile, email, identifier, ipv4, ipv6, isSyntheticDea, isSyntheticEmail, isSyntheticIp, isSyntheticNpi, isSyntheticPhone, isSyntheticSsn, luhnMod10, makeCorpus, name, npi, npiCheckDigit, phone, profileTolerated, resolveKind, resolveMix, resolveQuirk, safe, sameCodeSet, sfc32Next, splitmix32, ssn, uuid, validateProfileQuirks };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map