@cosyte/x12 0.0.4 → 0.0.5

package/CHANGELOG.md

@@ -9,6 +9,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **`renderCallerValue`**, plus the `BUILD_REFUSAL_VALUE_MAX_LENGTH` (63) and
+  `BUILD_REFUSAL_VALUE_MAX_RENDERED` (90) bounds. This is the single sanctioned route a
+  caller-supplied value takes into a `build*` refusal message, and both ceilings are exported so a
+  consumer can assert them rather than take them on trust - the builder-side counterpart to
+  `ALL_WARNING_MESSAGES` on the parse side. `BUILD_REFUSAL_VALUE_MAX_RENDERED` bounds the rendered
+  **fragment**, not the whole message: a message is that plus the site's own fixed template text.
 - **`X12OrphanSegment.anchor`**, plus the `X12OrphanAnchor` / `X12OrphanAnchorKind` types. Every
   retained orphan now records **where it sat in the structure** rather than only where it sat in the
   byte stream: `{ kind: "interchange", groupIndex }` for a segment outside every functional group,
@@ -28,6 +34,37 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- **A `build*` refusal message no longer grows with the value you passed in.** All twenty-three
+  caller-value slots across the ten builder modules route through `renderCallerValue`, capping the
+  rendered fragment at 90 characters. Nine are the `control number "…" exceeds the N-char spec limit`
+  refusal, where the branch fires _because_ the value is over-long; seven had no length gate at all
+  (`build999`'s ST-02 trace twice, `buildInterchange`'s transaction-set id, `build837`'s service-line
+  variant, `build834`'s INS-03 and HD-01 maintenance types, `buildTA1`'s note code); and seven are in
+  `build999`, found by adversarial review rather than by the census - the AK9-02 / AK9-03 / AK9-04
+  counts, typed `number` but reachable with a string from a `JSON.parse`d spec at 120,063 characters,
+  and three `.length` reads on caller-supplied arrays that a forged `{ length: … }` drove to 120,152.
+  Measured: a 120,000-character control number produced a **120,066-character**
+  `X12BuildError.message` from `buildInterchange` and now produces a **150-character** one. (150, not
+  90: the 90 is the ceiling on the interpolated fragment, not on the message.) **This is robustness
+  and log hygiene, not redaction, and the docs now say so** - you passed the value in and still hold
+  it, so bounding it hides nothing from you; what it buys is a fixed ceiling on anything that reaches
+  a log line or a JSON error envelope. The surviving characters are bounded but **not escaped**, and
+  on the ack path the value is not always strictly your own (TR3 005010X231A1 has AK2-02 echo the
+  acknowledged ST-02 verbatim). `err.code` remains the thing to branch on.
+- **A builder refusal handed a non-string where the types say `string` stays a typed error.**
+  `renderCallerValue` coerces rather than reading `.length` off whatever it is given, so a spec built
+  from `JSON.parse` that carries a numeric control number still raises `X12BuildError` with its
+  `code`, instead of an uncaught `TypeError` with none.
+- **The 835 remit-total balance warning points at the BPR instead of at the ST.** Its
+  `position.segmentIndex` was a literal `0`, which reads like "no segment" but is not one:
+  `tx.segments[0]` is the `ST`, so a consumer resolving the position landed on a segment with nothing
+  to do with the invariant. It is now the BPR's own 1-based body index, so
+  `tx.segments[w.position.segmentIndex]` is the segment carrying the BPR-02 the equation compares
+  against, matching the treatment claim-level and service-line warnings already had. The only
+  remaining `0` is a transaction that carries no BPR at all. The corresponding position inside
+  `build835` stays synthetic and is now named and documented as such: the builder has no parsed
+  segment stream to index into, and it consumes only the warning's `message`, which is a
+  registry lookup keyed by the invariant and therefore position-independent.
 - **A segment outside a transaction now survives a round trip, and so does its warning.**
   `serializeX12` re-emits every entry of `ix.orphanSegments` at its structural `anchor`, so a
   consumer who serializes an interchange and re-derives warnings from the copy no longer loses the

package/README.md

@@ -45,7 +45,7 @@ That's the pitch: no schema upload, no spec knowledge. The parser accepts vendor
 - **Postel's Law**: a lenient parser (deviations → warnings with a stable code + positional context) and a conservative serializer. `serializeX12` is byte-faithful **for the segments on the model** by default: each comes back verbatim, including element padding, composites, and `?`-release escapes. **`serialize(parse(s)) === s` is not guaranteed in general.** Six constructs are known not to survive: line breaks between segments (any run of CR / LF between segments is absorbed at parse, so a pretty-printed or double-spaced file emits compact), a doubled terminator outside a transaction, a missing final terminator (the emit supplies one), post-IEA `trailingBytes` (re-joined, not verbatim), a TA1 that followed a functional group (emitted right after the ISA, so it is **reordered**, though nothing is lost), and a segment whose first element is empty outside a transaction (skipped entirely, with no warning at all). A **segment outside a transaction is not on that list**: it is reported as `X12_UNEXPECTED_SEGMENT`, kept on the model at `ix.orphanSegments` with a structural `anchor`, and re-emitted at that anchor, so the segment, its value and its warning all survive the round trip - placement is by the anchor and never by `segmentIndex`, which indexes the input stream the emit does not follow. The last five break the round trip on inputs with no line breaks at all, so do not treat "no line breaks" as sufficient; five of the six are silent, so a clean warnings list does not mean byte-exact either. Measured across this repo's 56 fixtures: every emit is a fixed point and re-parses to an identical model with an identical warning stream, the 14 with no line breaks return byte-identical, and the other 42 differ by line breaks and nothing else. See [Line endings between segments](./docs-content/spec-notes-envelope.md). `{ specClean: true }` reconciles the envelope, and `{ specClean: true, recomputeCounts: true }` also emits the corrected counts (`recomputeCounts` does nothing on its own). A mismatch is always warned, never silently corrected. Only **4 structural failures** are ever fatal.
 - **Money is exact**: every monetary/percent/quantity field decodes as `X12Decimal` (string-backed, BigInt arithmetic). The library **never `parseFloat`s** an EDI amount.
 - **Safety-critical fidelity**: TRN reassociation traces, 835 balance invariants, 837 HL hierarchy integrity, 834 maintenance types, and 278 certification actions are preserved **verbatim** and never inferred; ambiguity yields a warning or a typed refusal, never a confident wrong answer.
-- **PHI-disciplined**: synthetic-only fixtures, a PHI commit-gate, and a warning `message` that is a **lookup into a frozen registry**, not something built from your document. No warning factory in the library takes a value parameter, so no element can reach a diagnostic: the code and `position` say what and where, and the bytes stay on the model. `ALL_WARNING_MESSAGES` is exported so you can assert it. **Builder refusals are a different, and weaker, surface:** a `build*` function that refuses a spec carries structural locators and numeric totals in most cases, but at least sixteen refusal sites across ten builder modules interpolate a caller-supplied value into the thrown message verbatim and unbounded. Nine of them are the over-long control number, where the branch fires because the value is over-long; seven are not gated on length at all (`build999`'s ST-02 trace, `buildInterchange`'s transaction-set id, `build837`'s line variant, `build834`'s maintenance types, `buildTA1`'s note code). Measured: a 120,000-byte value gives a 120,155-byte `Error.message` from `build999`. Log `err.code`, not `err.message`, from a builder. Tracked in [KNOWN-LIMITATIONS.md](./KNOWN-LIMITATIONS.md). **The one deliberate exception:** `X12ParseError.snippet` on the four Tier-3 structural fatals is a bounded (≤ 64 character) copy of the start of the input, so on real traffic it can carry PHI. The library does not redact it. Redact at your call site, or log `err.code` and `err.position` instead. See [Keeping PHI out of logs](./docs-content/troubleshooting.md).
+- **PHI-disciplined**: synthetic-only fixtures, a PHI commit-gate, and a warning `message` that is a **lookup into a frozen registry**, not something built from your document. No warning factory in the library takes a value parameter, so no element can reach a diagnostic: the code and `position` say what and where, and the bytes stay on the model. `ALL_WARNING_MESSAGES` is exported so you can assert it. **Builder refusals are a different, and deliberately weaker, surface:** twenty-three refusal sites across ten builder modules name a value you passed in, so you can see which control number, count or code was refused. Each goes through `renderCallerValue`, capping the rendered **fragment** at `BUILD_REFUSAL_VALUE_MAX_RENDERED` (90 characters); all three names are exported so you can assert the ceiling. The whole `message` is that plus the site's own fixed text, so it is bounded by a constant but a larger one: a 120,000-character control number gave a 120,066-character `X12BuildError.message` before this and gives 150 now. That is robustness, not redaction: the value is one you supplied and bounding it hides nothing from you. It is also not escaped, and on the **ack** path it is not always strictly your own, since `build999`'s AK2-02 and `buildTA1` echo an inbound document's control numbers by design. Log `err.code`, not `err.message`, from a builder. Tracked in [KNOWN-LIMITATIONS.md](./KNOWN-LIMITATIONS.md). **The one deliberate exception:** `X12ParseError.snippet` on the four Tier-3 structural fatals is a bounded (≤ 64 character) copy of the start of the input, so on real traffic it can carry PHI. The library does not redact it. Redact at your call site, or log `err.code` and `err.position` instead. See [Keeping PHI out of logs](./docs-content/troubleshooting.md).
 
 See the [**Cookbook**](./docs-content/cookbook.md) for task-oriented recipes (post an 835, route 277CA rejections, round-trip a 271, walk an 837, read a 999) and [**KNOWN-LIMITATIONS.md**](./KNOWN-LIMITATIONS.md) for the honest do-not-over-trust list.
 

package/dist/index.cjs

@@ -1888,6 +1888,7 @@ function get835(delimiters, tx) {
   const warnings = [];
   const body = tx.se === void 0 ? tx.segments.slice(1) : tx.segments.slice(1, -1);
   let payment = EMPTY_HEADER;
+  let bprSegmentIndex = 0;
   const traces = [];
   let payer;
   let payee;
@@ -1916,6 +1917,7 @@ function get835(delimiters, tx) {
     switch (seg.id) {
       case "BPR": {
         payment = decodeBpr(seg, delimiters);
+        bprSegmentIndex = position.segmentIndex;
         break;
       }
       case "TRN": {
@@ -2083,7 +2085,7 @@ function get835(delimiters, tx) {
     payment.totalActualPayment,
     finalClaims,
     providerAdjustments,
-    { segmentIndex: 0, transactionIndex: 0 }
+    { segmentIndex: bprSegmentIndex, transactionIndex: 0 }
   );
   if (remitTotalWarn !== void 0) warnings.push(remitTotalWarn);
   return Object.freeze({
@@ -2444,10 +2446,32 @@ var Remit835BuildError = class extends Error {
   }
 };
 
+// src/builder/caller-value.ts
+var BUILD_REFUSAL_VALUE_MAX_LENGTH = 63;
+var MAX_LENGTH_DIGITS = 10;
+var BUILD_REFUSAL_VALUE_MAX_RENDERED = BUILD_REFUSAL_VALUE_MAX_LENGTH + 2 + 1 + " ( characters)".length + MAX_LENGTH_DIGITS;
+function renderCallerValue(value) {
+  const text = coerce(value);
+  if (text.length <= BUILD_REFUSAL_VALUE_MAX_LENGTH) return `"${text}"`;
+  return `"${text.slice(0, BUILD_REFUSAL_VALUE_MAX_LENGTH)}\u2026" (${String(text.length)} characters)`;
+}
+function coerce(value) {
+  if (typeof value === "string") return value;
+  try {
+    return String(value);
+  } catch {
+    return "[unrenderable value]";
+  }
+}
+
 // src/transactions/remit/build-835.ts
 var X221A1_VERSION_RELEASE = "005010X221A1";
 var X12_835_FUNCTIONAL_ID = "HP";
 var X12_AGENCY_CODE = "X";
+var UNANCHORED_BUILD_POSITION = Object.freeze({
+  segmentIndex: 0,
+  transactionIndex: 0
+});
 function build835(spec) {
   const { envelope } = spec;
   enforceStructuralSpec(spec);
@@ -2621,7 +2645,7 @@ function enforceStructuralSpec(spec) {
   }
 }
 function enforceBalance(spec) {
-  const position = { segmentIndex: 0, transactionIndex: 0 };
+  const position = UNANCHORED_BUILD_POSITION;
   const claims = spec.claims.map(materializeClaim);
   for (const claim of claims) {
     const claimWarn = checkClaimBalance(claim, position);
@@ -2927,7 +2951,7 @@ function padControl(value, width) {
   if (value.length < width) return "0".repeat(width - value.length) + value;
   throw new Remit835BuildError(
     REMIT_835_BUILD_ERROR_CODES.X12_835_BUILD_INVALID_SPEC,
-    `build835: control number "${value}" exceeds the ${String(width)}-char spec limit.`
+    `build835: control number ${renderCallerValue(value)} exceeds the ${String(width)}-char spec limit.`
   );
 }
 function expandYY(yymmdd) {
@@ -4276,7 +4300,7 @@ function enforceClaim(variant, claim, locator) {
     if (line.variant !== variant) {
       throw new Claim837BuildError(
         CLAIM_837_BUILD_ERROR_CODES.X12_837_BUILD_INVALID_SPEC,
-        `build837${variant}: claim at ${locator} has a "${line.variant}" service line at index ${String(l)}; every line must be "${variant}".`
+        `build837${variant}: claim at ${locator} has a ${renderCallerValue(line.variant)} service line at index ${String(l)}; every line must be "${variant}".`
       );
     }
     const code = line.variant === "I" ? line.revenueCode : line.procedureCode;
@@ -4620,7 +4644,7 @@ function padControl2(value, width) {
   if (value.length < width) return "0".repeat(width - value.length) + value;
   throw new Claim837BuildError(
     CLAIM_837_BUILD_ERROR_CODES.X12_837_BUILD_INVALID_SPEC,
-    `build837: control number "${value}" exceeds the ${String(width)}-char spec limit.`
+    `build837: control number ${renderCallerValue(value)} exceeds the ${String(width)}-char spec limit.`
   );
 }
 function expandYY2(yymmdd) {
@@ -5485,7 +5509,7 @@ function padControl3(value, width) {
   if (value.length < width) return "0".repeat(width - value.length) + value;
   throw new Eligibility271BuildError(
     ELIGIBILITY_271_BUILD_ERROR_CODES.X12_271_BUILD_INVALID_SPEC,
-    `build271: control number "${value}" exceeds the ${String(width)}-char spec limit.`
+    `build271: control number ${renderCallerValue(value)} exceeds the ${String(width)}-char spec limit.`
   );
 }
 function expandYY3(yymmdd) {
@@ -6259,7 +6283,7 @@ function padControl4(value, width) {
   if (value.length < width) return "0".repeat(width - value.length) + value;
   throw new ClaimStatus277BuildError(
     CLAIM_STATUS_277_BUILD_ERROR_CODES.X12_277_BUILD_INVALID_SPEC,
-    `build277: control number "${value}" exceeds the ${String(width)}-char spec limit.`
+    `build277: control number ${renderCallerValue(value)} exceeds the ${String(width)}-char spec limit.`
   );
 }
 function expandYY4(yymmdd) {
@@ -6916,7 +6940,7 @@ function padControl5(value, width) {
   if (value.length < width) return "0".repeat(width - value.length) + value;
   throw new Premium820BuildError(
     PREMIUM_820_BUILD_ERROR_CODES.X12_820_BUILD_INVALID_SPEC,
-    `build820: control number "${value}" exceeds the ${String(width)}-char spec limit.`
+    `build820: control number ${renderCallerValue(value)} exceeds the ${String(width)}-char spec limit.`
   );
 }
 function expandYY5(yymmdd) {
@@ -7431,7 +7455,7 @@ function enforceStructuralSpec6(spec) {
     if (lookupMaintenanceType(member.maintenanceTypeCode) === void 0) {
       throw new Enrollment834BuildError(
         ENROLLMENT_834_BUILD_ERROR_CODES.X12_834_BUILD_UNKNOWN_MAINTENANCE_TYPE,
-        `build834: member at index ${String(m)} has an unknown INS-03 maintenance type code "${member.maintenanceTypeCode}" (outside X12 Code Source 875).`
+        `build834: member at index ${String(m)} has an unknown INS-03 maintenance type code ${renderCallerValue(member.maintenanceTypeCode)} (outside X12 Code Source 875).`
       );
     }
     for (let c = 0; c < (member.healthCoverages ?? []).length; c += 1) {
@@ -7441,7 +7465,7 @@ function enforceStructuralSpec6(spec) {
       if (hd01 !== void 0 && hd01 !== "" && lookupMaintenanceType(hd01) === void 0) {
         throw new Enrollment834BuildError(
           ENROLLMENT_834_BUILD_ERROR_CODES.X12_834_BUILD_UNKNOWN_MAINTENANCE_TYPE,
-          `build834: coverage at member[${String(m)}].healthCoverages[${String(c)}] has an unknown HD-01 maintenance type code "${hd01}" (outside X12 Code Source 875).`
+          `build834: coverage at member[${String(m)}].healthCoverages[${String(c)}] has an unknown HD-01 maintenance type code ${renderCallerValue(hd01)} (outside X12 Code Source 875).`
         );
       }
     }
@@ -7590,7 +7614,7 @@ function padControl6(value, width) {
   if (value.length < width) return "0".repeat(width - value.length) + value;
   throw new Enrollment834BuildError(
     ENROLLMENT_834_BUILD_ERROR_CODES.X12_834_BUILD_INVALID_SPEC,
-    `build834: control number "${value}" exceeds the ${String(width)}-char spec limit.`
+    `build834: control number ${renderCallerValue(value)} exceeds the ${String(width)}-char spec limit.`
   );
 }
 function expandYY6(yymmdd) {
@@ -8246,7 +8270,7 @@ function padControl7(value, width) {
   if (value.length < width) return "0".repeat(width - value.length) + value;
   throw new ServicesReview278BuildError(
     AUTH_278_BUILD_ERROR_CODES.X12_278_BUILD_INVALID_SPEC,
-    `build278: control number "${value}" exceeds the ${String(width)}-char spec limit.`
+    `build278: control number ${renderCallerValue(value)} exceeds the ${String(width)}-char spec limit.`
   );
 }
 function expandYY7(yymmdd) {
@@ -8848,7 +8872,7 @@ function enforceAcceptIsClean(group) {
   if (functionalIsAccept && functionalHasErrorCodes) {
     throw new AckBuildError(
       ACK_BUILD_ERROR_CODES.X12_ACK_ACCEPT_WITH_ERRORS,
-      `build999: AK9-01 was 'A' (Accept) but AK9-05..AK9-09 carried ${String(
+      `build999: AK9-01 was 'A' (Accept) but AK9-05..AK9-09 carried ${renderCallerValue(
         (group.syntaxErrorCodes ?? []).length
       )} syntax error code(s). Use 'E' (Accept, with errors noted) or a reject disposition instead.`
     );
@@ -8859,13 +8883,13 @@ function enforceAcceptIsClean(group) {
     if (responseIsAccept && responseHasErrors) {
       throw new AckBuildError(
         ACK_BUILD_ERROR_CODES.X12_ACK_ACCEPT_WITH_ERRORS,
-        `build999: AK2 (ST-02 ${response.transactionSetControlNumber}) IK5-01 was 'A' (Accept) but the response carried error payload. Use 'E' (Accept, with errors noted) or a reject disposition instead.`
+        `build999: AK2 (ST-02 ${renderCallerValue(response.transactionSetControlNumber)}) IK5-01 was 'A' (Accept) but the response carried error payload. Use 'E' (Accept, with errors noted) or a reject disposition instead.`
       );
     }
     if (functionalIsAccept && (!responseIsAccept || responseHasErrors)) {
       throw new AckBuildError(
         ACK_BUILD_ERROR_CODES.X12_ACK_ACCEPT_WITH_ERRORS,
-        `build999: AK9-01 was 'A' (Accept) but transaction response (ST-02 ${response.transactionSetControlNumber}) reported a non-accept disposition or carried errors. Lift the functional disposition to 'P' (Partial), 'E' (Accept, errors noted), or a reject.`
+        `build999: AK9-01 was 'A' (Accept) but transaction response (ST-02 ${renderCallerValue(response.transactionSetControlNumber)}) reported a non-accept disposition or carried errors. Lift the functional disposition to 'P' (Partial), 'E' (Accept, errors noted), or a reject.`
       );
     }
   }
@@ -8877,25 +8901,25 @@ function enforceCountInvariants(group) {
   if (declared < 0 || received < 0 || accepted < 0) {
     throw new AckBuildError(
       ACK_BUILD_ERROR_CODES.X12_ACK_COUNT_MISMATCH,
-      `build999: AK9 counts must be non-negative (declared=${String(declared)}, received=${String(received)}, accepted=${String(accepted)}).`
+      `build999: AK9 counts must be non-negative (declared=${renderCallerValue(declared)}, received=${renderCallerValue(received)}, accepted=${renderCallerValue(accepted)}).`
     );
   }
   if (accepted > received) {
     throw new AckBuildError(
       ACK_BUILD_ERROR_CODES.X12_ACK_COUNT_MISMATCH,
-      `build999: AK9-04 accepted (${String(accepted)}) cannot exceed AK9-03 received (${String(received)}).`
+      `build999: AK9-04 accepted (${renderCallerValue(accepted)}) cannot exceed AK9-03 received (${renderCallerValue(received)}).`
     );
   }
   if (received > declared) {
     throw new AckBuildError(
       ACK_BUILD_ERROR_CODES.X12_ACK_COUNT_MISMATCH,
-      `build999: AK9-03 received (${String(received)}) cannot exceed AK9-02 declared (${String(declared)}).`
+      `build999: AK9-03 received (${renderCallerValue(received)}) cannot exceed AK9-02 declared (${renderCallerValue(declared)}).`
     );
   }
   if (group.transactionResponses.length !== received) {
     throw new AckBuildError(
       ACK_BUILD_ERROR_CODES.X12_ACK_COUNT_MISMATCH,
-      `build999: AK9-03 received (${String(received)}) must equal the number of supplied transaction responses (${String(group.transactionResponses.length)}).`
+      `build999: AK9-03 received (${renderCallerValue(received)}) must equal the number of supplied transaction responses (${renderCallerValue(group.transactionResponses.length)}).`
     );
   }
 }
@@ -8964,7 +8988,7 @@ function buildIk5(response, esc, elementSeparator, segmentTerminator) {
   if (codes.length > 5) {
     throw new AckBuildError(
       ACK_BUILD_ERROR_CODES.X12_ACK_COUNT_MISMATCH,
-      `build999: IK5 accepts up to 5 syntax error codes (IK5-02..IK5-06); ${String(codes.length)} supplied.`
+      `build999: IK5 accepts up to 5 syntax error codes (IK5-02..IK5-06); ${renderCallerValue(codes.length)} supplied.`
     );
   }
   for (const code of codes) parts.push(esc(code));
@@ -8982,7 +9006,7 @@ function buildAk9(group, esc, elementSeparator, segmentTerminator) {
   if (codes.length > 5) {
     throw new AckBuildError(
       ACK_BUILD_ERROR_CODES.X12_ACK_COUNT_MISMATCH,
-      `build999: AK9 accepts up to 5 syntax error codes (AK9-05..AK9-09); ${String(codes.length)} supplied.`
+      `build999: AK9 accepts up to 5 syntax error codes (AK9-05..AK9-09); ${renderCallerValue(codes.length)} supplied.`
     );
   }
   for (const code of codes) parts.push(esc(code));
@@ -9001,7 +9025,7 @@ function padControl8(value, width) {
   if (value.length < width) return "0".repeat(width - value.length) + value;
   throw new AckBuildError(
     ACK_BUILD_ERROR_CODES.X12_ACK_INVALID_SPEC,
-    `build999: control number "${value}" exceeds the ${String(width)}-char spec limit.`
+    `build999: control number ${renderCallerValue(value)} exceeds the ${String(width)}-char spec limit.`
   );
 }
 function expandYY8(yymmdd) {
@@ -9031,7 +9055,7 @@ function enforceAcceptIsClean2(spec) {
   if (spec.ackCode === TA1_ACK_CODES.A && spec.noteCode !== "000") {
     throw new AckBuildError(
       ACK_BUILD_ERROR_CODES.X12_TA1_ACCEPT_WITH_NOTE,
-      `buildTA1: TA1-04 was "A" (Accept) but TA1-05 carried note "${spec.noteCode}". An accept must cite "000" (no error). Use ackCode "E" (accept, errors noted) when the inbound had defects you elected to ignore.`
+      `buildTA1: TA1-04 was "A" (Accept) but TA1-05 carried note ${renderCallerValue(spec.noteCode)}. An accept must cite "000" (no error). Use ackCode "E" (accept, errors noted) when the inbound had defects you elected to ignore.`
     );
   }
 }
@@ -9322,7 +9346,11 @@ function buildTransaction(tx, esc, elementSeparator, segmentTerminator) {
     if (segment.length === 0 || (segment[0] ?? "") === "") {
       throw new X12BuildError(
         X12_BUILD_ERROR_CODES.X12_BUILD_INVALID_SPEC,
-        `buildInterchange: a segment spec in transaction "${esc(tx.transactionSetIdCode)}" has no segment id.`
+        // Rendered from the RAW id, not the `?`-escaped one. `esc` can double
+        // the length, so escaping first made the reported "(N characters)" the
+        // escaped length rather than the caller's: a 100-character all-`?` id
+        // reported 200. The escape exists for the wire, and this is a message.
+        `buildInterchange: a segment spec in transaction ${renderCallerValue(tx.transactionSetIdCode)} has no segment id.`
       );
     }
     bodySegments += joinSeg2(segment.map(esc), elementSeparator, segmentTerminator);
@@ -9348,7 +9376,7 @@ function padControl9(value, width) {
   if (value.length < width) return "0".repeat(width - value.length) + value;
   throw new X12BuildError(
     X12_BUILD_ERROR_CODES.X12_BUILD_INVALID_SPEC,
-    `buildInterchange: control number "${value}" exceeds the ${String(width)}-char spec limit.`
+    `buildInterchange: control number ${renderCallerValue(value)} exceeds the ${String(width)}-char spec limit.`
   );
 }
 function expandYY9(yymmdd) {
@@ -9642,7 +9670,7 @@ var profiles = Object.freeze({
 });
 
 // src/index.ts
-var VERSION = "0.0.4";
+var VERSION = "0.0.5";
 
 exports.ACK_BUILD_ERROR_CODES = ACK_BUILD_ERROR_CODES;
 exports.ALL_WARNING_MESSAGES = ALL_WARNING_MESSAGES;
@@ -9655,6 +9683,8 @@ exports.AUTH_278_LOOP_2000E = AUTH_278_LOOP_2000E;
 exports.AUTH_278_LOOP_2000F = AUTH_278_LOOP_2000F;
 exports.AckBuildError = AckBuildError;
 exports.BALANCE_INVARIANTS = BALANCE_INVARIANTS;
+exports.BUILD_REFUSAL_VALUE_MAX_LENGTH = BUILD_REFUSAL_VALUE_MAX_LENGTH;
+exports.BUILD_REFUSAL_VALUE_MAX_RENDERED = BUILD_REFUSAL_VALUE_MAX_RENDERED;
 exports.CARC = CARC;
 exports.CLAIM_837D_LOOP_2000A = CLAIM_837D_LOOP_2000A;
 exports.CLAIM_837D_LOOP_2300 = CLAIM_837D_LOOP_2300;
@@ -9816,6 +9846,7 @@ exports.partitionWarnings = partitionWarnings;
 exports.pre005010 = pre005010;
 exports.profiles = profiles;
 exports.remitBalanceMismatch = remitBalanceMismatch;
+exports.renderCallerValue = renderCallerValue;
 exports.resolveHiQualifier = resolveHiQualifier;
 exports.segmentCountMismatch = segmentCountMismatch;
 exports.serializeX12 = serializeX12;