@cosyte/synth 0.0.1

package/dist/astm/index.cjs

@@ -0,0 +1,847 @@
+'use strict';
+
+var astm = require('@cosyte/astm');
+
+// src/rng/splitmix32.ts
+function splitmix32(seed) {
+  let a = seed | 0;
+  return function next() {
+    a = a + 2654435769 | 0;
+    let t = a ^ a >>> 16;
+    t = Math.imul(t, 569420461);
+    t = t ^ t >>> 15;
+    t = Math.imul(t, 1935289751);
+    t = t ^ t >>> 15;
+    return t >>> 0;
+  };
+}
+
+// src/rng/sfc32.ts
+function sfc32Next(s) {
+  s.a |= 0;
+  s.b |= 0;
+  s.c |= 0;
+  s.d |= 0;
+  const t = (s.a + s.b | 0) + s.d | 0;
+  s.d = s.d + 1 | 0;
+  s.a = s.b ^ s.b >>> 9;
+  s.b = s.c + (s.c << 3) | 0;
+  s.c = s.c << 21 | s.c >>> 11;
+  s.c = s.c + t | 0;
+  return t >>> 0;
+}
+
+// src/rng/rng.ts
+var Sfc32Rng = class {
+  seed;
+  #state;
+  constructor(seed) {
+    this.seed = seed | 0;
+    const mix = splitmix32(this.seed);
+    this.#state = { a: mix(), b: mix(), c: mix(), d: mix() };
+    for (let i = 0; i < 8; i += 1) sfc32Next(this.#state);
+  }
+  nextUint32() {
+    return sfc32Next(this.#state);
+  }
+  float() {
+    return this.nextUint32() / 4294967296;
+  }
+  int(min, max) {
+    if (max < min) throw new RangeError(`Rng.int: max (${String(max)}) < min (${String(min)})`);
+    const span = max - min + 1;
+    return min + Math.floor(this.float() * span);
+  }
+  bool(p = 0.5) {
+    return this.float() < p;
+  }
+  pick(items) {
+    if (items.length === 0) throw new RangeError("Rng.pick: empty array");
+    return items[this.int(0, items.length - 1)];
+  }
+  digits(n) {
+    let out = "";
+    for (let i = 0; i < n; i += 1) out += String(this.int(0, 9));
+    return out;
+  }
+};
+function createRng(seed) {
+  return new Sfc32Rng(seed);
+}
+
+// src/corpus.ts
+function makeCorpus(seed, artifacts, quirks = []) {
+  const counts = {};
+  const formats = /* @__PURE__ */ new Set();
+  const frozenArtifacts = artifacts.map((a) => {
+    counts[a.kind] = (counts[a.kind] ?? 0) + 1;
+    formats.add(a.format);
+    return Object.freeze({ ...a, warnings: Object.freeze([...a.warnings]) });
+  });
+  const manifest = Object.freeze({
+    formats: Object.freeze([...formats]),
+    counts: Object.freeze(counts),
+    quirks: Object.freeze([...quirks])
+  });
+  return Object.freeze({
+    seed,
+    manifest,
+    artifacts: Object.freeze(frozenArtifacts)
+  });
+}
+
+// src/safe/reserved.ts
+var SYNTHETIC_ASSIGNING_AUTHORITY = Object.freeze({
+  /** 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). */
+  universalId: "2.16.840.1.113883.19.999",
+  /** The universal id type (HD.3). */
+  universalIdType: "ISO"
+});
+var RESERVED_EMAIL_DOMAINS = Object.freeze([
+  "example.com",
+  "example.org",
+  "example.net"
+]);
+var TEST_NET_V4_PREFIXES = Object.freeze([
+  "192.0.2",
+  // TEST-NET-1
+  "198.51.100",
+  // TEST-NET-2
+  "203.0.113"
+  // TEST-NET-3
+]);
+var DOC_V6_PREFIX = "2001:db8";
+var NPI_LUHN_PREFIX = "80840";
+function luhnMod10(digits) {
+  let sum = 0;
+  let double = false;
+  for (let i = digits.length - 1; i >= 0; i -= 1) {
+    let d = digits.charCodeAt(i) - 48;
+    if (d < 0 || d > 9) continue;
+    if (double) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+    double = !double;
+  }
+  return sum % 10;
+}
+function npiCheckDigit(base9) {
+  const partial = luhnMod10(`${NPI_LUHN_PREFIX}${base9}0`);
+  return (10 - partial) % 10;
+}
+var DEA_REGISTRANT_TYPES = Object.freeze([
+  "A",
+  "B",
+  "F",
+  "G",
+  "M",
+  "P",
+  "R",
+  "X"
+]);
+function deaCheckDigit(base6) {
+  let odd = 0;
+  let even = 0;
+  for (let i = 0; i < 6; i += 1) {
+    const digit = base6.charCodeAt(i) - 48;
+    if (i % 2 === 0) odd += digit;
+    else even += digit;
+  }
+  return (odd + 2 * even) % 10;
+}
+
+// src/safe/names-pool.ts
+var SYNTHETIC_GIVEN_NAMES = Object.freeze([
+  "Testina",
+  "Fixtura",
+  "Synthos",
+  "Placeholda",
+  "Sampleton",
+  "Prototius",
+  "Stubbina",
+  "Exampla",
+  "Quilliam",
+  "Fabrica",
+  "Simula",
+  "Testry",
+  "Seedwin",
+  "Corpora",
+  "Reprodo",
+  "Mocktavia",
+  "Dummett",
+  "Voidwin",
+  "Deteria",
+  "Randomir"
+]);
+var SYNTHETIC_FAMILY_NAMES = Object.freeze([
+  "Testerson",
+  "Fauxman",
+  "Placeholt",
+  "Mockridge",
+  "Fixtingham",
+  "Synthwell",
+  "Dummerton",
+  "Examplewood",
+  "Fabricant",
+  "Simulacre",
+  "Nonesuch",
+  "Seedman",
+  "Corpusworth",
+  "Reprodus",
+  "Voidmark",
+  "Deterwood",
+  "Randomson",
+  "Quillfeather",
+  "Notreal",
+  "Genfield"
+]);
+var SYNTHETIC_STREET_NAMES = Object.freeze([
+  "Fixture Lane",
+  "Sample Street",
+  "Placeholder Avenue",
+  "Synthetic Way",
+  "Example Boulevard",
+  "Testing Terrace",
+  "Mock Road",
+  "Prototype Court"
+]);
+var SYNTHETIC_CITY_NAMES = Object.freeze([
+  "Faketon",
+  "Synthville",
+  "Exampleburg",
+  "Testford",
+  "Mockhaven",
+  "Fixtureton"
+]);
+
+// src/safe/providers.ts
+function ssn(rng, block = "never-issued") {
+  if (block === "advertising") {
+    return `987-65-432${String(rng.int(0, 9))}`;
+  }
+  const area = rng.int(900, 999);
+  const group = rng.digits(2);
+  const serial = rng.digits(4);
+  return `${String(area)}-${group}-${serial}`;
+}
+function phone(rng) {
+  const area = `${String(rng.int(2, 9))}${rng.digits(2)}`;
+  const line = `01${rng.digits(2)}`;
+  return `(${area}) 555-${line}`;
+}
+function name(rng) {
+  return { given: rng.pick(SYNTHETIC_GIVEN_NAMES), family: rng.pick(SYNTHETIC_FAMILY_NAMES) };
+}
+function email(rng, person) {
+  const domain = rng.pick(RESERVED_EMAIL_DOMAINS);
+  const slug = person ? `${person.given}.${person.family}`.toLowerCase() : `synth${rng.digits(6)}`;
+  return `${slug}@${domain}`;
+}
+function ipv4(rng) {
+  return `${rng.pick(TEST_NET_V4_PREFIXES)}.${String(rng.int(1, 254))}`;
+}
+function ipv6(rng) {
+  const tail = rng.nextUint32().toString(16).padStart(4, "0").slice(-4);
+  return `${DOC_V6_PREFIX}::${tail}`;
+}
+function uuid(rng) {
+  const bytes = new Uint8Array(16);
+  for (let i = 0; i < 16; i += 1) bytes[i] = rng.int(0, 255);
+  bytes[6] = (bytes[6] ?? 0) & 15 | 64;
+  bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0"));
+  return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10, 16).join("")}`;
+}
+function npi(rng) {
+  const base9 = rng.digits(9);
+  const wrongCheck = (npiCheckDigit(base9) + 1) % 10;
+  return `${base9}${String(wrongCheck)}`;
+}
+function dea(rng, person) {
+  const type = rng.pick(DEA_REGISTRANT_TYPES);
+  const initialSource = person?.family ?? rng.pick(SYNTHETIC_FAMILY_NAMES);
+  const initial = initialSource.slice(0, 1).toUpperCase();
+  const base6 = rng.digits(6);
+  const wrongCheck = (deaCheckDigit(base6) + 1) % 10;
+  return `${type}${initial}${base6}${String(wrongCheck)}`;
+}
+function identifier(rng, typeCode = "MR") {
+  return {
+    value: rng.digits(8),
+    typeCode,
+    assigningAuthority: SYNTHETIC_ASSIGNING_AUTHORITY.namespaceId,
+    assigningAuthorityOid: SYNTHETIC_ASSIGNING_AUTHORITY.universalId
+  };
+}
+function address(rng) {
+  const number = rng.int(1, 9999);
+  return {
+    street: `${String(number)} ${rng.pick(SYNTHETIC_STREET_NAMES)}`,
+    city: rng.pick(SYNTHETIC_CITY_NAMES),
+    state: rng.pick(US_STATES),
+    zip: "00000"
+  };
+}
+function dateYmd(rng, minYear = 1930, maxYear = 2010) {
+  const year = rng.int(minYear, maxYear);
+  const month = rng.int(1, 12);
+  const daysInMonth = new Date(Date.UTC(year, month, 0)).getUTCDate();
+  const day = rng.int(1, daysInMonth);
+  return `${String(year).padStart(4, "0")}${String(month).padStart(2, "0")}${String(day).padStart(2, "0")}`;
+}
+var US_STATES = Object.freeze([
+  "AL",
+  "AK",
+  "AZ",
+  "AR",
+  "CA",
+  "CO",
+  "CT",
+  "DE",
+  "FL",
+  "GA",
+  "HI",
+  "ID",
+  "IL",
+  "IN",
+  "IA",
+  "KS",
+  "KY",
+  "LA",
+  "ME",
+  "MD",
+  "MA",
+  "MI",
+  "MN",
+  "MS",
+  "MO",
+  "MT",
+  "NE",
+  "NV",
+  "NH",
+  "NJ",
+  "NM",
+  "NY",
+  "NC",
+  "ND",
+  "OH",
+  "OK",
+  "OR",
+  "PA",
+  "RI",
+  "SC",
+  "SD",
+  "TN",
+  "TX",
+  "UT",
+  "VT",
+  "VA",
+  "WA",
+  "WV",
+  "WI",
+  "WY"
+]);
+
+// src/safe/index.ts
+var safe = Object.freeze({
+  ssn,
+  phone,
+  name,
+  email,
+  ipv4,
+  ipv6,
+  uuid,
+  identifier,
+  address,
+  dateYmd,
+  npi,
+  dea
+});
+
+// src/astm/identity.ts
+var SYNTHETIC_MIDDLE_INITIALS = Object.freeze([
+  "A",
+  "B",
+  "C",
+  "J",
+  "M",
+  "R",
+  "T"
+]);
+var SYNTHETIC_SENDERS = Object.freeze([
+  "SYNTH-LIS",
+  "FIXTURE-HOST",
+  "PLACEHOLDER-LAB"
+]);
+var SYNTHETIC_ANALYZERS = Object.freeze([
+  "SYNTH-ANALYZER^ModelS^1",
+  "MOCK-CHEM^ModelC^2",
+  "FIXTURE-HEMA^ModelH^1"
+]);
+function astmPatient(rng) {
+  const person = safe.name(rng);
+  const middle = rng.pick(SYNTHETIC_MIDDLE_INITIALS);
+  const birthDate = safe.dateYmd(rng, 1935, 2010);
+  const sex = rng.pick(["M", "F"]);
+  const practiceAssignedId = `PRA${safe.identifier(rng, "MR").value}`;
+  const laboratoryAssignedId = `LAB${safe.identifier(rng, "MR").value}`;
+  return { person, middle, birthDate, sex, practiceAssignedId, laboratoryAssignedId };
+}
+function astmOrder(rng) {
+  const specimenId = `ACC${rng.digits(8)}`;
+  const priority = rng.pick(["R", "S"]);
+  return { specimenId, priority };
+}
+function astmHeaderIdentity(rng) {
+  const sender = rng.pick(SYNTHETIC_SENDERS);
+  const analyzer = rng.pick(SYNTHETIC_ANALYZERS);
+  return { sender, analyzer };
+}
+
+// src/astm/example-codes.ts
+var EXAMPLE_ASTM_TESTS = Object.freeze([
+  {
+    localCode: "GLU",
+    loinc: "2345-7",
+    name: "Glucose",
+    units: "mg/dL",
+    referenceRange: "70-110",
+    valueLow: 55,
+    valueHigh: 260,
+    decimals: 0
+  },
+  {
+    localCode: "K",
+    loinc: "2823-3",
+    name: "Potassium",
+    units: "mmol/L",
+    referenceRange: "3.5-5.1",
+    valueLow: 28,
+    valueHigh: 62,
+    decimals: 1
+  },
+  {
+    localCode: "NA",
+    loinc: "2951-2",
+    name: "Sodium",
+    units: "mmol/L",
+    referenceRange: "136-145",
+    valueLow: 125,
+    valueHigh: 155,
+    decimals: 0
+  },
+  {
+    localCode: "CREA",
+    loinc: "2160-0",
+    name: "Creatinine",
+    units: "mg/dL",
+    referenceRange: "0.6-1.3",
+    valueLow: 4,
+    valueHigh: 32,
+    decimals: 1
+  },
+  {
+    localCode: "HGB",
+    loinc: "718-7",
+    name: "Hemoglobin",
+    units: "g/dL",
+    referenceRange: "12.0-17.5",
+    valueLow: 80,
+    valueHigh: 190,
+    decimals: 1
+  },
+  {
+    localCode: "WBC",
+    loinc: "6690-2",
+    name: "Leukocytes",
+    units: "10*3/uL",
+    referenceRange: "4.5-11.0",
+    valueLow: 30,
+    valueHigh: 150,
+    decimals: 1
+  },
+  {
+    localCode: "TSH",
+    loinc: "3016-3",
+    name: "Thyrotropin",
+    units: "mIU/L",
+    referenceRange: "0.40-4.50",
+    valueLow: 2,
+    valueHigh: 90,
+    decimals: 2
+  },
+  {
+    localCode: "ALT",
+    loinc: "1742-6",
+    name: "Alanine aminotransferase",
+    units: "U/L",
+    referenceRange: "7-56",
+    valueLow: 5,
+    valueHigh: 120,
+    decimals: 0
+  }
+]);
+var ASTM_ABNORMAL_FLAGS = Object.freeze(["N", "L", "H", "A"]);
+var ASTM_RESULT_STATUSES = Object.freeze(["F", "P", "C"]);
+var ASTM_COMMENT_TEXT = Object.freeze([
+  "Synthetic fixture comment - not a clinical observation.",
+  "Sample generated by @cosyte/synth.",
+  "Placeholder result comment for conformance testing."
+]);
+
+// src/astm/message.ts
+function resultValue(rng, low, high, decimals) {
+  const raw = rng.int(low, high);
+  if (decimals === 0) return String(raw);
+  const scale = 10 ** decimals;
+  return (raw / scale).toFixed(decimals);
+}
+function buildResultInput(options) {
+  const rng = createRng(options.seed);
+  const head = astmHeaderIdentity(rng);
+  const patient = astmPatient(rng);
+  const order = astmOrder(rng);
+  const resultCount = options.resultCount ?? rng.int(1, 4);
+  const records = [
+    {
+      type: "P",
+      practiceAssignedId: patient.practiceAssignedId,
+      laboratoryAssignedId: patient.laboratoryAssignedId,
+      name: { last: patient.person.family, first: patient.person.given, middle: patient.middle },
+      birthDate: patient.birthDate,
+      sex: patient.sex
+    },
+    {
+      type: "O",
+      specimenId: order.specimenId,
+      universalTestId: ["", "", "", "ALL"],
+      priority: order.priority,
+      actionCode: "N",
+      reportType: "F"
+    }
+  ];
+  for (let i = 0; i < resultCount; i += 1) {
+    const test = rng.pick(EXAMPLE_ASTM_TESTS);
+    records.push({
+      type: "R",
+      universalTestId: ["", "", "", test.localCode, test.name, test.loinc],
+      value: resultValue(rng, test.valueLow, test.valueHigh, test.decimals),
+      units: test.units,
+      referenceRange: test.referenceRange,
+      abnormalFlags: rng.pick(ASTM_ABNORMAL_FLAGS),
+      resultStatus: "F"
+    });
+  }
+  if (options.comment ?? true) {
+    records.push({ type: "C", source: "L", text: rng.pick(ASTM_COMMENT_TEXT), commentType: "G" });
+  }
+  return {
+    header: { fields: [head.sender, head.analyzer] },
+    records,
+    terminationCode: "N"
+  };
+}
+function generateAstmResult(options) {
+  return astm.buildAstmMessage(buildResultInput(options));
+}
+function generateAstmOrder(options) {
+  return generateAstmResult({ ...options, resultCount: 0, comment: false });
+}
+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);
+}
+function astmRoundTrip(raw) {
+  const message = astm.parseAstmRecords(raw);
+  const warnings = message.warnings.map((w) => String(w.code));
+  const byteStable = astm.serializeAstmRecords(message) === raw;
+  return { content: raw, warnings, byteStable, specClean: warnings.length === 0 && byteStable };
+}
+function astmFramedRoundTrip(bytes) {
+  const { message, frameWarnings } = astm.parseFramedAstm(bytes);
+  const warnings = [
+    ...frameWarnings.map((w) => String(w.code)),
+    ...message.warnings.map((w) => String(w.code))
+  ];
+  const reframed = astm.serializeFramedAstm(message);
+  const byteStable = bytesEqual(reframed, bytes);
+  const content = latin1(bytes);
+  return { content, warnings, byteStable, specClean: warnings.length === 0 && byteStable };
+}
+function bytesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) if (a[i] !== b[i]) return false;
+  return true;
+}
+function latin1(bytes) {
+  let out = "";
+  for (const b of bytes) out += String.fromCharCode(b);
+  return out;
+}
+
+// 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.");
+  }
+  return Object.freeze({
+    name: spec.name,
+    ...spec.givenNames ? { givenNames: Object.freeze([...spec.givenNames]) } : {},
+    ...spec.familyNames ? { familyNames: Object.freeze([...spec.familyNames]) } : {},
+    quirks: Object.freeze([...spec.quirks ?? []])
+  });
+}
+
+// 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) {
+  if (a.length !== b.length) return false;
+  const counts = /* @__PURE__ */ new Map();
+  for (const c of a) counts.set(c, (counts.get(c) ?? 0) + 1);
+  for (const c of b) {
+    const n = counts.get(c);
+    if (n === void 0) return false;
+    if (n === 1) counts.delete(c);
+    else counts.set(c, n - 1);
+  }
+  return counts.size === 0;
+}
+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}.`
+    );
+  }
+  return descriptor;
+}
+function profileTolerated(disposition, intendedWarnings, warningsUnderProfile) {
+  const stillHasIntended = intendedWarnings.some((c) => warningsUnderProfile.includes(c));
+  switch (disposition) {
+    case "suppressed":
+      return !stillHasIntended;
+    case "rebadged":
+      return !stillHasIntended && warningsUnderProfile.includes(PROFILE_QUIRK_APPLIED);
+    case "bare":
+      return false;
+  }
+}
+function assertIntendedWarnings(quirk, 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.`
+    );
+  }
+}
+function validateProfileQuirks(profile, registry, format) {
+  for (const name2 of profile.quirks) resolveQuirk(registry, format, name2);
+  return profile.quirks;
+}
+
+// src/astm/quirk.ts
+var ASTM_QUIRKS = Object.freeze({
+  "unknown-escape": Object.freeze({
+    name: "unknown-escape",
+    format: "astm",
+    intendedWarnings: Object.freeze(["ASTM_UNKNOWN_ESCAPE_SEQUENCE"]),
+    grounding: "ASTM E1394 escape delimiter (&); a non-standard &Z& body is preserved verbatim and flagged. Re-badged by @cosyte/astm's public `referenceCorpus` profile (kxepal/python-astm + senaite OSS).",
+    toleratingProfile: "referenceCorpus",
+    disposition: "rebadged"
+  }),
+  "unknown-record-type": Object.freeze({
+    name: "unknown-record-type",
+    format: "astm",
+    intendedWarnings: Object.freeze(["ASTM_RECORD_UNKNOWN_TYPE"]),
+    grounding: "ASTM E1394 permits manufacturer/site-defined record types; a Z record is surfaced as unsupported. A tolerable code (in the parser's defineAstmProfile allow-list) \u2014 a consumer authors a profile to re-badge it; no built-in public profile does.",
+    disposition: "bare"
+  })
+});
+function toleratingProfile(quirk) {
+  return quirk === "unknown-escape" ? astm.astmProfiles.referenceCorpus : void 0;
+}
+var CR = "\r";
+function applyQuirk(quirk, records) {
+  const lines = records.split(CR);
+  switch (quirk) {
+    case "unknown-escape": {
+      for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (line !== void 0 && line.startsWith("R|")) {
+          const fields = line.split("|");
+          const units = fields[4];
+          if (units !== void 0 && units.length > 0) {
+            fields[4] = `&Z&${units}`;
+            lines[i] = fields.join("|");
+            return lines.join(CR);
+          }
+        }
+      }
+      return records;
+    }
+    case "unknown-record-type": {
+      for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (line !== void 0 && line.startsWith("C|")) {
+          lines[i] = `Z${line.slice(1)}`;
+          return lines.join(CR);
+        }
+      }
+      return records;
+    }
+  }
+}
+function generateAstmQuirk(options) {
+  const seed = options.seed ?? 0;
+  const kind = "Result";
+  const descriptor = resolveQuirk(ASTM_QUIRKS, "astm", options.quirk);
+  const clean = generateAstmResult({ seed });
+  const content = applyQuirk(options.quirk, clean);
+  if (content === clean) {
+    throw new Error(
+      `generateAstmQuirk: quirk "${options.quirk}" found no structural anchor in a ${kind} report at seed ${seed} \u2014 refusing to emit a fixture that does not carry the intended deviation.`
+    );
+  }
+  assertIntendedWarnings(
+    descriptor.name,
+    descriptor.intendedWarnings,
+    astm.parseAstmRecords(content).warnings.map((w) => String(w.code))
+  );
+  return Object.freeze({
+    format: "astm",
+    quirk: descriptor.name,
+    kind,
+    content,
+    intendedWarnings: descriptor.intendedWarnings
+  });
+}
+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 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)
+    );
+    return {
+      profileName: descriptor.toleratingProfile,
+      disposition: descriptor.disposition,
+      warnings,
+      tolerated: profileTolerated(
+        descriptor.disposition,
+        artifact.intendedWarnings,
+        warnings
+      )
+    };
+  })() : void 0;
+  return {
+    content: artifact.content,
+    warnings: bare,
+    intendedWarnings: artifact.intendedWarnings,
+    intendedWarningHeld: sameCodeSet(bare, artifact.intendedWarnings),
+    ...withProfile ? { withProfile } : {}
+  };
+}
+var ALL_ASTM_QUIRKS = Object.freeze(
+  Object.keys(ASTM_QUIRKS)
+);
+function astmQuirkCorpus(options) {
+  const quirks = options.profile ? validateProfileQuirks(options.profile, ASTM_QUIRKS, "astm") : options.quirks ?? ALL_ASTM_QUIRKS;
+  const names = quirks.length > 0 ? quirks : ALL_ASTM_QUIRKS;
+  const count = options.count ?? names.length;
+  const seedStream = createRng(options.seed);
+  const artifacts = Array.from({ length: count }, (_unused, i) => {
+    const quirk = names[i % names.length];
+    const artifactSeed = seedStream.nextUint32();
+    const artifact = generateAstmQuirk({ seed: artifactSeed, quirk });
+    return {
+      format: "astm",
+      kind: `Result~${quirk}`,
+      content: artifact.content,
+      warnings: artifact.intendedWarnings
+    };
+  });
+  return makeCorpus(options.seed, artifacts, [...new Set(names)]);
+}
+var astmQuirkProfile = defineSynthProfile({
+  name: "cosyte-astm-quirks",
+  quirks: [...ALL_ASTM_QUIRKS]
+});
+
+// src/astm/index.ts
+var DEFAULT_MIX = Object.freeze(["Result", "Order"]);
+function generateKind(kind, seed) {
+  switch (kind) {
+    case "Result":
+      return astmRoundTrip(generateAstmResult({ seed }));
+    case "Order":
+      return astmRoundTrip(generateAstmOrder({ seed }));
+  }
+}
+function astmCorpus(options) {
+  const { seed, mix = DEFAULT_MIX } = options;
+  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);
+    return {
+      format: "astm",
+      kind,
+      content: rt.content,
+      warnings: rt.warnings
+    };
+  });
+  return makeCorpus(seed, artifacts);
+}
+
+exports.ASTM_ABNORMAL_FLAGS = ASTM_ABNORMAL_FLAGS;
+exports.ASTM_COMMENT_TEXT = ASTM_COMMENT_TEXT;
+exports.ASTM_QUIRKS = ASTM_QUIRKS;
+exports.ASTM_RESULT_STATUSES = ASTM_RESULT_STATUSES;
+exports.EXAMPLE_ASTM_TESTS = EXAMPLE_ASTM_TESTS;
+exports.astmCorpus = astmCorpus;
+exports.astmFramedRoundTrip = astmFramedRoundTrip;
+exports.astmHeaderIdentity = astmHeaderIdentity;
+exports.astmOrder = astmOrder;
+exports.astmPatient = astmPatient;
+exports.astmQuirkCorpus = astmQuirkCorpus;
+exports.astmQuirkProfile = astmQuirkProfile;
+exports.astmQuirkRoundTrip = astmQuirkRoundTrip;
+exports.astmRoundTrip = astmRoundTrip;
+exports.generateAstmOrder = generateAstmOrder;
+exports.generateAstmQuirk = generateAstmQuirk;
+exports.generateAstmResult = generateAstmResult;
+exports.generateAstmResultFramed = generateAstmResultFramed;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map