@adviser/cement 0.3.3 → 0.3.5

package/index.cjs

@@ -40,7 +40,7 @@ __export(src_exports, {
   BaseSysAbstraction: () => BaseSysAbstraction,
   BuildURI: () => BuildURI,
   ConstTime: () => ConstTime,
-  EnvImpl: () => EnvImpl2,
+  EnvImpl: () => EnvImpl,
   Future: () => Future,
   HeadersImpl: () => HeadersImpl,
   HttpHeader: () => HttpHeader,
@@ -95,6 +95,7 @@ __export(src_exports, {
   isURL: () => isURL,
   key: () => key,
   logValue: () => logValue,
+  param: () => param2,
   registerEnvAction: () => registerEnvAction,
   runtimeFn: () => runtimeFn,
   toCryptoRuntime: () => toCryptoRuntime,
@@ -348,9 +349,9 @@ var SysTime = class extends Time {
     return /* @__PURE__ */ new Date();
   }
   Sleep(duration) {
-    return new Promise((resolve2) => {
+    return new Promise((resolve) => {
       setTimeout(() => {
-        resolve2();
+        resolve();
       }, duration);
     });
   }
@@ -463,13 +464,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();
     });
   }
 };
@@ -540,8 +543,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);
     }));
   }
@@ -567,20 +570,21 @@ var ResolveSeq = class {
   }
   reset() {
   }
-  async _step(item) {
+  _step(item) {
     if (!item) {
-      return;
+      return Promise.resolve();
     }
     item.fn(this.ctx).then((value) => item.future.resolve(value)).catch((e) => item.future.reject(e)).finally(() => {
       this._seqFutures.shift();
-      this._step(this._seqFutures[0]);
+      void this._step(this._seqFutures[0]);
     });
+    return Promise.resolve();
   }
   async add(fn, id) {
     const future = new Future();
     this._seqFutures.push({ future, fn, id });
     if (this._seqFutures.length === 1) {
-      this._step(this._seqFutures[0]);
+      void this._step(this._seqFutures[0]);
     }
     return future.asPromise();
   }
@@ -716,7 +720,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;
@@ -737,28 +744,7 @@ function runtimeFn() {
   };
 }
 
-// src/txt-en-decoder.ts
-var encoder = new TextEncoder();
-var decoder = new TextDecoder();
-var Utf8EnDecoder = class {
-  encode(str) {
-    return encoder.encode(str);
-  }
-  decode(data) {
-    return decoder.decode(data);
-  }
-};
-var utf8EnDecoder = new Utf8EnDecoder();
-function Utf8EnDecoderSingleton() {
-  return utf8EnDecoder;
-}
-
-// 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 {
@@ -798,95 +784,8 @@ var _DenoEnvActions = class _DenoEnvActions {
 };
 _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 {
@@ -924,96 +823,51 @@ var _NodeEnvActions = class _NodeEnvActions {
 };
 _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(key2) {
+    return this.env.get(key2);
   }
-};
-var _NodeSystemService = class _NodeSystemService {
-  constructor() {
-    this._exitService = new NodeExitServiceImpl();
-    this._exitService.injectExitHandlers(_NodeSystemService._exitHandlers);
+  set(key2, value) {
+    if (value) {
+      this.env.set(key2, value);
+    }
   }
-  Env() {
-    return envFactory();
+  delete(key2) {
+    this.env.delete(key2);
   }
-  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({});
@@ -1054,6 +908,156 @@ var CFEnvActions = class _CFEnvActions {
   }
 };
 
+// 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) },
@@ -1080,17 +1084,67 @@ 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((key2) => {
+      if (Array.isArray(key2)) {
+        if (key2.length === 2) {
+          const [k, v] = key2;
+          if (typeof k === "string" && typeof v === "string") {
+            this.set(k, v);
+            return;
+          }
+        }
+        for (const item of key2) {
+          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(key2)) {
+          for (const [k, v] of key2) {
+            if (typeof k === "string" && typeof v === "string") {
+              this.set(k, v);
+            }
+          }
+        } else {
+          const rKey = key2;
+          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;
@@ -1153,40 +1207,23 @@ var EnvImpl2 = class {
   }
 };
 
-// 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;
+// src/txt-en-decoder.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var Utf8EnDecoder = class {
+  encode(str) {
+    return encoder.encode(str);
   }
-  register(env) {
-    const sym = Symbol.for(this.opts.symbol || "CP_ENV");
-    const browser = globalThis;
-    browser[sym] = env;
-    return env;
+  decode(data) {
+    return decoder.decode(data);
   }
 };
+var utf8EnDecoder = new Utf8EnDecoder();
+function Utf8EnDecoderSingleton() {
+  return utf8EnDecoder;
+}
+
+// src/web/web-sys-abstraction.ts
 var WebFileService = class {
   get baseDir() {
     throw new Error("basedir-Method not implemented.");
@@ -1249,106 +1286,15 @@ var WebSystemService = class {
   }
 };
 var my = void 0;
-function WebSysAbstraction(param) {
+function WebSysAbstraction(param3) {
   if (!my) {
     my = new BaseSysAbstraction({
-      TxtEnDecoder: (param == null ? void 0 : param.TxtEnDecoder) || Utf8EnDecoderSingleton(),
+      TxtEnDecoder: (param3 == null ? void 0 : param3.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, param3);
 }
 
 // src/utils/relative-path.ts
@@ -1397,23 +1343,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;
@@ -1422,29 +1368,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 = [];
@@ -1496,12 +1442,12 @@ 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) => {
@@ -1515,8 +1461,8 @@ function localStripper(path3, restrips, obj) {
   for (const key2 in ret) {
     if (Object.prototype.hasOwnProperty.call(ret, key2)) {
       let nextPath;
-      if (path3) {
-        nextPath = [path3, key2].join(".");
+      if (path) {
+        nextPath = [path, key2].join(".");
       } else {
         nextPath = key2;
       }
@@ -1543,20 +1489,7 @@ 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()
-};
+var key = param;
 function coerceKey(key2, def) {
   if (typeof key2 === "object") {
     const keys = Object.keys(key2);
@@ -1712,49 +1645,6 @@ function getParamResult(key2, val, msgFn = (key3) => {
   }
   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) {
@@ -2014,7 +1904,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 {
@@ -2032,6 +1922,7 @@ var ConsoleWriterStreamDefaultWriter = class {
       default:
         console.log(strObj);
     }
+    return Promise.resolve();
   }
 };
 var ConsoleWriterStream = class {
@@ -2042,8 +1933,8 @@ var ConsoleWriterStream = class {
   abort(reason) {
     throw new Error("Method not implemented.");
   }
-  async close() {
-    return;
+  close() {
+    return Promise.resolve();
   }
   getWriter() {
     if (this.locked) {
@@ -2071,7 +1962,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);
       }
@@ -2095,7 +1986,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);
     });
   }
@@ -2256,9 +2149,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");
@@ -2508,11 +2398,9 @@ var LoggerImpl = class _LoggerImpl {
     this._attributes[key2] = getLen(value, toLogValueCtx(this.levelHandler));
     return this;
   }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   Hash(value, key2 = "hash") {
-    this._attributes[key2] = asyncLogValue(
-      async () => `${getLen(value, toLogValueCtx(this.levelHandler)).value()}:${await hash(value)}`
-    );
-    return this;
+    throw new Error("Not implemented");
   }
   Url(url, key2 = "url") {
     this.Ref(key2, () => URI.from(url).toString());
@@ -2545,8 +2433,8 @@ var LoggerImpl = class _LoggerImpl {
     return this.Uint64(key2, value);
   }
   async Flush() {
-    return new Promise((resolve2) => {
-      this._logWriter._flush(void 0, resolve2);
+    return new Promise((resolve) => {
+      this._logWriter._flush(void 0, resolve);
     });
   }
   With() {
@@ -2857,8 +2745,8 @@ function MockLogger(params) {
 
 // src/tracer.ts
 var Metric = class {
-  constructor(path3) {
-    this.path = path3;
+  constructor(path) {
+    this.path = path;
   }
   set(value) {
     this.value = value;
@@ -2893,23 +2781,23 @@ var Metrics = class {
     return obj;
   }
   get(ipath) {
-    const path3 = ipath.replace(/[/]+/g, "/").trim();
-    if (path3.startsWith("/")) {
-      if (path3.slice(1).length === 0) {
-        throw new Error(`Metrics path must contain value /:${path3}`);
+    const path = ipath.replace(/[/]+/g, "/").trim();
+    if (path.startsWith("/")) {
+      if (path.slice(1).length === 0) {
+        throw new Error(`Metrics path must contain value /:${path}`);
       }
-      let metric = this.map.get(path3);
+      let metric = this.map.get(path);
       if (!metric) {
-        metric = new Metric(path3);
-        this.map.set(path3, metric);
+        metric = new Metric(path);
+        this.map.set(path, metric);
       }
-      this.spanRefs.set(path3, metric);
+      this.spanRefs.set(path, metric);
       return metric;
-    } else if (path3.includes("/")) {
-      throw new Error(`Metrics path must start with /:${path3}`);
+    } else if (path.includes("/")) {
+      throw new Error(`Metrics path must start with /:${path}`);
     }
     const rootPath = this.tracenode.getRootPath();
-    return this.get(`${rootPath}/${path3}`);
+    return this.get(`${rootPath}/${path}`);
   }
 };
 var TraceNode = class _TraceNode {
@@ -3209,6 +3097,8 @@ __export(utils_exports, {
   FanoutWriteStream: () => FanoutWriteStream,
   array2stream: () => array2stream,
   devnull: () => devnull,
+  getParamsResult: () => getParamsResult,
+  param: () => param,
   rebuffer: () => rebuffer,
   rebufferArray: () => rebufferArray,
   stream2array: () => stream2array,
@@ -3322,6 +3212,9 @@ function pump(ps, controller, next) {
       ps.tmpLen += value.length;
     }
     pump(ps, controller, next);
+  }).catch((err) => {
+    controller.error(err);
+    next();
   });
 }
 function rebuffer(a, chunkSize) {
@@ -3333,8 +3226,8 @@ function rebuffer(a, chunkSize) {
   };
   return new ReadableStream({
     async pull(controller) {
-      return new Promise((resolve2) => {
-        pump(state, controller, resolve2);
+      return new Promise((resolve) => {
+        pump(state, controller, resolve);
       });
     }
   });
@@ -3399,6 +3292,9 @@ function uint8array2stream(str) {
     }
   });
 }
+
+// src/index.ts
+var param2 = param;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BaseSysAbstraction,
@@ -3459,6 +3355,7 @@ function uint8array2stream(str) {
   isURL,
   key,
   logValue,
+  param,
   registerEnvAction,
   runtimeFn,
   toCryptoRuntime,