@adviser/cement 0.3.20 → 0.4.1

package/node/index.cjs

@@ -50,449 +50,6 @@ 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/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;
-  }
-};
-
-// src/utils/coerce-uint8.ts
-var globalBuffer = globalThis;
-function coerceIntoUint8(raw) {
-  if (raw instanceof ArrayBuffer) {
-    return Result.Ok(new Uint8Array(raw));
-  }
-  if (ArrayBuffer.isView(raw)) {
-    return Result.Ok(new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength));
-  }
-  if (raw instanceof Blob) {
-    return Result.Err("Blob not supported");
-  }
-  if (globalBuffer.Buffer && globalBuffer.Buffer.isBuffer(raw)) {
-    return Result.Ok(new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength));
-  }
-  if (raw instanceof Uint8Array) {
-    return Result.Ok(raw);
-  }
-  if (Result.Is(raw)) {
-    if (raw.isErr()) {
-      return Result.Err(raw);
-    }
-    return coerceIntoUint8(raw.unwrap());
-  }
-  return Result.Err("Not a Uint8Array");
-}
-
-// src/txt-en-decoder.ts
-var TxtOps = class {
-  constructor() {
-    this.encoder = new TextEncoder();
-    this.decoder = new TextDecoder();
-  }
-  encode(str) {
-    return this.encoder.encode(str);
-  }
-  decode(data) {
-    if (Result.Is(data)) {
-      if (data.isErr()) {
-        throw data.Err();
-      }
-      const unwrapped = data.unwrap();
-      if (typeof unwrapped === "string") {
-        return this.decode(unwrapped);
-      }
-    }
-    if (typeof data === "string") {
-      return data;
-    }
-    return this.decoder.decode(coerceIntoUint8(data).Ok());
-  }
-  async asyncDecode(data) {
-    let resolved = await data;
-    if (resolved instanceof Blob) {
-      resolved = await resolved.arrayBuffer();
-    }
-    return this.decode(resolved);
-  }
-};
-var txtEnDecoder;
-function TxtEnDecoderSingleton() {
-  txtEnDecoder = txtEnDecoder != null ? txtEnDecoder : new TxtOps();
-  return txtEnDecoder;
-}
-
-// src/node/node-file-service.ts
-var NodeFileService = class {
-  constructor(baseDir = import_node_process.default.cwd()) {
-    this.baseDir = this.abs(baseDir);
-  }
-  // nodeImport(fname: string): string {
-  //   // console.log('nodeImport:'+ fname);
-  //   if (path.isAbsolute(fname)) {
-  //     return fname;
-  //   } else {
-  //     return "./" + path.normalize(fname);
-  //   }
-  // }
-  readFileString(fname) {
-    return import_node_fs.default.promises.readFile(fname, { encoding: "utf-8" });
-  }
-  dirname(fname) {
-    return import_node_path.default.dirname(fname);
-  }
-  basename(fname) {
-    return import_node_path.default.basename(fname);
-  }
-  join(...paths) {
-    return import_node_path.default.join(...paths);
-  }
-  relative(from, to) {
-    if (to === void 0) {
-      to = from;
-      from = import_node_process.default.cwd();
-    }
-    const ret = import_node_path.default.relative(from, to);
-    return ret;
-  }
-  abs(fname) {
-    if (import_node_path.default.isAbsolute(fname)) {
-      return fname;
-    } else {
-      const cwd = import_node_process.default.cwd();
-      return import_node_path.default.resolve(cwd, fname);
-    }
-  }
-  isAbsolute(fname) {
-    return import_node_path.default.isAbsolute(fname);
-  }
-  async writeFileString(fname, content, ende = TxtEnDecoderSingleton()) {
-    const o = await this.create(fname);
-    const wr = o.stream.getWriter();
-    await wr.write(ende.encode(content));
-    await wr.close();
-  }
-  async create(fname) {
-    let oName = fname;
-    if (!import_node_path.default.isAbsolute(fname)) {
-      oName = this.abs(fname);
-    }
-    const base = import_node_path.default.dirname(oName);
-    await import_node_fs.default.promises.mkdir(base, { recursive: true });
-    const out = import_node_fs.default.createWriteStream(oName);
-    return {
-      name: oName,
-      stream: new WritableStream({
-        write(chunk) {
-          out.write(chunk);
-        },
-        close() {
-          out.close();
-        },
-        abort() {
-          throw new Error("not implemented");
-        }
-      })
-    };
-  }
-};
-
-// src/sys-abstraction.ts
-var TimeMode = {
-  REAL: "real",
-  CONST: "const",
-  STEP: "step"
-};
-var RandomMode = {
-  CONST: "const",
-  STEP: "step",
-  RANDOM: "random"
-};
-var IDMode = {
-  UUID: "uuid",
-  CONST: "const",
-  STEP: "step"
-};
-
-// src/time.ts
-var Time = class {
-  TimeSince(start) {
-    const now = this.Now();
-    return now.getTime() - start.getTime();
-  }
-};
-var TimeUnits = {
-  Microsecond: 1,
-  Second: 1e3 * 1,
-  //Microsecond,
-  Minute: 60 * 1e3 * 1,
-  //Second,
-  Hour: 60 * 60 * 1e3 * 1
-  // Minute,
-};
-
-// src/base-sys-abstraction.ts
-var SysTime = class extends Time {
-  Now() {
-    return /* @__PURE__ */ new Date();
-  }
-  Sleep(duration) {
-    return new Promise((resolve) => {
-      setTimeout(() => {
-        resolve();
-      }, duration);
-    });
-  }
-};
-var ConstTime = class extends Time {
-  Now() {
-    return new Date(2021, 1, 1, 0, 0, 0, 0);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  Sleep(duration) {
-    return Promise.resolve();
-  }
-};
-var StepTime = class extends Time {
-  constructor() {
-    super();
-    this._step = new ConstTime().Now();
-    this._start = 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);
-    }
-    return this._step;
-  }
-  Sleep(duration) {
-    this._step = new Date(this._step.getTime() + duration);
-    return Promise.resolve();
-  }
-};
-function TimeFactory(timeMode) {
-  switch (timeMode) {
-    case TimeMode.REAL:
-      return new SysTime();
-    case TimeMode.CONST:
-      return new ConstTime();
-    case TimeMode.STEP:
-      return new StepTime();
-  }
-  return new SysTime();
-}
-var RandomService = class {
-  constructor(mode) {
-    this._step = 0;
-    this._mode = mode;
-  }
-  Random0ToValue(value) {
-    switch (this._mode) {
-      case RandomMode.CONST:
-        return 0.5 * value;
-      case RandomMode.STEP:
-        this._step += 1e-4;
-        return this._step * value;
-      case RandomMode.RANDOM:
-        return Math.random() * value;
-      default:
-        throw new Error("Unknown RandomMode");
-    }
-  }
-};
-var IdService = class {
-  constructor(mode) {
-    this._step = 0;
-    if (!mode) {
-      mode = IDMode.UUID;
-    }
-    this._mode = mode;
-  }
-  NextId() {
-    switch (this._mode) {
-      case IDMode.UUID:
-        return crypto.randomUUID();
-      case IDMode.CONST:
-        return "VeryUniqueID";
-      case IDMode.STEP:
-        return `STEPId-${this._step++}`;
-      default:
-        throw new Error("Unknown IDMode");
-    }
-  }
-};
-function consumeReadableStream(reader, writeFn) {
-  reader.read().then(({ done, value }) => {
-    if (done) {
-      return;
-    }
-    writeFn(value).then(() => {
-      consumeReadableStream(reader, writeFn);
-    }).catch((e) => {
-      console.error("consumeReadableStream:writeFn", e);
-    });
-  }).catch((e) => {
-    console.error("consumeReadableStream:read", e);
-  });
-}
-function CFWriteableStream(writeFn) {
-  const ts = new TransformStream();
-  consumeReadableStream(ts.readable.getReader(), writeFn);
-  return ts.writable;
-}
-var BaseSysAbstraction = class {
-  constructor(params) {
-    this._time = new SysTime();
-    this._idService = new IdService();
-    this._randomService = new RandomService(RandomMode.RANDOM);
-    this._fileSystem = params.FileSystem;
-    this._systemService = params.SystemService;
-    this._txtEnDe = params.TxtEnDecoder;
-    const decoder = this._txtEnDe;
-    this._stdout = CFWriteableStream((chunk) => {
-      const decoded = decoder.decode(chunk);
-      console.log(decoded.trimEnd());
-      return Promise.resolve();
-    });
-    this._stderr = CFWriteableStream((chunk) => {
-      const decoded = decoder.decode(chunk);
-      console.error(decoded.trimEnd());
-      return Promise.resolve();
-    });
-  }
-};
-var WrapperSysAbstraction = class {
-  constructor(base, params) {
-    this._time = base._time;
-    this._stdout = base._stdout;
-    this._stderr = base._stderr;
-    this._idService = base._idService;
-    this._randomService = base._randomService;
-    this._fileSystem = base._fileSystem;
-    this._systemService = base._systemService;
-    if (params) {
-      if (params.TimeMode) {
-        this._time = TimeFactory(params.TimeMode);
-      }
-      if (params.Stdout) {
-        this._stdout = params.Stdout;
-      }
-      if (params.Stderr) {
-        this._stderr = params.Stderr;
-      }
-      if (params.IdMode) {
-        this._idService = new IdService(params.IdMode);
-      }
-      if (params.RandomMode) {
-        this._randomService = new RandomService(params.RandomMode);
-      }
-      if (params.FileSystem) {
-        this._fileSystem = params.FileSystem;
-      }
-      if (params.SystemService) {
-        this._systemService = params.SystemService;
-      }
-    }
-  }
-  Time() {
-    return this._time;
-  }
-  NextId() {
-    return this._idService.NextId();
-  }
-  Random0ToValue(value) {
-    return this._randomService.Random0ToValue(value);
-  }
-  Stdout() {
-    return this._stdout;
-  }
-  Stderr() {
-    return this._stderr;
-  }
-  System() {
-    return this._systemService;
-  }
-  FileSystem() {
-    return this._fileSystem;
-  }
-};
-
 // src/future.ts
 var _promise, _resolveFn, _rejectFn;
 var Future = class {
@@ -617,6 +174,86 @@ var LRUMap = class {
   //   }
 };
 
+// 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;
+  }
+};
+
 // src/resolve-once.ts
 var ResolveOnce = class {
   constructor(ctx) {
@@ -746,26 +383,165 @@ var KeyedResolvOnce = class extends Keyed {
   constructor(kp = {}) {
     super((key) => new ResolveOnce(key), kp);
   }
-  /**
-   *
-   * @returns The values of the resolved keys
-   */
-  values() {
-    return Array.from(this._map.entries()).filter(([_, v]) => v._onceDone).map(([k, v]) => {
-      if (v._onceDone) {
-        if (v._onceError) {
-          return {
-            key: k,
-            value: Result.Err(v._onceError)
-          };
+  /**
+   *
+   * @returns The values of the resolved keys
+   */
+  values() {
+    return Array.from(this._map.entries()).filter(([_, v]) => v._onceDone).map(([k, v]) => {
+      if (v._onceDone) {
+        if (v._onceError) {
+          return {
+            key: k,
+            value: Result.Err(v._onceError)
+          };
+        }
+        return {
+          key: k,
+          value: Result.Ok(v._onceValue)
+        };
+      }
+      throw new Error("KeyedResolvOnce.values impossible");
+    });
+  }
+};
+
+// src/utils/coerce-uint8.ts
+var globalBuffer = globalThis;
+function coerceIntoUint8(raw) {
+  if (raw instanceof ArrayBuffer) {
+    return Result.Ok(new Uint8Array(raw));
+  }
+  if (ArrayBuffer.isView(raw)) {
+    return Result.Ok(new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength));
+  }
+  if (raw instanceof Blob) {
+    return Result.Err("Blob not supported");
+  }
+  if (globalBuffer.Buffer && globalBuffer.Buffer.isBuffer(raw)) {
+    return Result.Ok(new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength));
+  }
+  if (raw instanceof Uint8Array) {
+    return Result.Ok(raw);
+  }
+  if (Result.Is(raw)) {
+    if (raw.isErr()) {
+      return Result.Err(raw);
+    }
+    return coerceIntoUint8(raw.unwrap());
+  }
+  return Result.Err("Not a Uint8Array");
+}
+
+// src/txt-en-decoder.ts
+var TxtOps = class {
+  constructor() {
+    this.encoder = new TextEncoder();
+    this.decoder = new TextDecoder();
+  }
+  encode(str) {
+    return this.encoder.encode(str);
+  }
+  decode(data) {
+    if (Result.Is(data)) {
+      if (data.isErr()) {
+        throw data.Err();
+      }
+      const unwrapped = data.unwrap();
+      if (typeof unwrapped === "string") {
+        return this.decode(unwrapped);
+      }
+    }
+    if (typeof data === "string") {
+      return data;
+    }
+    return this.decoder.decode(coerceIntoUint8(data).Ok());
+  }
+  async asyncDecode(data) {
+    let resolved = await data;
+    if (resolved instanceof Blob) {
+      resolved = await resolved.arrayBuffer();
+    }
+    return this.decode(resolved);
+  }
+};
+var txtEnDecoder = new ResolveOnce();
+function TxtEnDecoderSingleton() {
+  return txtEnDecoder.once(() => new TxtOps());
+}
+
+// src/node/node-file-service.ts
+var NodeFileService = class {
+  constructor(baseDir = import_node_process.default.cwd()) {
+    this.baseDir = this.abs(baseDir);
+  }
+  // nodeImport(fname: string): string {
+  //   // console.log('nodeImport:'+ fname);
+  //   if (path.isAbsolute(fname)) {
+  //     return fname;
+  //   } else {
+  //     return "./" + path.normalize(fname);
+  //   }
+  // }
+  readFileString(fname) {
+    return import_node_fs.default.promises.readFile(fname, { encoding: "utf-8" });
+  }
+  dirname(fname) {
+    return import_node_path.default.dirname(fname);
+  }
+  basename(fname) {
+    return import_node_path.default.basename(fname);
+  }
+  join(...paths) {
+    return import_node_path.default.join(...paths);
+  }
+  relative(from, to) {
+    if (to === void 0) {
+      to = from;
+      from = import_node_process.default.cwd();
+    }
+    const ret = import_node_path.default.relative(from, to);
+    return ret;
+  }
+  abs(fname) {
+    if (import_node_path.default.isAbsolute(fname)) {
+      return fname;
+    } else {
+      const cwd = import_node_process.default.cwd();
+      return import_node_path.default.resolve(cwd, fname);
+    }
+  }
+  isAbsolute(fname) {
+    return import_node_path.default.isAbsolute(fname);
+  }
+  async writeFileString(fname, content, ende = TxtEnDecoderSingleton()) {
+    const o = await this.create(fname);
+    const wr = o.stream.getWriter();
+    await wr.write(ende.encode(content));
+    await wr.close();
+  }
+  async create(fname) {
+    let oName = fname;
+    if (!import_node_path.default.isAbsolute(fname)) {
+      oName = this.abs(fname);
+    }
+    const base = import_node_path.default.dirname(oName);
+    await import_node_fs.default.promises.mkdir(base, { recursive: true });
+    const out = import_node_fs.default.createWriteStream(oName);
+    return {
+      name: oName,
+      stream: new WritableStream({
+        write(chunk) {
+          out.write(chunk);
+        },
+        close() {
+          out.close();
+        },
+        abort() {
+          throw new Error("not implemented");
         }
-        return {
-          key: k,
-          value: Result.Ok(v._onceValue)
-        };
-      }
-      throw new Error("KeyedResolvOnce.values impossible");
-    });
+      })
+    };
   }
 };
 
@@ -806,6 +582,40 @@ function runtimeFn() {
   };
 }
 
+// src/sys-abstraction.ts
+var TimeMode = {
+  REAL: "real",
+  CONST: "const",
+  STEP: "step"
+};
+var RandomMode = {
+  CONST: "const",
+  STEP: "step",
+  RANDOM: "random"
+};
+var IDMode = {
+  UUID: "uuid",
+  CONST: "const",
+  STEP: "step"
+};
+
+// src/time.ts
+var Time = class {
+  TimeSince(start) {
+    const now = this.Now();
+    return now.getTime() - start.getTime();
+  }
+};
+var TimeUnits = {
+  Microsecond: 1,
+  Second: 1e3 * 1,
+  //Microsecond,
+  Minute: 60 * 1e3 * 1,
+  //Second,
+  Hour: 60 * 60 * 1e3 * 1
+  // Minute,
+};
+
 // src/deno/deno-env-actions.ts
 var once = new ResolveOnce();
 var _deno;
@@ -1169,6 +979,224 @@ var EnvImpl = class {
   }
 };
 
+// src/web/web-basic-sys-abstraction.ts
+var baseSysAbstraction = new ResolveOnce();
+
+// src/cf/cf-basic-sys-abstraction.ts
+var baseSysAbstraction2 = new ResolveOnce();
+
+// src/deno/deno-basic-sys-abstraction.ts
+var baseSysAbstraction3 = new ResolveOnce();
+
+// src/node/node-basic-sys-abstraction.ts
+var NodeRuntimeService = class {
+  constructor(ende) {
+    this._txtEnDe = ende;
+    this._gthis = globalThis;
+  }
+  Env() {
+    return envFactory();
+  }
+  Args() {
+    return this._gthis.process.argv;
+  }
+  Stdout() {
+    return new WritableStream({
+      write: (chunk) => {
+        this._gthis.process.stdout.write(chunk);
+      }
+    });
+  }
+  Stderr() {
+    return new WritableStream({
+      write: (chunk) => {
+        this._gthis.process.stderr.write(chunk);
+      }
+    });
+  }
+};
+var baseSysAbstraction4 = new ResolveOnce();
+function NodeBasicSysAbstraction(param2) {
+  var _a;
+  const my = baseSysAbstraction4.once(() => {
+    return new BaseBasicSysAbstraction({
+      TxtEnDecoder: (param2 == null ? void 0 : param2.TxtEnDecoder) || TxtEnDecoderSingleton()
+    });
+  });
+  return new WrapperBasicSysAbstraction(my, {
+    basicRuntimeService: new NodeRuntimeService((_a = param2 == null ? void 0 : param2.TxtEnDecoder) != null ? _a : my._txtEnDe),
+    ...param2
+  });
+}
+
+// src/base-sys-abstraction.ts
+var SysTime = class extends Time {
+  Now() {
+    return /* @__PURE__ */ new Date();
+  }
+  Sleep(duration) {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve();
+      }, duration);
+    });
+  }
+};
+var ConstTime = class extends Time {
+  Now() {
+    return new Date(2021, 1, 1, 0, 0, 0, 0);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  Sleep(duration) {
+    return Promise.resolve();
+  }
+};
+var StepTime = class extends Time {
+  constructor() {
+    super();
+    this._step = new ConstTime().Now();
+    this._start = 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);
+    }
+    return this._step;
+  }
+  Sleep(duration) {
+    this._step = new Date(this._step.getTime() + duration);
+    return Promise.resolve();
+  }
+};
+function TimeFactory(timeMode) {
+  switch (timeMode) {
+    case TimeMode.REAL:
+      return new SysTime();
+    case TimeMode.CONST:
+      return new ConstTime();
+    case TimeMode.STEP:
+      return new StepTime();
+  }
+  return new SysTime();
+}
+var RandomService = class {
+  constructor(mode) {
+    this._step = 0;
+    this._mode = mode;
+  }
+  Random0ToValue(value) {
+    switch (this._mode) {
+      case RandomMode.CONST:
+        return 0.5 * value;
+      case RandomMode.STEP:
+        this._step += 1e-4;
+        return this._step * value;
+      case RandomMode.RANDOM:
+        return Math.random() * value;
+      default:
+        throw new Error("Unknown RandomMode");
+    }
+  }
+};
+var IdService = class {
+  constructor(mode) {
+    this._step = 0;
+    if (!mode) {
+      mode = IDMode.UUID;
+    }
+    this._mode = mode;
+  }
+  NextId() {
+    switch (this._mode) {
+      case IDMode.UUID:
+        return crypto.randomUUID();
+      case IDMode.CONST:
+        return "VeryUniqueID";
+      case IDMode.STEP:
+        return `STEPId-${this._step++}`;
+      default:
+        throw new Error("Unknown IDMode");
+    }
+  }
+};
+var BaseBasicSysAbstraction = class {
+  constructor(params) {
+    this._time = new SysTime();
+    // system independent services
+    this._idService = new IdService();
+    this._randomService = new RandomService(RandomMode.RANDOM);
+    this._txtEnDe = params.TxtEnDecoder;
+  }
+};
+var BaseSysAbstraction = class extends BaseBasicSysAbstraction {
+  constructor(params) {
+    super(params);
+    this._fileSystem = params.FileSystem;
+    this._systemService = params.SystemService;
+  }
+};
+var WrapperBasicSysAbstraction = class {
+  constructor(base, params) {
+    this._time = base._time;
+    this._basicRuntimeService = params.basicRuntimeService;
+    this._idService = base._idService;
+    this._randomService = base._randomService;
+    if (params.TimeMode) {
+      this._time = TimeFactory(params.TimeMode);
+    }
+    if (params.IdMode) {
+      this._idService = new IdService(params.IdMode);
+    }
+    if (params.RandomMode) {
+      this._randomService = new RandomService(params.RandomMode);
+    }
+  }
+  Time() {
+    return this._time;
+  }
+  NextId() {
+    return this._idService.NextId();
+  }
+  Random0ToValue(value) {
+    return this._randomService.Random0ToValue(value);
+  }
+  Stdout() {
+    return this._basicRuntimeService.Stdout();
+  }
+  Stderr() {
+    return this._basicRuntimeService.Stderr();
+  }
+  Env() {
+    return this._basicRuntimeService.Env();
+  }
+  Args() {
+    return this._basicRuntimeService.Args();
+  }
+  // System(): SystemService {
+  //   return this._systemService;
+  // }
+  // FileSystem(): FileService {
+  //   return this._fileSystem;
+  // }
+};
+var WrapperRuntimeSysAbstraction = class extends WrapperBasicSysAbstraction {
+  constructor(base, params) {
+    var _a, _b;
+    super(base, params);
+    this._systemService = (_a = params.systemService) != null ? _a : base._systemService;
+    this._fileSystem = (_b = params.fileSystem) != null ? _b : base._fileSystem;
+  }
+  System() {
+    return this._systemService;
+  }
+  FileSystem() {
+    return this._fileSystem;
+  }
+};
+
 // src/node/node-sys-abstraction.ts
 var import_node_process2 = __toESM(require("process"), 1);
 var NodeExitServiceImpl = class {
@@ -1229,12 +1257,6 @@ var _NodeSystemService = class _NodeSystemService {
     this._exitService = new NodeExitServiceImpl();
     this._exitService.injectExitHandlers(_NodeSystemService._exitHandlers);
   }
-  Env() {
-    return envFactory();
-  }
-  Args() {
-    return import_node_process2.default.argv;
-  }
   OnExit(hdl) {
     const id = crypto.randomUUID();
     _NodeSystemService._exitHandlers.push({ hdl, id });
@@ -1251,16 +1273,19 @@ var _NodeSystemService = class _NodeSystemService {
 };
 _NodeSystemService._exitHandlers = [];
 var NodeSystemService = _NodeSystemService;
-var my = void 0;
+var baseSysAbstraction5 = new ResolveOnce();
 function NodeSysAbstraction(param2) {
-  if (!my) {
-    my = new BaseSysAbstraction({
+  const my = baseSysAbstraction5.once(
+    () => new BaseSysAbstraction({
       TxtEnDecoder: (param2 == null ? void 0 : param2.TxtEnDecoder) || TxtEnDecoderSingleton(),
       FileSystem: new NodeFileService(),
       SystemService: new NodeSystemService()
-    });
-  }
-  return new WrapperSysAbstraction(my, param2);
+    })
+  );
+  return new WrapperRuntimeSysAbstraction(my, {
+    basicRuntimeService: NodeBasicSysAbstraction(param2),
+    ...param2
+  });
 }
 
 // src/node/mock-file-service.ts