@cosyte/synth 0.0.7 → 0.0.8

package/dist/index.d.cts

@@ -1,25 +1,25 @@
-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-DYMDojVw.cjs';
+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-B9uVinAe.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-B9uVinAe.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-IaHp4z7N.cjs';
 
 /**
  * The reserved / never-collide identifier facts that make a `@cosyte/synth` value **provably
- * synthetic** — the ground truth behind the synthetic-safety invariant.
+ * synthetic**: the ground truth behind the synthetic-safety invariant.
  *
  * These are **facts**, not copyrighted prose: authoritative ranges published by SSA, NANPA, and the
  * IETF that are guaranteed never to denote a real person or a real routable resource. Every provider
- * draws only from these; the predicates here are the executable half of the CI synthetic-safety gate —
+ * draws only from these; the predicates here are the executable half of the CI synthetic-safety gate:
  * they let a test assert that no emitted value falls **outside** a reserved source.
  *
  * Sources:
- * - **SSN** — SSA never issues area numbers `000`, `666`, or `900–999`; the `987-65-4320…4329` block
+ * - **SSN**, SSA never issues area numbers `000`, `666`, or `900–999`; the `987-65-4320…4329` block
  *   is SSA's explicitly-reserved advertising range. (ssa.gov)
- * - **Phone** — NANP reserves `555-0100…555-0199` as the fictional/non-working line range. (nanpa.com)
- * - **Email/domain** — RFC 2606 / RFC 6761 reserved: `example.com`/`.net`/`.org` and the `.example`,
+ * - **Phone**, NANP reserves `555-0100…555-0199` as the fictional/non-working line range. (nanpa.com)
+ * - **Email/domain**, RFC 2606 / RFC 6761 reserved: `example.com`/`.net`/`.org` and the `.example`,
  *   `.test`, `.invalid`, `.localhost` TLDs.
- * - **IP** — RFC 5737 IPv4 TEST-NET-1/2/3 (`192.0.2.0/24`, `198.51.100.0/24`, `203.0.113.0/24`) and
+ * - **IP**, RFC 5737 IPv4 TEST-NET-1/2/3 (`192.0.2.0/24`, `198.51.100.0/24`, `203.0.113.0/24`) and
  *   RFC 3849 IPv6 documentation prefix `2001:db8::/32`.
- * - **NPI** — a real National Provider Identifier is a 10-digit number whose last digit is a Luhn
+ * - **NPI**, a real National Provider Identifier is a 10-digit number whose last digit is a Luhn
  *   check digit computed over the `80840` prefix + the 9-digit base (CMS NPI check-digit rule, ISO
  *   7812). A number whose check digit is **wrong** therefore cannot be a NPPES-issued NPI. `synth`
  *   emits NPIs with a deliberately-invalid check digit, so no generated NPI can collide with a real
@@ -30,7 +30,7 @@ export { P as PROFILE_QUIRK_APPLIED, a as QuirkArtifact, Q as QuirkDescriptor, c
 /**
  * The synthetic **assigning authority** `@cosyte/synth` mints MRNs / account / member identifiers
  * under. There is **no** reserved MRN range (an MRN is unique only within its assigning-authority /
- * OID namespace), so — a documented design decision — every synthetic identifier
+ * OID namespace), so, as a documented design decision, every synthetic identifier
  * is scoped to a namespace that clearly cannot be a real facility's: a `SYNTH`-labelled authority whose
  * OID lives under HL7's designated **example** root `2.16.840.1.113883.19`. A value under this AA can
  * never collide with a real record because the *namespace itself* is synthetic.
@@ -38,7 +38,7 @@ export { P as PROFILE_QUIRK_APPLIED, a as QuirkArtifact, Q as QuirkDescriptor, c
 declare const SYNTHETIC_ASSIGNING_AUTHORITY: Readonly<{
     /** The human-readable assigning-authority namespace id (HL7 HD.1). */
     namespaceId: "COSYTE-SYNTH";
-    /** The universal id — an OID under HL7's example arc `2.16.840.1.113883.19` (HD.2). */
+    /** The universal id, an OID under HL7's example arc `2.16.840.1.113883.19` (HD.2). */
     universalId: "2.16.840.1.113883.19.999";
     /** The universal id type (HD.3). */
     universalIdType: "ISO";
@@ -51,7 +51,7 @@ declare const TEST_NET_V4_PREFIXES: readonly string[];
 declare const DOC_V6_PREFIX = "2001:db8";
 /**
  * The `80840` prefix prepended to a 10-digit NPI before the Luhn check (the CMS NPI check-digit
- * rule — `80840` is the ISO 7812 issuer identifier for the US health-application namespace). A real
+ * rule: `80840` is the ISO 7812 issuer identifier for the US health-application namespace). A real
  * NPI satisfies `luhn("80840" + npi) ≡ 0 (mod 10)`.
  */
 declare const NPI_LUHN_PREFIX = "80840";
@@ -65,7 +65,7 @@ declare const NPI_LUHN_PREFIX = "80840";
  */
 declare function luhnMod10(digits: string): number;
 /**
- * The correct NPI check digit for a 9-digit base — the value that makes `80840` + base + check pass
+ * The correct NPI check digit for a 9-digit base: the value that makes `80840` + base + check pass
  * the Luhn check.
  *
  * @param base9 - The 9-digit NPI base (positions 1–9).
@@ -73,7 +73,7 @@ declare function luhnMod10(digits: string): number;
  * @example
  * ```ts
  * import { npiCheckDigit } from "@cosyte/synth";
- * npiCheckDigit("123456789"); // 3 — so 1234567893 is a Luhn-valid NPI shape
+ * npiCheckDigit("123456789"); // 3, so 1234567893 is a Luhn-valid NPI shape
  * ```
  */
 declare function npiCheckDigit(base9: string): number;
@@ -82,7 +82,7 @@ declare function npiCheckDigit(base9: string): number;
  * from. A real DEA number is `<registrant-type><last-name-initial>` + 7 digits; the first letter is the
  * registrant type (A/B/F/G/M/P/R/X are the widely-published values; the second letter is the
  * registrant's last-name initial). These letters are a **fact** about the number's shape, not
- * copyrighted prose — they only shape the value; the synthetic guarantee is the deliberately-**invalid
+ * copyrighted prose: they only shape the value; the synthetic guarantee is the deliberately-**invalid
  * checksum** (see {@link dea} / {@link isSyntheticDea}).
  */
 declare const DEA_REGISTRANT_TYPES: readonly string[];
@@ -101,7 +101,7 @@ declare const DEA_REGISTRANT_TYPES: readonly string[];
  */
 declare function deaCheckDigit(base6: string): number;
 /**
- * Whether a DEA number (`XX` + 7 digits, case-insensitive) is **provably synthetic** — its check digit
+ * Whether a DEA number (`XX` + 7 digits, case-insensitive) is **provably synthetic**: its check digit
  * (the 7th digit) does **not** match the published DEA checksum, so it cannot be a validly-issued DEA
  * registration. A checksum-valid DEA number (which *could* denote a real prescriber) returns `false`; a
  * value that is not the DEA shape returns `false`.
@@ -111,12 +111,12 @@ declare function deaCheckDigit(base6: string): number;
  * @example
  * ```ts
  * import { isSyntheticDea } from "@cosyte/synth";
- * isSyntheticDea("AF1234561"); // depends on the base — true when the 7th digit is wrong
+ * isSyntheticDea("AF1234561"); // depends on the base: true when the 7th digit is wrong
  * ```
  */
 declare function isSyntheticDea(value: string): boolean;
 /**
- * Whether a 10-digit NPI is **provably synthetic** — i.e. its check digit is invalid, so it cannot be
+ * Whether a 10-digit NPI is **provably synthetic**, i.e. its check digit is invalid, so it cannot be
  * a NPPES-issued NPI. A Luhn-valid 10-digit NPI (which *could* denote a real registered provider)
  * returns `false`; a non-10-digit value returns `false` (not an NPI shape).
  *
@@ -125,14 +125,14 @@ declare function isSyntheticDea(value: string): boolean;
  * @example
  * ```ts
  * import { isSyntheticNpi } from "@cosyte/synth";
- * isSyntheticNpi("1234567894"); // true  — invalid check digit (valid would be 1234567893)
- * isSyntheticNpi("1234567893"); // false — Luhn-valid, could be a real NPI
+ * isSyntheticNpi("1234567894"); // true: invalid check digit (valid would be 1234567893)
+ * isSyntheticNpi("1234567893"); // false: Luhn-valid, could be a real NPI
  * ```
  */
 declare function isSyntheticNpi(value: string): boolean;
 /**
  * Whether a `ddd-dd-dddd` (or `ddddddddd`) SSN string is drawn from an SSA never-issued / reserved
- * space — area `000`, `666`, or `900–999`. A real, issuable SSN returns `false`.
+ * space: area `000`, `666`, or `900–999`. A real, issuable SSN returns `false`.
  *
  * @param value - The candidate SSN (dashes optional).
  * @returns `true` when the SSN is provably synthetic.
@@ -184,12 +184,12 @@ declare function isSyntheticEmail(value: string): boolean;
 declare function isSyntheticIp(value: string): boolean;
 
 /**
- * The shipped **clearly-fake name pool** — `@cosyte/synth`'s own license-clean synthetic data.
+ * The shipped **clearly-fake name pool**: `@cosyte/synth`'s own license-clean synthetic data.
  *
  * Deliberately **not** a `faker`-style realistic-name corpus (which could match a real person at a real
- * address — the exact hazard the synthetic-safety invariant forbids). Every token is
+ * address: the exact hazard the synthetic-safety invariant forbids). Every token is
  * an obviously-invented, fixture-flavoured word: a reader can tell at a glance it names no one. The pool
- * is small on purpose — structural coverage, not demographic realism, is the goal.
+ * is small on purpose: structural coverage, not demographic realism, is the goal.
  *
  * `# synthetic: true`
  *
@@ -208,7 +208,7 @@ declare const SYNTHETIC_STREET_NAMES: readonly string[];
 declare const SYNTHETIC_CITY_NAMES: readonly string[];
 
 /**
- * The `safe` namespace — the single entry point for every synthetic-by-construction value provider.
+ * The `safe` namespace: the single entry point for every synthetic-by-construction value provider.
  *
  * Grouped under one object so a consumer reads `safe.ssn(rng)` / `safe.phone(rng)` and it is
  * self-evident that the value is drawn from a guaranteed-non-colliding synthetic source.
@@ -220,7 +220,7 @@ declare const SYNTHETIC_CITY_NAMES: readonly string[];
 
 /**
  * The synthetic-safety provider namespace. Every function draws only from a reserved range or the
- * shipped fake-name pool — no value it returns can be real or plausibly-real PHI.
+ * shipped fake-name pool, no value it returns can be real or plausibly-real PHI.
  *
  * @example
  * ```ts
@@ -246,14 +246,14 @@ declare const safe: Readonly<{
 }>;
 
 /**
- * `splitmix32` — a tiny, well-studied 32-bit mixing PRNG used **only** to expand a single integer
+ * `splitmix32`: a tiny, well-studied 32-bit mixing PRNG used **only** to expand a single integer
  * seed into the four 32-bit state words that seed {@link ../rng/sfc32.sfc32}. It is not the corpus
  * generator itself (that is `sfc32`); it exists so that a one-number seed deterministically produces a
  * well-distributed 128-bit `sfc32` state, avoiding the poor low-bit behavior of naive
  * `state = seed`-style initialization.
  *
- * Zero-dependency, `Math.random`-free (lint-enforced): the whole point of the library is that a seed —
- * and only the seed — determines the output, on any machine, any run.
+ * Zero-dependency, `Math.random`-free (lint-enforced): the whole point of the library is that a seed,
+ * and only the seed, determines the output, on any machine, any run.
  *
  * @module
  */
@@ -273,10 +273,10 @@ declare const safe: Readonly<{
 declare function splitmix32(seed: number): () => number;
 
 /**
- * `sfc32` (Small Fast Counter, 32-bit, 128-bit state) — the deterministic, non-cryptographic PRNG that
+ * `sfc32` (Small Fast Counter, 32-bit, 128-bit state): the deterministic, non-cryptographic PRNG that
  * drives every value `@cosyte/synth` generates. Chosen over `mulberry32` (whose author flags that it
  * skips ~1/3 of 32-bit outputs) and over a CSPRNG (`node:crypto`, which is **not seedable** and would
- * defeat reproducibility). A synthetic-fixture generator has **no secrets** — statistical quality plus
+ * defeat reproducibility). A synthetic-fixture generator has **no secrets**: statistical quality plus
  * byte-for-byte reproducibility is exactly the right trade.
  *
  * The state is four 32-bit words. This module exposes the raw step function; {@link ../rng/rng.Rng}
@@ -302,7 +302,7 @@ interface Sfc32State {
  *
  * This is the canonical `sfc32` step. The state object is mutated (the counter `d` increments and the
  * mixing words rotate); callers that need reproducible independence hold their own state and never
- * share it — {@link ../rng/rng.Rng} creates a fresh state per seed so two runs from the same seed are
+ * share it: {@link ../rng/rng.Rng} creates a fresh state per seed so two runs from the same seed are
  * identical.
  *
  * @param s - The state to advance. Mutated in place.
@@ -320,10 +320,10 @@ declare function sfc32Next(s: Sfc32State): number;
  * Stable diagnostic codes for `@cosyte/synth` and the {@link SynthError} they travel on.
  *
  * Unlike a parser (which recovers from bad *input* into Tier-2 warnings), a **generator** has no input
- * to tolerate — its reflex is *synthetic-by-construction* and *fail-closed on impossibility*. So the
+ * to tolerate: its reflex is *synthetic-by-construction* and *fail-closed on impossibility*. So the
  * codes here are **fatal**: a caller asked for something the library cannot honor spec-clean, and the
  * only safe answer is to throw, never to silently fabricate a value or a byte workaround. Codes are `key ===
- * value` and part of the public contract —
+ * value` and part of the public contract:
  * renaming one is a breaking change.
  *
  * @module
@@ -346,7 +346,7 @@ 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.
-     * Fatal — never a hand-written byte fallback.
+     * 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.
@@ -354,51 +354,51 @@ declare const SYNTH_FATAL_CODES: {
      */
     readonly SYNTH_UNSUPPORTED_FORMAT: "SYNTH_UNSUPPORTED_FORMAT";
     /**
-     * A vendor quirk was requested that the target format's profile system does not support. Fatal —
+     * 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.
      */
     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
+     * 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.
+     * 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. */
+    /** 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. */
+    /** 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 —
+     * 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}.
+ * 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.
+ * 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.
+ * 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
@@ -416,7 +416,7 @@ declare const SYNTH_FATAL_MESSAGES: Readonly<Record<SynthFatalCode, string>>;
  * {@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
+ * 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
@@ -480,7 +480,7 @@ declare function resolveKind<T extends string>(allowed: readonly T[], requested:
  * 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
+ * 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.
  *
@@ -498,7 +498,7 @@ declare function resolveKind<T extends string>(allowed: readonly T[], requested:
 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/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
  * each parser's own builder/serializer** (so output is spec-clean by construction) and draws every
  * value from a **guaranteed-non-colliding synthetic source** (so no output can be real or
@@ -507,7 +507,7 @@ declare function resolveMix<T extends string>(allowed: readonly T[], requested:
  * This root entry point exposes the **format-agnostic core**: the seeded PRNG, the synthetic-safety
  * providers, the `Corpus` abstraction, the profile skeleton, and the fatal codes. Per-format
  * generation lives behind its own subpath (`@cosyte/synth/hl7`) so importing the root never pulls a
- * parser — the lazy per-format boundary.
+ * parser: the lazy per-format boundary.
  *
  * @module
  */