@cosyte/astm 0.0.1

package/dist/index.cjs

@@ -0,0 +1,2071 @@
+'use strict';
+
+// src/common/errors.ts
+var FATAL_CODES = {
+  /** Input was empty or whitespace-only — there is nothing to parse. Shared across layers. */
+  EMPTY_INPUT: "EMPTY_INPUT",
+  /** The first record is not an `H` (header) record — an ASTM message must lead with `H`. */
+  ASTM_RECORD_NO_HEADER: "ASTM_RECORD_NO_HEADER",
+  /** The `H` record is too short to declare the four delimiters (field/repeat/component/escape). */
+  ASTM_RECORD_UNDECLARED_DELIMITERS: "ASTM_RECORD_UNDECLARED_DELIMITERS"
+};
+var AstmParseError = class extends Error {
+  code;
+  position;
+  /**
+   * Construct a new `AstmParseError`. Both fields are required so every thrower
+   * populates positional context and no PHI-bearing snippet is ever attached.
+   *
+   * @internal
+   */
+  constructor(code, message, position) {
+    super(message);
+    this.name = "AstmParseError";
+    this.code = code;
+    this.position = position;
+  }
+};
+
+// src/common/freeze.ts
+function deepFreeze(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (Object.isFrozen(value)) return value;
+  Object.freeze(value);
+  for (const key of Object.keys(value)) {
+    deepFreeze(value[key]);
+  }
+  return value;
+}
+
+// src/common/delimiters.ts
+var CANONICAL_DELIMITERS = {
+  field: "|",
+  repeat: "\\",
+  component: "^",
+  escape: "&"
+};
+function readDelimiters(headerRecord) {
+  if (headerRecord.length < 5) return void 0;
+  if (headerRecord.charAt(0) !== "H") return void 0;
+  const field = headerRecord.charAt(1);
+  const defEnd = headerRecord.indexOf(field, 2);
+  const definition = headerRecord.slice(2, defEnd === -1 ? headerRecord.length : defEnd);
+  if (definition.length < 3) return void 0;
+  const repeat = definition.charAt(0);
+  const component = definition.charAt(1);
+  const escape = definition.charAt(2);
+  if (field === repeat || field === component || field === escape) return void 0;
+  return { field, repeat, component, escape };
+}
+function isNonStandard(d) {
+  return d.field !== CANONICAL_DELIMITERS.field || d.repeat !== CANONICAL_DELIMITERS.repeat || d.component !== CANONICAL_DELIMITERS.component || d.escape !== CANONICAL_DELIMITERS.escape;
+}
+
+// src/common/dates.ts
+function parseAstmDate(raw) {
+  const s = raw.trim();
+  if (!/^\d{4,}$/u.test(s)) return void 0;
+  const year = Number(s.slice(0, 4));
+  const truncated = s.length < 14 && s.length % 2 === 1;
+  const base = { raw: s, year, ...truncated ? { truncated: true } : {} };
+  if (s.length < 6) return { ...base, precision: "year" };
+  const month = Number(s.slice(4, 6));
+  if (s.length < 8) return { ...base, month, precision: "month" };
+  const day = Number(s.slice(6, 8));
+  if (s.length < 10) return { ...base, month, day, precision: "day" };
+  const hour = Number(s.slice(8, 10));
+  if (s.length < 12) return { ...base, month, day, hour, precision: "hour" };
+  const minute = Number(s.slice(10, 12));
+  if (s.length < 14) return { ...base, month, day, hour, minute, precision: "minute" };
+  const second = Number(s.slice(12, 14));
+  return { ...base, month, day, hour, minute, second, precision: "second" };
+}
+function astmDateToLocalISO(d) {
+  const p2 = (n) => String(n).padStart(2, "0");
+  let out = String(d.year).padStart(4, "0");
+  if (d.month !== void 0) out += `-${p2(d.month)}`;
+  if (d.day !== void 0) out += `-${p2(d.day)}`;
+  if (d.hour !== void 0) out += `T${p2(d.hour)}`;
+  if (d.minute !== void 0) out += `:${p2(d.minute)}`;
+  if (d.second !== void 0) out += `:${p2(d.second)}`;
+  return out;
+}
+
+// src/common/coding-system.ts
+function recognizeUniversalTestId(components) {
+  const nonEmpty = (i) => {
+    const c = components[i];
+    return c !== void 0 && c.length > 0 ? c : void 0;
+  };
+  const loincCandidate = nonEmpty(0);
+  const testName = nonEmpty(1);
+  const codingScheme = nonEmpty(2);
+  const localCode = nonEmpty(3);
+  let provenance;
+  if (loincCandidate !== void 0) provenance = "inline-loinc-candidate";
+  else if (localCode !== void 0) provenance = "local-code";
+  else if (testName !== void 0) provenance = "name-only";
+  else provenance = "empty";
+  const base = { components, provenance };
+  return {
+    ...base,
+    ...loincCandidate !== void 0 ? { loincCandidate } : {},
+    ...testName !== void 0 ? { testName } : {},
+    ...codingScheme !== void 0 ? { codingScheme } : {},
+    ...localCode !== void 0 ? { localCode } : {}
+  };
+}
+function primaryCode(u) {
+  return u.loincCandidate ?? u.localCode;
+}
+
+// src/common/warnings.ts
+var WARNING_CODES = {
+  /** A record's type letter is not one of the modeled types — surfaced as an unsupported record. */
+  ASTM_RECORD_UNKNOWN_TYPE: "ASTM_RECORD_UNKNOWN_TYPE",
+  /** The header declared delimiters other than the canonical `H|\^&` — tolerated, noted. */
+  ASTM_NONSTANDARD_DELIMITERS: "ASTM_NONSTANDARD_DELIMITERS",
+  /** An escape sequence body was not one of `&F&`/`&S&`/`&R&`/`&E&` — preserved verbatim. */
+  ASTM_UNKNOWN_ESCAPE_SEQUENCE: "ASTM_UNKNOWN_ESCAPE_SEQUENCE",
+  /**
+   * A result value field carried an *unescaped* component delimiter, so it split into more than one
+   * component. Both the full raw value and the split are surfaced and this warning fires — the
+   * ambiguity is never resolved silently into a truncated value.
+   */
+  ASTM_RECORD_AMBIGUOUS_VALUE_SPLIT: "ASTM_RECORD_AMBIGUOUS_VALUE_SPLIT",
+  /**
+   * A result's abnormal-flag field (`R` field 7) carried a letter outside HL7 Table 0078. The flag is
+   * surfaced as `undefined` — never dropped, and **never coerced to `normal`** (a clinical error).
+   */
+  ASTM_RECORD_UNDEFINED_ABNORMAL_FLAG: "ASTM_RECORD_UNDEFINED_ABNORMAL_FLAG",
+  /**
+   * A result's status field (`R` field 9) carried a letter that is not a recognized status. It is
+   * surfaced as `undefined` and, like every non-`F` status, never reads as active-final.
+   */
+  ASTM_RECORD_UNDEFINED_RESULT_STATUS: "ASTM_RECORD_UNDEFINED_RESULT_STATUS",
+  /**
+   * A result's reference-range field (`R` field 6) did not match a recognized form (`low-high`,
+   * `<high`, `>low`). The text is surfaced verbatim as `unparsed` — a bound is **never fabricated**.
+   */
+  ASTM_RECORD_UNPARSEABLE_REFERENCE_RANGE: "ASTM_RECORD_UNPARSEABLE_REFERENCE_RANGE",
+  /**
+   * A result carried a numeric value but no units (`R` field 5 empty). Units are vendor free text
+   * (not UCUM); a missing unit is flagged here and **never defaulted, guessed, or converted**.
+   */
+  ASTM_RECORD_UNITS_ABSENT: "ASTM_RECORD_UNITS_ABSENT",
+  /**
+   * A `C` (comment) record had no valid preceding `H`/`P`/`O`/`R` parent — an **orphan**. The comment
+   * is attached to the message root (`attachedToRoot: true`) and surfaced, **never dropped**.
+   */
+  ASTM_RECORD_ORPHAN_COMMENT: "ASTM_RECORD_ORPHAN_COMMENT",
+  /**
+   * A `YYYYMMDDHHMMSS` timestamp had an odd digit run that truncates a two-digit component in half
+   * (e.g. a partial day/hour). The raw run is preserved and the structured value stops at the last
+   * **complete** component — the dangling digit is **never zero-filled into a fabricated time**.
+   */
+  ASTM_RECORD_PARTIAL_TIMESTAMP: "ASTM_RECORD_PARTIAL_TIMESTAMP",
+  /**
+   * A `Q` (request-information) record carried a request-information status code (field 13). The code
+   * *set* is `[OSS-derived / paywalled]` with no publicly-groundable enumeration, so the parser
+   * interprets **none** of them: the status is surfaced verbatim and this value-free warning flags that
+   * it was passed through **uninterpreted** — never mapped to a guessed meaning.
+   */
+  ASTM_RECORD_UNINTERPRETED_QUERY_STATUS: "ASTM_RECORD_UNINTERPRETED_QUERY_STATUS",
+  /**
+   * A message carried **both** a `Q` (request) and an `R` (result) record — a contradictory shape. The
+   * message is classified `host-query` (the `Q` **dominates**, so it is never read as a result set) and
+   * this warning flags the anomaly. Positional context only; no field value.
+   */
+  ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND: "ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND",
+  /**
+   * The downgraded form an active vendor {@link AstmProfile} produces from a deviation it *expects*
+   * (see `src/profiles/`). The original warning is **never dropped**: its code moves to
+   * {@link AstmRecordWarning.toleratedCode}, the warning is re-badged `PROFILE_QUIRK_APPLIED` with
+   * `expected: true` and the tolerating profile named, so a consumer can filter known, grounded noise
+   * while the fact of the deviation — and where it was — survives. A profile can only ever reach this
+   * path for a **non-safety-critical** code (enforced at profile-definition time); a safety-critical
+   * deviation (a result value, flag, status, patient identifier, code system, or a frame-integrity
+   * warning) can **never** be tolerated, so it can never be re-badged here.
+   */
+  PROFILE_QUIRK_APPLIED: "PROFILE_QUIRK_APPLIED"
+};
+function unknownRecordType(position) {
+  return {
+    code: WARNING_CODES.ASTM_RECORD_UNKNOWN_TYPE,
+    message: "Unrecognized record type \u2014 surfaced verbatim as an unsupported record.",
+    position
+  };
+}
+function nonStandardDelimiters(position) {
+  return {
+    code: WARNING_CODES.ASTM_NONSTANDARD_DELIMITERS,
+    message: "Header declared non-canonical delimiters \u2014 read from the header and honored.",
+    position
+  };
+}
+function unknownEscapeSequence(position) {
+  return {
+    code: WARNING_CODES.ASTM_UNKNOWN_ESCAPE_SEQUENCE,
+    message: "Unrecognized escape sequence preserved verbatim.",
+    position
+  };
+}
+function ambiguousValueSplit(position) {
+  return {
+    code: WARNING_CODES.ASTM_RECORD_AMBIGUOUS_VALUE_SPLIT,
+    message: "Result value contained an unescaped component delimiter \u2014 full raw value and split both surfaced.",
+    position
+  };
+}
+function undefinedAbnormalFlag(position) {
+  return {
+    code: WARNING_CODES.ASTM_RECORD_UNDEFINED_ABNORMAL_FLAG,
+    message: "Abnormal flag is not in HL7 Table 0078 \u2014 surfaced as undefined, never as normal.",
+    position
+  };
+}
+function undefinedResultStatus(position) {
+  return {
+    code: WARNING_CODES.ASTM_RECORD_UNDEFINED_RESULT_STATUS,
+    message: "Result status is not a recognized status letter \u2014 surfaced as undefined.",
+    position
+  };
+}
+function unparseableReferenceRange(position) {
+  return {
+    code: WARNING_CODES.ASTM_RECORD_UNPARSEABLE_REFERENCE_RANGE,
+    message: "Reference range did not match a recognized form \u2014 surfaced verbatim, no bound invented.",
+    position
+  };
+}
+function unitsAbsent(position) {
+  return {
+    code: WARNING_CODES.ASTM_RECORD_UNITS_ABSENT,
+    message: "Numeric result value carried no units \u2014 never defaulted, guessed, or converted.",
+    position
+  };
+}
+function orphanComment(position) {
+  return {
+    code: WARNING_CODES.ASTM_RECORD_ORPHAN_COMMENT,
+    message: "Comment had no valid preceding parent \u2014 attached to the message root, never dropped.",
+    position
+  };
+}
+function partialTimestamp(position) {
+  return {
+    code: WARNING_CODES.ASTM_RECORD_PARTIAL_TIMESTAMP,
+    message: "Timestamp digit run truncates a component \u2014 preserved verbatim, never zero-filled.",
+    position
+  };
+}
+function uninterpretedQueryStatus(position) {
+  return {
+    code: WARNING_CODES.ASTM_RECORD_UNINTERPRETED_QUERY_STATUS,
+    message: "Query request-information status surfaced verbatim \u2014 code set paywalled, never interpreted.",
+    position
+  };
+}
+function ambiguousMessageKind(position) {
+  return {
+    code: WARNING_CODES.ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND,
+    message: "Message carried both a Q (request) and an R (result) record \u2014 classified host-query; Q dominates.",
+    position
+  };
+}
+function profileQuirkApplied(original, profileName) {
+  return {
+    code: WARNING_CODES.PROFILE_QUIRK_APPLIED,
+    message: `Profile "${profileName}" expected ${original.code}: ${original.message}`,
+    position: original.position,
+    expected: true,
+    profile: profileName,
+    toleratedCode: original.code
+  };
+}
+
+// src/records/result-semantics.ts
+var ABNORMAL_FLAG_MEANINGS = {
+  L: "below-normal",
+  H: "above-normal",
+  LL: "critically-below-normal",
+  HH: "critically-above-normal",
+  "<": "below-scale",
+  ">": "above-scale",
+  N: "normal",
+  A: "abnormal",
+  AA: "very-abnormal",
+  U: "significant-change-up",
+  D: "significant-change-down",
+  B: "better",
+  W: "worse",
+  S: "susceptible",
+  R: "resistant",
+  I: "intermediate"
+};
+function interpretAbnormalFlag(raw) {
+  const key = raw.trim();
+  if (isAbnormalFlagCode(key)) {
+    return { raw, code: key, meaning: ABNORMAL_FLAG_MEANINGS[key], recognized: true };
+  }
+  return { raw, meaning: "undefined", recognized: false };
+}
+function isAbnormalFlagCode(value) {
+  return Object.prototype.hasOwnProperty.call(ABNORMAL_FLAG_MEANINGS, value);
+}
+var RESULT_STATUS_MEANINGS = {
+  F: "final",
+  C: "correction",
+  P: "preliminary",
+  R: "previously-transmitted",
+  S: "partial",
+  I: "pending",
+  X: "cancelled"
+};
+function interpretResultStatus(raw) {
+  if (raw === void 0 || raw.trim().length === 0) {
+    return {
+      meaning: "unspecified",
+      recognized: false,
+      isActiveFinal: false,
+      supersedes: false,
+      cancelled: false
+    };
+  }
+  const key = raw.trim();
+  if (isResultStatusCode(key)) {
+    return {
+      raw,
+      code: key,
+      meaning: RESULT_STATUS_MEANINGS[key],
+      recognized: true,
+      isActiveFinal: key === "F",
+      supersedes: key === "C",
+      cancelled: key === "X"
+    };
+  }
+  return {
+    raw,
+    meaning: "undefined",
+    recognized: false,
+    isActiveFinal: false,
+    supersedes: false,
+    cancelled: false
+  };
+}
+function isResultStatusCode(value) {
+  return Object.prototype.hasOwnProperty.call(RESULT_STATUS_MEANINGS, value);
+}
+var NUMBER = "-?\\d+(?:\\.\\d+)?";
+var OPEN_LOW = new RegExp(`^<\\s*(${NUMBER})$`, "u");
+var OPEN_HIGH = new RegExp(`^>\\s*(${NUMBER})$`, "u");
+var CLOSED = new RegExp(`^(${NUMBER})\\s*-\\s*(${NUMBER})$`, "u");
+function parseReferenceRange(raw) {
+  const text = raw.trim();
+  const low = OPEN_LOW.exec(text);
+  if (low?.[1] !== void 0) return { raw, high: low[1], kind: "open-low" };
+  const high = OPEN_HIGH.exec(text);
+  if (high?.[1] !== void 0) return { raw, low: high[1], kind: "open-high" };
+  const closed = CLOSED.exec(text);
+  if (closed?.[1] !== void 0 && closed[2] !== void 0) {
+    return { raw, low: closed[1], high: closed[2], kind: "closed" };
+  }
+  return { raw, kind: "unparsed" };
+}
+
+// src/records/host-query.ts
+function classifyMessage(records) {
+  let hasQuery = false;
+  let hasResults = false;
+  let hasOrders = false;
+  for (const r of records) {
+    if (r.type === "Q") hasQuery = true;
+    else if (r.type === "R") hasResults = true;
+    else if (r.type === "O") hasOrders = true;
+  }
+  let kind;
+  if (hasQuery) kind = "host-query";
+  else if (hasResults) kind = "results";
+  else if (hasOrders) kind = "orders";
+  else kind = "indeterminate";
+  return { kind, hasQuery, hasResults, hasOrders, isHostQueryRequest: kind === "host-query" };
+}
+
+// src/profiles/apply.ts
+function toleranceApplies(tolerance, warning) {
+  if (tolerance.code !== warning.code) return false;
+  const match = tolerance.match;
+  if (match === void 0) return true;
+  if (match.recordType !== void 0 && warning.position.recordType !== match.recordType) {
+    return false;
+  }
+  if (match.fieldIndex !== void 0 && warning.position.fieldIndex !== match.fieldIndex) {
+    return false;
+  }
+  return true;
+}
+function applyAstmProfile(profile, warning) {
+  if (warning.expected === true) return warning;
+  for (const tolerance of profile.tolerate) {
+    if (toleranceApplies(tolerance, warning)) {
+      return profileQuirkApplied(warning, profile.name);
+    }
+  }
+  return warning;
+}
+function applyAstmProfileToWarnings(warnings, profile) {
+  if (profile === void 0) return [...warnings];
+  return warnings.map((w) => applyAstmProfile(profile, w));
+}
+function resolveProfileTransport(profile) {
+  return profile?.transport;
+}
+
+// src/profiles/describe.ts
+function buildDescribe(p) {
+  const lines = [`Profile '${p.name}'`];
+  if (p.description !== void 0) {
+    lines.push(`  description: ${p.description}`);
+  }
+  lines.push(`  lineage: ${p.lineage.join(" \u2192 ")}`);
+  if (p.transport !== void 0) {
+    lines.push(`  transport: forces ${p.transport} framing (detection override)`);
+  }
+  if (p.provenance !== void 0) {
+    lines.push(`  grounded in: ${p.provenance.source} (${p.provenance.reference})`);
+  }
+  if (p.tolerate.length === 0) {
+    lines.push("  tolerates: nothing (conservative baseline)");
+  } else {
+    lines.push(`  tolerates ${String(p.tolerate.length)} quirk(s):`);
+    for (const t of p.tolerate) {
+      const scope = t.match?.recordType !== void 0 ? ` @record ${t.match.recordType}${t.match.fieldIndex !== void 0 ? `.${String(t.match.fieldIndex)}` : ""}` : t.match?.fieldIndex !== void 0 ? ` @field ${String(t.match.fieldIndex)}` : "";
+      lines.push(`    - ${t.code}${scope}: ${t.rationale}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/profiles/merge.ts
+function normaliseParents(ext) {
+  if (ext === void 0) return [];
+  if (Array.isArray(ext)) return ext;
+  return [ext];
+}
+function mergeLineage(parents, selfName) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const p of parents) {
+    const parentLineage = p.lineage.length > 0 ? p.lineage : [p.name];
+    for (const n of parentLineage) {
+      if (!seen.has(n)) {
+        seen.add(n);
+        out.push(n);
+      }
+    }
+  }
+  if (!seen.has(selfName)) out.push(selfName);
+  return Object.freeze(out);
+}
+function toleranceKey(t) {
+  return `${t.code} ${t.match?.recordType ?? ""} ${String(t.match?.fieldIndex ?? "")}`;
+}
+function mergeTolerations(parents, self) {
+  const order = [];
+  const byKey = /* @__PURE__ */ new Map();
+  const layer = (list) => {
+    for (const t of list) {
+      const key = toleranceKey(t);
+      if (!byKey.has(key)) order.push(key);
+      byKey.set(key, t);
+    }
+  };
+  for (const p of parents) layer(p.tolerate);
+  layer(self);
+  return Object.freeze(order.map((k) => byKey.get(k)));
+}
+function mergeProvenance(parents, self) {
+  if (self !== void 0) return self;
+  for (let i = parents.length - 1; i >= 0; i--) {
+    const p = parents[i];
+    if (p?.provenance !== void 0) return p.provenance;
+  }
+  return void 0;
+}
+function mergeDescription(parents, self) {
+  if (self !== void 0) return self;
+  for (let i = parents.length - 1; i >= 0; i--) {
+    const p = parents[i];
+    if (p?.description !== void 0) return p.description;
+  }
+  return void 0;
+}
+function mergeTransport(parents, self) {
+  if (self !== void 0) return self;
+  for (let i = parents.length - 1; i >= 0; i--) {
+    const p = parents[i];
+    if (p?.transport !== void 0) return p.transport;
+  }
+  return void 0;
+}
+
+// src/profiles/errors.ts
+var AstmProfileDefinitionError = class extends Error {
+  /** The offending profile's `name`, when it could be read. */
+  profileName;
+  /**
+   * Construct a new `AstmProfileDefinitionError`.
+   *
+   * @param message - A human-readable explanation of what was invalid.
+   * @param profileName - The offending profile's name, when known.
+   * @internal
+   */
+  constructor(message, profileName) {
+    super(message);
+    this.name = "AstmProfileDefinitionError";
+    if (profileName !== void 0) this.profileName = profileName;
+  }
+};
+
+// src/frames/warnings.ts
+var FRAME_WARNING_CODES = {
+  /**
+   * A frame's two-hex-char checksum did not match the modulo-256 sum recomputed over its bytes. The
+   * frame is surfaced with `trusted: false` and its text is **never merged** into a reassembled
+   * record (default **warn** in lenient mode, escalated to a thrown error in `strict`). Corruption is
+   * never silently trusted — the "checksums are routinely not validated" claim was refuted; we
+   * validate.
+   */
+  ASTM_FRAME_BAD_CHECKSUM: "ASTM_FRAME_BAD_CHECKSUM",
+  /**
+   * A frame's sequence number was not the expected next value (`1 → … → 7 → 0 → …`) — a frame was
+   * possibly dropped. The stream is **never silently concatenated across the gap** as if contiguous;
+   * the in-progress record is tainted and not emitted as a clean reassembly.
+   */
+  ASTM_FRAME_SEQUENCE_GAP: "ASTM_FRAME_SEQUENCE_GAP",
+  /**
+   * A frame opened with `STX` but no valid terminator + checksum was found before the stream ended
+   * (or before the next `STX`), or a record's frames ended on an intermediate `ETB` with no final
+   * `ETX`. The partial bytes are surfaced flagged untrusted and **no partial record is invented**
+   * (warn in lenient, thrown in `strict`).
+   */
+  ASTM_FRAME_UNTERMINATED: "ASTM_FRAME_UNTERMINATED",
+  /**
+   * A frame's record text exceeded the 240-byte limit without a split. The frame is still surfaced
+   * (and, if its checksum validates, reassembled) — the deviation is flagged, not silently dropped
+   * (warn in lenient, thrown in `strict`).
+   */
+  ASTM_FRAME_OVERSIZE: "ASTM_FRAME_OVERSIZE"
+};
+function frameBadChecksum(position) {
+  return {
+    code: FRAME_WARNING_CODES.ASTM_FRAME_BAD_CHECKSUM,
+    message: "Frame checksum mismatch \u2014 surfaced untrusted, never merged into a record.",
+    position
+  };
+}
+function frameSequenceGap(position) {
+  return {
+    code: FRAME_WARNING_CODES.ASTM_FRAME_SEQUENCE_GAP,
+    message: "Frame number out of sequence \u2014 possible dropped frame, never silently bridged.",
+    position
+  };
+}
+function frameUnterminated(position) {
+  return {
+    code: FRAME_WARNING_CODES.ASTM_FRAME_UNTERMINATED,
+    message: "Unterminated frame \u2014 partial bytes surfaced untrusted, no partial record invented.",
+    position
+  };
+}
+function frameOversize(position) {
+  return {
+    code: FRAME_WARNING_CODES.ASTM_FRAME_OVERSIZE,
+    message: "Frame text exceeded the 240-byte limit without a split \u2014 flagged, never dropped.",
+    position
+  };
+}
+
+// src/ltp/warnings.ts
+var LTP_WARNING_CODES = {
+  /**
+   * The transport detector could not tell a framed stream from a raw (unframed) one from its leading
+   * byte — it was neither `STX`/`ENQ` nor a bare record letter. It **defaults to framed** and warns,
+   * never guessing silently into data loss; a profile override forces the mode. (cobas b121 drops
+   * framing over TCP; cobas 4800 / Iguana retain it — both realities exist, so an unrecognizable lead
+   * is defaulted, not assumed.)
+   */
+  ASTM_LTP_AMBIGUOUS_TRANSPORT: "ASTM_LTP_AMBIGUOUS_TRANSPORT",
+  /**
+   * A control event arrived in a protocol state that did not expect it — e.g. an inbound `ACK`/`NAK`
+   * at a receiver (which sends, never receives, those), or an `ENQ` mid-transfer. The event is
+   * surfaced and handled defensively (an unexpected `ACK`/`NAK` is **never** read as acceptance of
+   * data); it never advances the transfer as if valid.
+   */
+  ASTM_LTP_UNEXPECTED_EVENT: "ASTM_LTP_UNEXPECTED_EVENT",
+  /**
+   * The receiver rejected a received frame with a `NAK` instead of accepting it — because its
+   * checksum failed, it was unterminated, or its frame number was out of sequence. The frame's text
+   * is **never** appended to the record and the transfer does **not** advance; the receiver awaits the
+   * sender's retransmit. This is the protocol-level face of the frame codec's fail-safe: a bad frame
+   * drives retransmit, not acceptance.
+   */
+  ASTM_LTP_FRAME_REJECTED: "ASTM_LTP_FRAME_REJECTED"
+};
+function ltpAmbiguousTransport() {
+  return {
+    code: LTP_WARNING_CODES.ASTM_LTP_AMBIGUOUS_TRANSPORT,
+    message: "Leading byte was neither a frame start (STX/ENQ) nor a record letter \u2014 defaulted to framed; override with a profile to force raw."
+  };
+}
+function ltpUnexpectedEvent(frameNumber) {
+  return {
+    code: LTP_WARNING_CODES.ASTM_LTP_UNEXPECTED_EVENT,
+    message: "Control event arrived in a state that did not expect it \u2014 handled defensively, never read as acceptance.",
+    ...frameNumber !== void 0 ? { frameNumber } : {}
+  };
+}
+function ltpFrameRejected(frameNumber) {
+  return {
+    code: LTP_WARNING_CODES.ASTM_LTP_FRAME_REJECTED,
+    message: "Frame rejected (bad checksum, unterminated, or out of sequence) \u2014 NAK sent, retransmit expected, never accepted.",
+    ...frameNumber !== void 0 ? { frameNumber } : {}
+  };
+}
+
+// src/profiles/safety.ts
+var TOLERABLE_CODES = Object.freeze(
+  /* @__PURE__ */ new Set([
+    WARNING_CODES.ASTM_RECORD_UNKNOWN_TYPE,
+    WARNING_CODES.ASTM_NONSTANDARD_DELIMITERS,
+    WARNING_CODES.ASTM_UNKNOWN_ESCAPE_SEQUENCE,
+    WARNING_CODES.ASTM_RECORD_UNINTERPRETED_QUERY_STATUS
+  ])
+);
+var ALL_WARNING_CODES = [
+  ...Object.values(WARNING_CODES),
+  ...Object.values(FRAME_WARNING_CODES),
+  ...Object.values(LTP_WARNING_CODES)
+];
+var ALL_ASTM_WARNING_CODES = Object.freeze(
+  new Set(ALL_WARNING_CODES)
+);
+var SAFETY_CRITICAL_CODES = Object.freeze(
+  new Set(ALL_WARNING_CODES.filter((c) => !TOLERABLE_CODES.has(c)))
+);
+function isSafetyCriticalCode(code) {
+  return SAFETY_CRITICAL_CODES.has(code);
+}
+
+// src/profiles/validate.ts
+var KNOWN_OPTION_KEYS = [
+  "name",
+  "description",
+  "tolerate",
+  "transport",
+  "provenance",
+  "extends"
+];
+var KNOWN_TRANSPORTS = ["framed", "raw"];
+function levenshtein(a, b) {
+  if (a === b) return 0;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  let prev = [];
+  for (let j = 0; j <= b.length; j++) prev.push(j);
+  for (let i = 1; i <= a.length; i++) {
+    const curr = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a.charCodeAt(i - 1) === b.charCodeAt(j - 1) ? 0 : 1;
+      curr.push(Math.min((prev[j] ?? 0) + 1, (curr[j - 1] ?? 0) + 1, (prev[j - 1] ?? 0) + cost));
+    }
+    prev = curr;
+  }
+  return prev[b.length] ?? 0;
+}
+function validateProfileName(opts) {
+  if (opts === null || opts === void 0) {
+    throw new AstmProfileDefinitionError(
+      `defineAstmProfile: options is required and must be an object. Received: ${String(opts)}.`
+    );
+  }
+  if (typeof opts.name !== "string") {
+    throw new AstmProfileDefinitionError(
+      `defineAstmProfile: 'name' is required and must be a non-empty string. Received: ${JSON.stringify(opts.name)}.`
+    );
+  }
+  if (opts.name.trim().length === 0) {
+    throw new AstmProfileDefinitionError(
+      `defineAstmProfile: 'name' is required and must be a non-empty string. Received: ${JSON.stringify(opts.name)}.`,
+      opts.name
+    );
+  }
+}
+function validateOptionKeys(opts) {
+  for (const key of Object.keys(opts)) {
+    if (KNOWN_OPTION_KEYS.includes(key)) continue;
+    let hint;
+    for (const known of KNOWN_OPTION_KEYS) {
+      if (levenshtein(key, known) <= 2) {
+        hint = known;
+        break;
+      }
+    }
+    throw new AstmProfileDefinitionError(
+      `Profile '${opts.name}' has unknown option key '${key}'. ` + (hint !== void 0 ? `Did you mean '${hint}'? ` : "") + `Known keys: ${KNOWN_OPTION_KEYS.join(", ")}.`,
+      opts.name
+    );
+  }
+}
+function validateTransport(opts) {
+  if (opts.transport === void 0) return;
+  if (typeof opts.transport !== "string" || !KNOWN_TRANSPORTS.includes(opts.transport)) {
+    throw new AstmProfileDefinitionError(
+      `Profile '${opts.name}' has an invalid 'transport' ${JSON.stringify(opts.transport)}. It must be one of: ${KNOWN_TRANSPORTS.join(", ")}.`,
+      opts.name
+    );
+  }
+}
+function validateTolerations(tolerate, profileName) {
+  for (const t of tolerate) {
+    if (typeof t.code !== "string" || !ALL_ASTM_WARNING_CODES.has(t.code)) {
+      throw new AstmProfileDefinitionError(
+        `Profile '${profileName}' tolerate entry has unknown warning code ${JSON.stringify(t.code)}. Only real codes from the record / frame / LTP registries may be named.`,
+        profileName
+      );
+    }
+    if (isSafetyCriticalCode(t.code)) {
+      throw new AstmProfileDefinitionError(
+        `Profile '${profileName}' may not tolerate '${t.code}' \u2014 it is a safety-critical warning code (a result value / flag / status / range / units, patient or comment context, message-kind ambiguity, code system, or a frame / LTP integrity warning). A profile quiets benign structural noise, never a deviation that could change a clinical reading or corrupt the wire \u2014 it can never make a bad checksum "ok" or a cancelled result read "final."`,
+        profileName
+      );
+    }
+    if (typeof t.rationale !== "string" || t.rationale.trim().length === 0) {
+      throw new AstmProfileDefinitionError(
+        `Profile '${profileName}' tolerate entry for '${t.code}' needs a non-empty 'rationale' documenting the real, grounded deviation it expects.`,
+        profileName
+      );
+    }
+  }
+}
+
+// src/profiles/define.ts
+function defineAstmProfile(opts) {
+  validateProfileName(opts);
+  validateOptionKeys(opts);
+  validateTransport(opts);
+  const selfTolerate = opts.tolerate ?? [];
+  validateTolerations(selfTolerate, opts.name);
+  const parents = normaliseParents(opts.extends);
+  const lineage = mergeLineage(parents, opts.name);
+  const tolerate = mergeTolerations(parents, selfTolerate);
+  const transport = mergeTransport(parents, opts.transport);
+  const provenance = mergeProvenance(parents, opts.provenance);
+  const description = mergeDescription(parents, opts.description);
+  validateTolerations(tolerate, opts.name);
+  const profile = {
+    name: opts.name,
+    lineage,
+    tolerate
+  };
+  if (description !== void 0) profile.description = description;
+  if (transport !== void 0) profile.transport = transport;
+  if (provenance !== void 0) profile.provenance = provenance;
+  const finalised = profile;
+  profile.describe = () => buildDescribe(finalised);
+  return Object.freeze(profile);
+}
+
+// src/profiles/default.ts
+var defaultProfile = defineAstmProfile({
+  name: "default",
+  description: "Conservative baseline \u2014 tolerates nothing; every deviation surfaces as a warning.",
+  tolerate: []
+});
+
+// src/profiles/reference-corpus.ts
+var referenceCorpus = defineAstmProfile({
+  name: "referenceCorpus",
+  description: "Non-standard-escape tolerance grounded firsthand in the escape-agnostic OSS reference corpus (python-astm / senaite). Syntactic encoding noise only \u2014 the value is preserved verbatim, never a safety-critical value.",
+  provenance: {
+    source: "kxepal/python-astm codec.py (BSD) + senaite.astm / senaite.lis2a",
+    reference: "https://github.com/kxepal/python-astm/blob/master/astm/codec.py ; https://github.com/senaite/senaite.astm",
+    retrieved: "2026-07-21",
+    note: "Firsthand-read: decode_record/decode_component/decode_repeated_component split on raw delimiters and never un-escape &F&/&S&/&R&/&E&."
+  },
+  tolerate: [
+    {
+      code: "ASTM_UNKNOWN_ESCAPE_SEQUENCE",
+      rationale: "The OSS reference stack (python-astm codec.py, firsthand-verified) treats '&' as literal data and never decodes escape sequences, so streams from that ecosystem carry non-standard '&\u2026&' bodies our escape-aware tokenizer flags. The body is preserved byte-for-byte in the value; the deviation is recognizable, syntactic, and non-clinical."
+    }
+  ]
+});
+
+// src/profiles/registry.ts
+var BUILT_INS = /* @__PURE__ */ new Map([
+  [defaultProfile.name, defaultProfile],
+  [referenceCorpus.name, referenceCorpus]
+]);
+function getAstmProfile(name) {
+  return BUILT_INS.get(name);
+}
+function listAstmProfiles() {
+  return Object.freeze([...BUILT_INS.keys()]);
+}
+var _defaultProfile = void 0;
+function setDefaultAstmProfile(profile) {
+  _defaultProfile = profile ?? void 0;
+}
+function getDefaultAstmProfile() {
+  return _defaultProfile;
+}
+
+// src/common/escapes.ts
+function decodeEscapes(leaf, d, onUnknown) {
+  const esc = d.escape;
+  if (!leaf.includes(esc)) return leaf;
+  let out = "";
+  let i = 0;
+  while (i < leaf.length) {
+    const ch = leaf.charAt(i);
+    if (ch !== esc) {
+      out += ch;
+      i += 1;
+      continue;
+    }
+    const close = leaf.indexOf(esc, i + 1);
+    if (close === -1) {
+      out += leaf.slice(i);
+      break;
+    }
+    const body = leaf.slice(i + 1, close);
+    const replacement = escapeBody(body, d);
+    if (replacement === void 0) {
+      out += esc + body + esc;
+      onUnknown?.();
+    } else {
+      out += replacement;
+    }
+    i = close + 1;
+  }
+  return out;
+}
+function escapeBody(body, d) {
+  switch (body) {
+    case "F":
+      return d.field;
+    case "S":
+      return d.component;
+    case "R":
+      return d.repeat;
+    case "E":
+      return d.escape;
+    default:
+      return void 0;
+  }
+}
+function splitEscapeAware(text, delimiter, escape) {
+  if (text.length === 0) return [""];
+  const out = [];
+  let current = "";
+  let i = 0;
+  while (i < text.length) {
+    const ch = text.charAt(i);
+    if (ch === escape) {
+      const close = text.indexOf(escape, i + 1);
+      if (close === -1) {
+        current += text.slice(i);
+        break;
+      }
+      current += text.slice(i, close + 1);
+      i = close + 1;
+      continue;
+    }
+    if (ch === delimiter) {
+      out.push(current);
+      current = "";
+      i += 1;
+      continue;
+    }
+    current += ch;
+    i += 1;
+  }
+  out.push(current);
+  return out;
+}
+
+// src/records/tokenize.ts
+function tokenizeRecord(record, d, onUnknownEscape) {
+  const rawFields = splitEscapeAware(record, d.field, d.escape);
+  return rawFields.map((raw, fieldIndex) => toField(raw, d, () => onUnknownEscape?.(fieldIndex)));
+}
+function toField(raw, d, onUnknownEscape) {
+  const rawRepeats = splitEscapeAware(raw, d.repeat, d.escape);
+  const repeats = rawRepeats.map(
+    (rep) => splitEscapeAware(rep, d.component, d.escape).map(
+      (comp) => decodeEscapes(comp, d, onUnknownEscape)
+    )
+  );
+  const components = repeats[0] ?? [""];
+  return { raw, components, repeats };
+}
+function fieldScalar(field) {
+  if (field === void 0) return void 0;
+  const first = field.components[0];
+  return first !== void 0 && first.length > 0 ? first : void 0;
+}
+
+// src/records/parse.ts
+var AstmStrictError = class extends Error {
+  warnings;
+  /** @internal */
+  constructor(warnings) {
+    super(`Strict mode: ${String(warnings.length)} tolerated deviation(s) rejected.`);
+    this.name = "AstmStrictError";
+    this.warnings = warnings;
+  }
+};
+function parseAstmRecords(raw, options = {}) {
+  const text = typeof raw === "string" ? raw : decodeBytes(raw);
+  if (text.trim().length === 0) {
+    throw new AstmParseError(FATAL_CODES.EMPTY_INPUT, "Input is empty.", { recordIndex: 0 });
+  }
+  const lines = text.split(/\r\n|\r|\n/u).filter((l) => l.length > 0);
+  const first = lines[0];
+  if (first === void 0 || first.charAt(0) !== "H") {
+    const leadType = first?.charAt(0);
+    throw new AstmParseError(
+      FATAL_CODES.ASTM_RECORD_NO_HEADER,
+      "First record is not an H (header) record.",
+      leadType !== void 0 && leadType.length > 0 ? { recordIndex: 0, recordType: leadType } : { recordIndex: 0 }
+    );
+  }
+  const delimiters = readDelimiters(first);
+  if (delimiters === void 0) {
+    throw new AstmParseError(
+      FATAL_CODES.ASTM_RECORD_UNDECLARED_DELIMITERS,
+      "Header record is too short to declare the four delimiters.",
+      { recordIndex: 0, recordType: "H" }
+    );
+  }
+  const warnings = [];
+  if (isNonStandard(delimiters)) {
+    warnings.push(nonStandardDelimiters({ recordIndex: 0, recordType: "H" }));
+  }
+  const built = lines.map(
+    (line2, recordIndex) => buildRecord(line2, recordIndex, delimiters, warnings)
+  );
+  const records = attachComments(built, warnings);
+  const classification = classifyMessage(records);
+  if (classification.hasQuery && classification.hasResults) {
+    warnings.push(ambiguousMessageKind({ recordIndex: 0, recordType: "H" }));
+  }
+  const profile = resolveProfile(options);
+  const finalWarnings = applyAstmProfileToWarnings(warnings, profile);
+  if (options.strict === true) {
+    const escalating = finalWarnings.filter((w) => w.expected !== true);
+    if (escalating.length > 0) {
+      throw new AstmStrictError(escalating);
+    }
+  }
+  const header = records[0];
+  const message = profile !== void 0 ? {
+    header,
+    records,
+    delimiters,
+    classification,
+    warnings: finalWarnings,
+    profile: { name: profile.name, lineage: profile.lineage }
+  } : { header, records, delimiters, classification, warnings: finalWarnings };
+  return deepFreeze(message);
+}
+function resolveProfile(options) {
+  if (options.profile === null) return void 0;
+  if (options.profile !== void 0) return options.profile;
+  return getDefaultAstmProfile();
+}
+function decodeBytes(bytes) {
+  let out = "";
+  for (const b of bytes) out += String.fromCharCode(b);
+  return out;
+}
+function astmField(fields, n) {
+  return fields[n - 1];
+}
+function buildRecord(line2, recordIndex, d, warnings) {
+  const rawType = line2.charAt(0);
+  const fields = tokenizeRecord(line2, d, (fieldIndex) => {
+    warnings.push(
+      unknownEscapeSequence({ recordIndex, recordType: rawType, fieldIndex: fieldIndex + 1 })
+    );
+  });
+  switch (rawType) {
+    case "H":
+      return {
+        type: "H",
+        recordIndex,
+        fields,
+        delimiters: d,
+        rawLine: line2
+      };
+    case "P":
+      return buildPatient(recordIndex, fields, warnings);
+    case "O":
+      return buildOrder(recordIndex, fields);
+    case "R":
+      return buildResult(recordIndex, fields, warnings);
+    case "C":
+      return buildComment(recordIndex, fields);
+    case "Q":
+      return buildQuery(recordIndex, fields, warnings);
+    // `M` (manufacturer) and `S` (scientific) are vendor-defined free-form data surfaced VERBATIM and
+    // NEVER interpreted into typed clinical fields — the exact wire line is preserved for round-trip.
+    case "M":
+      return { type: "M", recordIndex, fields, rawLine: line2 };
+    case "S":
+      return { type: "S", recordIndex, fields, rawLine: line2 };
+    case "L":
+      return { type: "L", recordIndex, fields };
+    default: {
+      warnings.push(unknownRecordType({ recordIndex, recordType: rawType }));
+      return { type: "unsupported", rawType, recordIndex, fields };
+    }
+  }
+}
+function buildPatient(recordIndex, fields, warnings) {
+  const nameField = astmField(fields, 6);
+  const name = nameField !== void 0 && fieldScalar(nameField) !== void 0 ? {
+    raw: nameField.raw,
+    ...definedString("last", nameField.components[0]),
+    ...definedString("first", nameField.components[1]),
+    ...definedString("middle", nameField.components[2])
+  } : void 0;
+  const birthDate = parseDateField(
+    fieldScalar(astmField(fields, 8)),
+    recordIndex,
+    "P",
+    8,
+    warnings
+  );
+  return {
+    type: "P",
+    recordIndex,
+    fields,
+    ...definedString("seq", fieldScalar(astmField(fields, 2))),
+    // The three patient identifiers stay DISTINCT — practice-assigned (3), laboratory-assigned (4),
+    // and a third ID (5) never collapse into one; conflating them is the primary misfiling path.
+    ...definedString("practiceAssignedId", fieldScalar(astmField(fields, 3))),
+    ...definedString("laboratoryAssignedId", fieldScalar(astmField(fields, 4))),
+    ...definedString("patientIdThree", fieldScalar(astmField(fields, 5))),
+    ...name !== void 0 ? { name } : {},
+    ...definedString("mothersMaidenName", fieldScalar(astmField(fields, 7))),
+    ...birthDate !== void 0 ? { birthDate } : {},
+    ...definedString("sex", fieldScalar(astmField(fields, 9)))
+  };
+}
+function buildOrder(recordIndex, fields) {
+  const utidField = astmField(fields, 5);
+  return {
+    type: "O",
+    recordIndex,
+    fields,
+    ...definedString("seq", fieldScalar(astmField(fields, 2))),
+    ...definedString("specimenId", fieldScalar(astmField(fields, 3))),
+    ...definedString("instrumentSpecimenId", fieldScalar(astmField(fields, 4))),
+    ...hasContent(utidField) ? { universalTestId: recognizeUniversalTestId(utidField.components) } : {},
+    // Priority (6), action code (~12), and report type (~26) are surfaced verbatim. The `~` field
+    // indices and the code sets are `[OSS-derived]` (paywalled), so they are never mapped to a
+    // guessed meaning — see the JSDoc on `OrderRecord`.
+    ...definedString("priority", fieldScalar(astmField(fields, 6))),
+    ...definedString("actionCode", fieldScalar(astmField(fields, 12))),
+    ...definedString("reportType", fieldScalar(astmField(fields, 26)))
+  };
+}
+function hasContent(field) {
+  return field !== void 0 && field.raw.length > 0;
+}
+function buildResult(recordIndex, fields, warnings) {
+  const utidField = astmField(fields, 3);
+  const valueField = astmField(fields, 4);
+  const startedAt = parseDateField(
+    fieldScalar(astmField(fields, 12)),
+    recordIndex,
+    "R",
+    12,
+    warnings
+  );
+  const completedAt = parseDateField(
+    fieldScalar(astmField(fields, 13)),
+    recordIndex,
+    "R",
+    13,
+    warnings
+  );
+  const ambiguous = valueField !== void 0 && valueField.components.length > 1;
+  const valueComponents = ambiguous ? valueField.components : void 0;
+  const value = ambiguous ? valueField.raw : fieldScalar(valueField);
+  if (ambiguous) {
+    warnings.push(ambiguousValueSplit({ recordIndex, recordType: "R", fieldIndex: 4 }));
+  }
+  const units = fieldScalar(astmField(fields, 5));
+  const rangeRaw = fieldRaw(astmField(fields, 6));
+  const flagRaw = fieldScalar(astmField(fields, 7));
+  const statusRaw = fieldScalar(astmField(fields, 9));
+  if (units === void 0 && value !== void 0 && isNumericValue(value)) {
+    warnings.push(unitsAbsent({ recordIndex, recordType: "R", fieldIndex: 5 }));
+  }
+  const range = rangeRaw !== void 0 ? parseReferenceRange(rangeRaw) : void 0;
+  if (range?.kind === "unparsed") {
+    warnings.push(unparseableReferenceRange({ recordIndex, recordType: "R", fieldIndex: 6 }));
+  }
+  const flag = flagRaw !== void 0 ? interpretAbnormalFlag(flagRaw) : void 0;
+  if (flag !== void 0 && !flag.recognized) {
+    warnings.push(undefinedAbnormalFlag({ recordIndex, recordType: "R", fieldIndex: 7 }));
+  }
+  const status = interpretResultStatus(statusRaw);
+  if (statusRaw !== void 0 && !status.recognized) {
+    warnings.push(undefinedResultStatus({ recordIndex, recordType: "R", fieldIndex: 9 }));
+  }
+  return {
+    type: "R",
+    recordIndex,
+    fields,
+    ...definedString("seq", fieldScalar(astmField(fields, 2))),
+    ...hasContent(utidField) ? { universalTestId: recognizeUniversalTestId(utidField.components) } : {},
+    ...definedString("value", value),
+    ...valueComponents !== void 0 ? { valueComponents } : {},
+    ...definedString("units", units),
+    ...definedString("referenceRange", rangeRaw),
+    ...range !== void 0 ? { range } : {},
+    ...definedString("abnormalFlags", flagRaw),
+    ...flag !== void 0 ? { flag } : {},
+    ...definedString("resultStatus", statusRaw),
+    status,
+    ...definedString("operator", fieldScalar(astmField(fields, 11))),
+    ...startedAt !== void 0 ? { startedAt } : {},
+    ...completedAt !== void 0 ? { completedAt } : {},
+    ...definedString("instrument", fieldScalar(astmField(fields, 14)))
+  };
+}
+function buildComment(recordIndex, fields) {
+  const textField = astmField(fields, 4);
+  const textComponents = textField !== void 0 && textField.components.length > 1 ? textField.components : void 0;
+  const text = textField !== void 0 && textField.raw.length > 0 ? textField.raw : void 0;
+  return {
+    type: "C",
+    recordIndex,
+    fields,
+    attachedToRoot: false,
+    ...definedString("seq", fieldScalar(astmField(fields, 2))),
+    ...definedString("source", fieldScalar(astmField(fields, 3))),
+    ...definedString("text", text),
+    ...textComponents !== void 0 ? { textComponents } : {},
+    ...definedString("commentType", fieldScalar(astmField(fields, 5)))
+  };
+}
+function buildQuery(recordIndex, fields, warnings) {
+  const utidField = astmField(fields, 5);
+  const utidRaw = fieldRaw(utidField);
+  const queriesAllTests = utidRaw !== void 0 && utidRaw.trim().toUpperCase() === "ALL";
+  const requestInformationStatus = fieldRaw(astmField(fields, 13));
+  if (requestInformationStatus !== void 0) {
+    warnings.push(uninterpretedQueryStatus({ recordIndex, recordType: "Q", fieldIndex: 13 }));
+  }
+  return {
+    type: "Q",
+    recordIndex,
+    fields,
+    ...definedString("seq", fieldScalar(astmField(fields, 2))),
+    // Range IDs are surfaced from the FULL field text (never truncated to a component); their internal
+    // caret structure is [OSS-derived]/paywalled and is not interpreted here.
+    ...definedString("startingRangeId", fieldRaw(astmField(fields, 3))),
+    ...definedString("endingRangeId", fieldRaw(astmField(fields, 4))),
+    ...hasContent(utidField) && !queriesAllTests ? { universalTestId: recognizeUniversalTestId(utidField.components) } : {},
+    queriesAllTests,
+    ...definedString("requestInformationStatus", requestInformationStatus)
+  };
+}
+function attachComments(records, warnings) {
+  let lastParentIndex;
+  return records.map((rec) => {
+    if (rec.type === "H" || rec.type === "P" || rec.type === "O" || rec.type === "R") {
+      lastParentIndex = rec.recordIndex;
+      return rec;
+    }
+    if (rec.type !== "C") return rec;
+    if (lastParentIndex === void 0) {
+      warnings.push(orphanComment({ recordIndex: rec.recordIndex, recordType: "C" }));
+      return { ...rec, attachedToRoot: true };
+    }
+    return { ...rec, parentIndex: lastParentIndex, attachedToRoot: false };
+  });
+}
+function parseDateField(raw, recordIndex, recordType, fieldIndex, warnings) {
+  if (raw === void 0) return void 0;
+  const date = parseAstmDate(raw);
+  if (date?.truncated === true) {
+    warnings.push(partialTimestamp({ recordIndex, recordType, fieldIndex }));
+  }
+  return date;
+}
+function isNumericValue(value) {
+  return /^\s*[<>]?\s*-?\d+(?:\.\d+)?\s*$/u.test(value);
+}
+function fieldRaw(field) {
+  return field !== void 0 && field.raw.length > 0 ? field.raw : void 0;
+}
+function definedString(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+
+// src/records/serialize.ts
+var AstmSerializeError = class extends Error {
+  /** Stable discriminant; `ASTM_EMIT_UNENCODABLE_VALUE` for a `CR`/`LF` in a value. */
+  code;
+  /** 0-based ordinal of the record within the message, when known. */
+  recordIndex;
+  /** @internal */
+  constructor(message, recordIndex) {
+    super(message);
+    this.name = "AstmSerializeError";
+    this.code = "ASTM_EMIT_UNENCODABLE_VALUE";
+    if (recordIndex !== void 0) this.recordIndex = recordIndex;
+  }
+};
+function encodeComponent(leaf, d, recordIndex) {
+  if (leaf.includes("\r") || leaf.includes("\n")) {
+    throw new AstmSerializeError(
+      "A value contains a record terminator (CR/LF), which cannot be escaped without breaking framing.",
+      recordIndex
+    );
+  }
+  return leaf.split(d.escape).join(d.escape + "E" + d.escape).split(d.field).join(d.escape + "F" + d.escape).split(d.component).join(d.escape + "S" + d.escape).split(d.repeat).join(d.escape + "R" + d.escape);
+}
+function encodeField(repeats, d, recordIndex) {
+  return repeats.map((rep) => rep.map((c) => encodeComponent(c, d, recordIndex)).join(d.component)).join(d.repeat);
+}
+function serializeAstmRecord(record, d = CANONICAL_DELIMITERS) {
+  if (record.type === "M" || record.type === "S") return record.rawLine;
+  if (record.type === "H") return serializeHeader(record, d);
+  return record.fields.map((f) => encodeField(f.repeats, d, record.recordIndex)).join(d.field);
+}
+function serializeHeader(header, d) {
+  const head = "H" + d.field + d.repeat + d.component + d.escape;
+  const src = header.delimiters;
+  const defEnd = header.rawLine.indexOf(src.field, 2);
+  if (defEnd === -1) return head;
+  const dataPortion = header.rawLine.slice(defEnd + 1);
+  const dataFields = tokenizeRecord(dataPortion, src);
+  const rest = dataFields.map((f) => d.field + encodeField(f.repeats, d, header.recordIndex)).join("");
+  return head + rest;
+}
+function serializeAstmRecords(input, d = CANONICAL_DELIMITERS) {
+  const records = Array.isArray(input) ? input : input.records;
+  return records.map((r) => serializeAstmRecord(r, d) + "\r").join("");
+}
+function serializeField(field, d = CANONICAL_DELIMITERS) {
+  return encodeField(field.repeats, d);
+}
+
+// src/records/build.ts
+function line(fields) {
+  const d = CANONICAL_DELIMITERS;
+  const encoded = fields.map((comps) => comps.map((c) => encodeComponent(c, d)).join(d.component));
+  let end = encoded.length;
+  while (end > 0 && encoded[end - 1] === "") end -= 1;
+  return encoded.slice(0, end).join(d.field);
+}
+function utid(components) {
+  return components === void 0 ? [""] : [...components];
+}
+function at(fields, position1, value) {
+  if (value === void 0) return;
+  fields[position1 - 1] = [value];
+}
+function buildPatientLine(input, seq) {
+  const f = [["P"], [seq]];
+  at(f, 3, input.practiceAssignedId);
+  at(f, 4, input.laboratoryAssignedId);
+  at(f, 5, input.patientIdThree);
+  if (input.name !== void 0) {
+    f[5] = [input.name.last ?? "", input.name.first ?? "", input.name.middle ?? ""];
+  }
+  at(f, 7, input.mothersMaidenName);
+  at(f, 8, input.birthDate);
+  at(f, 9, input.sex);
+  return line(padGaps(f));
+}
+function buildOrderLine(input, seq) {
+  const f = [["O"], [seq]];
+  at(f, 3, input.specimenId);
+  at(f, 4, input.instrumentSpecimenId);
+  if (input.universalTestId !== void 0) f[4] = [...utid(input.universalTestId)];
+  at(f, 6, input.priority);
+  at(f, 12, input.actionCode);
+  at(f, 26, input.reportType);
+  return line(padGaps(f));
+}
+function buildResultLine(input, seq) {
+  const f = [["R"], [seq]];
+  if (input.universalTestId !== void 0) f[2] = [...utid(input.universalTestId)];
+  at(f, 4, input.value);
+  at(f, 5, input.units);
+  at(f, 6, input.referenceRange);
+  at(f, 7, input.abnormalFlags);
+  at(f, 9, input.resultStatus);
+  at(f, 11, input.operator);
+  at(f, 12, input.startedAt);
+  at(f, 13, input.completedAt);
+  at(f, 14, input.instrument);
+  return line(padGaps(f));
+}
+function buildCommentLine(input, seq) {
+  const f = [["C"], [seq]];
+  at(f, 3, input.source);
+  if (input.textComponents !== void 0) f[3] = [...input.textComponents];
+  else at(f, 4, input.text);
+  at(f, 5, input.commentType);
+  return line(padGaps(f));
+}
+function buildQueryLine(input, seq) {
+  const f = [["Q"], [seq]];
+  at(f, 3, input.startingRangeId);
+  at(f, 4, input.endingRangeId);
+  if (input.queriesAllTests === true) f[4] = ["ALL"];
+  else if (input.universalTestId !== void 0) f[4] = [...utid(input.universalTestId)];
+  at(f, 13, input.requestInformationStatus);
+  return line(padGaps(f));
+}
+function buildVerbatimLine(input, seq) {
+  return [input.type, seq, ...input.fields.map(guardWireSafe)].join(CANONICAL_DELIMITERS.field);
+}
+function guardWireSafe(value) {
+  if (value.includes("\r") || value.includes("\n")) {
+    throw new AstmSerializeError(
+      "A verbatim field contains a record terminator (CR/LF), which would break framing."
+    );
+  }
+  return value;
+}
+function padGaps(fields) {
+  const out = [];
+  for (let i = 0; i < fields.length; i += 1) out[i] = fields[i] ?? [""];
+  return out;
+}
+function buildAstmMessage(input) {
+  const lines = [];
+  const d = CANONICAL_DELIMITERS;
+  const headerFields = input.header?.fields ?? [];
+  const headerRest = headerFields.map((v) => d.field + guardWireSafe(v)).join("");
+  lines.push("H" + d.field + d.repeat + d.component + d.escape + headerRest);
+  const counters = /* @__PURE__ */ new Map();
+  const nextSeq = (type, override) => {
+    if (override !== void 0) return override;
+    const n = (counters.get(type) ?? 0) + 1;
+    counters.set(type, n);
+    return String(n);
+  };
+  for (const rec of input.records) {
+    switch (rec.type) {
+      case "P":
+        lines.push(buildPatientLine(rec, nextSeq("P", rec.seq)));
+        break;
+      case "O":
+        lines.push(buildOrderLine(rec, nextSeq("O", rec.seq)));
+        break;
+      case "R":
+        lines.push(buildResultLine(rec, nextSeq("R", rec.seq)));
+        break;
+      case "C":
+        lines.push(buildCommentLine(rec, nextSeq("C", rec.seq)));
+        break;
+      case "Q":
+        lines.push(buildQueryLine(rec, nextSeq("Q", rec.seq)));
+        break;
+      case "M":
+      case "S":
+        lines.push(buildVerbatimLine(rec, nextSeq(rec.type)));
+        break;
+      default: {
+        const bad = rec;
+        throw new TypeError(`Unknown ASTM record type to build: ${String(bad.type)}`);
+      }
+    }
+  }
+  const term = [["L"], ["1"]];
+  if (input.terminationCode !== void 0) term[2] = [input.terminationCode];
+  lines.push(line(padGaps(term)));
+  return lines.map((l) => l + "\r").join("");
+}
+
+// src/records/extractors.ts
+function results(msg) {
+  return msg.records.filter((r) => r.type === "R");
+}
+function patient(msg) {
+  return msg.records.find((r) => r.type === "P");
+}
+function orders(msg) {
+  return msg.records.filter((r) => r.type === "O");
+}
+function comments(msg) {
+  return msg.records.filter((r) => r.type === "C");
+}
+function commentsFor(msg, parent) {
+  return msg.records.filter(
+    (r) => r.type === "C" && r.parentIndex === parent.recordIndex
+  );
+}
+function query(msg) {
+  return msg.records.filter((r) => r.type === "Q");
+}
+
+// src/profiles/index.ts
+var astmProfiles = Object.freeze({
+  default: defaultProfile,
+  referenceCorpus
+});
+
+// src/terminology/catalog.ts
+function defineLivdCatalog(entries) {
+  const index = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const bucket = index.get(entry.vendorCode);
+    if (bucket) bucket.push(entry);
+    else index.set(entry.vendorCode, [entry]);
+  }
+  const catalog = {
+    size: index.size,
+    lookup(vendorCode) {
+      const bucket = index.get(vendorCode);
+      if (!bucket || bucket.length === 0) return { status: "unmapped" };
+      const distinct = [...new Set(bucket.map((e) => e.loinc))];
+      if (distinct.length > 1) {
+        return deepFreeze({ status: "ambiguous", candidates: distinct });
+      }
+      const [first] = bucket;
+      if (first === void 0) return { status: "unmapped" };
+      return deepFreeze({
+        status: "mapped",
+        loinc: first.loinc,
+        ...first.loincLongName !== void 0 ? { loincLongName: first.loincLongName } : {}
+      });
+    }
+  };
+  return Object.freeze(catalog);
+}
+
+// src/terminology/warnings.ts
+var LIVD_WARNING_CODES = {
+  /**
+   * A record carried a vendor/local test code, but the consumer-supplied LIVD catalog held **no**
+   * entry for it. The code stays surfaced verbatim and the mapping is `unmapped` — a LOINC is
+   * **never** guessed. Purely advisory: the raw code and value are untouched.
+   */
+  ASTM_LIVD_UNMAPPED_CODE: "ASTM_LIVD_UNMAPPED_CODE",
+  /**
+   * A vendor/local test code matched **more than one distinct LOINC** in the catalog (e.g. the same
+   * transmission code used by two devices for different analytes). The mapping is `ambiguous` and the
+   * candidate LOINCs are surfaced for inspection, but **none is chosen** — refusing to pick is the
+   * fail-safe, since guessing wrong mis-identifies the test.
+   */
+  ASTM_LIVD_AMBIGUOUS_MAPPING: "ASTM_LIVD_AMBIGUOUS_MAPPING"
+};
+function livdUnmappedCode(position) {
+  return {
+    code: LIVD_WARNING_CODES.ASTM_LIVD_UNMAPPED_CODE,
+    message: "Reported test code had no LIVD mapping \u2014 surfaced unmapped, never a guessed LOINC.",
+    position
+  };
+}
+function livdAmbiguousMapping(position) {
+  return {
+    code: LIVD_WARNING_CODES.ASTM_LIVD_AMBIGUOUS_MAPPING,
+    message: "Reported test code mapped to multiple distinct LOINCs \u2014 surfaced ambiguous, never one guessed.",
+    position
+  };
+}
+
+// src/terminology/apply.ts
+function mapTestId(uid, catalog) {
+  if (uid.loincCandidate !== void 0) {
+    return { status: "inline-loinc", loinc: uid.loincCandidate, source: "wire" };
+  }
+  const code = primaryCode(uid);
+  if (code === void 0) return { status: "no-code" };
+  const hit = catalog.lookup(code);
+  switch (hit.status) {
+    case "mapped":
+      return {
+        status: "mapped",
+        loinc: hit.loinc,
+        ...hit.loincLongName !== void 0 ? { loincLongName: hit.loincLongName } : {},
+        source: "livd",
+        derived: true
+      };
+    case "ambiguous":
+      return { status: "ambiguous", candidates: hit.candidates };
+    case "unmapped":
+      return { status: "unmapped" };
+  }
+}
+function testIdOf(record) {
+  return record.universalTestId;
+}
+function lookupLivdForRecord(record, catalog) {
+  const uid = testIdOf(record);
+  const recognized = uid ?? recognizeUniversalTestId([]);
+  const mapping = mapTestId(recognized, catalog);
+  const reportedCode = primaryCode(recognized);
+  return {
+    recordIndex: record.recordIndex,
+    recordType: record.type,
+    ...reportedCode !== void 0 ? { reportedCode } : {},
+    provenance: recognized.provenance,
+    mapping
+  };
+}
+function applyLivd(msg, catalog) {
+  const annotations = [];
+  const warnings = [];
+  for (const record of msg.records) {
+    if (record.type !== "R" && record.type !== "O") continue;
+    const annotation = lookupLivdForRecord(record, catalog);
+    annotations.push(annotation);
+    const position = { recordIndex: record.recordIndex, recordType: record.type };
+    if (annotation.mapping.status === "unmapped") {
+      warnings.push(livdUnmappedCode(position));
+    } else if (annotation.mapping.status === "ambiguous") {
+      warnings.push(livdAmbiguousMapping(position));
+    }
+  }
+  return deepFreeze({ annotations, warnings });
+}
+
+// src/ltp/constants.ts
+var ENQ = 5;
+var ACK = 6;
+var NAK = 21;
+var EOT = 4;
+var RECORD_TYPE_LETTERS = new Set(
+  [..."HPORCQMSL"].map((c) => c.charCodeAt(0))
+);
+
+// src/frames/constants.ts
+var STX = 2;
+var ETX = 3;
+var ETB = 23;
+var CR = 13;
+var LF = 10;
+var FN_ZERO = 48;
+var FN_SEVEN = 55;
+var MAX_FRAME_TEXT = 240;
+var FRAME_NUMBER_MODULUS = 8;
+var FIRST_FRAME_NUMBER = 1;
+
+// src/ltp/transport.ts
+function detectFraming(bytes, options = {}) {
+  if (options.override !== void 0) {
+    return { framing: options.override, defaulted: false, warnings: [] };
+  }
+  const lead = bytes[0];
+  if (lead === STX || lead === ENQ) {
+    return { framing: "framed", defaulted: false, warnings: [] };
+  }
+  if (lead !== void 0 && RECORD_TYPE_LETTERS.has(lead)) {
+    return { framing: "raw", defaulted: false, warnings: [] };
+  }
+  return { framing: "framed", defaulted: true, warnings: [ltpAmbiguousTransport()] };
+}
+
+// src/ltp/reducer.ts
+var EMPTY = new Uint8Array(0);
+function ltpInitialState() {
+  return freezeState({
+    phase: "neutral",
+    expectedFrame: FIRST_FRAME_NUMBER,
+    records: [],
+    recordOpen: false,
+    openRecord: EMPTY
+  });
+}
+function ltpReduce(state, event) {
+  switch (event.type) {
+    case "enq":
+      return establish(state);
+    case "eot":
+      return terminate(state);
+    case "ack":
+    case "nak":
+      return { state, actions: [], warnings: [ltpUnexpectedEvent()] };
+    case "frame":
+      return onFrame(state, event.frame);
+  }
+}
+function establish(state) {
+  const warnings = state.phase === "transfer" ? [ltpUnexpectedEvent()] : [];
+  const next = freezeState({
+    phase: "transfer",
+    expectedFrame: FIRST_FRAME_NUMBER,
+    records: state.records,
+    recordOpen: false,
+    openRecord: EMPTY
+  });
+  return { state: next, actions: [{ type: "sendAck" }], warnings };
+}
+function terminate(state) {
+  const next = freezeState({
+    phase: "neutral",
+    expectedFrame: FIRST_FRAME_NUMBER,
+    records: state.records,
+    recordOpen: false,
+    openRecord: EMPTY
+  });
+  return { state: next, actions: [], warnings: [] };
+}
+function onFrame(state, frame) {
+  if (state.phase === "neutral") {
+    const established = freezeState({
+      phase: "transfer",
+      expectedFrame: FIRST_FRAME_NUMBER,
+      records: state.records,
+      recordOpen: false,
+      openRecord: EMPTY
+    });
+    const step = processTransferFrame(established, frame);
+    return {
+      state: step.state,
+      actions: step.actions,
+      warnings: [ltpUnexpectedEvent(frame.frameNumber), ...step.warnings]
+    };
+  }
+  return processTransferFrame(state, frame);
+}
+function processTransferFrame(state, frame) {
+  if (!frame.trusted) {
+    return reject(state, frame.frameNumber);
+  }
+  const fn = frame.frameNumber;
+  if (fn === void 0) {
+    return reject(state, void 0);
+  }
+  if (state.lastAcceptedFrame !== void 0 && fn === state.lastAcceptedFrame) {
+    return { state, actions: [{ type: "sendAck" }], warnings: [] };
+  }
+  if (fn !== state.expectedFrame) {
+    return reject(state, fn);
+  }
+  return acceptFrame(state, frame, fn);
+}
+function acceptFrame(state, frame, fn) {
+  const nextExpected = (fn + 1) % FRAME_NUMBER_MODULUS;
+  const accumulated = concatBytes([state.openRecord, frame.text]);
+  const actions = [{ type: "sendAck" }];
+  if (frame.terminator === "ETX") {
+    actions.push({ type: "deliverRecord", record: accumulated.slice() });
+    const next2 = freezeState({
+      phase: "transfer",
+      expectedFrame: nextExpected,
+      lastAcceptedFrame: fn,
+      records: [...state.records, accumulated],
+      recordOpen: false,
+      openRecord: EMPTY
+    });
+    return { state: next2, actions, warnings: [] };
+  }
+  const next = freezeState({
+    phase: "transfer",
+    expectedFrame: nextExpected,
+    lastAcceptedFrame: fn,
+    records: state.records,
+    recordOpen: true,
+    openRecord: accumulated
+  });
+  return { state: next, actions, warnings: [] };
+}
+function reject(state, frameNumber) {
+  return {
+    state,
+    actions: [{ type: "sendNak" }],
+    warnings: [ltpFrameRejected(frameNumber)]
+  };
+}
+function freezeState(fields) {
+  const state = {
+    phase: fields.phase,
+    expectedFrame: fields.expectedFrame,
+    ...fields.lastAcceptedFrame !== void 0 ? { lastAcceptedFrame: fields.lastAcceptedFrame } : {},
+    records: Object.freeze([...fields.records]),
+    recordOpen: fields.recordOpen,
+    openRecord: fields.openRecord
+  };
+  return Object.freeze(state);
+}
+function concatBytes(chunks) {
+  let total = 0;
+  for (const c of chunks) total += c.length;
+  const out = new Uint8Array(total);
+  let at2 = 0;
+  for (const c of chunks) {
+    out.set(c, at2);
+    at2 += c.length;
+  }
+  return out;
+}
+
+// src/frames/checksum.ts
+function computeChecksum(bytes, start, endInclusive) {
+  let sum = 0;
+  for (let i = start; i <= endInclusive; i++) {
+    sum = sum + (bytes[i] ?? 0) & 255;
+  }
+  return sum;
+}
+function toChecksumHex(checksum) {
+  return (checksum & 255).toString(16).toUpperCase().padStart(2, "0");
+}
+function hexNibble(code) {
+  if (code === void 0) return void 0;
+  if (code >= 48 && code <= 57) return code - 48;
+  if (code >= 65 && code <= 70) return code - 65 + 10;
+  if (code >= 97 && code <= 102) return code - 97 + 10;
+  return void 0;
+}
+function parseChecksumHex(bytes, i0, i1) {
+  const hi = hexNibble(bytes[i0]);
+  const lo = hexNibble(bytes[i1]);
+  if (hi === void 0 || lo === void 0) return void 0;
+  return hi << 4 | lo;
+}
+
+// src/frames/errors.ts
+var AstmFrameStrictError = class extends Error {
+  warnings;
+  /** @internal */
+  constructor(warnings) {
+    super(`Strict mode: ${String(warnings.length)} frame deviation(s) rejected.`);
+    this.name = "AstmFrameStrictError";
+    this.warnings = warnings;
+  }
+};
+
+// src/frames/decode.ts
+function decodeAstmFrames(bytes, options = {}) {
+  if (bytes.length === 0) {
+    throw new AstmParseError(FATAL_CODES.EMPTY_INPUT, "Framed input is empty.", { recordIndex: 0 });
+  }
+  const frames = [];
+  const records = [];
+  const warnings = [];
+  let recordChunks = [];
+  let recordTainted = false;
+  let recordOpen = false;
+  let expected = FIRST_FRAME_NUMBER;
+  const n = bytes.length;
+  let i = 0;
+  while (i < n) {
+    if (bytes[i] !== STX) {
+      i++;
+      continue;
+    }
+    const stxOffset = i;
+    const fnIndex = i + 1;
+    const frameNumber = fnIndex < n ? readFrameNumber(bytes[fnIndex]) : void 0;
+    let termIndex = -1;
+    let oversize = false;
+    for (let k = i + 2; k < n; k++) {
+      const b = bytes[k];
+      if (b === ETB || b === ETX) {
+        termIndex = k;
+        break;
+      }
+      if (b === STX) break;
+      if (k - (i + 2) + 1 > MAX_FRAME_TEXT) oversize = true;
+    }
+    const checksumTruncated = termIndex !== -1 && termIndex + 2 >= n;
+    if (termIndex === -1 || checksumTruncated) {
+      const textEnd = termIndex !== -1 ? termIndex : nextStxOrEnd(bytes, i + 2, n);
+      const text2 = bytes.slice(Math.min(i + 2, textEnd), textEnd);
+      frames.push({
+        ...frameNumber !== void 0 ? { frameNumber } : {},
+        text: text2,
+        byteOffset: stxOffset,
+        checksum: { computed: 0, valid: false },
+        trusted: false,
+        unterminated: true,
+        oversize
+      });
+      warnings.push(frameUnterminated(framePosition(frameNumber, stxOffset)));
+      recordTainted = true;
+      recordOpen = false;
+      i = termIndex === -1 ? textEnd : n;
+      continue;
+    }
+    const termKind = bytes[termIndex] === ETB ? "ETB" : "ETX";
+    const computed = computeChecksum(bytes, fnIndex, termIndex);
+    const declared = parseChecksumHex(bytes, termIndex + 1, termIndex + 2);
+    const valid = declared !== void 0 && declared === computed;
+    const checksum = declared !== void 0 ? { computed, declared, valid } : { computed, valid };
+    const text = bytes.slice(i + 2, termIndex);
+    const frame = {
+      ...frameNumber !== void 0 ? { frameNumber } : {},
+      terminator: termKind,
+      text,
+      byteOffset: stxOffset,
+      checksum,
+      trusted: valid,
+      unterminated: false,
+      oversize
+    };
+    frames.push(frame);
+    if (frameNumber !== void 0 && isFrameDigit(frameNumber) && frameNumber === expected) {
+      expected = (frameNumber + 1) % FRAME_NUMBER_MODULUS;
+    } else {
+      warnings.push(frameSequenceGap(framePosition(frameNumber, stxOffset)));
+      recordTainted = true;
+      if (frameNumber !== void 0 && isFrameDigit(frameNumber)) {
+        expected = (frameNumber + 1) % FRAME_NUMBER_MODULUS;
+      }
+    }
+    if (oversize) warnings.push(frameOversize(framePosition(frameNumber, stxOffset)));
+    if (!valid) {
+      warnings.push(frameBadChecksum(framePosition(frameNumber, stxOffset)));
+      recordTainted = true;
+    } else {
+      recordChunks.push(text);
+    }
+    if (termKind === "ETX") {
+      if (!recordTainted) records.push(concatBytes2(recordChunks));
+      recordChunks = [];
+      recordTainted = false;
+      recordOpen = false;
+    } else {
+      recordOpen = true;
+    }
+    i = termIndex + 3;
+    if (bytes[i] === CR) i++;
+    if (bytes[i] === LF) i++;
+  }
+  if (recordOpen) {
+    warnings.push(frameUnterminated({ byteOffset: n }));
+  }
+  if (options.strict === true && warnings.length > 0) {
+    throw new AstmFrameStrictError(warnings);
+  }
+  return freezeResult({ records, frames, warnings });
+}
+function freezeResult(result) {
+  for (const f of result.frames) {
+    Object.freeze(f.checksum);
+    Object.freeze(f);
+  }
+  for (const w of result.warnings) {
+    Object.freeze(w.position);
+    Object.freeze(w);
+  }
+  Object.freeze(result.records);
+  Object.freeze(result.frames);
+  Object.freeze(result.warnings);
+  return Object.freeze(result);
+}
+function readFrameNumber(fnByte) {
+  if (fnByte === void 0) return void 0;
+  return fnByte - FN_ZERO;
+}
+function isFrameDigit(frameNumber) {
+  return frameNumber >= 0 && frameNumber <= FN_SEVEN - FN_ZERO;
+}
+function framePosition(frameNumber, byteOffset) {
+  return frameNumber !== void 0 ? { frameNumber, byteOffset } : { byteOffset };
+}
+function nextStxOrEnd(bytes, from, end) {
+  for (let k = from; k < end; k++) {
+    if (bytes[k] === STX) return k;
+  }
+  return end;
+}
+function concatBytes2(chunks) {
+  let total = 0;
+  for (const c of chunks) total += c.length;
+  const out = new Uint8Array(total);
+  let at2 = 0;
+  for (const c of chunks) {
+    out.set(c, at2);
+    at2 += c.length;
+  }
+  return out;
+}
+
+// src/frames/encode.ts
+var AstmFrameEncodeError = class extends Error {
+  /** Stable discriminant. */
+  code;
+  /** Index of the offending record within the input, when applicable. */
+  recordIndex;
+  /** @internal */
+  constructor(message, recordIndex) {
+    super(message);
+    this.name = "AstmFrameEncodeError";
+    this.code = "ASTM_FRAME_EMPTY_RECORD";
+    if (recordIndex !== void 0) this.recordIndex = recordIndex;
+  }
+};
+function toBytes(input) {
+  if (typeof input !== "string") return input;
+  const out = new Uint8Array(input.length);
+  for (let i = 0; i < input.length; i += 1) out[i] = input.charCodeAt(i) & 255;
+  return out;
+}
+function encodeFrame(text, frameNumber, isFinal) {
+  const term = isFinal ? ETX : ETB;
+  const bytes = [STX, FN_ZERO + frameNumber, ...text, term];
+  const cs = computeChecksum(Uint8Array.from(bytes), 1, bytes.length - 1);
+  const hex = toChecksumHex(cs);
+  return [...bytes, hex.charCodeAt(0), hex.charCodeAt(1), CR, LF];
+}
+function composeAstmFrames(records, options = {}) {
+  if (records.length === 0) {
+    throw new AstmFrameEncodeError("Cannot frame an empty record list \u2014 nothing to transmit.");
+  }
+  const out = [];
+  let frameNumber = options.startFrameNumber ?? FIRST_FRAME_NUMBER;
+  records.forEach((record, recordIndex) => {
+    const bytes = toBytes(record);
+    if (bytes.length === 0) {
+      throw new AstmFrameEncodeError(
+        "Cannot frame an empty record \u2014 a frame must carry record bytes.",
+        recordIndex
+      );
+    }
+    for (let offset = 0; offset < bytes.length; offset += MAX_FRAME_TEXT) {
+      const chunk = bytes.subarray(offset, offset + MAX_FRAME_TEXT);
+      const isFinal = offset + MAX_FRAME_TEXT >= bytes.length;
+      out.push(...encodeFrame(chunk, frameNumber, isFinal));
+      frameNumber = (frameNumber + 1) % FRAME_NUMBER_MODULUS;
+    }
+  });
+  return Uint8Array.from(out);
+}
+
+// src/frames/compose.ts
+function parseFramedAstm(bytes, options = {}) {
+  const { records, frames, warnings } = decodeAstmFrames(bytes, options);
+  const joined = concatBytes3(records);
+  const message = parseAstmRecords(joined, options);
+  return { message, frames, frameWarnings: warnings };
+}
+function serializeFramedAstm(input, options = {}) {
+  const records = Array.isArray(input) ? input : input.records;
+  const recordBytes = records.map((r) => serializeAstmRecord(r) + "\r");
+  return composeAstmFrames(recordBytes, options);
+}
+function concatBytes3(chunks) {
+  let total = 0;
+  for (const c of chunks) total += c.length;
+  const out = new Uint8Array(total);
+  let at2 = 0;
+  for (const c of chunks) {
+    out.set(c, at2);
+    at2 += c.length;
+  }
+  return out;
+}
+
+// src/index.ts
+var VERSION = "0.0.0";
+
+exports.ALL_ASTM_WARNING_CODES = ALL_ASTM_WARNING_CODES;
+exports.ASTM_ACK = ACK;
+exports.ASTM_ENQ = ENQ;
+exports.ASTM_EOT = EOT;
+exports.ASTM_NAK = NAK;
+exports.AstmFrameEncodeError = AstmFrameEncodeError;
+exports.AstmFrameStrictError = AstmFrameStrictError;
+exports.AstmParseError = AstmParseError;
+exports.AstmProfileDefinitionError = AstmProfileDefinitionError;
+exports.AstmSerializeError = AstmSerializeError;
+exports.AstmStrictError = AstmStrictError;
+exports.CANONICAL_DELIMITERS = CANONICAL_DELIMITERS;
+exports.FATAL_CODES = FATAL_CODES;
+exports.FRAME_WARNING_CODES = FRAME_WARNING_CODES;
+exports.LIVD_WARNING_CODES = LIVD_WARNING_CODES;
+exports.LTP_WARNING_CODES = LTP_WARNING_CODES;
+exports.SAFETY_CRITICAL_CODES = SAFETY_CRITICAL_CODES;
+exports.TOLERABLE_CODES = TOLERABLE_CODES;
+exports.VERSION = VERSION;
+exports.WARNING_CODES = WARNING_CODES;
+exports.ambiguousMessageKind = ambiguousMessageKind;
+exports.ambiguousValueSplit = ambiguousValueSplit;
+exports.applyAstmProfile = applyAstmProfile;
+exports.applyAstmProfileToWarnings = applyAstmProfileToWarnings;
+exports.applyLivd = applyLivd;
+exports.astmDateToLocalISO = astmDateToLocalISO;
+exports.astmProfiles = astmProfiles;
+exports.attachComments = attachComments;
+exports.buildAstmMessage = buildAstmMessage;
+exports.classifyMessage = classifyMessage;
+exports.comments = comments;
+exports.commentsFor = commentsFor;
+exports.composeAstmFrames = composeAstmFrames;
+exports.computeChecksum = computeChecksum;
+exports.decodeAstmFrames = decodeAstmFrames;
+exports.decodeEscapes = decodeEscapes;
+exports.deepFreeze = deepFreeze;
+exports.defineAstmProfile = defineAstmProfile;
+exports.defineLivdCatalog = defineLivdCatalog;
+exports.detectFraming = detectFraming;
+exports.encodeComponent = encodeComponent;
+exports.fieldScalar = fieldScalar;
+exports.frameBadChecksum = frameBadChecksum;
+exports.frameOversize = frameOversize;
+exports.frameSequenceGap = frameSequenceGap;
+exports.frameUnterminated = frameUnterminated;
+exports.getAstmProfile = getAstmProfile;
+exports.getDefaultAstmProfile = getDefaultAstmProfile;
+exports.interpretAbnormalFlag = interpretAbnormalFlag;
+exports.interpretResultStatus = interpretResultStatus;
+exports.isNonStandard = isNonStandard;
+exports.isSafetyCriticalCode = isSafetyCriticalCode;
+exports.listAstmProfiles = listAstmProfiles;
+exports.livdAmbiguousMapping = livdAmbiguousMapping;
+exports.livdUnmappedCode = livdUnmappedCode;
+exports.lookupLivdForRecord = lookupLivdForRecord;
+exports.ltpAmbiguousTransport = ltpAmbiguousTransport;
+exports.ltpFrameRejected = ltpFrameRejected;
+exports.ltpInitialState = ltpInitialState;
+exports.ltpReduce = ltpReduce;
+exports.ltpUnexpectedEvent = ltpUnexpectedEvent;
+exports.nonStandardDelimiters = nonStandardDelimiters;
+exports.orders = orders;
+exports.orphanComment = orphanComment;
+exports.parseAstmDate = parseAstmDate;
+exports.parseAstmRecords = parseAstmRecords;
+exports.parseChecksumHex = parseChecksumHex;
+exports.parseFramedAstm = parseFramedAstm;
+exports.parseReferenceRange = parseReferenceRange;
+exports.partialTimestamp = partialTimestamp;
+exports.patient = patient;
+exports.primaryCode = primaryCode;
+exports.profileQuirkApplied = profileQuirkApplied;
+exports.query = query;
+exports.readDelimiters = readDelimiters;
+exports.recognizeUniversalTestId = recognizeUniversalTestId;
+exports.resolveProfileTransport = resolveProfileTransport;
+exports.results = results;
+exports.serializeAstmRecord = serializeAstmRecord;
+exports.serializeAstmRecords = serializeAstmRecords;
+exports.serializeField = serializeField;
+exports.serializeFramedAstm = serializeFramedAstm;
+exports.setDefaultAstmProfile = setDefaultAstmProfile;
+exports.splitEscapeAware = splitEscapeAware;
+exports.toChecksumHex = toChecksumHex;
+exports.tokenizeRecord = tokenizeRecord;
+exports.undefinedAbnormalFlag = undefinedAbnormalFlag;
+exports.undefinedResultStatus = undefinedResultStatus;
+exports.uninterpretedQueryStatus = uninterpretedQueryStatus;
+exports.unitsAbsent = unitsAbsent;
+exports.unknownEscapeSequence = unknownEscapeSequence;
+exports.unknownRecordType = unknownRecordType;
+exports.unparseableReferenceRange = unparseableReferenceRange;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map