@adviser/cement 0.3.3 → 0.3.5

package/test/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 key2 of __getOwnPropNames(from2))
-      if (!__hasOwnProp.call(to, key2) && key2 !== except)
-        __defProp(to, key2, { get: () => from2[key2], enumerable: !(desc = __getOwnPropDesc(from2, key2)) || desc.enumerable });
+    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 });
   }
   return to;
 };
@@ -80,8 +80,8 @@ var Future = class {
     __privateAdd(this, _rejectFn, () => {
       throw new Error("This Promise is not working as expected.");
     });
-    __privateSet(this, _promise, new Promise((resolve2, reject) => {
-      __privateSet(this, _resolveFn, resolve2);
+    __privateSet(this, _promise, new Promise((resolve, reject) => {
+      __privateSet(this, _resolveFn, resolve);
       __privateSet(this, _rejectFn, reject);
     }));
   }
@@ -256,9 +256,6 @@ var LogValue = class {
     return this.value();
   }
 };
-function asyncLogValue(val) {
-  throw new Error("Not implemented");
-}
 function logValue(val, ctx) {
   return logValueInternal(val, {
     ...ctx,
@@ -334,16 +331,16 @@ function logValueInternal(val, ctx) {
       }
       const res = {};
       const typedVal = val;
-      for (const key2 in typedVal) {
-        if (ctx.ignoreAttr.IsSome() && ctx.ignoreAttr.unwrap().test(key2)) {
+      for (const key in typedVal) {
+        if (ctx.ignoreAttr.IsSome() && ctx.ignoreAttr.unwrap().test(key)) {
           continue;
         }
-        const element = typedVal[key2];
+        const element = typedVal[key];
         if (element instanceof LogValue) {
-          res[key2] = element;
+          res[key] = element;
         } else {
           if (typeof element !== "function") {
-            res[key2] = logValueInternal(element, ctx);
+            res[key] = logValueInternal(element, ctx);
           }
         }
       }
@@ -513,9 +510,9 @@ var SysTime = class extends Time {
     return /* @__PURE__ */ new Date();
   }
   Sleep(duration) {
-    return new Promise((resolve2) => {
+    return new Promise((resolve) => {
       setTimeout(() => {
-        resolve2();
+        resolve();
       }, duration);
     });
   }
@@ -628,13 +625,15 @@ var BaseSysAbstraction = class {
     this._systemService = params.SystemService;
     this._txtEnDe = params.TxtEnDecoder;
     const decoder2 = this._txtEnDe;
-    this._stdout = CFWriteableStream(async (chunk) => {
+    this._stdout = CFWriteableStream((chunk) => {
       const decoded = decoder2.decode(chunk);
       console.log(decoded.trimEnd());
+      return Promise.resolve();
     });
-    this._stderr = CFWriteableStream(async (chunk) => {
+    this._stderr = CFWriteableStream((chunk) => {
       const decoded = decoder2.decode(chunk);
       console.error(decoded.trimEnd());
+      return Promise.resolve();
     });
   }
 };
@@ -778,24 +777,24 @@ var Keyed = class {
     this._map = /* @__PURE__ */ new Map();
     this.factory = factory;
   }
-  async asyncGet(key2) {
-    return this.get(await key2());
+  async asyncGet(key) {
+    return this.get(await key());
   }
-  get(key2) {
-    if (typeof key2 === "function") {
-      key2 = key2();
+  get(key) {
+    if (typeof key === "function") {
+      key = key();
     }
-    let keyed = this._map.get(key2);
+    let keyed = this._map.get(key);
     if (!keyed) {
-      keyed = this.factory(key2);
-      this._map.set(key2, keyed);
+      keyed = this.factory(key);
+      this._map.set(key, keyed);
     }
     return keyed;
   }
-  unget(key2) {
-    const keyed = this._map.get(key2);
+  unget(key) {
+    const keyed = this._map.get(key);
     keyed == null ? void 0 : keyed.reset();
-    this._map.delete(key2);
+    this._map.delete(key);
   }
   reset() {
     this._map.forEach((keyed) => keyed.reset());
@@ -804,7 +803,7 @@ var Keyed = class {
 };
 var KeyedResolvOnce = class extends Keyed {
   constructor() {
-    super((key2) => new ResolveOnce(key2));
+    super((key) => new ResolveOnce(key));
   }
 };
 
@@ -821,7 +820,10 @@ function isSet(value, ref = globalThis) {
 }
 function runtimeFn() {
   const gt = globalThis;
-  let isReactNative = isSet("navigator.product") && typeof gt["navigator"] === "object" && gt["navigator"]["product"] === "ReactNative";
+  let isReactNative = (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    isSet("navigator.product") && typeof gt["navigator"] === "object" && gt["navigator"]["product"] === "ReactNative"
+  );
   let isNodeIsh = false;
   if (!isSet("Deno")) {
     isNodeIsh = isSet("process.versions.node") && !isReactNative;
@@ -842,12 +844,7 @@ function runtimeFn() {
   };
 }
 
-// src/deno/deno-file-service.ts
-var path = __toESM(require("path"), 1);
-var Deno = globalThis.Deno;
-
-// src/deno/deno-sys-abstraction.ts
-var Deno2 = globalThis.Deno;
+// src/deno/deno-env-actions.ts
 var once = new ResolveOnce();
 var _deno;
 var _DenoEnvActions = class _DenoEnvActions {
@@ -862,8 +859,8 @@ var _DenoEnvActions = class _DenoEnvActions {
     return __privateGet(this, _deno).Deno.env;
   }
   register(env) {
-    for (const key2 of env.keys()) {
-      this._env.set(key2, env.get(key2) || "");
+    for (const key of env.keys()) {
+      this._env.set(key, env.get(key) || "");
     }
     return env;
   }
@@ -873,109 +870,22 @@ var _DenoEnvActions = class _DenoEnvActions {
   keys() {
     return Object.keys(this._env.toObject());
   }
-  get(key2) {
-    return this._env.get(key2);
+  get(key) {
+    return this._env.get(key);
   }
-  set(key2, value) {
+  set(key, value) {
     if (value) {
-      this._env.set(key2, value);
+      this._env.set(key, value);
     }
   }
-  delete(key2) {
-    this._env.delete(key2);
+  delete(key) {
+    this._env.delete(key);
   }
 };
 _deno = new WeakMap();
 var DenoEnvActions = _DenoEnvActions;
-var DenoExitServiceImpl = class {
-  constructor() {
-    this._exitHandlers = [];
-    this.invoked = false;
-    this._handleExit = async () => {
-      if (this.invoked) {
-        return;
-      }
-      this.invoked = true;
-      for (const h of this._exitHandlers) {
-        try {
-          const ret = h.hdl();
-          if (typeof ret.then === "function") {
-            await ret;
-          }
-        } finally {
-        }
-      }
-    };
-    globalThis.addEventListener("unhandledrejection", (e) => {
-      e.preventDefault();
-      this.exit(19);
-    });
-    globalThis.addEventListener("error", () => {
-      this.exit(19);
-    });
-    globalThis.addEventListener("uncaughtException", () => {
-      this.exit(19);
-    });
-    globalThis.addEventListener("unload", () => {
-      this.exit(0);
-    });
-    Deno2.addSignalListener("SIGQUIT", () => {
-      this.exit(3);
-    });
-    Deno2.addSignalListener("SIGINT", () => {
-      this.exit(2);
-    });
-    Deno2.addSignalListener("SIGTERM", () => {
-      this.exit(9);
-    });
-  }
-  injectExitHandlers(hdls) {
-    this._exitHandlers = hdls;
-  }
-  exit(code) {
-    this._handleExit().then(() => {
-      Deno2.exit(code);
-    }).catch((err) => {
-      console.error("ExitService: failed to handle exit", err);
-      Deno2.exit(code);
-    });
-  }
-};
-var _DenoSystemService = class _DenoSystemService {
-  constructor() {
-    this._exitService = new DenoExitServiceImpl();
-    this._exitService.injectExitHandlers(_DenoSystemService._exitHandlers);
-  }
-  Env() {
-    return envFactory();
-  }
-  Args() {
-    return Deno2.args;
-  }
-  OnExit(hdl) {
-    const id = crypto.randomUUID();
-    _DenoSystemService._exitHandlers.push({ hdl, id });
-    return () => {
-      const idx = _DenoSystemService._exitHandlers.findIndex((h) => h.id === id);
-      if (idx >= 0) {
-        _DenoSystemService._exitHandlers.splice(idx, 1);
-      }
-    };
-  }
-  Exit(code) {
-    this._exitService.exit(code);
-  }
-};
-_DenoSystemService._exitHandlers = [];
-var DenoSystemService = _DenoSystemService;
-
-// src/node/node-file-service.ts
-var import_node_path = __toESM(require("path"), 1);
-var import_node_fs = __toESM(require("fs"), 1);
-var import_node_process = __toESM(require("process"), 1);
 
-// src/node/node-sys-abstraction.ts
-var import_node_process2 = __toESM(require("process"), 1);
+// src/node/node-env-actions.ts
 var once2 = new ResolveOnce();
 var _node;
 var _NodeEnvActions = class _NodeEnvActions {
@@ -988,8 +898,8 @@ var _NodeEnvActions = class _NodeEnvActions {
     return once2.once(() => new _NodeEnvActions(opts));
   }
   register(env) {
-    for (const key2 of env.keys()) {
-      this._env[key2] = env.get(key2) || "";
+    for (const key of env.keys()) {
+      this._env[key] = env.get(key) || "";
     }
     return env;
   }
@@ -999,120 +909,75 @@ var _NodeEnvActions = class _NodeEnvActions {
   keys() {
     return Object.keys(this._env);
   }
-  get(key2) {
-    return this._env[key2];
+  get(key) {
+    return this._env[key];
   }
-  set(key2, value) {
+  set(key, value) {
     if (value) {
-      this._env[key2] = value;
+      this._env[key] = value;
     }
   }
-  delete(key2) {
-    delete this._env[key2];
+  delete(key) {
+    delete this._env[key];
   }
 };
 _node = new WeakMap();
 var NodeEnvActions = _NodeEnvActions;
-var NodeExitServiceImpl = class {
-  constructor() {
-    this._exitHandlers = [];
-    this.invoked = false;
-    this._handleExit = async () => {
-      if (this.invoked) {
-        return;
-      }
-      this.invoked = true;
-      for (const h of this._exitHandlers) {
-        try {
-          const ret = h.hdl();
-          if (typeof ret.then === "function") {
-            await ret;
-          }
-        } finally {
-        }
-      }
-    };
-    import_node_process2.default.on("unhandledRejection", (reason, p) => {
-      this.exit(19);
-    });
-    import_node_process2.default.on("uncaughtException", (error) => {
-      this.exit(18);
-    });
-    import_node_process2.default.on("close", () => {
-      this.exit(0);
-    });
-    import_node_process2.default.on("exit", () => {
-      this.exit(0);
-    });
-    import_node_process2.default.on("SIGQUIT", () => {
-      this.exit(3);
-    });
-    import_node_process2.default.on("SIGINT", () => {
-      this.exit(2);
-    });
-    import_node_process2.default.on("SIGTERM", () => {
-      this.exit(9);
-    });
+
+// src/web/web-env-actions.ts
+var once3 = new ResolveOnce();
+var BrowserEnvActions = class _BrowserEnvActions {
+  constructor(opts) {
+    this.env = /* @__PURE__ */ new Map();
+    this.opts = opts;
   }
-  injectExitHandlers(hdls) {
-    this._exitHandlers = hdls;
+  static new(opts) {
+    return once3.once(() => new _BrowserEnvActions(opts));
   }
-  exit(code) {
-    this._handleExit().then(() => {
-      import_node_process2.default.exit(code);
-    }).catch((err) => {
-      console.error("ExitService: failed to handle exit", err);
-      import_node_process2.default.exit(code);
-    });
+  get(key) {
+    return this.env.get(key);
   }
-};
-var _NodeSystemService = class _NodeSystemService {
-  constructor() {
-    this._exitService = new NodeExitServiceImpl();
-    this._exitService.injectExitHandlers(_NodeSystemService._exitHandlers);
+  set(key, value) {
+    if (value) {
+      this.env.set(key, value);
+    }
   }
-  Env() {
-    return envFactory();
+  delete(key) {
+    this.env.delete(key);
   }
-  Args() {
-    return import_node_process2.default.argv;
+  keys() {
+    return Array.from(this.env.keys());
   }
-  OnExit(hdl) {
-    const id = crypto.randomUUID();
-    _NodeSystemService._exitHandlers.push({ hdl, id });
-    return () => {
-      const idx = _NodeSystemService._exitHandlers.findIndex((h) => h.id === id);
-      if (idx >= 0) {
-        _NodeSystemService._exitHandlers.splice(idx, 1);
-      }
-    };
+  active() {
+    return true;
   }
-  Exit(code) {
-    this._exitService.exit(code);
+  register(env) {
+    const sym = Symbol.for(this.opts.symbol || "CP_ENV");
+    const browser = globalThis;
+    browser[sym] = env;
+    return env;
   }
 };
-_NodeSystemService._exitHandlers = [];
-var NodeSystemService = _NodeSystemService;
 
-// src/cf/cf-sys-abstraction.ts
-var once3 = new ResolveOnce();
+// src/cf/cf-env-actions.ts
+var once4 = new ResolveOnce();
 var CFEnvActions = class _CFEnvActions {
   constructor(env) {
     this.injectOnRegister = {};
     this.cfEnv = new Map(Object.entries(env.presetEnv || {}));
   }
   static new(opts) {
-    return once3.once(() => new _CFEnvActions(opts));
+    return once4.once(() => new _CFEnvActions(opts));
   }
   static inject(o) {
     const env = _CFEnvActions.new({});
-    for (const key2 in o) {
-      const value = o[key2];
+    for (const key in o) {
+      const value = o[key];
       if (typeof value === "string") {
         if (env.env) {
-          env.env.set(key2, value);
+          env.env.set(key, value);
         } else {
-          env.injectOnRegister[key2] = value;
+          env.injectOnRegister[key] = value;
         }
       }
     }
@@ -1122,27 +987,177 @@ var CFEnvActions = class _CFEnvActions {
   }
   register(env) {
     this.env = env;
-    for (const key2 in this.injectOnRegister) {
-      env.set(key2, this.injectOnRegister[key2]);
+    for (const key in this.injectOnRegister) {
+      env.set(key, this.injectOnRegister[key]);
     }
     return env;
   }
-  get(key2) {
-    return this.cfEnv.get(key2);
+  get(key) {
+    return this.cfEnv.get(key);
   }
-  set(key2, value) {
+  set(key, value) {
     if (value) {
-      this.cfEnv.set(key2, value);
+      this.cfEnv.set(key, value);
     }
   }
-  delete(key2) {
-    this.cfEnv.delete(key2);
+  delete(key) {
+    this.cfEnv.delete(key);
   }
   keys() {
     return Array.from(this.cfEnv.keys());
   }
 };
 
+// src/result.ts
+var Result = class _Result {
+  static Ok(t) {
+    return new ResultOK(t);
+  }
+  static Err(t) {
+    if (typeof t === "string") {
+      return new ResultError(new Error(t));
+    }
+    if (_Result.Is(t)) {
+      if (t.is_ok()) {
+        return new ResultError(new Error("Result Error is Ok"));
+      }
+      return t;
+    }
+    return new ResultError(t);
+  }
+  static Is(t) {
+    if (!t) {
+      return false;
+    }
+    if (t instanceof _Result) {
+      return true;
+    }
+    const rt = t;
+    if ([typeof rt.is_ok, typeof rt.is_err, typeof rt.unwrap, typeof rt.unwrap_err].every((x) => x === "function")) {
+      return true;
+    }
+    return false;
+  }
+  isOk() {
+    return this.is_ok();
+  }
+  isErr() {
+    return this.is_err();
+  }
+  Ok() {
+    return this.unwrap();
+  }
+  Err() {
+    return this.unwrap_err();
+  }
+};
+var ResultOK = class extends Result {
+  constructor(t) {
+    super();
+    this._t = t;
+  }
+  is_ok() {
+    return true;
+  }
+  is_err() {
+    return false;
+  }
+  unwrap_err() {
+    throw new Error("Result is Ok");
+  }
+  unwrap() {
+    return this._t;
+  }
+};
+var ResultError = class extends Result {
+  constructor(t) {
+    super();
+    this._error = t;
+  }
+  is_ok() {
+    return false;
+  }
+  is_err() {
+    return true;
+  }
+  unwrap() {
+    throw new Error(`Result is Err: ${this._error}`);
+  }
+  unwrap_err() {
+    return this._error;
+  }
+};
+function exception2Result(fn) {
+  try {
+    const res = fn();
+    if (res instanceof Promise) {
+      return res.then((value) => Result.Ok(value)).catch((e) => Result.Err(e));
+    }
+    return Result.Ok(res);
+  } catch (e) {
+    return Result.Err(e);
+  }
+}
+
+// src/utils/get-params-result.ts
+var _REQUIRED = class {
+  constructor() {
+    this.val = "REQUIRED";
+  }
+};
+var _OPTIONAL = class {
+  constructor() {
+    this.val = "OPTIONAL";
+  }
+};
+var param = {
+  REQUIRED: new _REQUIRED(),
+  OPTIONAL: new _OPTIONAL()
+};
+function getParamsResult(keys, getParam) {
+  const keyDef = keys.flat().reduce(
+    (acc, i) => {
+      if (typeof i === "string") {
+        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,
+            isOptional: i[k] === param.OPTIONAL
+          }))
+        );
+      }
+      return acc;
+    },
+    []
+  );
+  const msgFn = keys.find((k) => typeof k === "function") || ((...keys2) => {
+    const msg = keys2.join(",");
+    return `missing parameters: ${msg}`;
+  });
+  const errors = [];
+  const result = {};
+  for (const kd of keyDef) {
+    const val = getParam.getParam(kd.key);
+    if (val === void 0) {
+      if (typeof kd.def === "string") {
+        result[kd.key] = kd.def;
+      } else {
+        if (!kd.isOptional) {
+          errors.push(kd.key);
+        }
+      }
+    } else {
+      result[kd.key] = val;
+    }
+  }
+  if (errors.length) {
+    return Result.Err(msgFn(...errors));
+  }
+  return Result.Ok(result);
+}
+
 // src/sys-env.ts
 var envActions = [
   { id: "cf", fn: (opts) => CFEnvActions.new(opts) },
@@ -1158,30 +1173,80 @@ function envFactory(opts = {}) {
   }
   return _envFactories.get(found.id).once(() => {
     const action = found.fn(opts);
-    const ret = new EnvImpl2(action, opts);
+    const ret = new EnvImpl(action, opts);
     action.register(ret);
     return ret;
   });
 }
-var EnvImpl2 = class {
+function isIterable(obj) {
+  if (obj == null) {
+    return false;
+  }
+  return typeof obj[Symbol.iterator] === "function";
+}
+var EnvImpl = class {
   constructor(map, opts = {}) {
     this._onSet = [];
     this._map = map;
     this._updatePresets(opts.presetEnv);
   }
+  gets(...kparams) {
+    return getParamsResult(kparams, {
+      getParam: (k) => this.get(k)
+    });
+  }
+  sets(...keys) {
+    keys.forEach((key) => {
+      if (Array.isArray(key)) {
+        if (key.length === 2) {
+          const [k, v] = key;
+          if (typeof k === "string" && typeof v === "string") {
+            this.set(k, v);
+            return;
+          }
+        }
+        for (const item of key) {
+          if (Array.isArray(item)) {
+            if (item.length === 2) {
+              const [k, v] = item;
+              if (typeof k === "string" && typeof v === "string") {
+                this.set(k, v);
+              }
+            }
+          }
+        }
+      } else {
+        if (isIterable(key)) {
+          for (const [k, v] of key) {
+            if (typeof k === "string" && typeof v === "string") {
+              this.set(k, v);
+            }
+          }
+        } else {
+          const rKey = key;
+          for (const k in rKey) {
+            const v = rKey[k];
+            if (typeof k === "string" && typeof v === "string") {
+              this.set(k, v);
+            }
+          }
+        }
+      }
+    });
+  }
   _updatePresets(presetEnv) {
     if (!presetEnv) {
       return;
     }
-    for (const [key2, value] of presetEnv) {
-      this._map.set(key2, value);
+    for (const [key, value] of presetEnv) {
+      this._map.set(key, value);
     }
   }
-  _applyOnSet(onSet, key2, value) {
+  _applyOnSet(onSet, key, value) {
     onSet.forEach((item) => {
       let keys = [];
-      if (key2) {
-        keys = [key2];
+      if (key) {
+        keys = [key];
       } else {
         keys = this._map.keys();
       }
@@ -1195,9 +1260,9 @@ var EnvImpl2 = class {
         return false;
       }).forEach((k) => {
         let v;
-        if (!key2 && !value) {
+        if (!key && !value) {
           v = this._map.get(k);
-        } else if (key2 && !value) {
+        } else if (key && !value) {
           v = void 0;
         } else {
           v = value;
@@ -1215,56 +1280,23 @@ var EnvImpl2 = class {
     this._onSet.push(item);
     this._applyOnSet([item]);
   }
-  get(key2) {
-    return this._map.get(key2);
+  get(key) {
+    return this._map.get(key);
   }
-  set(key2, value) {
+  set(key, value) {
     if (!value) {
       return;
     }
-    this._map.set(key2, value);
-    this._applyOnSet(this._onSet, key2, value);
+    this._map.set(key, value);
+    this._applyOnSet(this._onSet, key, value);
   }
-  delete(key2) {
-    this._map.delete(key2);
-    this._applyOnSet(this._onSet, key2);
+  delete(key) {
+    this._map.delete(key);
+    this._applyOnSet(this._onSet, key);
   }
 };
 
 // src/web/web-sys-abstraction.ts
-var once4 = new ResolveOnce();
-var BrowserEnvActions = class _BrowserEnvActions {
-  constructor(opts) {
-    this.env = /* @__PURE__ */ new Map();
-    this.opts = opts;
-  }
-  static new(opts) {
-    return once4.once(() => new _BrowserEnvActions(opts));
-  }
-  get(key2) {
-    return this.env.get(key2);
-  }
-  set(key2, value) {
-    if (value) {
-      this.env.set(key2, value);
-    }
-  }
-  delete(key2) {
-    this.env.delete(key2);
-  }
-  keys() {
-    return Array.from(this.env.keys());
-  }
-  active() {
-    return true;
-  }
-  register(env) {
-    const sym = Symbol.for(this.opts.symbol || "CP_ENV");
-    const browser = globalThis;
-    browser[sym] = env;
-    return env;
-  }
-};
 var WebFileService = class {
   get baseDir() {
     throw new Error("basedir-Method not implemented.");
@@ -1327,106 +1359,15 @@ var WebSystemService = class {
   }
 };
 var my = void 0;
-function WebSysAbstraction(param) {
+function WebSysAbstraction(param2) {
   if (!my) {
     my = new BaseSysAbstraction({
-      TxtEnDecoder: (param == null ? void 0 : param.TxtEnDecoder) || Utf8EnDecoderSingleton(),
+      TxtEnDecoder: (param2 == null ? void 0 : param2.TxtEnDecoder) || Utf8EnDecoderSingleton(),
       FileSystem: new WebFileService(),
       SystemService: new WebSystemService()
     });
   }
-  return new WrapperSysAbstraction(my, param);
-}
-
-// src/result.ts
-var Result = class _Result {
-  static Ok(t) {
-    return new ResultOK(t);
-  }
-  static Err(t) {
-    if (typeof t === "string") {
-      return new ResultError(new Error(t));
-    }
-    if (_Result.Is(t)) {
-      if (t.is_ok()) {
-        return new ResultError(new Error("Result Error is Ok"));
-      }
-      return t;
-    }
-    return new ResultError(t);
-  }
-  static Is(t) {
-    if (!t) {
-      return false;
-    }
-    if (t instanceof _Result) {
-      return true;
-    }
-    const rt = t;
-    if ([typeof rt.is_ok, typeof rt.is_err, typeof rt.unwrap, typeof rt.unwrap_err].every((x) => x === "function")) {
-      return true;
-    }
-    return false;
-  }
-  isOk() {
-    return this.is_ok();
-  }
-  isErr() {
-    return this.is_err();
-  }
-  Ok() {
-    return this.unwrap();
-  }
-  Err() {
-    return this.unwrap_err();
-  }
-};
-var ResultOK = class extends Result {
-  constructor(t) {
-    super();
-    this._t = t;
-  }
-  is_ok() {
-    return true;
-  }
-  is_err() {
-    return false;
-  }
-  unwrap_err() {
-    throw new Error("Result is Ok");
-  }
-  unwrap() {
-    return this._t;
-  }
-};
-var ResultError = class extends Result {
-  constructor(t) {
-    super();
-    this._error = t;
-  }
-  is_ok() {
-    return false;
-  }
-  is_err() {
-    return true;
-  }
-  unwrap() {
-    throw new Error(`Result is Err: ${this._error}`);
-  }
-  unwrap_err() {
-    return this._error;
-  }
-};
-function exception2Result(fn) {
-  try {
-    const res = fn();
-    if (res instanceof Promise) {
-      return res.then((value) => Result.Ok(value)).catch((e) => Result.Err(e));
-    }
-    return Result.Ok(res);
-  } catch (e) {
-    return Result.Err(e);
-  }
+  return new WrapperSysAbstraction(my, param2);
 }
 
 // src/utils/relative-path.ts
@@ -1475,23 +1416,23 @@ var Path = class {
     this.parts.push(part);
   }
 };
-function splitPath(path3) {
+function splitPath(path) {
   const p = new Path();
-  if (path3 === "") {
+  if (path === "") {
     return p;
   }
-  for (let count = 0; path3.length; count++) {
-    if (path3.match(/^\/+/)) {
+  for (let count = 0; path.length; count++) {
+    if (path.match(/^\/+/)) {
       if (count === 0) {
         p.add(3 /* Root */);
       } else {
         p.add(1 /* Slash */);
       }
-      path3 = path3.replace(/^\/+/, "");
+      path = path.replace(/^\/+/, "");
     } else {
-      const part = path3.replace(/\/.*$/, "");
+      const part = path.replace(/\/.*$/, "");
       p.add(part);
-      path3 = path3.replace(/^[^/]+/, "");
+      path = path.replace(/^[^/]+/, "");
     }
   }
   return p;
@@ -1500,29 +1441,29 @@ function pathJoin(...paths) {
   let prev = "";
   const res = [];
   for (let i = 0; i < paths.length; i++) {
-    const path3 = paths[i];
-    if (path3 === "") {
+    const path = paths[i];
+    if (path === "") {
       continue;
     }
-    if (!(prev.endsWith("/") || path3.startsWith("/"))) {
+    if (!(prev.endsWith("/") || path.startsWith("/"))) {
       if (prev !== "") {
         res.push("/");
       }
-      res.push(path3);
+      res.push(path);
     } else {
-      res.push(path3);
+      res.push(path);
     }
-    prev = path3;
+    prev = path;
   }
   return res.join("");
 }
-function relativePath(path3, relative2) {
-  const relativeParts = splitPath(relative2);
+function relativePath(path, relative) {
+  const relativeParts = splitPath(relative);
   let result;
   if (relativeParts.parts[0] === 3 /* Root */) {
-    result = relative2;
+    result = relative;
   } else {
-    result = pathJoin(path3, relative2);
+    result = pathJoin(path, relative);
   }
   const unoptPath = splitPath(result);
   const out = [];
@@ -1574,45 +1515,45 @@ function stripper(strip, obj) {
   });
   return localStripper(void 0, restrips, obj);
 }
-function localStripper(path3, restrips, obj) {
+function localStripper(path, restrips, obj) {
   if (typeof obj !== "object" || obj === null) {
     return obj;
   }
   if (Array.isArray(obj)) {
-    return obj.map((i) => localStripper(path3, restrips, i));
+    return obj.map((i) => localStripper(path, restrips, i));
   }
   const ret = { ...obj };
-  const matcher = (key2, nextPath) => {
+  const matcher = (key, nextPath) => {
     for (const re of restrips) {
-      if (re.test(key2) || re.test(nextPath)) {
+      if (re.test(key) || re.test(nextPath)) {
         return true;
       }
     }
     return false;
   };
-  for (const key2 in ret) {
-    if (Object.prototype.hasOwnProperty.call(ret, key2)) {
+  for (const key in ret) {
+    if (Object.prototype.hasOwnProperty.call(ret, key)) {
       let nextPath;
-      if (path3) {
-        nextPath = [path3, key2].join(".");
+      if (path) {
+        nextPath = [path, key].join(".");
       } else {
-        nextPath = key2;
+        nextPath = key;
       }
-      if (matcher(key2, nextPath)) {
-        delete ret[key2];
+      if (matcher(key, nextPath)) {
+        delete ret[key];
         continue;
       }
-      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 (typeof ret[key] === "object") {
+        if (Array.isArray(ret[key])) {
+          ret[key] = ret[key].reduce((acc, v, i) => {
+            const toDelete = matcher(key, `${nextPath}[${i}]`);
             if (!toDelete) {
               acc.push(localStripper(`${nextPath}[${i}]`, restrips, v));
             }
             return acc;
           }, []);
         } else {
-          ret[key2] = localStripper(nextPath, restrips, ret[key2]);
+          ret[key] = localStripper(nextPath, restrips, ret[key]);
         }
       }
     }
@@ -1621,29 +1562,15 @@ function localStripper(path3, restrips, obj) {
 }
 
 // src/uri.ts
-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);
+function coerceKey(key, def) {
+  if (typeof key === "object") {
+    const keys = Object.keys(key);
     if (keys.length !== 1) {
-      throw new Error(`Invalid key: ${JSON.stringify(key2)}`);
+      throw new Error(`Invalid key: ${JSON.stringify(key)}`);
     }
-    return { key: keys[0], def: key2[keys[0]] };
+    return { key: keys[0], def: key[keys[0]] };
   }
-  return { key: key2, def };
+  return { key, def };
 }
 function falsy2undef(value) {
   return value === void 0 || value === null ? void 0 : value;
@@ -1746,8 +1673,8 @@ var MutableURL = class _MutableURL extends URL {
   toString() {
     let search = "";
     if (this._sysURL.searchParams.size) {
-      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)}`;
+      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)}`;
       }
     }
     let hostpart = "";
@@ -1782,57 +1709,14 @@ function from(fac, strURLUri, defaultProtocol) {
       throw new Error(`Invalid argument: ${typeof strURLUri}`);
   }
 }
-function getParamResult(key2, val, msgFn = (key3) => {
-  return `missing parameter: ${key3}`;
+function getParamResult(key, val, msgFn = (key2) => {
+  return `missing parameter: ${key2}`;
 }) {
   if (val === void 0) {
-    return Result.Err(msgFn(key2));
+    return Result.Err(msgFn(key));
   }
   return Result.Ok(val);
 }
-function getParamsResult(keys, getParam) {
-  const keyDef = keys.flat().reduce(
-    (acc, i) => {
-      if (typeof i === "string") {
-        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,
-            isOptional: i[k] instanceof _OPTIONAL
-          }))
-        );
-      }
-      return acc;
-    },
-    []
-  );
-  const msgFn = keys.find((k) => typeof k === "function") || ((...keys2) => {
-    const msg = keys2.join(",");
-    return `missing parameters: ${msg}`;
-  });
-  const errors = [];
-  const result = {};
-  for (const kd of keyDef) {
-    const val = getParam.getParam(kd.key);
-    if (val === void 0) {
-      if (typeof kd.def === "string") {
-        result[kd.key] = kd.def;
-      } else {
-        if (!kd.isOptional) {
-          errors.push(kd.key);
-        }
-      }
-    } else {
-      result[kd.key] = val;
-    }
-  }
-  if (errors.length) {
-    return Result.Err(msgFn(...errors));
-  }
-  return Result.Ok(result);
-}
 var BuildURI = class _BuildURI {
   // pathname needs this
   constructor(url) {
@@ -1886,47 +1770,47 @@ var BuildURI = class _BuildURI {
     const pathname = "./" + appendUrl.pathname;
     const basePath = this._url.pathname;
     this.pathname(relativePath(basePath, pathname));
-    for (const [key2, value] of appendUrl.getParams) {
-      this.setParam(key2, value);
+    for (const [key, value] of appendUrl.getParams) {
+      this.setParam(key, value);
     }
     return this;
   }
   cleanParams() {
-    for (const key2 of Array.from(this._url.searchParams.keys())) {
-      this._url.searchParams.delete(key2);
+    for (const key of Array.from(this._url.searchParams.keys())) {
+      this._url.searchParams.delete(key);
     }
     return this;
   }
-  delParam(key2) {
-    this._url.searchParams.delete(key2);
+  delParam(key) {
+    this._url.searchParams.delete(key);
     return this;
   }
-  defParam(key2, str) {
-    if (!this._url.searchParams.has(key2)) {
-      this._url.searchParams.set(key2, str);
+  defParam(key, str) {
+    if (!this._url.searchParams.has(key)) {
+      this._url.searchParams.set(key, str);
     }
     return this;
   }
-  setParam(key2, str) {
-    this._url.searchParams.set(key2, str);
+  setParam(key, str) {
+    this._url.searchParams.set(key, str);
     return this;
   }
-  hasParam(key2) {
-    return this._url.searchParams.has(key2);
+  hasParam(key) {
+    return this._url.searchParams.has(key);
   }
   get getParams() {
     return this._url.searchParams.entries();
   }
-  getParam(key2, def) {
-    const { key: k, def: d } = coerceKey(key2, def);
+  getParam(key, def) {
+    const { key: k, def: d } = coerceKey(key, def);
     let val = this._url.searchParams.get(k);
     if (!falsy2undef(val) && d) {
       val = d;
     }
     return falsy2undef(val);
   }
-  getParamResult(key2, msgFn) {
-    return getParamResult(key2, this.getParam(key2), msgFn);
+  getParamResult(key, msgFn) {
+    return getParamResult(key, this.getParam(key), msgFn);
   }
   getParamsResult(...keys) {
     return getParamsResult(keys, this);
@@ -1969,8 +1853,8 @@ var URI = class _URI {
     if (!(fPath.length === 0 || fPath === "/" || fPath === "./")) {
       intoUrl.pathname(fromUrl.pathname);
     }
-    for (const [key2, value] of fromUrl.getParams) {
-      intoUrl.setParam(key2, value);
+    for (const [key, value] of fromUrl.getParams) {
+      intoUrl.setParam(key, value);
     }
     return intoUrl.URI();
   }
@@ -2023,19 +1907,19 @@ var URI = class _URI {
   get getParams() {
     return this._url.searchParams.entries();
   }
-  hasParam(key2) {
-    return this._url.searchParams.has(key2);
+  hasParam(key) {
+    return this._url.searchParams.has(key);
   }
-  getParam(key2, def) {
-    const { key: k, def: d } = coerceKey(key2, def);
+  getParam(key, def) {
+    const { key: k, def: d } = coerceKey(key, def);
     let val = this._url.searchParams.get(k);
     if (!falsy2undef(val) && d) {
       val = d;
     }
     return falsy2undef(val);
   }
-  getParamResult(key2, msgFn) {
-    return getParamResult(key2, this.getParam(key2), msgFn);
+  getParamResult(key, msgFn) {
+    return getParamResult(key, this.getParam(key), msgFn);
   }
   getParamsResult(...keys) {
     return getParamsResult(keys, this);
@@ -2092,7 +1976,7 @@ var ConsoleWriterStreamDefaultWriter = class {
     this.ready = Promise.resolve(void 0);
     this.closed = Promise.resolve(void 0);
   }
-  async write(chunk) {
+  write(chunk) {
     let strObj = this.decoder.decode(chunk).trimEnd();
     let output = "log";
     try {
@@ -2110,6 +1994,7 @@ var ConsoleWriterStreamDefaultWriter = class {
       default:
         console.log(strObj);
     }
+    return Promise.resolve();
   }
 };
 var ConsoleWriterStream = class {
@@ -2120,8 +2005,8 @@ var ConsoleWriterStream = class {
   abort(reason) {
     throw new Error("Method not implemented.");
   }
-  async close() {
-    return;
+  close() {
+    return Promise.resolve();
   }
   getWriter() {
     if (this.locked) {
@@ -2149,7 +2034,7 @@ var LogWriterStream = class {
         const writer = this._out.getWriter();
         await writer.ready;
         await writer.write(encoded);
-        await writer.releaseLock();
+        writer.releaseLock();
       } catch (err) {
         console.error("Chunk error:", err);
       }
@@ -2173,7 +2058,9 @@ var LogWriterStream = class {
       return;
     }
     const my2 = this._toFlush.shift();
-    my2 == null ? void 0 : my2().finally(() => {
+    my2 == null ? void 0 : my2().catch((e) => {
+      console.error("Flush error:", e);
+    }).finally(() => {
       this._flush(this._toFlush);
     });
   }
@@ -2195,9 +2082,6 @@ function getLen(value, lvs) {
   }
   return logValue(() => -1, lvs);
 }
-function hash(value) {
-  return "not implemented";
-}
 function toLogValue(lop) {
   if (lop && typeof lop.then === "function") {
     throw new Error("async logValue Not implemented");
@@ -2296,9 +2180,9 @@ var LoggerImpl = class _LoggerImpl {
     this.levelHandler.disableLevel(level, ...modules);
     return this;
   }
-  Module(key2) {
-    this._attributes["module"] = logValue(key2, toLogValueCtx(this.levelHandler));
-    this._withAttributes["module"] = logValue(key2, toLogValueCtx(this.levelHandler));
+  Module(key) {
+    this._attributes["module"] = logValue(key, toLogValueCtx(this.levelHandler));
+    this._withAttributes["module"] = logValue(key, toLogValueCtx(this.levelHandler));
     return this;
   }
   // if the string is "*" it will enable for all modules
@@ -2339,10 +2223,10 @@ var LoggerImpl = class _LoggerImpl {
   }
   Err(err) {
     var _a;
-    let key2 = "error";
+    let key = "error";
     if (Result.Is(err)) {
       if (err.isOk()) {
-        key2 = "noerror";
+        key = "noerror";
         err = err.Ok();
       } else {
         err = err.Err();
@@ -2350,12 +2234,12 @@ var LoggerImpl = class _LoggerImpl {
     }
     if (err instanceof Error) {
       if (err.cause) {
-        this.coerceKey(key2, {
+        this.coerceKey(key, {
           message: err.message,
           cause: err.cause
         });
       } else {
-        this._attributes[key2] = logValue(err.message, toLogValueCtx(this.levelHandler));
+        this._attributes[key] = logValue(err.message, toLogValueCtx(this.levelHandler));
       }
       if (this.levelHandler.isStackExposed) {
         this._attributes["stack"] = logValue(
@@ -2364,7 +2248,7 @@ var LoggerImpl = class _LoggerImpl {
         );
       }
     } else {
-      this.Any(key2, err);
+      this.Any(key, err);
     }
     return this;
   }
@@ -2372,22 +2256,22 @@ var LoggerImpl = class _LoggerImpl {
     this._attributes["level"] = logValue(l, toLogValueCtx(this.levelHandler));
     return this;
   }
-  Ref(key2, action) {
+  Ref(key, action) {
     if (typeof action === "function") {
-      this._attributes[key2] = logValue(action, toLogValueCtx(this.levelHandler));
+      this._attributes[key] = logValue(action, toLogValueCtx(this.levelHandler));
     } else if (typeof action.toString === "function") {
-      this._attributes[key2] = logValue(() => action.toString(), toLogValueCtx(this.levelHandler));
+      this._attributes[key] = logValue(() => action.toString(), toLogValueCtx(this.levelHandler));
     } else {
-      this._attributes[key2] = logValue("INVALID REF", toLogValueCtx(this.levelHandler));
+      this._attributes[key] = logValue("INVALID REF", toLogValueCtx(this.levelHandler));
     }
     return this;
   }
-  Bool(key2, value) {
-    this.coerceKey(key2, !!value);
+  Bool(key, value) {
+    this.coerceKey(key, !!value);
     return this;
   }
   Http(...mix) {
-    const key2 = mix.find((x) => typeof x === "string");
+    const key = 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) {
@@ -2407,76 +2291,74 @@ var LoggerImpl = class _LoggerImpl {
       reqAndOrres = req;
     }
     if (reqAndOrres) {
-      this.Any(key2 || "Http", reqAndOrres);
+      this.Any(key || "Http", reqAndOrres);
     }
     return this;
   }
   Pair(x) {
-    for (const key2 of Object.keys(x)) {
-      const value = x[key2];
+    for (const key of Object.keys(x)) {
+      const value = x[key];
       if (value instanceof LogValue) {
-        this._attributes[key2] = value;
+        this._attributes[key] = value;
         continue;
       }
       if (Result.Is(value)) {
-        this.Result(key2, value);
+        this.Result(key, value);
         continue;
       }
-      this.Any(key2, value);
+      this.Any(key, value);
     }
     return this;
   }
-  Result(key2, res) {
+  Result(key, res) {
     if (res.isOk()) {
-      this._attributes[key2] = logValue(res.Ok(), toLogValueCtx(this.levelHandler));
+      this._attributes[key] = logValue(res.Ok(), toLogValueCtx(this.levelHandler));
     } else {
       this.Err(res.Err());
     }
     return this;
   }
-  Len(value, key2 = "len") {
-    this._attributes[key2] = getLen(value, toLogValueCtx(this.levelHandler));
+  Len(value, key = "len") {
+    this._attributes[key] = getLen(value, toLogValueCtx(this.levelHandler));
     return this;
   }
-  Hash(value, key2 = "hash") {
-    this._attributes[key2] = asyncLogValue(
-      async () => `${getLen(value, toLogValueCtx(this.levelHandler)).value()}:${await hash(value)}`
-    );
-    return this;
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  Hash(value, key = "hash") {
+    throw new Error("Not implemented");
   }
-  Url(url, key2 = "url") {
-    this.Ref(key2, () => URI.from(url).toString());
+  Url(url, key = "url") {
+    this.Ref(key, () => URI.from(url).toString());
     return this;
   }
-  coerceKey(key2, value) {
-    if (typeof key2 === "string") {
-      this._attributes[key2] = logValue(value, toLogValueCtx(this.levelHandler));
+  coerceKey(key, value) {
+    if (typeof key === "string") {
+      this._attributes[key] = logValue(value, toLogValueCtx(this.levelHandler));
     } else {
-      this.Pair(key2);
+      this.Pair(key);
     }
   }
-  Str(key2, value) {
-    this.coerceKey(key2, value);
+  Str(key, value) {
+    this.coerceKey(key, value);
     return this;
   }
-  Any(key2, value) {
-    this.coerceKey(key2, value);
+  Any(key, value) {
+    this.coerceKey(key, value);
     return this;
   }
-  Dur(key2, nsec) {
-    this._attributes[key2] = logValue(`${nsec}ms`, toLogValueCtx(this.levelHandler));
+  Dur(key, nsec) {
+    this._attributes[key] = logValue(`${nsec}ms`, toLogValueCtx(this.levelHandler));
     return this;
   }
-  Uint64(key2, value) {
-    this.coerceKey(key2, value);
+  Uint64(key, value) {
+    this.coerceKey(key, value);
     return this;
   }
-  Int(key2, value) {
-    return this.Uint64(key2, value);
+  Int(key, value) {
+    return this.Uint64(key, value);
   }
   async Flush() {
-    return new Promise((resolve2) => {
-      this._logWriter._flush(void 0, resolve2);
+    return new Promise((resolve) => {
+      this._logWriter._flush(void 0, resolve);
     });
   }
   With() {
@@ -2495,8 +2377,8 @@ var LoggerImpl = class _LoggerImpl {
   }
   _resetAttributes(fn) {
     const ret = fn();
-    Object.keys(this._attributes).forEach((key2) => {
-      delete this._attributes[key2];
+    Object.keys(this._attributes).forEach((key) => {
+      delete this._attributes[key];
     });
     Object.assign(this._attributes, this._withAttributes);
     return ret;
@@ -2563,8 +2445,8 @@ var WithLoggerBuilder = class {
     this._li.levelHandler.enableLevel(level, ...modules);
     return this;
   }
-  Module(key2) {
-    this._li.Module(key2);
+  Module(key) {
+    this._li.Module(key);
     return this;
   }
   SetDebug(...modules) {
@@ -2579,36 +2461,36 @@ var WithLoggerBuilder = class {
     this._li.Pair(x);
     return this;
   }
-  Str(key2, value) {
-    this._li.Str(key2, value);
+  Str(key, value) {
+    this._li.Str(key, value);
     return this;
   }
-  Len(value, key2) {
-    this._li.Len(value, key2);
+  Len(value, key) {
+    this._li.Len(value, key);
     return this;
   }
-  Hash(value, key2) {
-    this._li.Hash(value, key2);
+  Hash(value, key) {
+    this._li.Hash(value, key);
     return this;
   }
-  Ref(key2, action) {
-    this._li.Ref(key2, action);
+  Ref(key, action) {
+    this._li.Ref(key, action);
     return this;
   }
-  Bool(key2, value) {
-    this._li.Bool(key2, value);
+  Bool(key, value) {
+    this._li.Bool(key, value);
     return this;
   }
-  Result(key2, res) {
-    this._li.Result(key2, res);
+  Result(key, res) {
+    this._li.Result(key, res);
     return this;
   }
-  Url(url, key2) {
-    this._li.Url(url, key2);
+  Url(url, key) {
+    this._li.Url(url, key);
     return this;
   }
-  Int(key2, value) {
-    this._li.Int(key2, value);
+  Int(key, value) {
+    this._li.Int(key, value);
     return this;
   }
   Log() {
@@ -2643,16 +2525,16 @@ var WithLoggerBuilder = class {
     this._li.Timestamp();
     return this;
   }
-  Any(key2, value) {
-    this._li.Any(key2, value);
+  Any(key, value) {
+    this._li.Any(key, value);
     return this;
   }
-  Dur(key2, nsec) {
-    this._li.Dur(key2, nsec);
+  Dur(key, nsec) {
+    this._li.Dur(key, nsec);
     return this;
   }
-  Uint64(key2, value) {
-    this._li.Uint64(key2, value);
+  Uint64(key, value) {
+    this._li.Uint64(key, value);
     return this;
   }
 };