@blamejs/pki 0.8.55 → 0.8.57

package/lib/schema-attrcert.js

@@ -736,7 +736,7 @@ var decodeExtensions = DOOR.decodeExtensions;
  */
 var decodeExtension = DOOR.decodeExtension;
 
-module.exports = {
+module.exports = intrinsic.freeze({
   parse: parse,
   parseV1: parseV1,
   pemDecode: pemDecode,
@@ -749,4 +749,4 @@ module.exports = {
   readGeneralName: readGeneralName,
   validateAttributeValue: validateAttributeValue,
   validateExtensionValue: validateExtensionValue,
-};
+});

package/lib/schema-cmc.js

@@ -802,7 +802,7 @@ function parse(input, callerOpts) {
   return body;
 }
 
-module.exports = {
+module.exports = Object.freeze({
   parseEncryptedPop: parseEncryptedPop,
   parseTaggedRequest: parseTaggedRequest,
   parse: parse,
@@ -810,4 +810,4 @@ module.exports = {
   parsePkiResponse: parsePkiResponse,
   STATUS_BY_VALUE: STATUS_BY_VALUE,
   FAIL_INFO_BY_VALUE: FAIL_INFO_BY_VALUE,
-};
+});

package/lib/schema-cmp.js

@@ -883,7 +883,7 @@ function _readKem(sch, der, code, what) {
 function readKemBMParameter(p) { return _readKem(KEM_BM_PARAMETER, p, "cmp/bad-kem-data", "KemBMParameter"); }
 function readKemCiphertextInfo(d) { return _readKem(KEM_CIPHERTEXT_INFO, d, "cmp/bad-kem-ciphertext", "KemCiphertextInfo"); }
 
-module.exports = {
+module.exports = Object.freeze({
   parse: parse,
   pemDecode: pemDecode,
   pemEncode: pemEncode,
@@ -897,4 +897,4 @@ module.exports = {
   readName: readName,
   readKemBMParameter: readKemBMParameter,
   readKemCiphertextInfo: readKemCiphertextInfo,
-};
+});

package/lib/schema-cms.js

@@ -34,8 +34,13 @@
  *   (sec. 5.4); `authAttrsBytes` plays the same role for the sec. 9.2 MAC input and the
  *   RFC 5083 sec. 2.2 AAD. Embedded certificates and CRLs are surfaced as raw DER +
  *   their outer tag, validated against the closed CertificateChoices /
- *   RevocationInfoChoice tag sets, so an obsolete alternative never fails the
- *   parse but an out-of-set element does. DER-only, fail-closed.
+ *   RevocationInfoChoice tag sets, so an out-of-set element fails the parse. A
+ *   certificate alternative is surfaced raw whatever it holds; a `crls` entry in the
+ *   `other [1]` arm is read as RFC 5652 sec. 10.2.1 `OtherRevocationInfoFormat`,
+ *   which names its format and, for RFC 5940 `id-ri-ocsp-response`, carries the
+ *   embedded OCSP response as a record revocation checking takes directly. An
+ *   unrecognized format stays opaque; a malformed one fails the parse. DER-only,
+ *   fail-closed.
  *
  * @card
  *   Parse DER / PEM CMS (RFC 5652 / 5083 / 9629) into structured, validated fields:
@@ -49,6 +54,9 @@ var schema = require("./schema-engine");
 var pkix = require("./schema-pkix");
 var guard = require("./guard-all");
 var oid = require("./oid");
+/** @internal The OCSP response schema, for the RFC 5940 `crls` arm. `schema-ocsp` requires neither
+ *  this module nor anything that reaches it, so this is an ordinary top-of-file require. */
+var ocspSchema = require("./schema-ocsp");
 var frameworkError = require("./framework-error");
 var schemaX509 = require("./schema-x509");
 var schemaCrl = require("./schema-crl");
@@ -383,6 +391,78 @@ var CRL_CHOICE_TAGS = Object.assign(Object.create(null), {
   universal: Object.create(null),
   context: Object.assign(Object.create(null), { 1: true }),
 });
+
+/** @internal RFC 5652 sec. 10.2.1's `other` arm:
+ *
+ *    OtherRevocationInfoFormat ::= SEQUENCE { otherRevInfoFormat OBJECT IDENTIFIER, otherRevInfo ANY }
+ *
+ *  Exactly two components. OpenSSL's `crypto/cms/cms_asn1.c` makes `otherRevInfo` optional, so it both
+ *  accepts and can emit an entry carrying no revocation information at all; the ASN.1 above has no
+ *  OPTIONAL and the one-element form is refused here. */
+var OTHER_REV_INFO = schema.seq([
+  schema.field("otherRevInfoFormat", schema.oidLeaf()),
+  schema.field("otherRevInfo", schema.any()),
+], {
+  assert: "implicit", implicitTag: 1, arity: { exact: 2 },
+  code: "cms/bad-other-rev-info", what: "OtherRevocationInfoFormat",
+  build: function (m) {
+    return {
+      otherRevInfoFormat: m.fields.otherRevInfoFormat.value,
+      otherRevInfoNode: m.fields.otherRevInfo.value,
+    };
+  },
+});
+var OID_ID_RI_OCSP_RESPONSE = oid.byName("id-ri-ocsp-response");
+
+/** @internal The crls element mapper, which unlike `rawChoiceElement` needs the walk's own ctx: the
+ *  `other` arm's interior is decoded under the caller's caps and budget rather than at defaults.
+ *
+ *  The universal arm is surfaced raw as before, with one new refusal: RFC 5940 sec. 2 states that an
+ *  OCSP response is carried in the `other` arm, so a response placed where a CertificateList belongs
+ *  is a smuggle. It is detected POSITIVELY, by the OCSP module's own response detector, because the
+ *  CRL detector answers false for shapes that are not full CertificateLists and "not a CRL" would
+ *  therefore refuse more than sec. 2 forbids. */
+/** @internal The mapper bound to one walk's ctx, so it fits the one-argument shape a list projection
+ *  passes. The ctx is the walk's own, not a fresh one: that is what carries the caller's caps and the
+ *  budget already being spent into the embedded response. */
+function _mapCrlsWith(ctx, code, what) {
+  var mapper = crlChoiceElement(code, what);
+  return function (item) { return mapper(item, ctx); };
+}
+function crlChoiceElement(code, what) {
+  return function (item, ctx) {
+    var n = item.node;
+    var byClass = CRL_CHOICE_TAGS[n.tagClass];
+    if (!n.constructed || !byClass || byClass[n.tagNumber] !== true) {
+      throw NS.E(code, what + " element tag is outside the closed CHOICE set (RFC 5652 sec. 10.2.1-sec. 10.2.2)");
+    }
+    var out = rawElement(item);
+    if (n.tagClass !== "context") {
+      if (ocspSchema.matchesResponse(n)) {
+        throw NS.E("cms/misplaced-ocsp-response", "an OCSP response is carried in the other [1] " +
+          "RevocationInfoChoice arm under id-ri-ocsp-response, not in the CertificateList arm (RFC 5940 sec. 2)");
+      }
+      return out;
+    }
+    var other = schema.walk(OTHER_REV_INFO, n, ctx).result;
+    out.otherRevInfoFormat = other.otherRevInfoFormat;
+    out.otherRevInfoFormatName = ctx.oid.name(other.otherRevInfoFormat) || null;
+    out.otherRevInfoBytes = other.otherRevInfoNode.bytes;
+    out.ocspResponse = null;
+    if (other.otherRevInfoFormat === OID_ID_RI_OCSP_RESPONSE) {
+      var resp = ocspSchema.walkOcspResponse(other.otherRevInfoNode, ctx);
+      /** @internal RFC 5940 sec. 3: the carried response states a status. A `tryLater` or `malformed`
+       *  OCSPResponse is a VALID OCSPResponse that conveys no revocation information, so it is refused
+       *  HERE rather than in the OCSP module, whose standalone door must keep accepting it. */
+      if (resp.responseStatus.code !== 0) {
+        throw NS.E("cms/bad-ocsp-rev-info", "an id-ri-ocsp-response revocation entry carries a " +
+          resp.responseStatus.name + " OCSP response, which states no revocation status (RFC 5940 sec. 3)");
+      }
+      out.ocspResponse = resp;
+    }
+    return out;
+  };
+}
 CERT_CHOICE_TAGS.universal[asn1.TAGS.SEQUENCE] = true;
 CRL_CHOICE_TAGS.universal[asn1.TAGS.SEQUENCE] = true;
 function rawChoiceElement(allowed, code, what) {
@@ -648,7 +728,8 @@ var SIGNED_DATA = schema.seq([
     var version = m.fields.version.value;
     var encapContentInfo = m.fields.encapContentInfo.value.result;
     var certificates = m.fields.certificates.present ? m.fields.certificates.value.items.map(rawChoiceElement(CERT_CHOICE_TAGS, "cms/bad-certificates", "certificates")) : [];
-    var crls = m.fields.crls.present ? m.fields.crls.value.items.map(rawChoiceElement(CRL_CHOICE_TAGS, "cms/bad-crls", "crls")) : [];
+    var crls = m.fields.crls.present
+      ? guard.list.copyMap(m.fields.crls.value.items, _mapCrlsWith(ctx, "cms/bad-crls", "crls")) : [];
     var signerInfos = m.fields.signerInfos.value.items.map(function (it) { return it.value.result; });
 
     if (encapContentInfo.eContentType !== OID_DATA) {
@@ -909,10 +990,16 @@ var ORIGINATOR_INFO = schema.seq([
   schema.optional("crls", schema.implicitSetOf(1, schema.any(), { min: 1, code: "cms/bad-originator-crls", what: "crls" }), { tag: 1 }),
 ], {
   assert: "constructed", code: "cms/bad-originator-info", what: "OriginatorInfo",
-  build: function (m) {
+  /** @internal The build takes `ctx` because the crls mapper decodes the RFC 5940 arm under the
+   *  caller's own caps and budget. This one record is shared by EnvelopedData (RFC 5652 sec. 6.1),
+   *  AuthenticatedData (sec. 9.1) and AuthEnvelopedData (RFC 5083 sec. 2.1), so decoding only in
+   *  SignedData would leave three of the four content types RFC 5940 sec. 1 names undecoded. */
+  build: function (m, ctx) {
     return {
       certs: m.fields.certs.present ? m.fields.certs.value.items.map(rawChoiceElement(CERT_CHOICE_TAGS, "cms/bad-originator-certs", "OriginatorInfo certs")) : [],
-      crls: m.fields.crls.present ? m.fields.crls.value.items.map(rawChoiceElement(CRL_CHOICE_TAGS, "cms/bad-originator-crls", "OriginatorInfo crls")) : [],
+      crls: m.fields.crls.present
+        ? guard.list.copyMap(m.fields.crls.value.items,
+          _mapCrlsWith(ctx, "cms/bad-originator-crls", "OriginatorInfo crls")) : [],
     };
   },
 });
@@ -1184,7 +1271,14 @@ var CONTENT_INFO = schema.seq([
  * unauthAttrs }` (`aead` holds the validated AES-GCM/CCM nonce + ICV length, or
  * `null` for an unrecognized algorithm). A KEM recipient (RFC 9629) surfaces as
  * `{ type: "ori", oriType, oriValue, kemri }` with the parsed KEMRecipientInfo in
- * `kemri`. Every result additionally carries `contentType` (the dotted OID) and
+ * `kemri`. A `crls` entry is `{ bytes, tagClass, tagNumber }` for a CertificateList;
+ * an entry in the `other [1]` arm additionally carries `otherRevInfoFormat` (dotted),
+ * `otherRevInfoFormatName` (or `null`), `otherRevInfoBytes` (the raw ANY TLV) and,
+ * for RFC 5940 `id-ri-ocsp-response`, `ocspResponse` holding the embedded response
+ * as a record `pki.path.ocspChecker` and `pki.path.verifyOcspResponse` take
+ * directly. A response whose `responseType` is one this build does not decode keeps
+ * its envelope in `ocspResponse` with `basicResponse` null and the body in
+ * `responseBytes.response` as it arrived. `originatorInfo.crls` carries the same shapes. Every result additionally carries `contentType` (the dotted OID) and
  * `contentTypeName` (its registry name) naming which of the five shapes was
  * dispatched. The raw byte ranges an external verifier hashes (`eContent`,
  * `signature`, `signedAttrsBytes`, `authAttrsBytes`, `mac`) are surfaced
@@ -1337,16 +1431,27 @@ function parseCertsOnly(der, E, prefix, maxCerts, requireCert) {
   } else if (allCerts.length === 0 && allCrls.length === 0) {
     throw E(prefix + "/no-certificates", "a certs-only message must contain at least one certificate or CRL (RFC 8551 sec. 3.8)");
   }
+  /** @internal `maxCerts` caps the certificates and CRLs PARSED and RETURNED, which is a resource
+   *  bound. It may not decide which messages are accepted. The tag-class test reads a field off an
+   *  entry the parse already produced and costs nothing, so it runs over EVERY entry before the cap
+   *  is applied: taken after it, a cap leaving no room for the crls dropped a tagged entry silently,
+   *  so a capped reader accepted a message an uncapped reader refuses and handed back an empty crls
+   *  list where revocation information had been. Only the X.509 and CRL parsing below stays bounded,
+   *  which is the work the bound exists for. */
+  for (var ci = 0; ci < allCerts.length; ci++) {
+    if (allCerts[ci].tagClass !== "universal") throw E(prefix + "/bad-certificate-choice", "a certs-only response exchanges plain X.509 certificates; a tagged CertificateChoices alternative is not permitted (RFC 5272)");
+  }
+  for (var cj = 0; cj < allCrls.length; cj++) {
+    if (allCrls[cj].tagClass !== "universal") throw E(prefix + "/bad-crl", "a certs-only response CRL must be a plain X.509 CertificateList, not a tagged otherRevInfo alternative (RFC 5652 sec. 10.2.1)");
+  }
   var certs = (maxCerts != null && allCerts.length > maxCerts) ? allCerts.slice(0, maxCerts) : allCerts;
   for (var i = 0; i < certs.length; i++) {
-    if (certs[i].tagClass !== "universal") throw E(prefix + "/bad-certificate-choice", "a certs-only response exchanges plain X.509 certificates; a tagged CertificateChoices alternative is not permitted (RFC 5272)");
     try { schemaX509.parse(certs[i].bytes); }
     catch (e) { throw E(prefix + "/bad-certificate", "a certs-only response carried a non-certificate in its certificates field (RFC 5272 sec. 4.1)", e); }
   }
   var crlCap = maxCerts != null ? (maxCerts - certs.length) : null;
   var crls = (crlCap != null && allCrls.length > crlCap) ? allCrls.slice(0, crlCap) : allCrls;
   for (var j = 0; j < crls.length; j++) {
-    if (crls[j].tagClass !== "universal") throw E(prefix + "/bad-crl", "a certs-only response CRL must be a plain X.509 CertificateList, not a tagged otherRevInfo alternative (RFC 5652 sec. 10.2.1)");
     try { schemaCrl.parse(crls[j].bytes); }
     catch (e) { throw E(prefix + "/bad-crl", "a certs-only response carried a non-CRL in its crls field", e); }
   }
@@ -1465,7 +1570,7 @@ function sameAlgorithmModuloDefaults(a, c) {
   return ak === ck;
 }
 
-module.exports = {
+module.exports = Object.freeze({
   parse: parse,
   parseAlgorithmProtection: parseAlgorithmProtection,
   algorithmProtectionReport: algorithmProtectionReport,   // @internal
@@ -1490,4 +1595,4 @@ module.exports = {
   AEAD_ALGS: AEAD_ALGS,
   AEAD_GCM_ICVLENS: AEAD_GCM_ICVLENS,
   AEAD_CCM_ICVLENS: AEAD_CCM_ICVLENS,
-};
+});

package/lib/schema-crmf.js

@@ -515,7 +515,7 @@ var decodeExtensions = DOOR.decodeExtensions;
  */
 var decodeExtension = DOOR.decodeExtension;
 
-module.exports = {
+module.exports = intrinsic.freeze({
   parse: parse,
   pemDecode: pemDecode,
   pemEncode: pemEncode,
@@ -525,4 +525,4 @@ module.exports = {
   walkCertReqMessages: walkCertReqMessages,
   walkCertTemplate: walkCertTemplate,
   certReqMessagesSchema: CERT_REQ_MESSAGES,
-};
+});

package/lib/schema-csr.js

@@ -383,7 +383,7 @@ var decodeExtensions = DOOR.decodeExtensions;
  */
 var decodeExtension = DOOR.decodeExtension;
 
-module.exports = {
+module.exports = intrinsic.freeze({
   parse: parse,
   pemDecode: pemDecode,
   pemEncode: pemEncode,
@@ -391,4 +391,4 @@ module.exports = {
   decodeExtensions: decodeExtensions,
   decodeExtension: decodeExtension,
   certificationRequestSchema: CERTIFICATION_REQUEST,
-};
+});

package/lib/schema-ocsp.js

@@ -40,6 +40,7 @@ var oid = require("./oid");
 var constants = require("./constants");
 var frameworkError = require("./framework-error");
 var intrinsic = require("./guard-intrinsic");
+var guard = require("./guard-all");
 var _hasOwn = intrinsic.hasOwn;
 var _String = intrinsic.String;
 
@@ -319,18 +320,24 @@ var RESPONSE_BYTES = schema.seq([
   schema.field("response", schema.octetString()),
 ], {
   assert: "sequence", arity: { exact: 2 }, code: "ocsp/bad-response-bytes", what: "ResponseBytes",
+  /** @internal RFC 6960 sec. 4.2.1 dispatches the body on `responseType`, so a type this build does
+   *  not read leaves `basicResponse` null and the body in `response` exactly as it arrived. The
+   *  envelope is the part every reader shares, and which bodies this build decodes is its own support
+   *  limit rather than a shape rule: `parseResponse` refuses an unread body at its door, where the
+   *  caller asked for a response to read, and a response carried inside another structure stays
+   *  readable as far as its envelope goes. A body that claims id-pkix-ocsp-basic is still decoded,
+   *  and still refused when it is not one. */
   build: function (m, ctx) {
     var responseType = m.fields.responseType.value;
     var raw = m.fields.response.value;
-    if (responseType !== OID_OCSP_BASIC) {
-      throw NS.E("ocsp/unsupported-response-type", (ctx.oid.name(responseType) || responseType) + " is not id-pkix-ocsp-basic (RFC 6960 sec. 4.2.1)");
-    }
     return {
       responseType: responseType,
       responseTypeName: ctx.oid.name(responseType) || null,
       response: raw,
-      basicResponse: schema.embeddedDer(BASIC_OCSP_RESPONSE, raw, ctx,
-        { code: "ocsp/bad-der", what: "BasicOCSPResponse" }).result,
+      basicResponse: responseType === OID_OCSP_BASIC
+        ? schema.embeddedDer(BASIC_OCSP_RESPONSE, raw, ctx,
+          { code: "ocsp/bad-der", what: "BasicOCSPResponse" }).result
+        : null,
     };
   },
 });
@@ -506,7 +513,19 @@ var parseRequest = pkix.makeParser({ pemLabel: "OCSP REQUEST", PemError: PemErro
  *     above it, or an option outside this set, is refused. A parse that exceeds one is
  *     refused with the `/too-large` code of this format.
  */
-var parseResponse = pkix.makeRecordingParser({ pemLabel: "OCSP RESPONSE", PemError: PemError, ErrorClass: OcspError, prefix: "ocsp", what: "OCSP response", topSchema: OCSP_RESPONSE, ns: NS }, "ocspResponse");
+var _parseResponseRecorded = pkix.makeRecordingParser({ pemLabel: "OCSP RESPONSE", PemError: PemError, ErrorClass: OcspError, prefix: "ocsp", what: "OCSP response", topSchema: OCSP_RESPONSE, ns: NS }, "ocspResponse");
+/** @internal The decision is made on `responseType`, the field RFC 6960 sec. 4.2.1 dispatches on,
+ *  rather than on the absent `basicResponse` that follows from it. A non-successful response carries
+ *  no responseBytes at all and keeps reaching the caller, which is the status a live responder
+ *  returns. */
+function parseResponse(input, caps) {
+  var out = _parseResponseRecorded(input, caps);
+  var rb = out.responseBytes;
+  if (rb && rb.responseType !== OID_OCSP_BASIC) {
+    throw NS.E("ocsp/unsupported-response-type", (rb.responseTypeName || rb.responseType) + " is not id-pkix-ocsp-basic (RFC 6960 sec. 4.2.1)");
+  }
+  return out;
+}
 
 /**
  * @primitive  pki.schema.ocsp.pemDecode
@@ -580,9 +599,25 @@ function matchesRequest(root) {
   return true;
 }
 
+/** @internal Walk an ALREADY-DECODED OCSPResponse node under the caller's own parse resources, for a
+ *  carrier that embeds one: RFC 5940 sec. 2 puts an OCSPResponse in a CMS `crls` field, and the CMS
+ *  parse reaches it with a node it has already decoded and a budget it is already spending.
+ *  `parseResponse(bytes)` cannot serve that: it re-decodes from scratch and starts a fresh budget, so
+ *  a caller's tightened caps would not reach the embedded walk. `withResources` carries the caps and
+ *  the budget while keeping this module's own error class, so a malformed embedded response still
+ *  reports an `ocsp/*` code. The record is a recording one, so `guard.parsed.fromTrustedSource`
+ *  accepts it wherever a parsed response is taken and a rebuilt copy is still refused. The re-decode
+ *  this walker performs on raw DER is STRICT, unlike the CMS one: an OCSPResponse has no
+ *  BER-tolerant door. */
+var walkOcspResponse = guard.parsed.recordingWalker("ocspResponse", function (node, ctx) {
+  return schema.walk(OCSP_RESPONSE, node, schema.withResources(NS, ctx)).result;
+  // allow:bare-decode the re-decode a recording walker performs on raw DER a caller hands it, outside any parse.
+}, function (der) { return asn1.decode(der); });
+
 module.exports = {
   parseRequest: parseRequest,
   parseResponse: parseResponse,
+  walkOcspResponse: walkOcspResponse,
   pemDecode: pemDecode,
   pemEncode: pemEncode,
   matchesRequest: matchesRequest,

package/lib/schema-pkix.js

@@ -2630,7 +2630,7 @@ function dnsNameProblem(s) {
   if (_hasWhitespace(s)) return "whitespace";
   if (_charAt(s, 0) === "." || _charAt(s, s.length - 1) === ".") return "leading/trailing dot";
   if (_strIndexOf(s, "_") !== -1) return "underscore forbidden in dNSName";
-  var labels = _split(s, ".");
+  var labels = intrinsic.splitChar(s, 46);
   for (var i = 0; i < labels.length; i++) {
     var label = labels[i];
     if (label.length === 0) return "empty label";
@@ -2644,7 +2644,7 @@ function dnsNameProblem(s) {
   return null;
 }
 
-module.exports = {
+module.exports = intrinsic.freeze({
   dnsNameProblem: dnsNameProblem,
   pemDecode: pemDecode,
   pemDecodeAll: pemDecodeAll,
@@ -2720,5 +2720,5 @@ module.exports = {
   attribute: attribute,
   extension: extension,
   extensions: extensions,
-};
+});
 

package/lib/schema-x509.js

@@ -337,7 +337,7 @@ var decodeExtensions = DOOR.decodeExtensions;
  */
 var decodeExtension = DOOR.decodeExtension;
 
-module.exports = {
+module.exports = intrinsic.freeze({
   parse:     parse,
   pemDecode: pemDecode,
   pemEncode: pemEncode,
@@ -350,4 +350,4 @@ module.exports = {
    *  Not on the curated `pki.schema.x509` surface. */
   tbsCertificateSchema: TBS_CERTIFICATE_ALONE,
   certificateSchema:    CERTIFICATE,
-};
+});

package/lib/sigstore.js

@@ -1501,7 +1501,7 @@ var SAN_OID = oid.byName("subjectAltName");
  * reports for a certificate it cannot read, so the fix adds no new code to the public surface. */
 var _sanDecoder = pkix.certExtensionDecoders(
   pkix.makeNS("x509", frameworkError.CertificateError, oid)).byOid[SAN_OID];
-var FULCIO_PREFIX = _join(_arraySlice(_split(oid.byName("otherName"), "."), 0, -1), ".") + ".";
+var FULCIO_PREFIX = _join(_arraySlice(intrinsic.splitChar(oid.byName("otherName"), 46), 0, -1), ".") + ".";
 function _identity(leaf) {
   var out = { san: null, extensions: _create(null) };
   try {

package/lib/tlog.js

@@ -391,7 +391,7 @@ function parseNote(input) {
   var signedBytes = _subarray(buf, 0, end);
   var rest = _bufToString(_subarray(buf, end + 1), "utf8");
   var signatures = [];
-  var lines = rest.length === 0 ? [] : _split(rest, "\n");
+  var lines = rest.length === 0 ? [] : intrinsic.splitChar(rest, 10);
   /** @internal A note ends with a newline, so the split leaves one empty tail element; anything
    *  else after it is a line the format does not have. The drop goes through the capture: dispatching
    *  through `Array.prototype.pop` let a replacement pop TWICE, taking the last signature line with the
@@ -603,7 +603,7 @@ function parseCheckpoint(input) {
   var note = parseNote(input);
   var text = note.text;
   /** @internal The text ends with a newline, so the split leaves an empty tail that is not a line. */
-  var lines = _split(text, "\n");
+  var lines = intrinsic.splitChar(text, 10);
   if (lines.length > 0 && lines[lines.length - 1] === "") _pop(lines);
   if (lines.length < MIN_CHECKPOINT_LINES) {
     throw _err("tlog/bad-checkpoint", "a checkpoint body is an origin, a tree size and a root hash, got " +
@@ -918,7 +918,7 @@ function _segmentDigits(segment, expectX) {
  */
 function parseTilePath(path) {
   if (typeof path !== "string") throw _err("tlog/bad-input", "a tile path is a string");
-  var parts = _split(path, "/");
+  var parts = intrinsic.splitChar(path, 47);
   if (parts.length < 3 || parts[0] !== "tile") {
     throw _err("tlog/bad-tile", "a tile path begins tile/<level>/<index>");
   }
@@ -1034,7 +1034,10 @@ function parseEntryBundle(bytes) {
     if (p + 2 > buf.length) {
       throw _err("tlog/bad-bundle", "a trailing byte at offset " + p + " is not a whole length prefix");
     }
-    var len = buf.readUInt16BE(p);
+    /** @internal The length prefix comes from the capture. It decides where this entry ends and the
+     *  next begins, so a replaced reader hands the bounds check below a length the bundle does not
+     *  state and the entry that is parsed is a different run of bytes. */
+    var len = intrinsic.readUInt16BE(buf, p);
     p += 2;
     if (p + len > buf.length) {
       throw _err("tlog/bad-bundle", "the entry at offset " + (p - 2) + " declares " + len +