@adviser/cement 0.2.45 → 0.3.1

package/index.cjs

@@ -14,9 +14,9 @@ var __export = (target, all) => {
 };
 var __copyProps = (to, from2, except, desc) => {
   if (from2 && typeof from2 === "object" || typeof from2 === "function") {
-    for (let key of __getOwnPropNames(from2))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+    for (let key2 of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from2[key2], enumerable: !(desc = __getOwnPropDesc(from2, key2)) || desc.enumerable });
   }
   return to;
 };
@@ -65,7 +65,6 @@ __export(src_exports, {
   MutableURL: () => MutableURL,
   None: () => None,
   Option: () => Option,
-  REQUIRED: () => REQUIRED,
   RandomMode: () => RandomMode,
   RandomService: () => RandomService,
   ResolveOnce: () => ResolveOnce,
@@ -95,7 +94,9 @@ __export(src_exports, {
   exception2Result: () => exception2Result,
   hasHostPartProtocols: () => hasHostPartProtocols,
   isURL: () => isURL,
+  key: () => key,
   logValue: () => logValue,
+  registerEnvAction: () => registerEnvAction,
   runtimeFn: () => runtimeFn,
   toCryptoRuntime: () => toCryptoRuntime,
   utils: () => utils_exports
@@ -247,16 +248,16 @@ function logValueInternal(val, ctx) {
       }
       const res = {};
       const typedVal = val;
-      for (const key in typedVal) {
-        if (ctx.ignoreAttr.IsSome() && ctx.ignoreAttr.unwrap().test(key)) {
+      for (const key2 in typedVal) {
+        if (ctx.ignoreAttr.IsSome() && ctx.ignoreAttr.unwrap().test(key2)) {
           continue;
         }
-        const element = typedVal[key];
+        const element = typedVal[key2];
         if (element instanceof LogValue) {
-          res[key] = element;
+          res[key2] = element;
         } else {
           if (typeof element !== "function") {
-            res[key] = logValueInternal(element, ctx);
+            res[key2] = logValueInternal(element, ctx);
           }
         }
       }
@@ -663,24 +664,24 @@ var Keyed = class {
     this._map = /* @__PURE__ */ new Map();
     this.factory = factory;
   }
-  async asyncGet(key) {
-    return this.get(await key());
+  async asyncGet(key2) {
+    return this.get(await key2());
   }
-  get(key) {
-    if (typeof key === "function") {
-      key = key();
+  get(key2) {
+    if (typeof key2 === "function") {
+      key2 = key2();
     }
-    let keyed = this._map.get(key);
+    let keyed = this._map.get(key2);
     if (!keyed) {
-      keyed = this.factory(key);
-      this._map.set(key, keyed);
+      keyed = this.factory(key2);
+      this._map.set(key2, keyed);
     }
     return keyed;
   }
-  unget(key) {
-    const keyed = this._map.get(key);
+  unget(key2) {
+    const keyed = this._map.get(key2);
     keyed == null ? void 0 : keyed.reset();
-    this._map.delete(key);
+    this._map.delete(key2);
   }
   reset() {
     this._map.forEach((keyed) => keyed.reset());
@@ -689,12 +690,12 @@ var Keyed = class {
 };
 var KeyedResolvOnce = class extends Keyed {
   constructor() {
-    super((key) => new ResolveOnce(key));
+    super((key2) => new ResolveOnce(key2));
   }
 };
 var KeyedResolvSeq = class extends Keyed {
   constructor() {
-    super((key) => new ResolveSeq(key));
+    super((key2) => new ResolveSeq(key2));
   }
 };
 
@@ -715,16 +716,16 @@ var NodeEnvActions = class {
   keys() {
     return Object.keys(this._env);
   }
-  get(key) {
-    return this._env[key];
+  get(key2) {
+    return this._env[key2];
   }
-  set(key, value) {
+  set(key2, value) {
     if (value) {
-      this._env[key] = value;
+      this._env[key2] = value;
     }
   }
-  delete(key) {
-    delete this._env[key];
+  delete(key2) {
+    delete this._env[key2];
   }
 };
 _node = new WeakMap();
@@ -746,16 +747,16 @@ var DenoEnvActions = class {
   keys() {
     return Array.from(this._env.keys());
   }
-  get(key) {
-    return this._env.get(key);
+  get(key2) {
+    return this._env.get(key2);
   }
-  set(key, value) {
+  set(key2, value) {
     if (value) {
-      this._env.set(key, value);
+      this._env.set(key2, value);
     }
   }
-  delete(key) {
-    this._env.delete(key);
+  delete(key2) {
+    this._env.delete(key2);
   }
 };
 _deno = new WeakMap();
@@ -764,16 +765,16 @@ var BrowserEnvActions = class {
     this.env = /* @__PURE__ */ new Map();
     this.opts = opts;
   }
-  get(key) {
-    return this.env.get(key);
+  get(key2) {
+    return this.env.get(key2);
   }
-  set(key, value) {
+  set(key2, value) {
     if (value) {
-      this.env.set(key, value);
+      this.env.set(key2, value);
     }
   }
-  delete(key) {
-    this.env.delete(key);
+  delete(key2) {
+    this.env.delete(key2);
   }
   keys() {
     return Array.from(this.env.keys());
@@ -788,10 +789,26 @@ var BrowserEnvActions = class {
     return env;
   }
 };
+var envActions = [
+  { id: "node", fn: (opts) => new NodeEnvActions(opts) },
+  { id: "deno", fn: (opts) => new DenoEnvActions(opts) },
+  { id: "browser", fn: (opts) => new BrowserEnvActions(opts) }
+];
+function registerEnvAction(fn) {
+  const id = `id-${Math.random()}`;
+  envActions.unshift({ id, fn });
+  _envFactory.reset();
+  return () => {
+    const index = envActions.findIndex((i) => i.id === id);
+    if (index >= 0) {
+      envActions.splice(index, 1);
+    }
+  };
+}
 var _envFactory = new ResolveOnce();
 function envFactory(opts = {}) {
   return _envFactory.once(() => {
-    const found = [new NodeEnvActions(opts), new DenoEnvActions(opts), new BrowserEnvActions(opts)].find((env) => env.active());
+    const found = envActions.map((facItem) => facItem.fn(opts)).find((env) => env.active());
     if (!found) {
       throw new Error("SysContainer:envFactory: no env available");
     }
@@ -810,15 +827,15 @@ var EnvImpl = class {
     if (!presetEnv) {
       return;
     }
-    for (const [key, value] of presetEnv) {
-      this._map.set(key, value);
+    for (const [key2, value] of presetEnv) {
+      this._map.set(key2, value);
     }
   }
-  _applyOnSet(onSet, key, value) {
+  _applyOnSet(onSet, key2, value) {
     onSet.forEach((item) => {
       let keys = [];
-      if (key) {
-        keys = [key];
+      if (key2) {
+        keys = [key2];
       } else {
         keys = this._map.keys();
       }
@@ -832,9 +849,9 @@ var EnvImpl = class {
         return false;
       }).forEach((k) => {
         let v;
-        if (!key && !value) {
+        if (!key2 && !value) {
           v = this._map.get(k);
-        } else if (key && !value) {
+        } else if (key2 && !value) {
           v = void 0;
         } else {
           v = value;
@@ -852,19 +869,19 @@ var EnvImpl = class {
     this._onSet.push(item);
     this._applyOnSet([item]);
   }
-  get(key) {
-    return this._map.get(key);
+  get(key2) {
+    return this._map.get(key2);
   }
-  set(key, value) {
+  set(key2, value) {
     if (!value) {
       return;
     }
-    this._map.set(key, value);
-    this._applyOnSet(this._onSet, key, value);
+    this._map.set(key2, value);
+    this._applyOnSet(this._onSet, key2, value);
   }
-  delete(key) {
-    this._map.delete(key);
-    this._applyOnSet(this._onSet, key);
+  delete(key2) {
+    this._map.delete(key2);
+    this._applyOnSet(this._onSet, key2);
   }
 };
 
@@ -1202,37 +1219,37 @@ function localStripper(path, restrips, obj) {
     return obj.map((i) => localStripper(path, restrips, i));
   }
   const ret = { ...obj };
-  const matcher = (key, nextPath) => {
+  const matcher = (key2, nextPath) => {
     for (const re of restrips) {
-      if (re.test(key) || re.test(nextPath)) {
+      if (re.test(key2) || re.test(nextPath)) {
         return true;
       }
     }
     return false;
   };
-  for (const key in ret) {
-    if (Object.prototype.hasOwnProperty.call(ret, key)) {
+  for (const key2 in ret) {
+    if (Object.prototype.hasOwnProperty.call(ret, key2)) {
       let nextPath;
       if (path) {
-        nextPath = [path, key].join(".");
+        nextPath = [path, key2].join(".");
       } else {
-        nextPath = key;
+        nextPath = key2;
       }
-      if (matcher(key, nextPath)) {
-        delete ret[key];
+      if (matcher(key2, nextPath)) {
+        delete ret[key2];
         continue;
       }
-      if (typeof ret[key] === "object") {
-        if (Array.isArray(ret[key])) {
-          ret[key] = ret[key].reduce((acc, v, i) => {
-            const toDelete = matcher(key, `${nextPath}[${i}]`);
+      if (typeof ret[key2] === "object") {
+        if (Array.isArray(ret[key2])) {
+          ret[key2] = ret[key2].reduce((acc, v, i) => {
+            const toDelete = matcher(key2, `${nextPath}[${i}]`);
             if (!toDelete) {
               acc.push(localStripper(`${nextPath}[${i}]`, restrips, v));
             }
             return acc;
           }, []);
         } else {
-          ret[key] = localStripper(nextPath, restrips, ret[key]);
+          ret[key2] = localStripper(nextPath, restrips, ret[key2]);
         }
       }
     }
@@ -1241,16 +1258,29 @@ function localStripper(path, restrips, obj) {
 }
 
 // src/uri.ts
-var REQUIRED = 4711;
-function coerceKey(key, def) {
-  if (typeof key === "object") {
-    const keys = Object.keys(key);
+var _REQUIRED = class {
+  constructor() {
+    this.val = "REQUIRED";
+  }
+};
+var _OPTIONAL = class {
+  constructor() {
+    this.val = "OPTIONAL";
+  }
+};
+var key = {
+  REQUIRED: new _REQUIRED(),
+  OPTIONAL: new _OPTIONAL()
+};
+function coerceKey(key2, def) {
+  if (typeof key2 === "object") {
+    const keys = Object.keys(key2);
     if (keys.length !== 1) {
-      throw new Error(`Invalid key: ${JSON.stringify(key)}`);
+      throw new Error(`Invalid key: ${JSON.stringify(key2)}`);
     }
-    return { key: keys[0], def: key[keys[0]] };
+    return { key: keys[0], def: key2[keys[0]] };
   }
-  return { key, def };
+  return { key: key2, def };
 }
 function falsy2undef(value) {
   return value === void 0 || value === null ? void 0 : value;
@@ -1353,8 +1383,8 @@ var MutableURL = class _MutableURL extends URL {
   toString() {
     let search = "";
     if (this._sysURL.searchParams.size) {
-      for (const [key, value] of Array.from(this._sysURL.searchParams.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
-        search += `${!search.length ? "?" : "&"}${key}=${encodeURIComponent(value)}`;
+      for (const [key2, value] of Array.from(this._sysURL.searchParams.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
+        search += `${!search.length ? "?" : "&"}${key2}=${encodeURIComponent(value)}`;
       }
     }
     let hostpart = "";
@@ -1389,11 +1419,11 @@ function from(fac, strURLUri, defaultProtocol) {
       throw new Error(`Invalid argument: ${typeof strURLUri}`);
   }
 }
-function getParamResult(key, val, msgFn = (key2) => {
-  return `missing parameter: ${key2}`;
+function getParamResult(key2, val, msgFn = (key3) => {
+  return `missing parameter: ${key3}`;
 }) {
   if (val === void 0) {
-    return Result.Err(msgFn(key));
+    return Result.Err(msgFn(key2));
   }
   return Result.Ok(val);
 }
@@ -1401,9 +1431,15 @@ function getParamsResult(keys, getParam) {
   const keyDef = keys.flat().reduce(
     (acc, i) => {
       if (typeof i === "string") {
-        acc.push({ key: i });
+        acc.push({ key: i, def: void 0, isOptional: false });
       } else if (typeof i === "object") {
-        acc.push(...Object.keys(i).map((k) => ({ key: k, def: typeof i[k] === "string" ? i[k] : void 0 })));
+        acc.push(
+          ...Object.keys(i).map((k) => ({
+            key: k,
+            def: typeof i[k] === "string" ? i[k] : void 0,
+            isOptional: i[k] instanceof _OPTIONAL
+          }))
+        );
       }
       return acc;
     },
@@ -1421,7 +1457,9 @@ function getParamsResult(keys, getParam) {
       if (typeof kd.def === "string") {
         result[kd.key] = kd.def;
       } else {
-        errors.push(kd.key);
+        if (!kd.isOptional) {
+          errors.push(kd.key);
+        }
       }
     } else {
       result[kd.key] = val;
@@ -1485,47 +1523,47 @@ var BuildURI = class _BuildURI {
     const pathname = "./" + appendUrl.pathname;
     const basePath = this._url.pathname;
     this.pathname(relativePath(basePath, pathname));
-    for (const [key, value] of appendUrl.getParams) {
-      this.setParam(key, value);
+    for (const [key2, value] of appendUrl.getParams) {
+      this.setParam(key2, value);
     }
     return this;
   }
   cleanParams() {
-    for (const key of Array.from(this._url.searchParams.keys())) {
-      this._url.searchParams.delete(key);
+    for (const key2 of Array.from(this._url.searchParams.keys())) {
+      this._url.searchParams.delete(key2);
     }
     return this;
   }
-  delParam(key) {
-    this._url.searchParams.delete(key);
+  delParam(key2) {
+    this._url.searchParams.delete(key2);
     return this;
   }
-  defParam(key, str) {
-    if (!this._url.searchParams.has(key)) {
-      this._url.searchParams.set(key, str);
+  defParam(key2, str) {
+    if (!this._url.searchParams.has(key2)) {
+      this._url.searchParams.set(key2, str);
     }
     return this;
   }
-  setParam(key, str) {
-    this._url.searchParams.set(key, str);
+  setParam(key2, str) {
+    this._url.searchParams.set(key2, str);
     return this;
   }
-  hasParam(key) {
-    return this._url.searchParams.has(key);
+  hasParam(key2) {
+    return this._url.searchParams.has(key2);
   }
   get getParams() {
     return this._url.searchParams.entries();
   }
-  getParam(key, def) {
-    const { key: k, def: d } = coerceKey(key, def);
+  getParam(key2, def) {
+    const { key: k, def: d } = coerceKey(key2, def);
     let val = this._url.searchParams.get(k);
     if (!falsy2undef(val) && d) {
       val = d;
     }
     return falsy2undef(val);
   }
-  getParamResult(key, msgFn) {
-    return getParamResult(key, this.getParam(key), msgFn);
+  getParamResult(key2, msgFn) {
+    return getParamResult(key2, this.getParam(key2), msgFn);
   }
   getParamsResult(...keys) {
     return getParamsResult(keys, this);
@@ -1568,8 +1606,8 @@ var URI = class _URI {
     if (!(fPath.length === 0 || fPath === "/" || fPath === "./")) {
       intoUrl.pathname(fromUrl.pathname);
     }
-    for (const [key, value] of fromUrl.getParams) {
-      intoUrl.setParam(key, value);
+    for (const [key2, value] of fromUrl.getParams) {
+      intoUrl.setParam(key2, value);
     }
     return intoUrl.URI();
   }
@@ -1622,19 +1660,19 @@ var URI = class _URI {
   get getParams() {
     return this._url.searchParams.entries();
   }
-  hasParam(key) {
-    return this._url.searchParams.has(key);
+  hasParam(key2) {
+    return this._url.searchParams.has(key2);
   }
-  getParam(key, def) {
-    const { key: k, def: d } = coerceKey(key, def);
+  getParam(key2, def) {
+    const { key: k, def: d } = coerceKey(key2, def);
     let val = this._url.searchParams.get(k);
     if (!falsy2undef(val) && d) {
       val = d;
     }
     return falsy2undef(val);
   }
-  getParamResult(key, msgFn) {
-    return getParamResult(key, this.getParam(key), msgFn);
+  getParamResult(key2, msgFn) {
+    return getParamResult(key2, this.getParam(key2), msgFn);
   }
   getParamsResult(...keys) {
     return getParamsResult(keys, this);
@@ -2070,9 +2108,9 @@ var LoggerImpl = class _LoggerImpl {
     this.levelHandler.disableLevel(level, ...modules);
     return this;
   }
-  Module(key) {
-    this._attributes["module"] = logValue(key, toLogValueCtx(this.levelHandler));
-    this._withAttributes["module"] = logValue(key, toLogValueCtx(this.levelHandler));
+  Module(key2) {
+    this._attributes["module"] = logValue(key2, toLogValueCtx(this.levelHandler));
+    this._withAttributes["module"] = logValue(key2, toLogValueCtx(this.levelHandler));
     return this;
   }
   // if the string is "*" it will enable for all modules
@@ -2113,10 +2151,10 @@ var LoggerImpl = class _LoggerImpl {
   }
   Err(err) {
     var _a;
-    let key = "error";
+    let key2 = "error";
     if (Result.Is(err)) {
       if (err.isOk()) {
-        key = "noerror";
+        key2 = "noerror";
         err = err.Ok();
       } else {
         err = err.Err();
@@ -2124,12 +2162,12 @@ var LoggerImpl = class _LoggerImpl {
     }
     if (err instanceof Error) {
       if (err.cause) {
-        this.coerceKey(key, {
+        this.coerceKey(key2, {
           message: err.message,
           cause: err.cause
         });
       } else {
-        this._attributes[key] = logValue(err.message, toLogValueCtx(this.levelHandler));
+        this._attributes[key2] = logValue(err.message, toLogValueCtx(this.levelHandler));
       }
       if (this.levelHandler.isStackExposed) {
         this._attributes["stack"] = logValue(
@@ -2138,7 +2176,7 @@ var LoggerImpl = class _LoggerImpl {
         );
       }
     } else {
-      this.Any(key, err);
+      this.Any(key2, err);
     }
     return this;
   }
@@ -2146,22 +2184,22 @@ var LoggerImpl = class _LoggerImpl {
     this._attributes["level"] = logValue(l, toLogValueCtx(this.levelHandler));
     return this;
   }
-  Ref(key, action) {
+  Ref(key2, action) {
     if (typeof action === "function") {
-      this._attributes[key] = logValue(action, toLogValueCtx(this.levelHandler));
+      this._attributes[key2] = logValue(action, toLogValueCtx(this.levelHandler));
     } else if (typeof action.toString === "function") {
-      this._attributes[key] = logValue(() => action.toString(), toLogValueCtx(this.levelHandler));
+      this._attributes[key2] = logValue(() => action.toString(), toLogValueCtx(this.levelHandler));
     } else {
-      this._attributes[key] = logValue("INVALID REF", toLogValueCtx(this.levelHandler));
+      this._attributes[key2] = logValue("INVALID REF", toLogValueCtx(this.levelHandler));
     }
     return this;
   }
-  Bool(key, value) {
-    this.coerceKey(key, !!value);
+  Bool(key2, value) {
+    this.coerceKey(key2, !!value);
     return this;
   }
   Http(...mix) {
-    const key = mix.find((x) => typeof x === "string");
+    const key2 = mix.find((x) => typeof x === "string");
     mix = mix.filter((x) => typeof x !== "string");
     const resErrors = mix.filter((x) => Result.Is(x) && x.isErr());
     if (resErrors.length) {
@@ -2181,72 +2219,72 @@ var LoggerImpl = class _LoggerImpl {
       reqAndOrres = req;
     }
     if (reqAndOrres) {
-      this.Any(key || "Http", reqAndOrres);
+      this.Any(key2 || "Http", reqAndOrres);
     }
     return this;
   }
   Pair(x) {
-    for (const key of Object.keys(x)) {
-      const value = x[key];
+    for (const key2 of Object.keys(x)) {
+      const value = x[key2];
       if (value instanceof LogValue) {
-        this._attributes[key] = value;
+        this._attributes[key2] = value;
         continue;
       }
       if (Result.Is(value)) {
-        this.Result(key, value);
+        this.Result(key2, value);
         continue;
       }
-      this.Any(key, value);
+      this.Any(key2, value);
     }
     return this;
   }
-  Result(key, res) {
+  Result(key2, res) {
     if (res.isOk()) {
-      this._attributes[key] = logValue(res.Ok(), toLogValueCtx(this.levelHandler));
+      this._attributes[key2] = logValue(res.Ok(), toLogValueCtx(this.levelHandler));
     } else {
       this.Err(res.Err());
     }
     return this;
   }
-  Len(value, key = "len") {
-    this._attributes[key] = getLen(value, toLogValueCtx(this.levelHandler));
+  Len(value, key2 = "len") {
+    this._attributes[key2] = getLen(value, toLogValueCtx(this.levelHandler));
     return this;
   }
-  Hash(value, key = "hash") {
-    this._attributes[key] = asyncLogValue(
+  Hash(value, key2 = "hash") {
+    this._attributes[key2] = asyncLogValue(
       async () => `${getLen(value, toLogValueCtx(this.levelHandler)).value()}:${await hash(value)}`
     );
     return this;
   }
-  Url(url, key = "url") {
-    this.Ref(key, () => URI.from(url).toString());
+  Url(url, key2 = "url") {
+    this.Ref(key2, () => URI.from(url).toString());
     return this;
   }
-  coerceKey(key, value) {
-    if (typeof key === "string") {
-      this._attributes[key] = logValue(value, toLogValueCtx(this.levelHandler));
+  coerceKey(key2, value) {
+    if (typeof key2 === "string") {
+      this._attributes[key2] = logValue(value, toLogValueCtx(this.levelHandler));
     } else {
-      this.Pair(key);
+      this.Pair(key2);
     }
   }
-  Str(key, value) {
-    this.coerceKey(key, value);
+  Str(key2, value) {
+    this.coerceKey(key2, value);
     return this;
   }
-  Any(key, value) {
-    this.coerceKey(key, value);
+  Any(key2, value) {
+    this.coerceKey(key2, value);
     return this;
   }
-  Dur(key, nsec) {
-    this._attributes[key] = logValue(`${nsec}ms`, toLogValueCtx(this.levelHandler));
+  Dur(key2, nsec) {
+    this._attributes[key2] = logValue(`${nsec}ms`, toLogValueCtx(this.levelHandler));
     return this;
   }
-  Uint64(key, value) {
-    this.coerceKey(key, value);
+  Uint64(key2, value) {
+    this.coerceKey(key2, value);
     return this;
   }
-  Int(key, value) {
-    return this.Uint64(key, value);
+  Int(key2, value) {
+    return this.Uint64(key2, value);
   }
   async Flush() {
     return new Promise((resolve) => {
@@ -2269,8 +2307,8 @@ var LoggerImpl = class _LoggerImpl {
   }
   _resetAttributes(fn) {
     const ret = fn();
-    Object.keys(this._attributes).forEach((key) => {
-      delete this._attributes[key];
+    Object.keys(this._attributes).forEach((key2) => {
+      delete this._attributes[key2];
     });
     Object.assign(this._attributes, this._withAttributes);
     return ret;
@@ -2337,8 +2375,8 @@ var WithLoggerBuilder = class {
     this._li.levelHandler.enableLevel(level, ...modules);
     return this;
   }
-  Module(key) {
-    this._li.Module(key);
+  Module(key2) {
+    this._li.Module(key2);
     return this;
   }
   SetDebug(...modules) {
@@ -2353,36 +2391,36 @@ var WithLoggerBuilder = class {
     this._li.Pair(x);
     return this;
   }
-  Str(key, value) {
-    this._li.Str(key, value);
+  Str(key2, value) {
+    this._li.Str(key2, value);
     return this;
   }
-  Len(value, key) {
-    this._li.Len(value, key);
+  Len(value, key2) {
+    this._li.Len(value, key2);
     return this;
   }
-  Hash(value, key) {
-    this._li.Hash(value, key);
+  Hash(value, key2) {
+    this._li.Hash(value, key2);
     return this;
   }
-  Ref(key, action) {
-    this._li.Ref(key, action);
+  Ref(key2, action) {
+    this._li.Ref(key2, action);
     return this;
   }
-  Bool(key, value) {
-    this._li.Bool(key, value);
+  Bool(key2, value) {
+    this._li.Bool(key2, value);
     return this;
   }
-  Result(key, res) {
-    this._li.Result(key, res);
+  Result(key2, res) {
+    this._li.Result(key2, res);
     return this;
   }
-  Url(url, key) {
-    this._li.Url(url, key);
+  Url(url, key2) {
+    this._li.Url(url, key2);
     return this;
   }
-  Int(key, value) {
-    this._li.Int(key, value);
+  Int(key2, value) {
+    this._li.Int(key2, value);
     return this;
   }
   Log() {
@@ -2417,16 +2455,16 @@ var WithLoggerBuilder = class {
     this._li.Timestamp();
     return this;
   }
-  Any(key, value) {
-    this._li.Any(key, value);
+  Any(key2, value) {
+    this._li.Any(key2, value);
     return this;
   }
-  Dur(key, nsec) {
-    this._li.Dur(key, nsec);
+  Dur(key2, nsec) {
+    this._li.Dur(key2, nsec);
     return this;
   }
-  Uint64(key, value) {
-    this._li.Uint64(key, value);
+  Uint64(key2, value) {
+    this._li.Uint64(key2, value);
     return this;
   }
 };
@@ -2591,8 +2629,8 @@ var Metrics = class {
   }
   toJSON() {
     const obj = {};
-    for (const [key, value] of this.map) {
-      obj[key] = value.value;
+    for (const [key2, value] of this.map) {
+      obj[key2] = value.value;
     }
     return obj;
   }
@@ -2765,15 +2803,15 @@ var HeadersImpl = class extends Headers {
   values() {
     return this._headers.values();
   }
-  append(key, value) {
-    const values = this._headers.get(key);
+  append(key2, value) {
+    const values = this._headers.get(key2);
     if (typeof value === "undefined") {
       value = "";
     }
     if (Array.isArray(value)) {
-      this._headers.set(key, [values, ...value].filter((i) => i).join(", "));
+      this._headers.set(key2, [values, ...value].filter((i) => i).join(", "));
     } else {
-      this._headers.set(key, [values, value].filter((i) => i).join(", "));
+      this._headers.set(key2, [values, value].filter((i) => i).join(", "));
     }
     return this;
   }
@@ -2816,38 +2854,38 @@ var HttpHeader = class _HttpHeader {
   }
   _asStringString() {
     const ret = /* @__PURE__ */ new Map();
-    for (const [key, values] of this._headers) {
-      ret.set(key, values.join(", "));
+    for (const [key2, values] of this._headers) {
+      ret.set(key2, values.join(", "));
     }
     return ret;
   }
-  _key(key) {
-    return key.toLowerCase();
+  _key(key2) {
+    return key2.toLowerCase();
   }
-  Values(key) {
-    const values = this._headers.get(this._key(key));
+  Values(key2) {
+    const values = this._headers.get(this._key(key2));
     return values || [];
   }
-  Get(key) {
-    const values = this._headers.get(this._key(key));
+  Get(key2) {
+    const values = this._headers.get(this._key(key2));
     if (values === void 0 || values.length === 0) {
       return void 0;
     }
     return values[0];
   }
-  Set(key, valueOr) {
+  Set(key2, valueOr) {
     const value = Array.isArray(valueOr) ? valueOr : [valueOr];
-    this._headers.set(this._key(key), value);
+    this._headers.set(this._key(key2), value);
     return this;
   }
-  Add(key, value) {
+  Add(key2, value) {
     if (typeof value === "undefined") {
       return this;
     }
     const vs = Array.isArray(value) ? value : [value];
-    const values = this._headers.get(this._key(key));
+    const values = this._headers.get(this._key(key2));
     if (values === void 0) {
-      this._headers.set(this._key(key), vs);
+      this._headers.set(this._key(key2), vs);
     } else {
       values.push(...vs);
     }
@@ -2865,29 +2903,29 @@ var HttpHeader = class _HttpHeader {
   }
   Clone() {
     const clone = new _HttpHeader();
-    for (const [key, values] of this._headers.entries()) {
-      clone._headers.set(key, values.slice());
+    for (const [key2, values] of this._headers.entries()) {
+      clone._headers.set(key2, values.slice());
     }
     return clone;
   }
   AsRecordStringStringArray() {
     const obj = {};
-    for (const [key, values] of this._headers.entries()) {
-      obj[key] = [...values];
+    for (const [key2, values] of this._headers.entries()) {
+      obj[key2] = [...values];
     }
     return obj;
   }
   AsRecordStringString() {
     const obj = {};
-    for (const [key, values] of this._headers.entries()) {
-      obj[key] = values.join(", ");
+    for (const [key2, values] of this._headers.entries()) {
+      obj[key2] = values.join(", ");
     }
     return obj;
   }
   AsHeaderInit() {
     const obj = {};
-    for (const [key, values] of this._headers.entries()) {
-      obj[key] = values[0];
+    for (const [key2, values] of this._headers.entries()) {
+      obj[key2] = values[0];
     }
     return obj;
   }
@@ -2897,8 +2935,8 @@ var HttpHeader = class _HttpHeader {
   Merge(other) {
     const ret = this.Clone();
     if (other) {
-      for (const [key, values] of other.Items()) {
-        ret.Add(key, values);
+      for (const [key2, values] of other.Items()) {
+        ret.Add(key2, values);
       }
     }
     return ret;
@@ -3133,7 +3171,6 @@ function uint8array2stream(str) {
   MutableURL,
   None,
   Option,
-  REQUIRED,
   RandomMode,
   RandomService,
   ResolveOnce,
@@ -3163,7 +3200,9 @@ function uint8array2stream(str) {
   exception2Result,
   hasHostPartProtocols,
   isURL,
+  key,
   logValue,
+  registerEnvAction,
   runtimeFn,
   toCryptoRuntime,
   utils