@adviser/cement 0.2.17 → 0.2.19

package/index.cjs

@@ -74,12 +74,14 @@ var __yieldStar = (value) => {
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  BaseSysAbstraction: () => BaseSysAbstraction,
   BrowserEnvActions: () => BrowserEnvActions,
   BuildURI: () => BuildURI,
+  ConstTime: () => ConstTime,
   EnvImpl: () => EnvImpl,
-  FanoutWriter: () => FanoutWriter,
   Future: () => Future,
   IDMode: () => IDMode,
+  IdService: () => IdService,
   IsLogger: () => IsLogger,
   Keyed: () => Keyed,
   KeyedResolvOnce: () => KeyedResolvOnce,
@@ -88,31 +90,38 @@ __export(src_exports, {
   LevelHandlerImpl: () => LevelHandlerImpl,
   LogCollector: () => LogCollector,
   LogValue: () => LogValue,
-  LogWriterCollector: () => LogWriterCollector,
+  LogWriteStream: () => LogWriteStream,
   LogWriterStream: () => LogWriterStream,
   LoggerImpl: () => LoggerImpl,
   MockLogger: () => MockLogger,
+  MutableURL: () => MutableURL,
   None: () => None,
   Option: () => Option,
   RandomMode: () => RandomMode,
+  RandomService: () => RandomService,
   ResolveOnce: () => ResolveOnce,
   ResolveSeq: () => ResolveSeq,
   Result: () => Result,
   ResultError: () => ResultError,
   ResultOK: () => ResultOK,
   Some: () => Some,
+  StepTime: () => StepTime,
   String2TimeMode: () => String2TimeMode,
+  SysTime: () => SysTime,
   Time: () => Time,
+  TimeFactory: () => TimeFactory,
   TimeMode: () => TimeMode,
   TimeUnits: () => TimeUnits,
   URI: () => URI,
+  WrapperSysAbstraction: () => WrapperSysAbstraction,
   asyncLogValue: () => asyncLogValue,
   envFactory: () => envFactory,
   isURL: () => isURL,
   logValue: () => logValue,
   removeSelfRef: () => removeSelfRef,
   runtimeFn: () => runtimeFn,
-  toCryptoRuntime: () => toCryptoRuntime
+  toCryptoRuntime: () => toCryptoRuntime,
+  utils: () => utils_exports
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -197,7 +206,7 @@ function IsLogger(obj) {
   ].map((fn) => typeof obj[fn] === "function").reduce((a, b) => a && b, true);
 }
 
-// src/sys_abstraction.ts
+// src/sys-abstraction.ts
 var TimeMode = /* @__PURE__ */ ((TimeMode2) => {
   TimeMode2["REAL"] = "real";
   TimeMode2["CONST"] = "const";
@@ -244,7 +253,7 @@ var TimeUnits = /* @__PURE__ */ ((TimeUnits2) => {
   return TimeUnits2;
 })(TimeUnits || {});
 
-// src/base_sys_abstraction.ts
+// src/base-sys-abstraction.ts
 var SysTime = class extends Time {
   Now() {
     return /* @__PURE__ */ new Date();
@@ -270,13 +279,15 @@ var StepTime = class extends Time {
   constructor() {
     super();
     this._step = new ConstTime().Now();
+    this._start = this._step;
   }
-  Now() {
-    if (this._step.getTime() === 0) {
-      this._step = new ConstTime().Now();
-      return this._step;
+  Now(steps = 1) {
+    for (let i = 0; steps > 0 && i < steps; i++) {
+      this._step = new Date(this._step.getTime() + 1e3);
+    }
+    if (steps < 1) {
+      this._step = new Date(this._start.getTime() + steps * -1e3);
     }
-    this._step = new Date(this._step.getTime() + 1e3);
     return this._step;
   }
   Sleep(duration) {
@@ -588,7 +599,7 @@ var KeyedResolvSeq = class extends Keyed {
   }
 };
 
-// src/sys_env.ts
+// src/sys-env.ts
 var _node;
 var NodeEnvActions = class {
   // eslint-disable-next-line @typescript-eslint/no-useless-constructor, @typescript-eslint/no-unused-vars
@@ -758,7 +769,7 @@ var EnvImpl = class {
   }
 };
 
-// src/web/web_sys_abstraction.ts
+// src/web/web-sys-abstraction.ts
 var WebFileService = class {
   get baseDir() {
     throw new Error("basedir-Method not implemented.");
@@ -837,34 +848,100 @@ function falsy2undef(value) {
 }
 function ensureURLWithDefaultProto(url, defaultProtocol) {
   if (!url) {
-    return new URL(`${defaultProtocol}//`);
+    return new MutableURL(`${defaultProtocol}//`);
   }
   if (typeof url === "string") {
     try {
-      return new URL(url);
+      return new MutableURL(url);
     } catch (e) {
-      return new URL(`${defaultProtocol}//${url}`);
+      return new MutableURL(`${defaultProtocol}//${url}`);
     }
   } else {
-    return url;
+    return new MutableURL(url.toString());
   }
 }
 function isURL(value) {
   return value instanceof URL || !!value && typeof value.searchParams === "object" && typeof value.searchParams.sort === "function" && typeof value.hash === "string";
 }
+var MutableURL = class _MutableURL extends URL {
+  constructor(urlStr) {
+    super("defect://does.not.exist");
+    this._sysURL = new URL(urlStr);
+    this._protocol = this._sysURL.protocol;
+    this._hasHostpart = ["http:", "https:"].includes(this._protocol);
+    if (this._hasHostpart) {
+      this._pathname = this._sysURL.pathname;
+    } else {
+      this._pathname = urlStr.replace(new RegExp(`^${this._protocol}//`), "").replace(/[#?].*$/, "");
+    }
+    this.hash = this._sysURL.hash;
+  }
+  clone() {
+    return new _MutableURL(this.toString());
+  }
+  get hostname() {
+    if (!this._hasHostpart) {
+      throw new Error("you can use hostname only if protocol is http or https");
+    }
+    return this._sysURL.hostname;
+  }
+  set hostname(h) {
+    if (!this._hasHostpart) {
+      throw new Error("you can use hostname only if protocol is http or https");
+    }
+    this._sysURL.hostname = h;
+  }
+  set pathname(p) {
+    this._pathname = p;
+  }
+  get pathname() {
+    return this._pathname;
+  }
+  get protocol() {
+    return this._protocol;
+  }
+  set protocol(p) {
+    if (!p.endsWith(":")) {
+      p = `${p}:`;
+    }
+    this._protocol = p;
+  }
+  get searchParams() {
+    return this._sysURL.searchParams;
+  }
+  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)}`;
+      }
+    }
+    let hostpart = "";
+    if (this._hasHostpart) {
+      hostpart = this._sysURL.hostname;
+      if (this._sysURL.port) {
+        hostpart += `:${this._sysURL.port}`;
+      }
+      if (!this._pathname.startsWith("/")) {
+        hostpart += "/";
+      }
+    }
+    return `${this._protocol}//${hostpart}${this._pathname}${search}`;
+  }
+};
 function from(fac, strURLUri, defaultProtocol) {
   switch (typeof falsy2undef(strURLUri)) {
     case "undefined":
-      return fac(new URL(`${defaultProtocol}//`));
+      return fac(new MutableURL(`${defaultProtocol}///`));
     case "string":
       return fac(ensureURLWithDefaultProto(strURLUri, defaultProtocol));
     case "object":
       if (BuildURI.is(strURLUri)) {
-        return fac(new URL(strURLUri._url.toString()));
+        return fac(new MutableURL(strURLUri._url.toString()));
       } else if (URI.is(strURLUri)) {
-        return fac(new URL(strURLUri._url.toString()));
+        return fac(new MutableURL(strURLUri._url.toString()));
       } else if (isURL(strURLUri)) {
-        return fac(new URL(strURLUri.toString()));
+        return fac(new MutableURL(strURLUri.toString()));
       }
       throw new Error(`unknown object type: ${strURLUri}`);
     default:
@@ -886,46 +963,38 @@ var BuildURI = class _BuildURI {
     this._url.hostname = h;
     return this;
   }
-  password(p) {
-    this._url.password = p;
-    return this;
-  }
-  port(p) {
-    this._url.port = p;
-    return this;
-  }
-  username(u) {
-    this._url.username = u;
-    return this;
-  }
-  search(s) {
-    this._url.search = s;
-    return this;
-  }
+  // password(p: string) {
+  //   this._url.password = p;
+  //   return this;
+  // }
+  // port(p: string) {
+  //   this._url.port = p;
+  //   return this;
+  // }
+  // username(u: string) {
+  //   this._url.username = u;
+  //   return this;
+  // }
+  // search(s: string) {
+  //   this._url.search = s;
+  //   return this;
+  // }
   protocol(p) {
-    if (!p.endsWith(":")) {
-      p = `${p}:`;
-    }
-    const mySrc = this._url.toString();
-    const myDst = mySrc.replace(new RegExp(`^${this._url.protocol}`), `${p}`);
-    this._url = new URL(myDst);
+    this._url.protocol = p;
     return this;
   }
   pathname(p) {
-    const myp = this.URI().pathname;
-    const mySrc = this._url.toString();
-    const myDst = mySrc.replace(new RegExp(`^${this._url.protocol}//${myp}`), `${this._url.protocol}//${p}`);
-    this._url = new URL(myDst);
-    return this;
-  }
-  hash(h) {
-    this._url.hash = h;
-    return this;
-  }
-  host(h) {
-    this._url.host = h;
+    this._url.pathname = p;
     return this;
   }
+  // hash(h: string) {
+  //   this._url.hash = h;
+  //   return this;
+  // }
+  // host(h: string) {
+  //   this._url.host = h;
+  //   return this;
+  // }
   delParam(key) {
     this._url.searchParams.delete(key);
     return this;
@@ -944,6 +1013,9 @@ var BuildURI = class _BuildURI {
     this._url.searchParams.sort();
     return this._url.toString();
   }
+  toJSON() {
+    return this.toString();
+  }
   URI() {
     return URI.from(this._url);
   }
@@ -971,38 +1043,38 @@ var URI = class _URI {
     return from((url) => new _URI(url), strURLUri, defaultProtocol);
   }
   constructor(url) {
-    this._url = url;
+    this._url = url.clone();
   }
   build() {
-    return BuildURI.from(this.asURL());
+    return BuildURI.from(this._url);
   }
   get hostname() {
     return this._url.hostname;
   }
-  get password() {
-    return this._url.password;
-  }
-  get port() {
-    return this._url.port;
-  }
-  get username() {
-    return this._url.username;
-  }
-  get search() {
-    return this._url.search;
-  }
+  // get password(): string {
+  //   return this._url.password;
+  // }
+  // get port(): string {
+  //   return this._url.port;
+  // }
+  // get username(): string {
+  //   return this._url.username;
+  // }
+  // get search(): string {
+  //   return this._url.search;
+  // }
   get protocol() {
     return this._url.protocol;
   }
   get pathname() {
     return this._url.toString().replace(/^.*:\/\//, "").replace(/\?.*$/, "");
   }
-  get hash() {
-    return this._url.hash;
-  }
-  get host() {
-    return this._url.host;
-  }
+  // get hash(): string {
+  //   return this._url.hash;
+  // }
+  // get host(): string {
+  //   return this._url.host;
+  // }
   get getParams() {
     return this._url.searchParams.entries();
   }
@@ -1013,17 +1085,17 @@ var URI = class _URI {
     return falsy2undef(this._url.searchParams.get(key));
   }
   clone() {
-    return new _URI(this.asURL());
+    return new _URI(this._url);
   }
   asURL() {
-    const url = new URL(this._url.toString());
-    url.searchParams.sort();
-    return url;
+    return this._url.clone();
   }
   toString() {
-    this._url.searchParams.sort();
     return this._url.toString();
   }
+  toJSON() {
+    return this.toString();
+  }
 };
 
 // src/runtime.ts
@@ -1049,7 +1121,71 @@ function runtimeFn() {
   };
 }
 
-// src/logger_impl.ts
+// src/utils/console-write-stream.ts
+var ConsoleWriterStreamDefaultWriter = class {
+  constructor(stream) {
+    this.stream = stream;
+    this.desiredSize = null;
+    this.decoder = new TextDecoder();
+    this._stream = stream;
+    this.ready = Promise.resolve(void 0);
+    this.closed = Promise.resolve(void 0);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
+  abort(reason) {
+    throw new Error("Method not implemented.");
+  }
+  async close() {
+  }
+  releaseLock() {
+    this._stream.locked = false;
+    this.ready = Promise.resolve(void 0);
+    this.closed = Promise.resolve(void 0);
+  }
+  async write(chunk) {
+    const str = this.decoder.decode(chunk).trimEnd();
+    let output = "log";
+    try {
+      const decode = JSON.parse(str);
+      output = decode.level;
+    } catch (e) {
+    }
+    switch (output) {
+      case "error":
+        console.error(str);
+        break;
+      case "warn":
+        console.warn(str);
+        break;
+      default:
+        console.log(str);
+    }
+  }
+};
+var ConsoleWriterStream = class {
+  constructor() {
+    this.locked = false;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
+  abort(reason) {
+    throw new Error("Method not implemented.");
+  }
+  async close() {
+    return;
+  }
+  getWriter() {
+    if (this.locked) {
+      throw new Error("Stream is locked");
+    }
+    this.locked = true;
+    if (!this._writer) {
+      this._writer = new ConsoleWriterStreamDefaultWriter(this);
+    }
+    return this._writer;
+  }
+};
+
+// src/logger-impl.ts
 var encoder = new TextEncoder();
 var LevelHandlerImpl = class {
   constructor() {
@@ -1193,68 +1329,6 @@ function toLogValue(lop) {
   }
   return lop;
 }
-var ConsoleWriterStreamDefaultWriter = class {
-  constructor(stream) {
-    this.stream = stream;
-    this.desiredSize = null;
-    this.decoder = new TextDecoder();
-    this._stream = stream;
-    this.ready = Promise.resolve(void 0);
-    this.closed = Promise.resolve(void 0);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
-  abort(reason) {
-    throw new Error("Method not implemented.");
-  }
-  async close() {
-  }
-  releaseLock() {
-    this._stream.locked = false;
-    this.ready = Promise.resolve(void 0);
-    this.closed = Promise.resolve(void 0);
-  }
-  async write(chunk) {
-    const str = this.decoder.decode(chunk).trimEnd();
-    let output = "log";
-    try {
-      const decode = JSON.parse(str);
-      output = decode.level;
-    } catch (e) {
-    }
-    switch (output) {
-      case "error":
-        console.error(str);
-        break;
-      case "warn":
-        console.warn(str);
-        break;
-      default:
-        console.log(str);
-    }
-  }
-};
-var ConsoleWriterStream = class {
-  constructor() {
-    this.locked = false;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
-  abort(reason) {
-    throw new Error("Method not implemented.");
-  }
-  async close() {
-    return;
-  }
-  getWriter() {
-    if (this.locked) {
-      throw new Error("Stream is locked");
-    }
-    this.locked = true;
-    if (!this._writer) {
-      this._writer = new ConsoleWriterStreamDefaultWriter(this);
-    }
-    return this._writer;
-  }
-};
 var LoggerImpl = class _LoggerImpl {
   // readonly _id: string = "logger-" + Math.random().toString(36)
   constructor(params) {
@@ -1299,6 +1373,17 @@ var LoggerImpl = class _LoggerImpl {
       this._levelHandler = levelSingleton;
     }
   }
+  Attributes() {
+    return Array.from(Object.entries(this._attributes)).reduce(
+      (acc, [key, value]) => {
+        if (value instanceof LogValue) {
+          acc[key] = value.value();
+        }
+        return acc;
+      },
+      {}
+    );
+  }
   SetExposeStack(enable) {
     this._levelHandler.setExposeStack(enable);
     return this;
@@ -1322,7 +1407,7 @@ var LoggerImpl = class _LoggerImpl {
     return this;
   }
   Timestamp() {
-    this._attributes["ts"] = logValue(this._sys.Time().Now().toISOString());
+    this._attributes["ts"] = logValue(() => this._sys.Time().Now().toISOString());
     return this;
   }
   Warn() {
@@ -1439,18 +1524,11 @@ var LoggerImpl = class _LoggerImpl {
     return ret;
   }
   _produceError(attr, ...args) {
-    var _a;
     attr["msg"] = logValue(args.join(" "));
     const msg = attr["msg"].value();
     if (typeof msg === "string" && !msg.trim().length) {
       delete attr["msg"];
     }
-    if (((_a = toLogValue(attr["ts"])) == null ? void 0 : _a.value()) === "ETERNITY") {
-      this.Timestamp.call({
-        _sys: this._sys,
-        _attributes: attr
-      });
-    }
     return JSON.stringify(attr, removeSelfRef());
   }
   Msg(...args) {
@@ -1482,6 +1560,9 @@ var WithLoggerBuilder = class {
     Object.assign(this._li._withAttributes, this._li._attributes);
     return this._li;
   }
+  Attributes() {
+    return __spreadValues({}, this._li._attributes);
+  }
   SetExposeStack(enable) {
     this._li._levelHandler.setExposeStack(enable);
     return this;
@@ -1563,7 +1644,7 @@ var WithLoggerBuilder = class {
     return this;
   }
   Timestamp() {
-    this._li._attributes["ts"] = logValue("ETERNITY");
+    this._li.Timestamp();
     return this;
   }
   Any(key, value) {
@@ -1580,8 +1661,34 @@ var WithLoggerBuilder = class {
   }
 };
 
-// src/test/log_collector.ts
-var LogWriterCollector = class {
+// src/utils/fanout-write-stream.ts
+var FanoutWriteStream = class {
+  constructor(writers) {
+    this.desiredSize = null;
+    this._writers = writers;
+    this.ready = Promise.all(this._writers.map((w) => w.ready)).then(() => void 0);
+    this.closed = Promise.all(this._writers.map((w) => w.closed)).then(() => void 0);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  abort(reason) {
+    return Promise.all(this._writers.map((w) => w.abort(reason))).then(() => {
+    });
+  }
+  close() {
+    return Promise.all(this._writers.map((w) => w.close())).then(() => {
+    });
+  }
+  releaseLock() {
+    this._writers.map((w) => w.releaseLock());
+  }
+  write(chunk) {
+    return Promise.all(this._writers.map((w) => w.write(chunk))).then(() => {
+    });
+  }
+};
+
+// src/test/log-write-stream.ts
+var LogWriteStream = class {
   constructor(bufferArr) {
     this._resolveClosed = new Future();
     this.closed = this._resolveClosed.asPromise();
@@ -1606,30 +1713,6 @@ var LogWriterCollector = class {
     return Promise.resolve(void 0);
   }
 };
-var FanoutWriter = class {
-  constructor(writers) {
-    this.desiredSize = null;
-    this._writers = writers;
-    this.ready = Promise.all(this._writers.map((w) => w.ready)).then(() => void 0);
-    this.closed = Promise.all(this._writers.map((w) => w.closed)).then(() => void 0);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  abort(reason) {
-    return Promise.all(this._writers.map((w) => w.abort(reason))).then(() => {
-    });
-  }
-  close() {
-    return Promise.all(this._writers.map((w) => w.close())).then(() => {
-    });
-  }
-  releaseLock() {
-    this._writers.map((w) => w.releaseLock());
-  }
-  write(chunk) {
-    return Promise.all(this._writers.map((w) => w.write(chunk))).then(() => {
-    });
-  }
-};
 var LogCollector = class {
   constructor(pass) {
     this.locked = false;
@@ -1650,11 +1733,11 @@ var LogCollector = class {
   }
   getWriter() {
     if (!this._writer) {
-      const dests = [new LogWriterCollector(this._bufferArr)];
+      const dests = [new LogWriteStream(this._bufferArr)];
       if (this._pass) {
         dests.push(this._pass);
       }
-      this._writer = new FanoutWriter(dests);
+      this._writer = new FanoutWriteStream(dests);
     }
     return this._writer;
   }
@@ -1679,7 +1762,7 @@ var LogCollector = class {
   }
 };
 
-// src/test/mock_logger.ts
+// src/test/mock-logger.ts
 function MockLogger(params) {
   const lc = new LogCollector(params == null ? void 0 : params.pass);
   let modNames = ["MockLogger"];
@@ -1845,14 +1928,256 @@ function toCryptoRuntime(cryptoOpts = {}) {
   };
   return runtime;
 }
+
+// src/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  ConsoleWriterStream: () => ConsoleWriterStream,
+  ConsoleWriterStreamDefaultWriter: () => ConsoleWriterStreamDefaultWriter,
+  FanoutWriteStream: () => FanoutWriteStream,
+  array2stream: () => array2stream,
+  devnull: () => devnull,
+  rebuffer: () => rebuffer,
+  rebufferArray: () => rebufferArray,
+  receiveFromStream: () => receiveFromStream,
+  sendToStream: () => sendToStream,
+  stream2array: () => stream2array,
+  stream2string: () => stream2string,
+  stream2uint8array: () => stream2uint8array,
+  streamMap: () => streamMap,
+  string2stream: () => string2stream,
+  uint8array2stream: () => uint8array2stream
+});
+
+// src/utils/stream-map.ts
+function streamMap(s, sm) {
+  const state = { reader: s.getReader(), streamMap: sm, idx: 0 };
+  return new ReadableStream({
+    async pull(controller) {
+      const { done, value } = await state.reader.read();
+      if (done) {
+        if (state.streamMap.Close) {
+          state.streamMap.Close();
+        }
+        controller.close();
+        return;
+      }
+      const promiseOrU = state.streamMap.Map(value, state.idx++);
+      let mapped;
+      if (promiseOrU instanceof Promise || typeof promiseOrU.then === "function") {
+        mapped = await promiseOrU;
+      } else {
+        mapped = promiseOrU;
+      }
+      controller.enqueue(mapped);
+    }
+  });
+}
+async function devnull(a) {
+  const reader = a.getReader();
+  let cnt = 0;
+  while (true) {
+    const { done } = await reader.read();
+    if (done) {
+      break;
+    }
+    cnt++;
+  }
+  return cnt;
+}
+function array2stream(a) {
+  let i = 0;
+  return new ReadableStream({
+    pull(controller) {
+      if (i >= a.length) {
+        controller.close();
+        return;
+      }
+      controller.enqueue(a[i]);
+      i++;
+    }
+  });
+}
+async function stream2array(a) {
+  const ret = [];
+  const reader = a.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    ret.push(value);
+  }
+  return ret;
+}
+
+// src/utils/rebuffer.ts
+async function rebufferArray(a, chunkSize) {
+  return stream2array(rebuffer(array2stream(a), chunkSize));
+}
+function reChunk(cs, chunkSize) {
+  const len = cs.reduce((acc, v) => acc + v.length, 0);
+  const last = cs[cs.length - 1];
+  const lastOfs = len - last.length;
+  const rest = last.subarray(chunkSize - lastOfs);
+  cs[cs.length - 1] = last.subarray(0, chunkSize - lastOfs);
+  const chunk = new Uint8Array(chunkSize);
+  let ofs = 0;
+  for (const c of cs) {
+    chunk.set(c, ofs);
+    ofs += c.length;
+  }
+  return { rest, chunk };
+}
+function pump(ps, controller, next) {
+  ps.reader.read().then(({ done, value }) => {
+    if (done) {
+      if (ps.tmpLen > 0) {
+        controller.enqueue(reChunk(ps.tmp, ps.tmpLen).chunk);
+      }
+      controller.close();
+      next();
+      return;
+    }
+    if (ps.tmpLen + value.length > ps.chunkSize) {
+      ps.tmp.push(value);
+      const res = reChunk(ps.tmp, ps.chunkSize);
+      controller.enqueue(res.chunk);
+      ps.tmp = [res.rest];
+      ps.tmpLen = res.rest.length;
+      next();
+      return;
+    } else if (value.length) {
+      ps.tmp.push(value);
+      ps.tmpLen += value.length;
+    }
+    pump(ps, controller, next);
+  });
+}
+function rebuffer(a, chunkSize) {
+  const state = {
+    reader: a.getReader(),
+    tmp: [],
+    tmpLen: 0,
+    chunkSize
+  };
+  return new ReadableStream({
+    async pull(controller) {
+      return new Promise((resolve) => {
+        pump(state, controller, resolve);
+      });
+    }
+  });
+}
+
+// src/utils/stream2string.ts
+async function stream2string(stream, maxSize) {
+  if (!stream) {
+    return Promise.resolve("");
+  }
+  const reader = stream.getReader();
+  let res = "";
+  const decoder2 = new TextDecoder();
+  let rSize = 0;
+  while (typeof maxSize === "undefined" || rSize < maxSize) {
+    try {
+      const read = await reader.read();
+      if (read.done) {
+        break;
+      }
+      if (maxSize && rSize + read.value.length > maxSize) {
+        read.value = read.value.slice(0, maxSize - rSize);
+      }
+      const block = decoder2.decode(read.value, { stream: true });
+      rSize += read.value.length;
+      res += block;
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  return Promise.resolve(res);
+}
+async function stream2uint8array(stream) {
+  if (!stream) {
+    return Promise.resolve(new Uint8Array());
+  }
+  const reader = stream.getReader();
+  let res = new Uint8Array();
+  while (1) {
+    try {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      res = new Uint8Array([...res, ...value]);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  return Promise.resolve(res);
+}
+
+// src/utils/stream-test-helper.ts
+async function receiveFromStream(reb, state) {
+  return new Promise((resolve) => {
+    let reBufferCalls = 0;
+    const reader = reb.getReader();
+    function pump2() {
+      reader.read().then(({ done, value }) => {
+        state.CollectorFn({ done, value, fillCalls: state.fillCalls, reBufferCalls });
+        reBufferCalls++;
+        if (done) {
+          resolve();
+          return;
+        }
+        pump2();
+      });
+    }
+    pump2();
+  });
+}
+async function sendToStream(reb, state) {
+  return new Promise((resolve) => {
+    const writer = reb.getWriter();
+    function pump2(i) {
+      if (i >= state.sendChunks) {
+        writer.close();
+        resolve();
+        return;
+      }
+      writer.ready.then(() => {
+        state.fillCalls++;
+        writer.write(new Uint8Array(Array(state.sendChunkSize).fill(i)));
+        pump2(i + 1);
+      });
+    }
+    pump2(0);
+  });
+}
+
+// src/utils/string2stream.ts
+function string2stream(str) {
+  const encoder2 = new TextEncoder();
+  return uint8array2stream(encoder2.encode(str));
+}
+function uint8array2stream(str) {
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(str);
+      controller.close();
+    }
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BaseSysAbstraction,
   BrowserEnvActions,
   BuildURI,
+  ConstTime,
   EnvImpl,
-  FanoutWriter,
   Future,
   IDMode,
+  IdService,
   IsLogger,
   Keyed,
   KeyedResolvOnce,
@@ -1861,30 +2186,37 @@ function toCryptoRuntime(cryptoOpts = {}) {
   LevelHandlerImpl,
   LogCollector,
   LogValue,
-  LogWriterCollector,
+  LogWriteStream,
   LogWriterStream,
   LoggerImpl,
   MockLogger,
+  MutableURL,
   None,
   Option,
   RandomMode,
+  RandomService,
   ResolveOnce,
   ResolveSeq,
   Result,
   ResultError,
   ResultOK,
   Some,
+  StepTime,
   String2TimeMode,
+  SysTime,
   Time,
+  TimeFactory,
   TimeMode,
   TimeUnits,
   URI,
+  WrapperSysAbstraction,
   asyncLogValue,
   envFactory,
   isURL,
   logValue,
   removeSelfRef,
   runtimeFn,
-  toCryptoRuntime
+  toCryptoRuntime,
+  utils
 });
 //# sourceMappingURL=index.cjs.map