@blamejs/pki 0.8.30 → 0.8.48

package/lib/est.js

@@ -76,6 +76,12 @@ var intrinsic = require("./guard-intrinsic");
 var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
 var _strSlice = intrinsic.uncurry(String.prototype.slice);
 var _toLowerCase = intrinsic.uncurry(String.prototype.toLowerCase);
+/** @internal Each verb gates its body on a resolved promise and returns its refusals as rejected ones,
+ *  and both build from the RECEIVER, so reading the global binding at the call decides whether the body
+ *  runs and whether a refusal stays a refusal. Taken at load. */
+var _Promise = intrinsic.Promise;
+var _promiseResolve = intrinsic.uncurry(intrinsic.promiseResolve);
+var _promiseReject = intrinsic.uncurry(intrinsic.promiseReject);
 var pkix = require("./schema-pkix");
 var _hasOwn = intrinsic.hasOwn;
 var httpTransport = require("./http-transport");
@@ -151,7 +157,7 @@ function _knownOpts(opts, known, verb) {
 }
 
 function _snapProxy(opts) { return httpTransport.snapshotProxy(opts.proxy); }
-function _rej(e) { return Promise.reject(e); }
+function _rej(e) { return _promiseReject(_Promise, e); }
 
 
 /**
@@ -568,7 +574,14 @@ var NOT_IMPLEMENTED_OPS = intrinsic.assign(intrinsic.create(null), { fullcmc: 1
  *   var v = pki.est.classifyResponse(202, { "retry-after": "120" }, "", { op: "simpleenroll" });
  *   v.retryAfterSeconds;   // -> 120
  */
+/** @internal Every branch below answers with a fresh classification object, and the sentinel is added
+ * at the one exit rather than at each `return`, so a branch added later carries it without being
+ * told to. */
 function classifyResponse(status, headers, body, opts) {
+  return guard.verdict.shield(_classifyResponse(status, headers, body, opts));
+}
+
+function _classifyResponse(status, headers, body, opts) {
   opts = opts || {};
   opts = _knownOpts(opts, CLASSIFY_OPTS, "classifyResponse");
   var op = opts.op;
@@ -589,22 +602,22 @@ function classifyResponse(status, headers, body, opts) {
         throw E("est/bad-content-type", "a 200 " + op + " response must carry content-type " + spec.media + (spec.smimeTypes ? "; smime-type=" + spec.smimeTypes.join(" or ") : "") + ", got " + JSON.stringify(ct));
       }
     }
-    return { status: "ok", contentType: ct };
+    return guard.verdict.of({ status: "ok", contentType: ct });
   }
   if (status === 202) {
     var ra = h["retry-after"];
     if (ra === undefined || ra === null || String(ra).trim() === "") throw E("est/missing-retry-after", "an HTTP 202 EST response must include Retry-After (RFC 7030 sec. 4.2.3)");
     var raStr = String(ra).trim();
     var parsed = retryAfter.parse(raStr, { now: opts.now, E: E, code: "est/bad-retry-after" });
-    return { status: "retry", retryAfter: raStr, retryAfterSeconds: parsed.retryAfterSeconds, retryAfterDate: parsed.retryAfterDate };
+    return guard.verdict.of({ status: "retry", retryAfter: raStr, retryAfterSeconds: parsed.retryAfterSeconds, retryAfterDate: parsed.retryAfterDate });
   }
-  if (status === 501 && NOT_IMPLEMENTED_OPS[op]) return { status: "not-implemented", httpStatus: status };
+  if (status === 501 && NOT_IMPLEMENTED_OPS[op]) return guard.verdict.of({ status: "not-implemented", httpStatus: status });
   if (status === 204 || status === 404) {
-    if (op === "csrattrs") return { status: "none-available" };
-    if (status === 404 && NOT_IMPLEMENTED_OPS[op]) return { status: "not-implemented", httpStatus: status };
+    if (op === "csrattrs") return guard.verdict.of({ status: "none-available" });
+    if (status === 404 && NOT_IMPLEMENTED_OPS[op]) return guard.verdict.of({ status: "not-implemented", httpStatus: status });
     throw E("est/http-error", "HTTP " + status + " is not a valid " + op + " response");
   }
-  if (status >= 300 && status < 400) return { status: "redirect", location: h["location"] || null };
+  if (status >= 300 && status < 400) return guard.verdict.of({ status: "redirect", location: h["location"] || null });
   if (status >= 400) {
     var text;
     if (Buffer.isBuffer(body)) {
@@ -617,7 +630,7 @@ function classifyResponse(status, headers, body, opts) {
     }
     throw E("est/http-error", "EST server returned HTTP " + status + (text ? ": " + text : ""));
   }
-  return { status: "unexpected", httpStatus: status };
+  return guard.verdict.of({ status: "unexpected", httpStatus: status });
 }
 
 
@@ -1387,12 +1400,12 @@ function _fullcmcResult(res, opts, wanted, sent) {
     var certs = parseCertsOnly(der);
     var issuedCerts = _correlateIssued(certs.certificates, wanted, "certs-only");
     var issued = issuedCerts[0];
-    return { outcome: "issued", certificate: issued, issuedCertificates: issuedCerts,
+    return guard.verdict.of({ outcome: "issued", certificate: issued, issuedCertificates: issuedCerts,
       certificates: certs.certificates, crls: certs.crls,
       controls: [], statuses: [], publishTrustAnchors: null, trusted: false,
       signatureVerified: false,
       bound: { transactionId: false, senderNonce: false, dataReturn: false, bodyPartIDs: false },
-      boundToRequest: false };
+      boundToRequest: false });
   }
   return cmcVerify.verify(der, sent).then(function (verdict) {
     if (verdict.outcome !== "issued") return verdict;
@@ -1405,7 +1418,7 @@ function _fullcmcResult(res, opts, wanted, sent) {
 }
 
 function _tryDecodeCmcFault(res, sent) {
-  return Promise.resolve().then(function () {
+  return _promiseResolve(_Promise, undefined).then(function () {
     var pt = _partMediaType(_ciHeader(res.headers, "content-type"));
     if (pt.media !== "application/pkcs7-mime") return null;
     if (pt.ambiguous) return null;
@@ -1533,7 +1546,7 @@ function _enroll(op, baseUrl, csrInput, opts, proxySnap) {
 function cacerts(baseUrl, opts) {
   opts = opts || {};
   var proxySnap; try { proxySnap = _snapProxy(opts); } catch (_pe) { return _rej(E("est/bad-input", "the options object could not be read", _pe)); }
-  return Promise.resolve().then(function () {
+  return _promiseResolve(_Promise, undefined).then(function () {
     opts = _knownOpts(opts, CACERTS_OPTS, "cacerts");
     return _client("cacerts", "GET", baseUrl, null, { accept: "application/pkcs7-mime" }, opts, proxySnap, undefined, opts.transport);
   }).then(function (res) { return _certsResult("cacerts", res, opts, null); });
@@ -1599,7 +1612,7 @@ function cacerts(baseUrl, opts) {
 function simpleenroll(baseUrl, csrInput, opts) {
   opts = opts || {};
   var proxySnap; try { proxySnap = _snapProxy(opts); } catch (_pe) { return _rej(E("est/bad-input", "the options object could not be read", _pe)); }
-  return Promise.resolve().then(function () {
+  return _promiseResolve(_Promise, undefined).then(function () {
     opts = _knownOpts(opts, SIMPLEENROLL_OPTS, "simpleenroll");
     return _enroll("simpleenroll", baseUrl, csrInput, opts, proxySnap);
   });
@@ -1639,7 +1652,7 @@ function simpleenroll(baseUrl, csrInput, opts) {
 function simplereenroll(baseUrl, csrInput, opts) {
   opts = opts || {};
   var proxySnap; try { proxySnap = _snapProxy(opts); } catch (_pe) { return _rej(E("est/bad-input", "the options object could not be read", _pe)); }
-  return Promise.resolve().then(function () {
+  return _promiseResolve(_Promise, undefined).then(function () {
     opts = _knownOpts(opts, SIMPLEREENROLL_OPTS, "simplereenroll");
     if (!opts.oldCert) throw E("est/bad-input", "simplereenroll requires opts.oldCert (the certificate being renewed, RFC 7030 sec. 4.2.2)");
     if (typeof csrInput !== "function") reenrollGuard(opts.oldCert, _csrDer(csrInput));
@@ -1797,7 +1810,7 @@ async function _serverkeygenResult(res, opts, derived) {
 function serverkeygen(baseUrl, csrInput, opts) {
   opts = opts || {};
   var proxySnap; try { proxySnap = _snapProxy(opts); } catch (_pe) { return _rej(E("est/bad-input", "the options object could not be read", _pe)); }
-  return Promise.resolve().then(function () {
+  return _promiseResolve(_Promise, undefined).then(function () {
     opts = _knownOpts(opts, SERVERKEYGEN_OPTS, "serverkeygen");
     var checkedTransport = opts.transport;
     var csrDer = _csrDer(csrInput);
@@ -1859,7 +1872,7 @@ function _csrattrsResult(res, opts) {
 function csrattrs(baseUrl, opts) {
   opts = opts || {};
   var proxySnap; try { proxySnap = _snapProxy(opts); } catch (_pe) { return _rej(E("est/bad-input", "the options object could not be read", _pe)); }
-  return Promise.resolve().then(function () {
+  return _promiseResolve(_Promise, undefined).then(function () {
     opts = _knownOpts(opts, CSRATTRS_OPTS, "csrattrs");
     return _client("csrattrs", "GET", baseUrl, null, { accept: "application/csrattrs" }, opts, proxySnap, undefined, opts.transport);
   }).then(function (res) { return _csrattrsResult(res, opts); });

package/lib/framework-error.js

@@ -188,6 +188,11 @@ var SmimeError = defineClass("SmimeError", { withCause: true });
 
 var CtError = defineClass("CtError", { withCause: true });
 
+var TufError = defineClass("TufError", { withCause: true });
+var RelatedCertError = defineClass("RelatedCertError", { withCause: true });
+var AltSigError = defineClass("AltSigError", { withCause: true });
+var PossessionError = defineClass("PossessionError", { withCause: true });
+
 var ScepError = defineClass("ScepError", { withCause: true });
 
 var TlsError = defineClass("TlsError", { withCause: true });
@@ -196,6 +201,8 @@ var C509Error = defineClass("C509Error", { withCause: true });
 
 var MerkleError = defineClass("MerkleError", { withCause: true });
 
+var TlogError = defineClass("TlogError", { withCause: true });
+
 var CsrattrsError = defineClass("CsrattrsError", { withCause: true });
 
 var EstError = defineClass("EstError", { withCause: true });
@@ -245,6 +252,10 @@ module.exports = {
   CmpError:         CmpError,
   PathError:        PathError,
   CtError:          CtError,
+  TufError:         TufError,
+  RelatedCertError: RelatedCertError,
+  AltSigError:      AltSigError,
+  PossessionError:  PossessionError,
   ScepError:        ScepError,
   TlsError:         TlsError,
   C509Error:        C509Error,
@@ -256,6 +267,7 @@ module.exports = {
   WebauthnError:    WebauthnError,
   LintError:        LintError,
   MerkleError:      MerkleError,
+  TlogError:        TlogError,
   SmimeError:       SmimeError,
   CsrattrsError:    CsrattrsError,
   EstError:         EstError,

package/lib/guard-async.js

@@ -7,7 +7,7 @@ var _resolve = _intrinsic.uncurry(_intrinsic.promiseResolve);
 var _reject = _intrinsic.uncurry(_intrinsic.promiseReject);
 var _apply = _intrinsic.apply;
 var _String = _intrinsic.String;
-var _Promise = Promise;
+var _Promise = _intrinsic.Promise;
 /** @internal Bound at load, like every other operation this module decides with: a replacement
  * installed later would otherwise choose when a bound expires, or whether it ever does. */
 var _setTimeout = setTimeout;

package/lib/guard-bytes.js

@@ -6,12 +6,15 @@ var async = require("./guard-async");
 var identifier = require("./guard-identifier");
 var time = require("./guard-time");
 var intrinsic = require("./guard-intrinsic");
-var _NAMED_SCAN_MAX_ELEMENTS = require("./constants").LIMITS.NAMED_SCAN_MAX_ELEMENTS;
+var constants = require("./constants");
+var _NAMED_SCAN_MAX_ELEMENTS = constants.LIMITS.NAMED_SCAN_MAX_ELEMENTS;
 var util = intrinsic.assign(intrinsic.create(null), { types: intrinsic.types });
 var _isArray = intrinsic.isArray;
 var _bufferFrom = intrinsic.bufferFrom;
+var _abSlice = intrinsic.arrayBufferSlice;
 var _isView = intrinsic.isView;
 var _isBuffer = intrinsic.isBuffer;
+var _bufferCompare = intrinsic.compare;
 var _asyncIterator = intrinsic.asyncIterator;
 var _NO_ARGS = intrinsic.freeze([]);
 var _create = intrinsic.create;
@@ -42,7 +45,8 @@ var _mapSet = intrinsic.mapSet;
 var _taSet = intrinsic.typedArraySet;
 var _Set = intrinsic.Set;
 var _Map = intrinsic.Map;
-var _append = require("./guard-list").append;
+var guardList = require("./guard-list");
+var _append = guardList.append;
 
 function _ownArrayIndices(v, n) {
   var keys = _ownKeys(v);
@@ -71,6 +75,12 @@ function asyncStreamOf(x) {
   return stream;
 }
 
+/** @internal A streaming door's own refusal for a fault the WebCrypto layer raised while reading a
+ *  chunk. Anything else is rethrown as it stands.
+ *
+ *  @enforced-by behavioral -- the rule is which faults are translated and which are rethrown, which no
+ *  code shape distinguishes from any other error-code test; the vectors driving a chunk that is not a byte
+ *  source and an unrelated throw through a streaming door are the guard */
 function translateStreamError(e, E, code) {
   if (e && e.code === "webcrypto/data") throw E(code, "a streamed content chunk is not a byte source", e);
   if (e && e.code === "webcrypto/syntax") throw E(code, "the streamed content is not a valid async iterable of byte chunks", e);
@@ -167,6 +177,21 @@ function lengthOf(view) {
   return _lengthOf(view);
 }
 
+/** @internal A view's bytes as an ArrayBuffer of their own, read through the captured accessors.
+ * `v.buffer`, `v.byteOffset` and `v.byteLength` are getters on the TypedArray and DataView prototypes,
+ * so a replacement of any of them decides which bytes the result holds: measured, replacing them after
+ * the slicing helper had been captured turned a valid 64-byte Ed25519 signature into 64 zero bytes on
+ * its way out of `pki.webcrypto.subtle.sign`. This is the form for a value crossing into a WebCrypto
+ * return, where the API's type is an ArrayBuffer rather than a view.
+ *
+ * @enforced-by guard-shape-reinlined
+ * @guard-shape \(\s*([A-Za-z_$][\w$]*)\.buffer\s*,\s*\1\.byteOffset
+ */
+function toArrayBuffer(input) {
+  var offset = _offsetOf(input);
+  return _abSlice(_storeOf(input), offset, offset + _lengthOf(input));
+}
+
 function _refuseShared(v, ErrorClass, code, label) {
   if (util.types.isSharedArrayBuffer(v) ||
       (_isView(v) && util.types.isSharedArrayBuffer(_storeOf(v)))) {
@@ -233,10 +258,19 @@ function snapshotSource(input, ErrorClass, code, label) {
 }
 
 // @enforced-by behavioral -- a copy has no rename-proof code shape to detect (any `Buffer.from(x)`
+/** @internal `maxNodes` bounds the WORK, which the depth cap does not. A value that shares a subobject
+ *  with itself is a graph rather than a tree, and this copy visits every reference independently: with
+ *  `v = [v, v]` repeated n times, the depth is n and the work is 2 to the n. MEASURED through two shipped
+ *  doors, a DAG placed in a member beside the ones a verb validates, `pki.jose.thumbprint` took 748 ms at
+ *  16 levels, 2.9 seconds at 18 and 5.9 at 19, doubling every level up to a depth cap of 64, and
+ *  `pki.tuf.keyId` the same (CWE-770). The counter is shared across the whole walk, so the cost follows
+ *  the budget rather than the shape of the input. The figure is far above any real caller value: an
+ *  options bag or a JWK is tens of nodes, and a certificate chain passed as an anchor list is thousands. */
 function snapshotDeep(value, ErrorClass, code, label, opts) {
   var o = opts || {};
   var cap = o.maxDepth == null ? 64 : o.maxDepth;
-  return _deep(value, ErrorClass, code, label, cap, 0, o.collect || null);
+  var maxNodes = o.maxNodes == null ? constants.LIMITS.DEEP_COPY_MAX_NODES : o.maxNodes;
+  return _deep(value, ErrorClass, code, label, cap, 0, o.collect || null, { n: 0, max: maxNodes });
 }
 
 function _surface(names) {
@@ -345,8 +379,19 @@ function _protoChainHasProxy(v) {
 
 function _plainCopy(copy) { return copy; }
 
-function _deep(v, ErrorClass, code, label, cap, depth, collect) {
+function _deep(v, ErrorClass, code, label, cap, depth, collect, work) {
   if (depth > cap) throw _raise(ErrorClass, code, label + " is nested too deeply to copy");
+  /** @internal One unit per value visited, charged against the shared counter before the value is read.
+   *  The depth cap above bounds how far down the walk goes and says nothing about how WIDE the walk is
+   *  when references are shared, which is what the counter answers. */
+  if (work !== undefined) {
+    work.n += 1;
+    if (work.n > work.max) {
+      throw _raise(ErrorClass, code, label + " expands to more than " + work.max +
+        " values when copied: a value that holds the same subobject in more than one place is copied " +
+        "once per place, so a few dozen fields can expand without bound");
+    }
+  }
   if (v == null || typeof v !== "object") return v;
   _refuseShared(v, ErrorClass, code, label);
   if (_protoChainHasProxy(v)) {
@@ -360,20 +405,25 @@ function _deep(v, ErrorClass, code, label, cap, depth, collect) {
   if (_isBuffer(v) || _isView(v) || _isArrayBuffer(v)) {
     var bytesCopy = _copyBytesSameKind(v, ErrorClass, code, label, collect);
     if (bytesCopy.byteLength <= _NAMED_SCAN_MAX_ELEMENTS) {
-      _copyNamed(v, bytesCopy, ErrorClass, code, label, cap, depth, collect);
+      _copyNamed(v, bytesCopy, ErrorClass, code, label, cap, depth, collect, work);
     }
     return bytesCopy;
   }
   if (require("./guard-parsed").isRecordedAsProduced(v)) return v;   // allow:inline-require -- circular load: guard-parsed requires this module
   if (util.types.isDate(v)) {
     var dateCopy = new _Date(time.instantOf(v));
-    _copyNamed(v, dateCopy, ErrorClass, code, label, cap, depth, collect, _DATE_BEHAVIOR);
+    _copyNamed(v, dateCopy, ErrorClass, code, label, cap, depth, collect, work, _DATE_BEHAVIOR);
     return _plainCopy(dateCopy);
   }
   if (_isArray(v)) {
     var arr = [];
     var indexE = function (c, m) { return _raise(ErrorClass, c, m); };
-    var indices = _ownArrayIndices(v, v.length);
+    /** @internal The count is narrowed where it is taken and the copy's own length is set from it, not
+     * from a second read of the source. Read again at the end, a nested getter that shrank the source
+     * while the walk ran TRUNCATED the finished copy: both elements had been collected and the copy
+     * then reported one. The snapshot is of the array as it was counted. */
+    var vCount = guardList.count(v, "snapshotDeep");
+    var indices = _ownArrayIndices(v, vCount);
     if (identifier.readableIndices(v, indexE, code, label).length !== indices.length) {
       throw _raise(ErrorClass, code, label + " has an in-range index supplied by its prototype rather than the array itself; a list resolved through the prototype chain is refused");
     }
@@ -382,10 +432,10 @@ function _deep(v, ErrorClass, code, label, cap, depth, collect) {
       var element;
       try { element = v[k]; }
       catch (e) { throw _raise(ErrorClass, code, label + ": reading element " + k + " threw", e); }
-      arr[k] = _deep(element, ErrorClass, code, label, cap, depth + 1, collect);
+      arr[k] = _deep(element, ErrorClass, code, label, cap, depth + 1, collect, work);
     });
-    arr.length = v.length;
-    _copyNamed(v, arr, ErrorClass, code, label, cap, depth, collect);
+    arr.length = vCount;
+    _copyNamed(v, arr, ErrorClass, code, label, cap, depth, collect, work);
     return _plainCopy(arr);
   }
   var surface = _opaqueSurface(v, ErrorClass, code, label);
@@ -398,13 +448,13 @@ function _deep(v, ErrorClass, code, label, cap, depth, collect) {
       "fields as a plain object");
   }
   if (util.types.isMap(v)) {
-    return _plainCopy(_copyEntries(v, new _Map(), ErrorClass, code, label, cap, depth, collect));
+    return _plainCopy(_copyEntries(v, new _Map(), ErrorClass, code, label, cap, depth, collect, work));
   }
   if (util.types.isSet(v)) {
-    return _plainCopy(_copyEntries(v, new _Set(), ErrorClass, code, label, cap, depth, collect));
+    return _plainCopy(_copyEntries(v, new _Set(), ErrorClass, code, label, cap, depth, collect, work));
   }
   var out = _create(_getPrototypeOf(v) === null ? null : _ObjectProto);
-  _copyNamed(v, out, ErrorClass, code, label, cap, depth, collect);
+  _copyNamed(v, out, ErrorClass, code, label, cap, depth, collect, work);
   return out;
 }
 
@@ -416,14 +466,14 @@ function _namesToCopy(src, ErrorClass, code, label, atArgument) {
   return names;
 }
 
-function _copyEntries(src, dst, ErrorClass, code, label, cap, depth, collect) {
+function _copyEntries(src, dst, ErrorClass, code, label, cap, depth, collect, work) {
   var walk = util.types.isSet(src) ? _setForEach : _mapForEach;
   walk(src, function (value, key) {
-    var copiedValue = _deep(value, ErrorClass, code, label, cap, depth + 1, collect);
+    var copiedValue = _deep(value, ErrorClass, code, label, cap, depth + 1, collect, work);
     if (util.types.isSet(dst)) _setAdd(dst, copiedValue);
-    else _mapSet(dst, _deep(key, ErrorClass, code, label, cap, depth + 1, collect), copiedValue);
+    else _mapSet(dst, _deep(key, ErrorClass, code, label, cap, depth + 1, collect, work), copiedValue);
   });
-  _copyNamed(src, dst, ErrorClass, code, label, cap, depth, collect);
+  _copyNamed(src, dst, ErrorClass, code, label, cap, depth, collect, work);
   return dst;
 }
 
@@ -433,8 +483,22 @@ var _DATE_BEHAVIOR = (function () {
   return t;
 })();
 
-function _copyNamed(src, dst, ErrorClass, code, label, cap, depth, collect, behavior) {
+function _copyNamed(src, dst, ErrorClass, code, label, cap, depth, collect, work, behavior) {
   var keys = _namesToCopy(src, ErrorClass, code, label, depth === 0);
+  /** @internal Every PROPERTY is charged, not only every value `_deep` recurses into. A function is
+   *  carried across by reference rather than copied, so it took no charge, and the counter then
+   *  under-counted the real work by the property count: MEASURED through `pki.jose.thumbprint`, a graph
+   *  whose shared leaf carried 1000 function properties cost 17.7 seconds against 384 ms for the same
+   *  graph with a plain leaf, because the visits were capped and the per-visit work was not. Charging the
+   *  key run up front is one charge for work proportional to it. */
+  if (work !== undefined && keys.length > 0) {
+    work.n += keys.length;
+    if (work.n > work.max) {
+      throw _raise(ErrorClass, code, label + " expands to more than " + work.max +
+        " values when copied: a value that holds the same subobject in more than one place is copied " +
+        "once per place, so a few dozen fields can expand without bound");
+    }
+  }
   for (var k = 0; k < keys.length; k++) {
     var value;
     try { value = src[keys[k]]; }
@@ -442,7 +506,7 @@ function _copyNamed(src, dst, ErrorClass, code, label, cap, depth, collect, beha
     if (behavior && behavior[keys[k]] && typeof value === "function") continue;
     _defineProperty(dst, keys[k], {
       value: typeof value === "function" ? value
-        : _deep(value, ErrorClass, code, label, cap, depth + 1, collect),
+        : _deep(value, ErrorClass, code, label, cap, depth + 1, collect, work),
       writable: true, enumerable: _wasEnumerable(src, keys[k]), configurable: true,
     });
   }
@@ -465,7 +529,9 @@ function fixArguments(ErrorClass, code, args) {
       "a copy of a caller-supplied argument");
   }
   try {
-    for (var i = 0; i < args.length; i++) {
+    /** @internal The count is narrowed where it is taken, as every walk in `guard.list` is. */
+    var argCount = guardList.count(args, "fixArguments");
+    for (var i = 0; i < argCount; i++) {
       _append(values, snapshotDeep(args[i][0], ErrorClass, code, args[i][1], { collect: copies }));
     }
   } catch (e) {
@@ -484,8 +550,25 @@ function fixedCall(ErrorClass, code, args, body) {
   }), function () { if (handle) handle.release(); });
 }
 
+/**
+ * @internal The ORDER of two byte strings, through the captured operation. A DER SET OF is ordered by
+ * its members' encoded bytes and a byte-for-byte claim is this comparison, so whatever answers
+ * "before" and "equal" decides emitted bytes at one end and a verdict at the other: a replacement
+ * answering a fixed order sets the order of every SET this toolkit builds, and one answering zero turns
+ * a mismatch into a match. Offered here so a module can reach the captured operation through the guard
+ * surface it already takes. This is an ORDERING, not a secret comparison: a secret goes through
+ * `guard.crypto.constantTimeEqual`.
+ *
+ * @enforced-by guard-shape-reinlined
+ * @guard-shape Buffer\.compare\(
+ * @guard-via (?:guard\.bytes|intrinsic)\.compare\(
+ */
+function compare(a, b) { return _bufferCompare(a, b); }
+
 module.exports = intrinsic.freeze({
+  compare: compare,
   view: view, source: source, snapshot: snapshot, snapshotSource: snapshotSource,
   isByteSource: isByteSource, asyncStreamOf: asyncStreamOf, translateStreamError: translateStreamError, lengthOf: lengthOf, outputView: outputView,
+  toArrayBuffer: toArrayBuffer,
   snapshotDeep: snapshotDeep, fixArguments: fixArguments, fixedCall: fixedCall,
 });