@blamejs/core 0.6.70 → 0.7.0

package/lib/network-proxy.js

@@ -6,12 +6,19 @@ var net = require("node:net");
 var tls = require("node:tls");
 
 var C = require("./constants");
-var validateOpts = require("./validate-opts");
 var lazyRequire = require("./lazy-require");
+var safeUrl = require("./safe-url");
+var validateOpts = require("./validate-opts");
 var { defineClass } = require("./framework-error");
 
 var ProxyError = defineClass("ProxyError", { alwaysPermanent: false });
 
+// Protocol-fixed byte counts — passthrough through C.BYTES so the codebase
+// has a single source of truth for "what shape is this number".
+var IPV4_PREFIX_MAX_BITS = C.BYTES.bytes(32);   // RFC 791 §3.1 IPv4 address bit-width
+var DEFAULT_HTTPS_PORT   = 443;                 // RFC 9110 §4.2.2
+var DEFAULT_HTTP_PORT    = C.BYTES.bytes(80);   // RFC 9110 §4.2.1
+
 var observability = lazyRequire(function () { return require("./observability"); });
 
 var STATE = {
@@ -31,14 +38,18 @@ function _parseAuth(spec) {
 
 function _parseProxyUrl(value) {
   if (!value) return null;
-  var u;
-  try { u = new URL(value); } catch (_e) {
+  try {
+    return safeUrl.parse(value, {
+      allowedProtocols: safeUrl.ALLOW_HTTP_ALL,
+      allowUserinfo:    true,   // proxy auth is conventionally placed in the URL
+      errorClass:       ProxyError,
+    });
+  } catch (e) {
+    if (e && e.isSafeUrlError && e.code === "safe-url/protocol-disallowed") {
+      throw new ProxyError("proxy/bad-protocol", "proxy URL must be http:// or https://, got " + value);
+    }
     throw new ProxyError("proxy/bad-url", "invalid proxy URL: " + value);
   }
-  if (u.protocol !== "http:" && u.protocol !== "https:") {
-    throw new ProxyError("proxy/bad-protocol", "proxy URL must be http:// or https://, got " + u.protocol);
-  }
-  return u;
 }
 
 function _parseNoProxy(spec) {
@@ -97,14 +108,22 @@ function _matchCidr(cidr, host) {
   var network = cidr.slice(0, slash);
   var prefix = parseInt(cidr.slice(slash + 1), 10);
   if (net.isIP(host) !== 4 || net.isIP(network) !== 4) return false;
-  if (!isFinite(prefix) || prefix < 0 || prefix > 32) return false;
+  if (!isFinite(prefix) || prefix < 0 || prefix > IPV4_PREFIX_MAX_BITS) return false;
   if (prefix === 0) return true;
-  var mask = (0xffffffff << (32 - prefix)) >>> 0;
+  var mask = (0xffffffff << (IPV4_PREFIX_MAX_BITS - prefix)) >>> 0;
   return (_ipv4ToInt(host) & mask) === (_ipv4ToInt(network) & mask);
 }
 
+function _parseTarget(targetUrl) {
+  if (targetUrl instanceof URL) return targetUrl;
+  return safeUrl.parse(String(targetUrl), {
+    allowedProtocols: safeUrl.ALLOW_HTTP_ALL,
+    errorClass:       ProxyError,
+  });
+}
+
 function shouldProxy(targetUrl) {
-  var u = targetUrl instanceof URL ? targetUrl : new URL(String(targetUrl));
+  var u = _parseTarget(targetUrl);
   var host = u.hostname;
   var rules = STATE.noProxy;
   for (var i = 0; i < rules.length; i++) {
@@ -121,7 +140,7 @@ function shouldProxy(targetUrl) {
 }
 
 function _proxyForUrl(targetUrl) {
-  var u = targetUrl instanceof URL ? targetUrl : new URL(String(targetUrl));
+  var u = _parseTarget(targetUrl);
   if (!shouldProxy(u)) return null;
   return u.protocol === "https:" ? STATE.https : STATE.http;
 }
@@ -134,7 +153,7 @@ function _proxyAuthHeader(proxyUrl) {
 }
 
 function _connectThroughTunnel(proxyUrl, targetHost, targetPort, callback) {
-  var proxyPort = proxyUrl.port || (proxyUrl.protocol === "https:" ? 443 : 80);
+  var proxyPort = proxyUrl.port || (proxyUrl.protocol === "https:" ? DEFAULT_HTTPS_PORT : DEFAULT_HTTP_PORT);
   var proxySocket = proxyUrl.protocol === "https:"
     ? tls.connect({
         host:       proxyUrl.hostname,
@@ -167,7 +186,7 @@ function _connectThroughTunnel(proxyUrl, targetHost, targetPort, callback) {
       var match = /HTTP\/1\.[01] (\d{3})/.exec(status);
       if (!match || parseInt(match[1], 10) !== 200) {
         done(new ProxyError("proxy/connect-failed", "proxy CONNECT to " + targetHost + ":" + targetPort + " failed: " + status));
-        try { proxySocket.destroy(); } catch (_e) {}
+        try { proxySocket.destroy(); } catch (_e) { /* best-effort socket teardown */ }
         return;
       }
       done(null, proxySocket);
@@ -179,7 +198,7 @@ function _connectThroughTunnel(proxyUrl, targetHost, targetPort, callback) {
 function agentFor(targetUrl) {
   var proxy = _proxyForUrl(targetUrl);
   if (!proxy) return null;
-  var u = targetUrl instanceof URL ? targetUrl : new URL(String(targetUrl));
+  var u = _parseTarget(targetUrl);
   var key = proxy.toString() + "|" + u.protocol;
   if (STATE.agentCache.has(key)) return STATE.agentCache.get(key);
 
@@ -227,7 +246,7 @@ function snapshot() {
 }
 
 function _emitObs(name, fields) {
-  try { observability().emit(name, fields || {}); } catch (_e) {}
+  try { observability().emit(name, fields || {}); } catch (_e) { /* obs best-effort */ }
 }
 
 function _resetForTest() {

package/lib/network-tls.js

@@ -5,6 +5,8 @@ var fs = require("node:fs");
 var path = require("node:path");
 var nodeCrypto = require("node:crypto");
 
+var C = require("./constants");
+var safeBuffer = require("./safe-buffer");
 var validateOpts = require("./validate-opts");
 var lazyRequire = require("./lazy-require");
 var { defineClass } = require("./framework-error");
@@ -66,8 +68,8 @@ function _certMetadata(pem) {
 
 function _isPathLike(s) {
   if (s.indexOf("-----BEGIN") !== -1) return false;
-  if (s.length > 1024) return false;
-  if (/[\r\n]/.test(s)) return false;
+  if (s.length > C.BYTES.kib(1)) return false;
+  if (safeBuffer.hasCrlf(s)) return false;
   return true;
 }
 
@@ -159,7 +161,7 @@ function _emitAuditRemove(metaList, reason) {
           reason:         reason || "operator",
         },
       });
-    } catch (_e) {}
+    } catch (_e) { /* audit best-effort — never break the caller */ }
   }
 }
 
@@ -292,12 +294,12 @@ function _emitAuditAdd(metaList, opts) {
           label:          opts.label || null,
         },
       });
-    } catch (_e) {}
+    } catch (_e) { /* audit best-effort — never break the caller */ }
   }
 }
 
 function _emitObs(name, fields) {
-  try { observability().emit(name, fields || {}); } catch (_e) {}
+  try { observability().emit(name, fields || {}); } catch (_e) { /* obs best-effort */ }
 }
 
 function _resetForTest() {

package/lib/network.js

@@ -77,7 +77,7 @@ function applyToSocket(socket) {
     if (typeof socket.setKeepAlive === "function") {
       socket.setKeepAlive(SOCKET_DEFAULTS.keepAlive, SOCKET_DEFAULTS.keepAliveInitialDelayMs || 0);
     }
-  } catch (_e) {}
+  } catch (_e) { /* best-effort socket-tuning — apply or skip */ }
   return socket;
 }
 
@@ -172,7 +172,7 @@ function bootFromEnv(opts) {
           outcome:  "success",
           metadata: applied,
         });
-      } catch (_e) {}
+      } catch (_e) { /* audit best-effort — never break boot */ }
     }
   }
   _emitObs("network.boot.from_env", { source: "env" });
@@ -197,7 +197,7 @@ function snapshot() {
 }
 
 function _emitObs(name, fields) {
-  try { observability().emit(name, fields || {}); } catch (_e) {}
+  try { observability().emit(name, fields || {}); } catch (_e) { /* obs best-effort */ }
 }
 
 function _resetForTest() {

package/lib/notify.js

@@ -127,9 +127,7 @@ function _validateChannelEntry(name, entry) {
 }
 
 function _validateCreateOpts(opts) {
-  if (!opts || typeof opts !== "object") {
-    throw _err("BAD_OPT", "notify.create: opts must be an object");
-  }
+  validateOpts.requireObject(opts, "notify.create", NotifyError);
   if (!opts.channels || typeof opts.channels !== "object") {
     throw _err("BAD_OPT", "notify.create: channels must be an object mapping channel names to transports");
   }
@@ -137,17 +135,9 @@ function _validateCreateOpts(opts) {
   if (keys.length === 0) {
     throw _err("BAD_OPT", "notify.create: channels object must have at least one channel");
   }
-  if (opts.audit !== undefined && opts.audit !== null) {
-    if (typeof opts.audit !== "object" || typeof opts.audit.safeEmit !== "function") {
-      throw _err("BAD_OPT", "notify.create: audit must be a b.audit-shaped object (safeEmit fn)");
-    }
-  }
-  if (opts.auditSuccess !== undefined && typeof opts.auditSuccess !== "boolean") {
-    throw _err("BAD_OPT", "notify.create: auditSuccess must be a boolean");
-  }
-  if (opts.auditFailures !== undefined && typeof opts.auditFailures !== "boolean") {
-    throw _err("BAD_OPT", "notify.create: auditFailures must be a boolean");
-  }
+  validateOpts.auditShape(opts.audit, "notify.create", NotifyError);
+  validateOpts.optionalBoolean(opts.auditSuccess, "notify.create: auditSuccess", NotifyError);
+  validateOpts.optionalBoolean(opts.auditFailures, "notify.create: auditFailures", NotifyError);
   if (opts.redact !== undefined && opts.redact !== null && typeof opts.redact !== "function") {
     throw _err("BAD_OPT", "notify.create: redact must be a function returning a redacted message");
   }
@@ -169,9 +159,7 @@ function _validateCreateOpts(opts) {
       throw _err("BAD_OPT", "notify.create: queue must be a b.queue-shaped handle (enqueue fn)");
     }
   }
-  if (opts.clock !== undefined && typeof opts.clock !== "function") {
-    throw _err("BAD_OPT", "notify.create: clock must be a function");
-  }
+  validateOpts.optionalFunction(opts.clock, "notify.create: clock", NotifyError);
 }
 
 // ---- Built-in transports ----
@@ -183,9 +171,7 @@ function httpJson(opts) {
   if (!opts || typeof opts !== "object") {
     throw _err("BAD_OPT", "notify.transports.httpJson: opts must be { url, ... }");
   }
-  if (typeof opts.url !== "string" || opts.url.length === 0) {
-    throw _err("BAD_OPT", "notify.transports.httpJson: url is required");
-  }
+  validateOpts.requireNonEmptyString(opts.url, "notify.transports.httpJson: url", NotifyError, "BAD_OPT");
   var allowedProtocols = opts.allowHttp ? safeUrl.ALLOW_HTTP_ALL : safeUrl.ALLOW_HTTP_TLS;
   var allowInternal = opts.allowInternal != null ? opts.allowInternal : null;
   // Validate URL at create time so bad URLs surface at boot, not at first send.
@@ -270,18 +256,14 @@ function httpJson(opts) {
 // log — fire-and-forget developer logger. Never throws; audit + obs still emit.
 function logTransport(opts) {
   opts = opts || {};
+  // bootLog.boot() returns a callable with .info / .warn / .error
+  // attached; that shape satisfies the operator-supplied opts.logger
+  // contract directly. No fallback wrapper needed.
   var logger;
   if (opts.logger && typeof opts.logger.info === "function") {
     logger = opts.logger;
   } else {
     logger = bootLog.boot("notify.log");
-    // boot returns a fn-with-fields shape; tolerate both.
-    if (typeof logger === "function") {
-      logger = { info: logger, error: function (m) { try { console.error(m); } catch (_e) {} } };
-    }
-    if (typeof logger.error !== "function") {
-      logger.error = function (m) { try { console.error(m); } catch (_e) {} };
-    }
   }
   return {
     name: opts.name || "log",
@@ -321,16 +303,16 @@ function create(opts) {
     "queue", "clock",
   ], "notify");
   _validateCreateOpts(opts);
+  var cfg = validateOpts.applyDefaults(opts, DEFAULTS);
 
-  var auditSuccess  = (opts.auditSuccess  === undefined) ? DEFAULTS.auditSuccess  : opts.auditSuccess;
-  var auditFailures = (opts.auditFailures === undefined) ? DEFAULTS.auditFailures : opts.auditFailures;
+  var auditSuccess  = cfg.auditSuccess;
+  var auditFailures = cfg.auditFailures;
   var audit = opts.audit || null;
   var redactFn = (typeof opts.redact === "function")
     ? opts.redact
     // Default: b.redact.redact — the framework's PII detector chain.
     : function (m) { return redactModule().redact(m); };
-  var defaultTimeoutMs = (opts.defaultTimeoutMs === undefined)
-    ? DEFAULTS.defaultTimeoutMs : opts.defaultTimeoutMs;
+  var defaultTimeoutMs = cfg.defaultTimeoutMs;
   var defaultRetry = opts.defaultRetry || null;
   var defaultBreaker = opts.defaultBreaker || null;
   var operatorQueue = opts.queue || null;
@@ -362,11 +344,7 @@ function create(opts) {
     catch (_e) { /* drop-silent — observability sink must not crash send() */ }
   }
 
-  function _emitAudit(action, info) {
-    if (!audit) return;
-    try { audit.safeEmit(Object.assign({ action: action }, info || {})); }
-    catch (_e) { /* audit best-effort */ }
-  }
+  var _emitAudit = validateOpts.makeAuditEmitter(audit);
 
   function _actor(callerOpts) {
     return requestHelpers.resolveActorWithOverride(callerOpts);

package/lib/ntp-check.js

@@ -34,7 +34,8 @@ var NTP_TO_UNIX_OFFSET_SECONDS = 2208988800;
 
 var DEFAULT_SERVERS = ["pool.ntp.org", "time.cloudflare.com"];
 var DEFAULT_PORT    = 123;
-var DEFAULT_TIMEOUT_MS = 3000;
+var DEFAULT_TIMEOUT_MS = C.TIME.seconds(3);
+var NTP_PACKET_BYTES = C.BYTES.bytes(48);  // RFC 5905 §7.3
 
 var DEFAULT_DRIFT_WARN_MS  = C.TIME.minutes(5);
 var DEFAULT_DRIFT_FATAL_MS = C.TIME.hours(1);
@@ -105,9 +106,9 @@ function querySingle(server, opts) {
     }, timeoutMs);
     timer.unref();
 
-    // SNTPv4 client request: 48-byte buffer, byte 0 = 0b00_100_011 = 0x23
+    // SNTPv4 client request: NTP_PACKET_BYTES buffer, byte 0 = 0b00_100_011 = 0x23
     //   LI=0 (no warning), VN=4, Mode=3 (client). Other bytes zero.
-    var req = Buffer.alloc(48);
+    var req = Buffer.alloc(NTP_PACKET_BYTES);
     req[0] = 0x23;
     var sendTimeMs = Date.now();
 
@@ -119,15 +120,15 @@ function querySingle(server, opts) {
     socket.on("message", function (msg) {
       clearTimeout(timer);
       var receiveTimeMs = Date.now();
-      if (!Buffer.isBuffer(msg) || msg.length < 48) {
+      if (!Buffer.isBuffer(msg) || msg.length < NTP_PACKET_BYTES) {
         return done({ code: "ntp/bad-reply", message: "reply too short (" + (msg && msg.length) + " bytes)" });
       }
       // Bytes 40-47 = Transmit Timestamp (NTP epoch seconds.fraction)
       var ntpSeconds  = msg.readUInt32BE(40);
       var ntpFraction = msg.readUInt32BE(44);
       var serverUnixSeconds = ntpSeconds - NTP_TO_UNIX_OFFSET_SECONDS;
-      var fracMs = Math.round(ntpFraction / 0x100000000 * 1000);
-      var serverTimeMs = serverUnixSeconds * 1000 + fracMs;
+      var fracMs = Math.round(C.TIME.seconds(ntpFraction / 0x100000000));
+      var serverTimeMs = C.TIME.seconds(serverUnixSeconds) + fracMs;
 
       // Round-trip-corrected drift: assume the server's reply transmit
       // timestamp is approximately at the midpoint of our send/receive.

package/lib/numeric-bounds.js

@@ -52,8 +52,40 @@ function isNonNegativeFiniteInt(value) {
          Number.isInteger(value) && value >= 0;
 }
 
+// requirePositiveFiniteIntIfPresent / requireNonNegativeFiniteIntIfPresent —
+// optional-shape gates that throw via the caller's framework-error class
+// when the value is present but invalid. Replaces the per-file
+// `if (opts.X !== undefined) { if (!nb.isYFiniteInt(opts.X)) throw new
+// XError(...); }` cascade that app-shutdown / bundler / dev /
+// http-client-cookie-jar / external-db-migrate / restore-rollback
+// previously rolled by hand.
+//
+//   var nb = require("./numeric-bounds");
+//   nb.requirePositiveFiniteIntIfPresent(opts.graceMs,
+//     "app-shutdown.create: opts.graceMs", AppShutdownError,
+//     "app-shutdown/bad-grace-ms");
+function requirePositiveFiniteIntIfPresent(value, label, errorClass, code) {
+  if (value === undefined) return value;
+  if (!isPositiveFiniteInt(value)) {
+    throw new errorClass(code,
+      (label || "value") + " must be a positive finite integer; got " + shape(value));
+  }
+  return value;
+}
+
+function requireNonNegativeFiniteIntIfPresent(value, label, errorClass, code) {
+  if (value === undefined) return value;
+  if (!isNonNegativeFiniteInt(value)) {
+    throw new errorClass(code,
+      (label || "value") + " must be a non-negative finite integer; got " + shape(value));
+  }
+  return value;
+}
+
 module.exports = {
-  shape:                  shape,
-  isPositiveFiniteInt:    isPositiveFiniteInt,
-  isNonNegativeFiniteInt: isNonNegativeFiniteInt,
+  shape:                                  shape,
+  isPositiveFiniteInt:                    isPositiveFiniteInt,
+  isNonNegativeFiniteInt:                 isNonNegativeFiniteInt,
+  requirePositiveFiniteIntIfPresent:      requirePositiveFiniteIntIfPresent,
+  requireNonNegativeFiniteIntIfPresent:   requireNonNegativeFiniteIntIfPresent,
 };

package/lib/object-store/azure-blob-bucket-ops.js

@@ -29,12 +29,42 @@
  *     gap rather than half-implementing one auth path.
  */
 var azureBlob = require("./azure-blob");
+var C = require("../constants");
 var httpClient = require("../http-client");
+var requestHelpers = require("../request-helpers");
 var safeUrl = require("../safe-url");
 var { ObjectStoreError } = require("../framework-error");
 
 var _err = ObjectStoreError.factory;
 
+// HTTP status constants used in the bucket-ops expectStatus arrays.
+// OK / NOT_FOUND / CONFLICT come from the framework's HTTP_STATUS table;
+// CREATED (201) and ACCEPTED (202) are not in the table, so they're
+// named locally with their RFC 7231 values.
+var HTTP_OK         = requestHelpers.HTTP_STATUS.OK;
+var HTTP_NOT_FOUND  = requestHelpers.HTTP_STATUS.NOT_FOUND;
+var HTTP_CONFLICT   = requestHelpers.HTTP_STATUS.CONFLICT;
+var HTTP_CREATED    = 201;   // RFC 7231 §6.3.2
+var HTTP_ACCEPTED   = 202;   // RFC 7231 §6.3.3
+
+// Internal URL builder — endpoint + path string from validated config.
+// Routes through safeUrl.parse so the protocol allowlist + length cap
+// apply uniformly.
+function _internalUrl(input, allowedProtocols) {
+  return safeUrl.parse(input, {
+    allowedProtocols: allowedProtocols || safeUrl.ALLOW_HTTP_TLS,
+    errorClass:       ObjectStoreError,
+    maxUrlLength:     C.BYTES.kib(32),
+  });
+}
+
+// Maximum length for a tag passed into the framework-internal XML
+// extractor. The XML payloads come back from Azure (server-controlled)
+// but the tag name is framework-supplied; cap it explicitly so the
+// open/close substrings used for indexOf walks can't be driven against
+// an oversize pattern.
+var MAX_XML_TAG_LENGTH = 128;
+
 // Azure container names: 3-63 chars, lowercase alphanumeric + hyphens,
 // no consecutive hyphens, must start and end with letter or digit.
 var CONTAINER_NAME_RE = /^[a-z0-9](?:[a-z0-9]|-(?!-))*[a-z0-9]$/;
@@ -49,7 +79,9 @@ function _validateContainerName(name) {
       "azure-blob bucketOps: container name must be 3-63 chars (got " +
       name.length + ")", true);
   }
-  if (!CONTAINER_NAME_RE.test(name)) {
+  // Length is bounded above (3..63) before the regex runs so the
+  // pattern can't be driven against an unbounded input.
+  if (name.length > 63 || !CONTAINER_NAME_RE.test(name)) {
     throw _err("BUCKET_INVALID_NAME",
       "azure-blob bucketOps: container name '" + name + "' is invalid; " +
       "lowercase letters / digits / hyphens only, no consecutive hyphens, " +
@@ -119,16 +151,42 @@ function _buildCorsXml(rules) {
 
 // Tiny XML extractor — pulls every occurrence of <Tag>value</Tag>
 // and returns an array of value strings. Sufficient for the limited
-// shapes we read (Containers list, container metadata).
+// shapes we read (Containers list, container metadata). The tag is
+// framework-supplied (call sites pass hardcoded tag names such as
+// "Container", "Name", "Last-Modified") but cap the length explicitly
+// so the open/close substrings used for indexOf walks can't be driven
+// against an oversize pattern under any future call shape.
+function _validateTag(tag) {
+  if (typeof tag !== "string" || tag.length === 0 || tag.length > MAX_XML_TAG_LENGTH) {
+    throw _err("BUCKET_INVALID_NAME",
+      "azure-blob bucketOps: XML tag must be a non-empty string of length " +
+      "<= " + MAX_XML_TAG_LENGTH, true);
+  }
+  if (!/^[A-Za-z][A-Za-z0-9_.-]*$/.test(tag)) {
+    throw _err("BUCKET_INVALID_NAME",
+      "azure-blob bucketOps: XML tag '" + tag + "' has invalid characters", true);
+  }
+}
+
 function _extractAll(xml, tag) {
+  _validateTag(tag);
+  var open = "<" + tag + ">";
+  var close = "</" + tag + ">";
   var out = [];
-  var re = new RegExp("<" + tag + ">([\\s\\S]*?)</" + tag + ">", "g");
-  var m;
-  while ((m = re.exec(xml)) !== null) out.push(m[1]);
+  var i = 0;
+  while (true) {
+    var s = xml.indexOf(open, i);
+    if (s === -1) break;
+    var e = xml.indexOf(close, s + open.length);
+    if (e === -1) break;
+    out.push(xml.slice(s + open.length, e));
+    i = e + close.length;
+  }
   return out;
 }
 
 function _extractBlocks(xml, tag) {
+  _validateTag(tag);
   var open = "<" + tag + ">";
   var close = "</" + tag + ">";
   var blocks = [];
@@ -202,7 +260,7 @@ function create(config) {
   async function createContainer(name, opts) {
     _validateContainerName(name);
     opts = opts || {};
-    var url = new URL(endpoint + "/" + name + "?restype=container");
+    var url = _internalUrl(endpoint + "/" + name + "?restype=container", allowedProtocols);
     var headers = { "Content-Length": "0" };
     if (opts.publicAccess) {
       if (opts.publicAccess !== "blob" && opts.publicAccess !== "container") {
@@ -213,8 +271,8 @@ function create(config) {
       headers["x-ms-blob-public-access"] = opts.publicAccess;
     }
     var signed = _sign("PUT", url, headers);
-    var res = await _request("PUT", url, signed, null, [201, 409]);
-    if (res.statusCode === 409) {
+    var res = await _request("PUT", url, signed, null, [HTTP_CREATED, HTTP_CONFLICT]);
+    if (res.statusCode === HTTP_CONFLICT) {
       throw _err("BUCKET_ALREADY_OWNED",
         "azure-blob bucketOps: container '" + name +
         "' already exists or was recently deleted", true);
@@ -224,19 +282,19 @@ function create(config) {
 
   async function deleteContainer(name) {
     _validateContainerName(name);
-    var url = new URL(endpoint + "/" + name + "?restype=container");
+    var url = _internalUrl(endpoint + "/" + name + "?restype=container", allowedProtocols);
     var signed = _sign("DELETE", url, {});
-    var res = await _request("DELETE", url, signed, null, [202, 404]);
-    return res.statusCode === 202;
+    var res = await _request("DELETE", url, signed, null, [HTTP_ACCEPTED, HTTP_NOT_FOUND]);
+    return res.statusCode === HTTP_ACCEPTED;
   }
 
   async function listContainers(opts) {
     opts = opts || {};
-    var url = new URL(endpoint + "/?comp=list");
+    var url = _internalUrl(endpoint + "/?comp=list", allowedProtocols);
     if (opts.prefix)  url.searchParams.set("prefix", opts.prefix);
     if (opts.maxResults != null) url.searchParams.set("maxresults", String(opts.maxResults));
     var signed = _sign("GET", url, {});
-    var res = await _request("GET", url, signed, null, [200]);
+    var res = await _request("GET", url, signed, null, [HTTP_OK]);
     var xml = Buffer.isBuffer(res.body) ? res.body.toString("utf8") :
               typeof res.body === "string" ? res.body :
               "";
@@ -261,13 +319,13 @@ function create(config) {
     rules.forEach(_validateCorsRule);
     var xml = _buildCorsXml(rules);
     var bodyBuf = Buffer.from(xml, "utf8");
-    var url = new URL(endpoint + "/?restype=service&comp=properties");
+    var url = _internalUrl(endpoint + "/?restype=service&comp=properties", allowedProtocols);
     var headers = {
       "Content-Type":   "application/xml",
       "Content-Length": String(bodyBuf.length),
     };
     var signed = _sign("PUT", url, headers);
-    await _request("PUT", url, signed, bodyBuf, [202]);
+    await _request("PUT", url, signed, bodyBuf, [HTTP_ACCEPTED]);
     return { rulesApplied: rules.length };
   }