@cosyte/astm 0.0.14 → 0.0.15

package/dist/index.d.cts

@@ -2042,7 +2042,10 @@ declare function attachComments(records: readonly AstmRecord[], warnings: AstmRe
  * set (a non-canonical source is normalized to `H|\^&` by default). Normalizing sets the
  * four delimiter **roles**; it does not delete a declaration's surplus characters, so a
  * canonically-declared header that arrived carrying surplus keeps it on the default path
- * too.
+ * too, **except where that surplus could not be read back as surplus, when all of it is
+ * dropped** (see `declarationResidual` below). Emit re-encodes what it read, so bytes
+ * can differ without anything being lost: `O&BRIEN` in a canonical stream goes out as
+ * `O&E&BRIEN`.
  *
  * **One delimiter set for the whole stream.** Every record (including `H`, `M` and `S`)
  * is emitted against the delimiters being emitted with, and the header declares that same
@@ -2063,7 +2066,11 @@ declare function attachComments(records: readonly AstmRecord[], warnings: AstmRe
  * `H|\^&#` rather than losing the `#`. That holds on the **default** canonical path as
  * well as when a set is passed explicitly: the surplus of a canonically-declared header
  * survives normalization, because normalization is about the four roles and the surplus
- * has none.
+ * has none. It stops holding where the surplus itself could not be read back, and then
+ * **the whole surplus is dropped, not the offending character alone**, on the default
+ * path as much as any other: `declarationResidual` states which surpluses those are and
+ * why an all-or-nothing drop is the only one of the available answers that invents
+ * nothing.
  *
  * **Never break framing.** A component leaf that contains a record terminator
  * (`CR`/`LF`) cannot be escaped by the ASTM escape codec (only the four declared
@@ -2084,10 +2091,15 @@ declare function attachComments(records: readonly AstmRecord[], warnings: AstmRe
  * output, which is why they are refused at this one.
  *
  * **One position is not a modeled value and does not keep the byte:** the surplus
- * of a header's delimiter declaration, where any control character is dropped
+ * of a header's delimiter declaration, where a control character is dropped
  * silently (see `declarationResidual` below, where that disposition is argued and
  * where it long predates the frame-layer refusal). So "the record layer carries
  * these bytes" is a statement about values, not about every byte of every line.
+ * Measured, one character at a time in the surplus of an otherwise spec-clean
+ * `H|\^&` header: **31 of the 33 C0/`DEL` characters reach that rule and are
+ * dropped**, with `warnings: []` and no error. The two that do not are `CR` and
+ * `LF`, which never reach it at all, because they end the record while it is being
+ * read and so are never part of any surplus the model carries.
  *
  * **Check the delimiter set before writing.** Three conditions are required for the
  * emitted bytes to read back as the records that produced them (each separator exactly
@@ -2166,10 +2178,12 @@ declare class AstmSerializeError extends Error {
 type AstmSerializeErrorCode = "ASTM_EMIT_UNENCODABLE_VALUE" | "ASTM_EMIT_INVALID_DELIMITERS" | "ASTM_EMIT_TYPE_LETTER_COLLISION";
 /**
  * Escape-encode one component leaf for spec-clean emit: the inverse of
- * `decodeEscapes`. The **escape character itself is encoded first** (`&` → `&E&`)
- * so a later delimiter substitution can never double-encode the `&` it just
- * introduced; then the field / component / repeat delimiters map to their
- * mnemonics.
+ * `decodeEscapes`. Each character is read **once**, in one left-to-right pass, and
+ * written either as itself or as a whole `escape` + mnemonic + `escape` triple
+ * (`&` → `&E&`, the field / component / repeat delimiters → `&F&` / `&S&` / `&R&`).
+ * Nothing this encoder writes is examined again, which is what makes it the exact
+ * inverse of the decoder: the decoder reads the same output one token at a time,
+ * so every triple it meets is a triple this encoder wrote.
  *
  * A `CR`/`LF` in the leaf has no escape mnemonic and would break framing, so it
  * is rejected with an {@link AstmSerializeError} rather than emitted raw, as is a
@@ -2199,7 +2213,11 @@ declare function encodeComponent(leaf: string, d: Delimiters, recordIndex?: numb
  * The header (`H`) is special-cased: its delimiter-definition field is emitted as
  * the **literal** declaration of `d`, never escaped, escaping it would corrupt the
  * very declaration a reader depends on, followed by any characters the modeled
- * declaration carried beyond the three a reader takes its roles from. Manufacturer
+ * declaration carried beyond the three a reader takes its roles from. Those surplus
+ * characters are kept unless the surplus could not be read back as surplus, when
+ * **all** of it is dropped: that covers a surplus carrying the field delimiter or
+ * any control character, and it is silent, because emit has no warning channel.
+ * Manufacturer
  * (`M`) and scientific (`S`) records are reproduced **byte-identically** from their
  * preserved `rawLine` when they are already in `d`, and re-encoded from their fields
  * when they are not, so their fields never collapse into one on the next read.
@@ -2234,7 +2252,11 @@ declare function serializeAstmRecord(record: AstmRecord, d?: Delimiters): string
  * re-parsing it recovers every field. Passing `d` explicitly emits against that set
  * instead, and the header declares it. Normalization replaces the four delimiter
  * **roles**; a header declaration carrying characters beyond the three that hold a
- * role keeps them, on this path as on any other, rather than being truncated.
+ * role keeps them, on this path as on any other, rather than being truncated. The
+ * exception is a surplus that could not be read back as one, carrying the field
+ * delimiter or any control character: there the **whole** surplus is dropped, on
+ * every path including the default one, and silently, because emit returns a bare
+ * string with no channel to say so.
  *
  * **`d` is checked before anything is written.** Each of the four separators must be
  * exactly one character, none may be a record terminator, and no two may share a

package/dist/index.d.ts

@@ -2042,7 +2042,10 @@ declare function attachComments(records: readonly AstmRecord[], warnings: AstmRe
  * set (a non-canonical source is normalized to `H|\^&` by default). Normalizing sets the
  * four delimiter **roles**; it does not delete a declaration's surplus characters, so a
  * canonically-declared header that arrived carrying surplus keeps it on the default path
- * too.
+ * too, **except where that surplus could not be read back as surplus, when all of it is
+ * dropped** (see `declarationResidual` below). Emit re-encodes what it read, so bytes
+ * can differ without anything being lost: `O&BRIEN` in a canonical stream goes out as
+ * `O&E&BRIEN`.
  *
  * **One delimiter set for the whole stream.** Every record (including `H`, `M` and `S`)
  * is emitted against the delimiters being emitted with, and the header declares that same
@@ -2063,7 +2066,11 @@ declare function attachComments(records: readonly AstmRecord[], warnings: AstmRe
  * `H|\^&#` rather than losing the `#`. That holds on the **default** canonical path as
  * well as when a set is passed explicitly: the surplus of a canonically-declared header
  * survives normalization, because normalization is about the four roles and the surplus
- * has none.
+ * has none. It stops holding where the surplus itself could not be read back, and then
+ * **the whole surplus is dropped, not the offending character alone**, on the default
+ * path as much as any other: `declarationResidual` states which surpluses those are and
+ * why an all-or-nothing drop is the only one of the available answers that invents
+ * nothing.
  *
  * **Never break framing.** A component leaf that contains a record terminator
  * (`CR`/`LF`) cannot be escaped by the ASTM escape codec (only the four declared
@@ -2084,10 +2091,15 @@ declare function attachComments(records: readonly AstmRecord[], warnings: AstmRe
  * output, which is why they are refused at this one.
  *
  * **One position is not a modeled value and does not keep the byte:** the surplus
- * of a header's delimiter declaration, where any control character is dropped
+ * of a header's delimiter declaration, where a control character is dropped
  * silently (see `declarationResidual` below, where that disposition is argued and
  * where it long predates the frame-layer refusal). So "the record layer carries
  * these bytes" is a statement about values, not about every byte of every line.
+ * Measured, one character at a time in the surplus of an otherwise spec-clean
+ * `H|\^&` header: **31 of the 33 C0/`DEL` characters reach that rule and are
+ * dropped**, with `warnings: []` and no error. The two that do not are `CR` and
+ * `LF`, which never reach it at all, because they end the record while it is being
+ * read and so are never part of any surplus the model carries.
  *
  * **Check the delimiter set before writing.** Three conditions are required for the
  * emitted bytes to read back as the records that produced them (each separator exactly
@@ -2166,10 +2178,12 @@ declare class AstmSerializeError extends Error {
 type AstmSerializeErrorCode = "ASTM_EMIT_UNENCODABLE_VALUE" | "ASTM_EMIT_INVALID_DELIMITERS" | "ASTM_EMIT_TYPE_LETTER_COLLISION";
 /**
  * Escape-encode one component leaf for spec-clean emit: the inverse of
- * `decodeEscapes`. The **escape character itself is encoded first** (`&` → `&E&`)
- * so a later delimiter substitution can never double-encode the `&` it just
- * introduced; then the field / component / repeat delimiters map to their
- * mnemonics.
+ * `decodeEscapes`. Each character is read **once**, in one left-to-right pass, and
+ * written either as itself or as a whole `escape` + mnemonic + `escape` triple
+ * (`&` → `&E&`, the field / component / repeat delimiters → `&F&` / `&S&` / `&R&`).
+ * Nothing this encoder writes is examined again, which is what makes it the exact
+ * inverse of the decoder: the decoder reads the same output one token at a time,
+ * so every triple it meets is a triple this encoder wrote.
  *
  * A `CR`/`LF` in the leaf has no escape mnemonic and would break framing, so it
  * is rejected with an {@link AstmSerializeError} rather than emitted raw, as is a
@@ -2199,7 +2213,11 @@ declare function encodeComponent(leaf: string, d: Delimiters, recordIndex?: numb
  * The header (`H`) is special-cased: its delimiter-definition field is emitted as
  * the **literal** declaration of `d`, never escaped, escaping it would corrupt the
  * very declaration a reader depends on, followed by any characters the modeled
- * declaration carried beyond the three a reader takes its roles from. Manufacturer
+ * declaration carried beyond the three a reader takes its roles from. Those surplus
+ * characters are kept unless the surplus could not be read back as surplus, when
+ * **all** of it is dropped: that covers a surplus carrying the field delimiter or
+ * any control character, and it is silent, because emit has no warning channel.
+ * Manufacturer
  * (`M`) and scientific (`S`) records are reproduced **byte-identically** from their
  * preserved `rawLine` when they are already in `d`, and re-encoded from their fields
  * when they are not, so their fields never collapse into one on the next read.
@@ -2234,7 +2252,11 @@ declare function serializeAstmRecord(record: AstmRecord, d?: Delimiters): string
  * re-parsing it recovers every field. Passing `d` explicitly emits against that set
  * instead, and the header declares it. Normalization replaces the four delimiter
  * **roles**; a header declaration carrying characters beyond the three that hold a
- * role keeps them, on this path as on any other, rather than being truncated.
+ * role keeps them, on this path as on any other, rather than being truncated. The
+ * exception is a surplus that could not be read back as one, carrying the field
+ * delimiter or any control character: there the **whole** surplus is dropped, on
+ * every path including the default one, and silently, because emit returns a bare
+ * string with no channel to say so.
  *
  * **`d` is checked before anything is written.** Each of the four separators must be
  * exactly one character, none may be a record terminator, and no two may share a

package/dist/index.mjs

@@ -1433,6 +1433,13 @@ function encodeComponent(leaf, d, recordIndex) {
   assertEmittableDelimiters(d, recordIndex);
   return encodeLeaf(leaf, d, recordIndex);
 }
+function escapeMnemonic(ch, d) {
+  if (ch === d.escape) return "E";
+  if (ch === d.field) return "F";
+  if (ch === d.component) return "S";
+  if (ch === d.repeat) return "R";
+  return void 0;
+}
 function encodeLeaf(leaf, d, recordIndex) {
   if (leaf.includes("\r") || leaf.includes("\n")) {
     throw new AstmSerializeError(
@@ -1440,7 +1447,13 @@ function encodeLeaf(leaf, d, recordIndex) {
       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);
+  let out = "";
+  for (let i = 0; i < leaf.length; i += 1) {
+    const ch = leaf.charAt(i);
+    const mnemonic = escapeMnemonic(ch, d);
+    out += mnemonic === void 0 ? ch : d.escape + mnemonic + d.escape;
+  }
+  return out;
 }
 function encodeField(repeats, d, recordIndex) {
   return repeats.map((rep) => rep.map((c) => encodeLeaf(c, d, recordIndex)).join(d.component)).join(d.repeat);
@@ -2356,7 +2369,7 @@ function concatBytes3(chunks) {
 }
 
 // src/index.ts
-var VERSION = "0.0.14";
+var VERSION = "0.0.15";
 
 export { ALL_ASTM_WARNING_CODES, AMBIGUOUS_CODES, ACK as ASTM_ACK, ENQ as ASTM_ENQ, EOT as ASTM_EOT, NAK as ASTM_NAK, AstmAmbiguousStreamError, AstmFrameEncodeError, AstmFrameStrictError, AstmParseError, AstmProfileDefinitionError, AstmSerializeError, AstmStrictError, CANONICAL_DELIMITERS, FATAL_CODES, FRAME_WARNING_CODES, LIVD_WARNING_CODES, LTP_WARNING_CODES, SAFETY_CRITICAL_CODES, TOLERABLE_CODES, VERSION, WARNING_CODES, ambiguousMessageKind, ambiguousValueSplit, applyAstmProfile, applyAstmProfileToWarnings, applyLivd, astmDateToLocalISO, astmProfiles, attachComments, buildAstmMessage, classifyMessage, comments, commentsFor, composeAstmFrames, computeChecksum, decodeAstmFrames, decodeEscapes, deepFreeze, defineAstmProfile, defineLivdCatalog, delimitersRedeclared, detectFraming, encodeComponent, fieldScalar, fieldsUnseparated, frameBadChecksum, frameOversize, frameSequenceGap, frameUnterminated, getAstmProfile, getDefaultAstmProfile, interpretAbnormalFlag, interpretResultStatus, isNonStandard, isSafetyCriticalCode, listAstmProfiles, livdAmbiguousMapping, livdUnmappedCode, lookupLivdForRecord, ltpAmbiguousTransport, ltpFrameRejected, ltpInitialState, ltpReduce, ltpUnexpectedEvent, messages, nonStandardDelimiters, orders, orphanComment, parseAstmDate, parseAstmRecords, parseChecksumHex, parseFramedAstm, parseReferenceRange, partialTimestamp, patient, primaryCode, profileQuirkApplied, query, readDelimiters, recognizeUniversalTestId, resolveProfileTransport, results, serializeAstmRecord, serializeAstmRecords, serializeField, serializeFramedAstm, setDefaultAstmProfile, splitEscapeAware, toChecksumHex, tokenizeHeader, tokenizeRecord, undefinedAbnormalFlag, undefinedResultStatus, uninterpretedQueryStatus, unitsAbsent, unknownEscapeSequence, unknownRecordType, unpairedEscapeCharacter, unparseableReferenceRange, unreadableRedeclaration };
 //# sourceMappingURL=index.mjs.map