@blamejs/pki 0.6.39 → 0.6.41

package/lib/est.js

@@ -98,12 +98,12 @@ var OID_TEMPLATE = oid.byName("certificationRequestInfoTemplate");
 
 var OPERATIONS = ["cacerts", "simpleenroll", "simplereenroll", "fullcmc", "serverkeygen", "csrattrs"];
 
-var CLIENT_OPTS = {
+var CLIENT_OPTS = intrinsic.assign(intrinsic.create(null), {
   transport: 1, tls: 1, label: 1, timeout: 1, maxResponseBytes: 1, maxRedirects: 1, now: 1,
   auth: 1, username: 1, password: 1, allowCrossOriginRedirect: 1, proxy: 1,
-};
+});
 function _withClient(extra) {
-  var out = {};
+  var out = intrinsic.create(null);
   Object.keys(CLIENT_OPTS).forEach(function (k) { out[k] = 1; });
   Object.keys(extra || {}).forEach(function (k) { out[k] = 1; });
   return out;
@@ -119,18 +119,34 @@ var FULLCMC_OPTS = _withClient({
   transactionId: 1, senderNonce: 1, dataReturn: 1,
   responderCerts: 1, responseRecipient: 1, allowUnverifiedResponse: 1, allowUnboundResponse: 1,
 });
-var CLASSIFY_OPTS = { op: 1, now: 1 };
-var PATHS_OPTS = { label: 1 };
-var PARSE_SERVERKEYGEN_OPTS = {
+var CLASSIFY_OPTS = intrinsic.assign(intrinsic.create(null), { op: 1, now: 1 });
+var PATHS_OPTS = intrinsic.assign(intrinsic.create(null), { label: 1 });
+var PARSE_SERVERKEYGEN_OPTS = intrinsic.assign(intrinsic.create(null), {
   requestedEncryption: 1, expectedRecipientKeyId: 1, expectedRecipientKind: 1,
   expectedRecipientIssuerSerial: 1,
-};
+});
+
+var TRANSPORT_SHAPE = "(request) => Promise<{ status, headers, body }>";
 
+/** @internal Refused at the door, before any payload work, and again where the value is used. The
+ * checked value is RETURNED and it is that one the caller uses: reading the option again would ask
+ * a second time, and an accessor can answer differently on each read, so a value that passed here
+ * need not be the value that gets called. */
+function _assertTransport(opts) {
+  return guard.identifier.assertCallableOption(opts, "transport", E, "est/bad-input", "opts.transport", TRANSPORT_SHAPE);
+}
+
+/** @internal Settled first, as the sibling clients do: an options object whose reads change what it
+ * carries is refused here rather than answering one way to the check and another to the use, which
+ * is how a transport that passed could be replaced before it is called. */
 function _knownOpts(opts, known, verb) {
-  guard.identifier.assertKnownKeys(opts, known, E, "est/bad-input", function (k) {
+  var settled = guard.identifier.optionsObject(opts, E, "est/bad-input", "pki.est." + verb + " options");
+  guard.identifier.assertKnownKeys(settled, known, E, "est/bad-input", function (k) {
     return "unknown option " + JSON.stringify(k) + " for pki.est." + verb + " -- accepted: " +
       Object.keys(known).sort().join(", ");
   });
+  _assertTransport(settled);
+  return settled;
 }
 
 function _snapProxy(opts) { return httpTransport.snapshotProxy(opts.proxy); }
@@ -315,7 +331,7 @@ function splitMultipartMixed(body, contentType) {
     if (sep === -1) throw E("est/bad-multipart", "a multipart part is missing its header/body separator");
     var rawHeaders = _strSlice(seg, 0, sep);
     var partBody = _strSlice(seg, _stripTwoLeadingEol(seg, sep), _stripOneTrailingEol(seg, seg.length));
-    var headers = {};
+    var headers = intrinsic.create(null);
     var lines = _splitCrlf(_unfoldHeaders(rawHeaders));
     for (var li = 0; li < lines.length; li++) {
       var line = lines[li];
@@ -476,7 +492,7 @@ function _partMediaType(contentType) {
 
 function parseServerKeygenResponse(body, contentType, opts) {
   opts = opts || {};
-  _knownOpts(opts, PARSE_SERVERKEYGEN_OPTS, "parseServerKeygenResponse");
+  opts = _knownOpts(opts, PARSE_SERVERKEYGEN_OPTS, "parseServerKeygenResponse");
   var parts = splitMultipartMixed(body, contentType);
   if (parts.length !== 2) throw E("est/bad-multipart", "a serverkeygen response must have exactly two parts (RFC 7030 sec. 4.4.2)");
   var keyPart = null, certPart = null, encrypted = false;
@@ -513,18 +529,18 @@ function parseServerKeygenResponse(body, contentType, opts) {
 }
 
 
-var CONTENT_TYPE_BY_OP = {
+var CONTENT_TYPE_BY_OP = intrinsic.assign(intrinsic.create(null), {
   cacerts: { media: "application/pkcs7-mime" },
   simpleenroll: { media: "application/pkcs7-mime", smimeTypes: ["certs-only"] },
   simplereenroll: { media: "application/pkcs7-mime", smimeTypes: ["certs-only"] },
   fullcmc: { media: "application/pkcs7-mime", smimeTypes: ["certs-only", "cmc-response"] },
   serverkeygen: { media: "multipart/mixed" },
   csrattrs: { media: "application/csrattrs" },
-};
+});
 
 var CLASSIFIABLE_OPS = ["cacerts", "simpleenroll", "simplereenroll", "fullcmc", "serverkeygen", "csrattrs"];
 
-var NOT_IMPLEMENTED_OPS = { fullcmc: 1 };
+var NOT_IMPLEMENTED_OPS = intrinsic.assign(intrinsic.create(null), { fullcmc: 1 });
 
 /**
  * @primitive  pki.est.classifyResponse
@@ -553,15 +569,15 @@ var NOT_IMPLEMENTED_OPS = { fullcmc: 1 };
  */
 function classifyResponse(status, headers, body, opts) {
   opts = opts || {};
-  _knownOpts(opts, CLASSIFY_OPTS, "classifyResponse");
+  opts = _knownOpts(opts, CLASSIFY_OPTS, "classifyResponse");
   var op = opts.op;
   if (op !== undefined && op !== null && CLASSIFIABLE_OPS.indexOf(op) === -1) throw E("est/unsupported-operation", "unrecognized EST operation " + guard.text.showValue(op));
-  var h = {
+  var h = intrinsic.assign(intrinsic.create(null), {
     "content-type": _ciHeader(headers, "content-type"),
     "retry-after": _ciHeader(headers, "retry-after"),
     "location": _ciHeader(headers, "location"),
     "www-authenticate": _ciHeaderList(headers, "www-authenticate"),
-  };
+  });
   if (status === 200) {
     var spec = CONTENT_TYPE_BY_OP[op];
     var ct = h["content-type"] || "";
@@ -625,7 +641,7 @@ function classifyResponse(status, headers, body, opts) {
  */
 function paths(baseUrl, opts) {
   opts = opts || {};
-  _knownOpts(opts, PATHS_OPTS, "paths");
+  opts = _knownOpts(opts, PATHS_OPTS, "paths");
   var base = String(baseUrl);
   var prefix = base.slice(0, _stripTrailingSlashEnd(base)) + "/.well-known/est";
   if (opts.label != null) {
@@ -635,7 +651,7 @@ function paths(baseUrl, opts) {
     }
     prefix += "/" + label;
   }
-  var out = {};
+  var out = intrinsic.create(null);
   OPERATIONS.forEach(function (op) { out[op] = prefix + "/" + op; });
   return out;
 }
@@ -845,7 +861,7 @@ function _authScheme(opts) {
 function _authUser(opts) { return opts.auth && opts.auth.username !== undefined ? opts.auth.username : opts.username; }
 function _authPass(opts) { return opts.auth && opts.auth.password !== undefined ? opts.auth.password : opts.password; }
 function _hasCreds(opts) { return _authUser(opts) !== undefined || _authPass(opts) !== undefined; }
-var DIGEST_CODES = { unsupportedAlgorithm: "est/digest-unsupported-algorithm", weakAlgorithm: "est/digest-weak-algorithm", noQop: "est/digest-no-qop", badChallenge: "est/digest-bad-challenge" };
+var DIGEST_CODES = intrinsic.assign(intrinsic.create(null), { unsupportedAlgorithm: "est/digest-unsupported-algorithm", weakAlgorithm: "est/digest-weak-algorithm", noQop: "est/digest-no-qop", badChallenge: "est/digest-bad-challenge" });
 function _digestPolicy(opts) { return { allowMD5: !!(opts.auth && opts.auth.allowMD5), allowLegacyQop: !!(opts.auth && opts.auth.allowLegacyQop), codes: DIGEST_CODES }; }
 
 function _drive(method, url, body, headers, opts, transport, budgets) {
@@ -882,14 +898,14 @@ function _drive(method, url, body, headers, opts, transport, budgets) {
   }
   function step() {
     var hopBody = (typeof body === "function" && budgets.onAttempt) ? budgets.onAttempt() : body;
-    return guard.async.awaited(transport({ method: method, url: url.href, headers: _headersFor(url), body: hopBody, tls: _tlsFor(url), proxy: budgets.proxy, timeout: budgets.timeout, maxResponseBytes: budgets.maxResponseBytes }), E, "est/bad-input", "opts.transport").then(function (res) {
+    return guard.async.invoked(transport, [{ method: method, url: url.href, headers: _headersFor(url), body: hopBody, tls: _tlsFor(url), proxy: budgets.proxy, timeout: budgets.timeout, maxResponseBytes: budgets.maxResponseBytes }], E, "est/bad-input", "opts.transport").then(function (res) {
       res = res || {};
       var blen = _bodyLen(res);
       if (blen > budgets.maxResponseBytes) throw E("est/response-too-large", "the response body (" + blen + " bytes) exceeds the " + budgets.maxResponseBytes + "-byte cap (RFC 7030 sec. 6)");
-      var h = {
+      var h = intrinsic.assign(intrinsic.create(null), {
         location: _ciHeader(res.headers, "location"),
         "www-authenticate": _ciHeaderList(res.headers, "www-authenticate"),
-      };
+      });
       var status = res.status;
       if (status >= 300 && status < 400) {
         if (redirects >= budgets.maxRedirects) throw E("est/too-many-redirects", "the redirect chain exceeded maxRedirects=" + budgets.maxRedirects + " (RFC 7030 sec. 3.2.1)");
@@ -945,13 +961,16 @@ function _drive(method, url, body, headers, opts, transport, budgets) {
   return step();
 }
 
-function _client(op, method, baseUrl, body, headers, opts, proxySnap, onAttempt) {
+/** @internal `checked` is the transport the verb already took at its door. Taking it again here
+ * would ask the caller's options a second time, and anything read in between could change the
+ * answer, so a verb that holds one passes it and this reads the option only when none was held. */
+function _client(op, method, baseUrl, body, headers, opts, proxySnap, onAttempt, checked) {
   var base;
   try { base = new URL(String(baseUrl)); }
   catch (e) { throw E("est/bad-url", "the EST base URL did not parse: " + guard.text.showValue(baseUrl), e); }
   if (base.search || base.hash) throw E("est/bad-url", "the EST base URL must not carry a query or fragment component (RFC 7030 sec. 3.2.2)");
   var url = _parseUrl(paths(baseUrl, { label: opts.label })[op]);
-  var transport = opts.transport;
+  var transport = checked !== undefined ? checked : _assertTransport(opts);
   if (!transport) {
     var t = opts.tls || {};
     var hasAnchors = t.anchors !== undefined && t.anchors !== null && !(Array.isArray(t.anchors) && t.anchors.length === 0);
@@ -1086,16 +1105,23 @@ function fullcmc(baseUrl, request, opts) {
   var der, wanted, sent;
   try {
     if (typeof opts !== "object" || Buffer.isBuffer(opts)) throw E("est/bad-input", "pki.est.fullcmc options must be an object");
-    _knownOpts(opts, FULLCMC_OPTS, "fullcmc");
+    opts = _knownOpts(opts, FULLCMC_OPTS, "fullcmc");
+    /** @internal Held from the door, before the request is read. What follows traverses the
+     * caller's nested objects, and one of those reads must not be able to change which transport
+     * the request goes out on, so the value that was checked is the value carried below. */
+    var carriedTransport = opts.transport;
     var proxySnap;
     try { proxySnap = _snapProxy(opts); } catch (_pe) { throw E("est/bad-input", "the options object could not be read", _pe); }
     der = _cmcRequestDer(request);
     wanted = _requestedPublicKeys(der);
     sent = _cmcSent(opts, der);
+    /** @internal The copy below keeps own properties only, and a defaults bag holds its options on
+     * a prototype, so the transport is put back from the value held at the door. */
     opts = _shallowCopy(opts);
+    if (carriedTransport !== undefined) opts.transport = carriedTransport;
     var body = transferEncode(der);
     return _client("fullcmc", "POST", baseUrl, body,
-      { accept: "application/pkcs7-mime", "content-type": "application/pkcs7-mime; smime-type=CMC-request" }, opts, proxySnap)
+      { accept: "application/pkcs7-mime", "content-type": "application/pkcs7-mime; smime-type=CMC-request" }, opts, proxySnap, undefined, carriedTransport)
       .then(function (res) { return _fullcmcResult(res, opts, wanted, sent); });
   } catch (e) {
     return _rej(e);
@@ -1109,7 +1135,7 @@ function _correlateIssued(bag, wanted, arm) {
       "this /fullcmc request declared no certification request whose key a returned certificate could be " +
       "matched against, so a " + arm + " response cannot be read as an issuance (RFC 5272 sec. 4.1)");
   }
-  var byKey = {};
+  var byKey = intrinsic.create(null);
   wanted.forEach(function (k) {
     var hex = k.toString("hex");
     if (!byKey[hex]) byKey[hex] = { key: k, want: 0, have: null };
@@ -1211,8 +1237,8 @@ function _copyBytes(v) {
 }
 
 function _requestBinding(der) {
-  var out = { transactionId: undefined, senderNonce: undefined, dataReturn: undefined, bodyPartIDs: undefined,
-    bodyPartPaths: undefined };
+  var out = intrinsic.assign(intrinsic.create(null), { transactionId: undefined, senderNonce: undefined, dataReturn: undefined, bodyPartIDs: undefined,
+    bodyPartPaths: undefined });
   var body = cmcFmt.parse(der);
   var ids = [];
   var paths = [];
@@ -1287,16 +1313,16 @@ function _assertAgrees(name, supplied, carried) {
 
 function _copyRecipient(r) {
   if (!r || typeof r !== "object") return r;
-  var out = {}, k;
+  var out = intrinsic.create(null), k;
   for (k in r) { if (_hasOwn(r, k)) out[k] = _copyBytes(r[k]); }
   return out;
 }
 
 function _shallowCopy(o) {
-  var out = {}, k;
+  var out = intrinsic.create(null), k;
   for (k in o) { if (_hasOwn(o, k)) out[k] = o[k]; }
   if (out.auth && typeof out.auth === "object") {
-    var a = {}, ak;
+    var a = intrinsic.create(null), ak;
     for (ak in out.auth) { if (_hasOwn(out.auth, ak)) a[ak] = out.auth[ak]; }
     out.auth = a;
   }
@@ -1414,9 +1440,12 @@ function _causedBy(e, target) {
   return false;
 }
 
-var ENROLL_HEADERS = { accept: "application/pkcs7-mime", "content-type": "application/pkcs10" };
+var ENROLL_HEADERS = intrinsic.assign(intrinsic.create(null), { accept: "application/pkcs7-mime", "content-type": "application/pkcs10" });
 
 function _enrollBound(op, baseUrl, builder, opts, proxySnap) {
+  /** @internal Held before anything else the caller supplied is read, and carried to the client:
+   * the builder runs during the handshake, so a later read could answer with a different value. */
+  var checkedTransport = opts.transport;
   if (_authScheme(opts) === "digest") {
     throw E("est/channel-binding-digest-unsupported",
       "Digest authentication cannot be combined with a channel-bound CSR builder: the Authorization header " +
@@ -1443,7 +1472,7 @@ function _enrollBound(op, baseUrl, builder, opts, proxySnap) {
         .then(null, function (e) { attempt.error = e; attempt.done = true; throw e; });
     };
   }
-  return _client(op, "POST", baseUrl, hopBody, ENROLL_HEADERS, opts, proxySnap, hopBody)
+  return _client(op, "POST", baseUrl, hopBody, ENROLL_HEADERS, opts, proxySnap, hopBody, checkedTransport)
     .then(function (res) {
       if (current && current.error) throw current.error;
       if (!current || !current.done) {
@@ -1461,10 +1490,11 @@ function _enrollBound(op, baseUrl, builder, opts, proxySnap) {
 
 function _enroll(op, baseUrl, csrInput, opts, proxySnap) {
   if (typeof csrInput === "function") return _enrollBound(op, baseUrl, csrInput, opts, proxySnap);
+  var checkedTransport = opts.transport;
   var csrDer = _csrDer(csrInput);
   var spki = csr.parse(csrDer).subjectPublicKeyInfo;
   var body = transferEncode(csrDer);
-  return _client(op, "POST", baseUrl, body, ENROLL_HEADERS, opts, proxySnap)
+  return _client(op, "POST", baseUrl, body, ENROLL_HEADERS, opts, proxySnap, undefined, checkedTransport)
     .then(function (res) { return _certsResult(op, res, opts, spki); });
 }
 
@@ -1505,8 +1535,8 @@ 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 () {
-    _knownOpts(opts, CACERTS_OPTS, "cacerts");
-    return _client("cacerts", "GET", baseUrl, null, { accept: "application/pkcs7-mime" }, opts, proxySnap);
+    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); });
 }
 
@@ -1571,7 +1601,7 @@ 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 () {
-    _knownOpts(opts, SIMPLEENROLL_OPTS, "simpleenroll");
+    opts = _knownOpts(opts, SIMPLEENROLL_OPTS, "simpleenroll");
     return _enroll("simpleenroll", baseUrl, csrInput, opts, proxySnap);
   });
 }
@@ -1611,7 +1641,7 @@ 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 () {
-    _knownOpts(opts, SIMPLEREENROLL_OPTS, "simplereenroll");
+    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));
     return _enroll("simplereenroll", baseUrl, csrInput, opts, proxySnap);
@@ -1755,7 +1785,8 @@ 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 () {
-    _knownOpts(opts, SERVERKEYGEN_OPTS, "serverkeygen");
+    opts = _knownOpts(opts, SERVERKEYGEN_OPTS, "serverkeygen");
+    var checkedTransport = opts.transport;
     var csrDer = _csrDer(csrInput);
     var derived = _serverkeygenEncryptionFromCsr(csrDer);
     if (opts.requestedEncryption !== undefined && !!opts.requestedEncryption !== derived.requestedEncryption) throw E("est/bad-input", "opts.requestedEncryption (" + !!opts.requestedEncryption + ") contradicts the CSR's advertised key-encryption attribute (" + derived.requestedEncryption + ") (RFC 7030 sec. 4.4.1)");
@@ -1772,7 +1803,7 @@ function serverkeygen(baseUrl, csrInput, opts) {
     if ((opts.expectedRecipientKeyId !== undefined || opts.expectedRecipientIssuerSerial != null) && !derived.requestedEncryption) {
       throw E("est/bad-input", "a recipient expectation (expectedRecipientKeyId / expectedRecipientIssuerSerial) implies an encrypted key, but the CSR advertised no DecryptKeyIdentifier / AsymmetricDecryptKeyIdentifier attribute (RFC 7030 sec. 4.4.1)");
     }
-    return _client("serverkeygen", "POST", baseUrl, transferEncode(csrDer), { accept: "multipart/mixed", "content-type": "application/pkcs10" }, opts, proxySnap)
+    return _client("serverkeygen", "POST", baseUrl, transferEncode(csrDer), { accept: "multipart/mixed", "content-type": "application/pkcs10" }, opts, proxySnap, undefined, checkedTransport)
       .then(function (res) { return _serverkeygenResult(res, opts, derived); });
   });
 }
@@ -1816,8 +1847,8 @@ 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 () {
-    _knownOpts(opts, CSRATTRS_OPTS, "csrattrs");
-    return _client("csrattrs", "GET", baseUrl, null, { accept: "application/csrattrs" }, opts, proxySnap);
+    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/guard-async.js

@@ -6,6 +6,7 @@ var _intrinsic = require("./guard-intrinsic");
 var _resolve = _intrinsic.uncurry(_intrinsic.promiseResolve);
 var _reject = _intrinsic.uncurry(_intrinsic.promiseReject);
 var _apply = _intrinsic.apply;
+var _String = _intrinsic.String;
 var _Promise = Promise;
 // @internal
 // @enforced-by behavioral -- the rule has no rename-proof code shape (it is the ABSENCE of a wrapper
@@ -29,4 +30,19 @@ function awaited(value, E, code, label) {
   });
 }
 
-module.exports = _intrinsic.freeze({ deferred: deferred, awaited: awaited });
+// @internal
+// @enforced-by behavioral -- a RED vector drives a bound class constructor through a client verb
+/** @internal Call a caller-supplied producer and hand back its promise. A synchronous throw from
+ * the call becomes the boundary's typed error, the same as a rejected promise or a non-thenable
+ * return already does. Some values pass a callability check and still throw when called: binding a
+ * class constructor hides its source, and a proxy can throw from its apply trap. */
+function invoked(fn, args, E, code, label) {
+  var out;
+  try { out = _apply(fn, undefined, args); }
+  catch (e) {
+    throw E(code, label + " threw when it was called: " + (e && e.message ? e.message : _String(e)), e);
+  }
+  return awaited(out, E, code, label);
+}
+
+module.exports = _intrinsic.freeze({ deferred: deferred, awaited: awaited, invoked: invoked });

package/lib/guard-bytes.js

@@ -6,7 +6,7 @@ var async = require("./guard-async");
 var identifier = require("./guard-identifier");
 var time = require("./guard-time");
 var intrinsic = require("./guard-intrinsic");
-var util = { types: intrinsic.types };
+var util = intrinsic.assign(intrinsic.create(null), { types: intrinsic.types });
 var _isArray = intrinsic.isArray;
 var _bufferFrom = intrinsic.bufferFrom;
 var _isView = intrinsic.isView;
@@ -41,7 +41,7 @@ var _mapSet = intrinsic.mapSet;
 var _taSet = intrinsic.typedArraySet;
 var _Set = intrinsic.Set;
 var _Map = intrinsic.Map;
-function _append(arr, v) { _defineProperty(arr, arr.length, { value: v, writable: true, enumerable: true, configurable: true }); }
+var _append = require("./guard-list").append;
 
 function _ownArrayIndices(v, n) {
   var keys = _ownKeys(v);
@@ -65,7 +65,7 @@ function asyncStreamOf(x) {
   if (isByteSource(x) || x == null || (typeof x !== "object" && typeof x !== "function")) return null;
   var acquire = x[_asyncIterator];
   if (typeof acquire !== "function") return null;
-  var stream = {};
+  var stream = intrinsic.create(null);
   stream[_asyncIterator] = function () { return _apply(acquire, x, _NO_ARGS); };
   return stream;
 }

package/lib/guard-compress.js

@@ -15,17 +15,17 @@ var _sizeOf = _intrinsic.sizeOf;
 var _subarray = _intrinsic.uncurry(Uint8Array.prototype.subarray);
 var _hasOwn = _intrinsic.hasOwn;
 
-var DECOMPRESS = {
+var DECOMPRESS = _intrinsic.assign(_intrinsic.create(null), {
   zlib: zlib.inflateSync,
   brotli: zlib.brotliDecompressSync,
   zstd: zlib.zstdDecompressSync,
-};
+});
 
-var _PROBE_COMPRESS = {
+var _PROBE_COMPRESS = _intrinsic.assign(_intrinsic.create(null), {
   zlib: zlib.deflateSync,
   brotli: zlib.brotliCompressSync,
   zstd: zlib.zstdCompressSync,
-};
+});
 
 function _reportsTruncation(name) {
   var compress = _PROBE_COMPRESS[name];
@@ -47,7 +47,7 @@ function _reportsTruncation(name) {
   return !cutAccepted;
 }
 
-var SAFE = {};
+var SAFE = _intrinsic.create(null);
 _intrinsic.forEach(_objectKeys(DECOMPRESS), function (n) { if (_reportsTruncation(n)) SAFE[n] = true; });
 
 // @enforced-by guard-shape-reinlined

package/lib/guard-identifier.js

@@ -2,7 +2,7 @@
 // Copyright (c) blamejs contributors
 "use strict";
 var intrinsic = require("./guard-intrinsic");
-var util = { types: intrinsic.types };
+var util = intrinsic.assign(intrinsic.create(null), { types: intrinsic.types });
 // @internal
 
 var _isArray = intrinsic.isArray;
@@ -32,13 +32,14 @@ var _Set = intrinsic.Set;
 var _Map = intrinsic.Map;
 var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
 var _strSplit = intrinsic.uncurry(String.prototype.split);
+var _fnToString = intrinsic.uncurry(Function.prototype.toString);
 var _hasOwn = intrinsic.hasOwn;
 var _String = intrinsic.String;
 var _Number = intrinsic.Number;
 var _BigInt = intrinsic.BigInt;
 var _Object = intrinsic.Object;
 var _BufferProto = intrinsic.BufferProto;
-function _append(arr, v) { _defineProperty(arr, arr.length, { value: v, writable: true, enumerable: true, configurable: true }); }
+var _append = require("./guard-list").append;
 
 function _isDottedDecimal(str) {
   if (str.length === 0) return false;
@@ -390,7 +391,50 @@ function _settle(opts, E, code, label) {
   return opts;
 }
 
+/** @internal An injectable callback option, refused unless it is callable. A value that is present
+ * but not a function reaches the call site otherwise, where the operator gets a bare TypeError
+ * naming no option; and one read as absent sends the caller to whatever default the boundary
+ * installs, which for a transport is a real network client the caller was trying to replace. Take a
+ * value only when it is known to be present; `assertCallableOption` decides presence.
+ *
+ * Callable is all this asks. A class constructor answers "function" to typeof and still throws when
+ * called, but no test here separates one from an ordinary function: freezing a function leaves its
+ * prototype non-writable exactly as a class's is, and reading the source text mistakes a method
+ * named `class` for the keyword. The boundary that calls the value reports that throw as its own
+ * typed error (`guard.async.invoked`), which covers a class however it is disguised, binding it
+ * included, and rejects nothing a caller can legitimately pass. */
+// @enforced-by behavioral -- the shape is a typeof test against a string literal, and the pattern
+// @enforced-by behavioral -- scanner blanks every literal, so "function" cannot be told from
+// @enforced-by behavioral -- "string" or "object"; a lexical rule would flag every type check in
+// @enforced-by behavioral -- lib. The per-verb vectors across est, scep, acme, cmp and ct are the
+// @enforced-by behavioral -- guard: each drives the shipped verb and asserts the typed refusal.
+function assertCallable(value, E, code, label, shape) {
+  var wanted = label + " must be a function" + (shape ? " " + shape : "");
+  if (value === undefined) {
+    throw E(code, wanted + ", got undefined");
+  }
+  if (typeof value !== "function") {
+    throw E(code, wanted + ", got " + (value === null ? "null" : typeof value));
+  }
+  return value;
+}
+
+/** @internal The option form: an option counts as supplied when a name lookup finds the key, so a
+ * merge that produced `{ transport: undefined }` is a value the caller set rather than an option it
+ * left out. Presence is asked the way the boundary asks for the value, which is a plain lookup, so
+ * an inherited option from a defaults bag is checked rather than skipped; testing own keys alone
+ * would let an inherited null pass here and then be read as absent, selecting the default client.
+ * Only a key no lookup finds falls through to that default. */
+// @enforced-by behavioral -- the per-verb vectors across est, scep, acme, cmp, ct and path drive the
+// @enforced-by behavioral -- shipped verb and assert the typed refusal for each unusable value
+function assertCallableOption(opts, key, E, code, label, shape) {
+  if (opts == null || !(key in _Object(opts))) return undefined;
+  return assertCallable(opts[key], E, code, label, shape);
+}
+
 module.exports = intrinsic.freeze({
+  assertCallable: assertCallable,
+  assertCallableOption: assertCallableOption,
   assertCanonicalOid: assertCanonicalOid,
   assertKnownKeys: assertKnownKeys,
   assertPlainRecord: assertPlainRecord,

package/lib/guard-json.js

@@ -12,7 +12,7 @@ var _hasOwn = require("./guard-intrinsic").hasOwn;
 var _Number = require("./guard-intrinsic").Number;
 var _isFinite = require("./guard-intrinsic").isFinite;
 var _stringify = require("./guard-intrinsic").stringify;
-function _append(arr, v) { _defineProperty(arr, arr.length, { value: v, writable: true, enumerable: true, configurable: true }); }
+var _append = require("./guard-list").append;
 var limits = require("./guard-limits");
 
 function _hexVal(c) {

package/lib/guard-list.js

@@ -4,6 +4,21 @@
 // @internal
 
 var _freeze = require("./guard-intrinsic").freeze;
+var _defineProperty = require("./guard-intrinsic").defineProperty;
+var _isArray = require("./guard-intrinsic").isArray;
+
+var MAX_ARRAY_LENGTH = 4294967295;
+
+// @enforced-by guard-shape-reinlined
+// @guard-shape defineProperty\(\s*\w+\s*,\s*\w+\.length\s*,\s*\{\s*value:
+// @guard-via guard\.list\.append\(
+function append(list, value) {
+  if (!_isArray(list)) throw new TypeError("guard.list.append: the receiver must be an array");
+  var n = list.length;
+  if (n >= MAX_ARRAY_LENGTH) throw new RangeError("guard.list.append: the array is at its maximum length");
+  _defineProperty(list, n, { value: value, writable: true, enumerable: true, configurable: true });
+  return list;
+}
 
 // @enforced-by behavioral -- `.indexOf(x) !== -1` has no rename-proof form that separates a
 function contains(list, value) {
@@ -34,6 +49,7 @@ function allMatch(list, predicate) {
 }
 
 module.exports = _freeze({
+  append: append,
   contains: contains,
   containsAll: containsAll,
   anyMatches: anyMatches,

package/lib/guard-name.js

@@ -152,7 +152,7 @@ function escapeControlBytes(str) {
   return out;
 }
 
-var DN_SPECIAL = { 0x2c: 1, 0x2b: 1, 0x22: 1, 0x5c: 1, 0x3c: 1, 0x3e: 1, 0x3b: 1 };
+var DN_SPECIAL = intrinsic.assign(intrinsic.create(null), { 0x2c: 1, 0x2b: 1, 0x22: 1, 0x5c: 1, 0x3c: 1, 0x3e: 1, 0x3b: 1 });
 // @enforced-by behavioral -- the escaping has no rename-proof code shape distinct
 function escapeDnValue(v) {
   var s = _String(v), out = "";

package/lib/guard-parsed.js

@@ -20,7 +20,7 @@ var _weakSet = require("./guard-intrinsic").weakSet;
 var _weakHas = require("./guard-intrinsic").weakHas;
 var _WeakMap = require("./guard-intrinsic").WeakMap;
 var _defineProperty = require("./guard-intrinsic").defineProperty;
-function _append(arr, v) { _defineProperty(arr, arr.length, { value: v, writable: true, enumerable: true, configurable: true }); }
+var _append = require("./guard-list").append;
 
 function _isBytes(x) {
   return bytes.isByteSource(x);

package/lib/guard-time.js

@@ -3,7 +3,9 @@
 "use strict";
 // @internal
 
-var util = { types: require("./guard-intrinsic").types };
+var _create = require("./guard-intrinsic").create;
+var _assign = require("./guard-intrinsic").assign;
+var util = _assign(_create(null), { types: require("./guard-intrinsic").types });
 var _freeze = require("./guard-intrinsic").freeze;
 var _isNaN = Number.isNaN;
 var _Date = Date;

package/lib/guard-verdict.js

@@ -38,4 +38,10 @@ function carries(obj, key) {
   return obj != null && _hasOwn(_Object(obj), key);
 }
 
-module.exports = _freeze({ of: of, carries: carries });
+// @enforced-by behavioral -- for a target that cannot be rebuilt, an Error carrying a field a
+function set(target, key, value) {
+  _defineProperty(target, key, { value: value, enumerable: true, configurable: true, writable: true });
+  return target;
+}
+
+module.exports = _freeze({ of: of, carries: carries, set: set });

package/lib/hpke.js

@@ -102,8 +102,8 @@ function _labeledExpand(kdf, suiteId, prk, label, info, len) {
 }
 
 
-var OKP_SPKI = { X25519: "302a300506032b656e032100", X448: "3042300506032b656f033900" };
-var OKP_PKCS8 = { X25519: "302e020100300506032b656e04220420", X448: "3046020100300506032b656f043a0438" };
+var OKP_SPKI = intrinsic.assign(intrinsic.create(null), { X25519: "302a300506032b656e032100", X448: "3042300506032b656f033900" });
+var OKP_PKCS8 = intrinsic.assign(intrinsic.create(null), { X25519: "302e020100300506032b656e04220420", X448: "3046020100300506032b656f043a0438" });
 
 function _importPublic(kem, raw) {
   if (!Buffer.isBuffer(raw) || raw.length !== kem.Npub) {
@@ -318,9 +318,9 @@ function _recipPrivate(suite, sk) {
   }
 }
 
-var _COMMON_KEYS = { mode: 1, info: 1, psk: 1, pskId: 1 };
+var _COMMON_KEYS = intrinsic.assign(intrinsic.create(null), { mode: 1, info: 1, psk: 1, pskId: 1 });
 function _withCommon(extra) {
-  var out = {};
+  var out = intrinsic.create(null);
   Object.keys(_COMMON_KEYS).forEach(function (k) { out[k] = 1; });
   Object.keys(extra).forEach(function (k) { out[k] = 1; });
   return out;
@@ -348,12 +348,12 @@ function _mode(opts, keys, who) {
 }
 
 // @module @intro; a data registry, not a callable primitive).
-var suites = {
-  KEM: { DHKEM_P256_HKDF_SHA256: 0x0010, DHKEM_P521_HKDF_SHA512: 0x0012, DHKEM_X25519_HKDF_SHA256: 0x0020, DHKEM_X448_HKDF_SHA512: 0x0021 },
-  KDF: { HKDF_SHA256: 0x0001, HKDF_SHA512: 0x0003 },
-  AEAD: { AES_128_GCM: 0x0001, AES_256_GCM: 0x0002, CHACHA20_POLY1305: 0x0003, EXPORT_ONLY: 0xFFFF },
-  MODE: { BASE: MODE_BASE, PSK: MODE_PSK, AUTH: MODE_AUTH, AUTH_PSK: MODE_AUTH_PSK },
-};
+var suites = intrinsic.assign(intrinsic.create(null), {
+  KEM: intrinsic.assign(intrinsic.create(null), { DHKEM_P256_HKDF_SHA256: 0x0010, DHKEM_P521_HKDF_SHA512: 0x0012, DHKEM_X25519_HKDF_SHA256: 0x0020, DHKEM_X448_HKDF_SHA512: 0x0021 }),
+  KDF: intrinsic.assign(intrinsic.create(null), { HKDF_SHA256: 0x0001, HKDF_SHA512: 0x0003 }),
+  AEAD: intrinsic.assign(intrinsic.create(null), { AES_128_GCM: 0x0001, AES_256_GCM: 0x0002, CHACHA20_POLY1305: 0x0003, EXPORT_ONLY: 0xFFFF }),
+  MODE: intrinsic.assign(intrinsic.create(null), { BASE: MODE_BASE, PSK: MODE_PSK, AUTH: MODE_AUTH, AUTH_PSK: MODE_AUTH_PSK }),
+});
 
 
 /**

package/lib/http-digest.js

@@ -17,10 +17,10 @@ var ALGS = intrinsic.assign(intrinsic.create(null), {
   "SHA-256": { hash: "sha256", rank: 2, sess: false }, "SHA-256-SESS": { hash: "sha256", rank: 2, sess: true },
   "MD5": { hash: "md5", rank: 1, sess: false }, "MD5-SESS": { hash: "md5", rank: 1, sess: true },
 });
-var DEFAULT_CODES = {
+var DEFAULT_CODES = intrinsic.assign(intrinsic.create(null), {
   unsupportedAlgorithm: "digest/unsupported-algorithm", weakAlgorithm: "digest/weak-algorithm",
   noQop: "digest/no-qop", badChallenge: "digest/bad-challenge",
-};
+});
 
 function H(hash, s) { return crypto.createHash(hash).update(s, "latin1").digest("hex"); }
 function KD(hash, secret, data) { return H(hash, secret + ":" + data); }