@adviser/cement 0.3.19 → 0.4.0

package/src/base-sys-abstraction.ts

@@ -1,7 +1,21 @@
 import { FileService } from "./file-service.js";
-import { TimeMode, RandomMode, IDMode, SystemService, VoidFunc, SysAbstraction } from "./sys-abstraction.js";
+import { runtimeFn } from "./runtime.js";
+import {
+  TimeMode,
+  RandomMode,
+  IDMode,
+  SystemService,
+  VoidFunc,
+  BasicSysAbstraction,
+  BasicRuntimeService,
+} from "./sys-abstraction.js";
 import { Time } from "./time.js";
 import { TxtEnDecoder } from "./txt-en-decoder.js";
+import { WebBasicSysAbstraction } from "./web/web-basic-sys-abstraction.js";
+import { Env } from "./sys-env.js";
+import { CFBasicSysAbstraction } from "./cf/cf-basic-sys-abstraction.js";
+import { DenoBasicSysAbstraction } from "./deno/deno-basic-sys-abstraction.js";
+import { NodeBasicSysAbstraction } from "./node/node-basic-sys-abstraction.js";
 
 export class SysTime extends Time {
   Now(): Date {
@@ -110,8 +124,11 @@ export class IdService {
   }
 }
 
-export interface BaseSysAbstractionParams {
+export interface BaseBasicSysAbstractionParams {
   readonly TxtEnDecoder: TxtEnDecoder;
+}
+
+export interface BaseSysAbstractionParams extends BaseBasicSysAbstractionParams {
   readonly FileSystem: FileService;
   readonly SystemService: SystemService;
 }
@@ -127,141 +144,84 @@ export interface ExitService {
 }
 
 // some black magic to make it work with CF workers
-function consumeReadableStream(
-  reader: ReadableStreamDefaultReader<Uint8Array>,
-  writeFn: (chunk: Uint8Array) => Promise<void>,
-): void {
-  reader
-    .read()
-    .then(({ done, value }) => {
-      if (done) {
-        return;
-      }
-      writeFn(value)
-        .then(() => {
-          consumeReadableStream(reader, writeFn);
-        })
-        .catch((e) => {
-          // eslint-disable-next-line no-console
-          console.error("consumeReadableStream:writeFn", e);
-        });
-    })
-    .catch((e) => {
-      // eslint-disable-next-line no-console
-      console.error("consumeReadableStream:read", e);
-    });
-}
-
-function CFWriteableStream(writeFn: (chunk: Uint8Array) => Promise<void>): WritableStream<Uint8Array> {
-  const ts = new TransformStream<Uint8Array, Uint8Array>();
-  consumeReadableStream(ts.readable.getReader(), writeFn);
-  return ts.writable;
-}
 
-export class BaseSysAbstraction {
+export class BaseBasicSysAbstraction {
   readonly _time: SysTime = new SysTime();
-  readonly _stdout: WritableStream<Uint8Array>;
-  readonly _stderr: WritableStream<Uint8Array>;
 
+  // system independent services
   readonly _idService: IdService = new IdService();
   readonly _randomService: RandomService = new RandomService(RandomMode.RANDOM);
+  readonly _txtEnDe: TxtEnDecoder;
+
+  constructor(params: BaseBasicSysAbstractionParams) {
+    this._txtEnDe = params.TxtEnDecoder;
+  }
+}
+
+export class BaseSysAbstraction extends BaseBasicSysAbstraction {
+  // system related services
   readonly _fileSystem: FileService;
   readonly _systemService: SystemService;
-  readonly _txtEnDe: TxtEnDecoder;
 
   constructor(params: BaseSysAbstractionParams) {
+    super(params);
     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);
-      // eslint-disable-next-line no-console
-      console.log(decoded.trimEnd());
-      return Promise.resolve();
-    });
-    this._stderr = CFWriteableStream((chunk) => {
-      const decoded = decoder.decode(chunk);
-      // eslint-disable-next-line no-console
-      console.error(decoded.trimEnd());
-      return Promise.resolve();
-    });
-    /* this is not CF worker compatible
-    this._stdout = new WritableStream({
-      write(chunk): Promise<void> {
-        return new Promise((resolve) => {
-          const decoded = decoder.decode(chunk);
-          // eslint-disable-next-line no-console
-          console.log(decoded.trimEnd());
-          resolve();
-        });
-      },
-    });
-    this._stderr = new WritableStream({
-      write(chunk): Promise<void> {
-        return new Promise((resolve) => {
-          const decoded = decoder.decode(chunk);
-          // eslint-disable-next-line no-console
-          console.error(decoded.trimEnd());
-          resolve();
-        });
-      },
-    });
-    */
   }
 }
 
-export interface WrapperSysAbstractionParams {
-  readonly TimeMode?: TimeMode;
-  readonly IdMode?: IDMode;
-  readonly Stdout?: WritableStream<Uint8Array>;
-  readonly Stderr?: WritableStream<Uint8Array>;
-  readonly RandomMode?: RandomMode;
-  readonly FileSystem?: FileService;
-  readonly SystemService?: SystemService;
-  readonly TxtEnDecoder?: TxtEnDecoder;
+export interface BasicSysAbstractionParams {
+  readonly TimeMode: TimeMode;
+  readonly IdMode: IDMode;
+  readonly RandomMode: RandomMode;
+  // readonly FileSystem: FileService;
+  // readonly SystemService: SystemService;
+  readonly TxtEnDecoder: TxtEnDecoder;
+  // readonly BasicRuntimeService: BasicSysAbstraction;
+}
+
+export type WrapperBasicSysAbstractionParams = Partial<BasicRuntimeService & BasicSysAbstractionParams>;
+
+export function BasicSysAbstractionFactory(params?: WrapperBasicSysAbstractionParams): BasicSysAbstraction {
+  const fn = runtimeFn();
+  switch (true) {
+    case fn.isBrowser:
+      return WebBasicSysAbstraction(params);
+    case fn.isDeno:
+      return DenoBasicSysAbstraction(params);
+    case fn.isCFWorker:
+      return CFBasicSysAbstraction(params);
+    case fn.isNodeIsh:
+      return NodeBasicSysAbstraction(params);
+    default:
+      throw new Error("Unknown runtime");
+  }
 }
 
-export class WrapperSysAbstraction implements SysAbstraction {
+export class WrapperBasicSysAbstraction implements BasicSysAbstraction {
   readonly _time: Time;
-  readonly _stdout: WritableStream<Uint8Array>;
-  readonly _stderr: WritableStream<Uint8Array>;
   readonly _idService: IdService;
   readonly _randomService: RandomService;
-  readonly _fileSystem: FileService;
-  readonly _systemService: SystemService;
-  constructor(base: BaseSysAbstraction, params?: WrapperSysAbstractionParams) {
+  readonly _basicRuntimeService: BasicRuntimeService;
+  constructor(
+    base: BaseBasicSysAbstraction,
+    params: Partial<BasicSysAbstractionParams> & { basicRuntimeService: BasicRuntimeService },
+  ) {
     this._time = base._time;
-    this._stdout = base._stdout;
-    this._stderr = base._stderr;
+    this._basicRuntimeService = params.basicRuntimeService;
     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;
-      }
+    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(): Time {
     return this._time;
   }
@@ -272,10 +232,41 @@ export class WrapperSysAbstraction implements SysAbstraction {
     return this._randomService.Random0ToValue(value);
   }
   Stdout(): WritableStream {
-    return this._stdout;
+    return this._basicRuntimeService.Stdout();
   }
   Stderr(): WritableStream {
-    return this._stderr;
+    return this._basicRuntimeService.Stderr();
+  }
+  Env(): Env {
+    return this._basicRuntimeService.Env();
+  }
+  Args(): string[] {
+    return this._basicRuntimeService.Args();
+  }
+
+  // System(): SystemService {
+  //   return this._systemService;
+  // }
+  // FileSystem(): FileService {
+  //   return this._fileSystem;
+  // }
+}
+// export const BaseSysAbstraction = new BaseSysAbstractionImpl()
+
+export class WrapperRuntimeSysAbstraction extends WrapperBasicSysAbstraction {
+  readonly _systemService: SystemService;
+  readonly _fileSystem: FileService;
+  constructor(
+    base: BaseSysAbstraction,
+    params: Partial<BaseBasicSysAbstraction> & {
+      systemService?: SystemService;
+      fileSystem?: FileService;
+      basicRuntimeService: BasicRuntimeService;
+    },
+  ) {
+    super(base, params);
+    this._systemService = params.systemService ?? base._systemService;
+    this._fileSystem = params.fileSystem ?? base._fileSystem;
   }
 
   System(): SystemService {
@@ -285,4 +276,3 @@ export class WrapperSysAbstraction implements SysAbstraction {
     return this._fileSystem;
   }
 }
-// export const BaseSysAbstraction = new BaseSysAbstractionImpl()

package/src/cf/cf-basic-sys-abstraction.ts

@@ -0,0 +1,79 @@
+import { BaseBasicSysAbstraction, WrapperBasicSysAbstraction, WrapperBasicSysAbstractionParams } from "../base-sys-abstraction.js";
+import { ResolveOnce } from "../resolve-once.js";
+import { BasicRuntimeService, BasicSysAbstraction } from "../sys-abstraction.js";
+import { Env, envFactory } from "../sys-env.js";
+import { TxtEnDecoder, TxtEnDecoderSingleton } from "../txt-en-decoder.js";
+
+export class CFRuntimeService implements BasicRuntimeService {
+  readonly _txtEnDe: TxtEnDecoder;
+  constructor(ende: TxtEnDecoder) {
+    this._txtEnDe = ende;
+  }
+  Env(): Env {
+    return envFactory();
+  }
+  Args(): string[] {
+    throw new Error("Args-Method not implemented.");
+  }
+
+  Stdout(): WritableStream<Uint8Array> {
+    return CFWriteableStream((chunk) => {
+      const decoded = this._txtEnDe.decode(chunk);
+      // eslint-disable-next-line no-console
+      console.log(decoded.trimEnd());
+      return Promise.resolve();
+    });
+  }
+  Stderr(): WritableStream<Uint8Array> {
+    return CFWriteableStream((chunk) => {
+      const decoded = this._txtEnDe.decode(chunk);
+      // eslint-disable-next-line no-console
+      console.error(decoded.trimEnd());
+      return Promise.resolve();
+    });
+  }
+}
+
+function consumeReadableStream(
+  reader: ReadableStreamDefaultReader<Uint8Array>,
+  writeFn: (chunk: Uint8Array) => Promise<void>,
+): void {
+  reader
+    .read()
+    .then(({ done, value }) => {
+      if (done) {
+        return;
+      }
+      writeFn(value)
+        .then(() => {
+          consumeReadableStream(reader, writeFn);
+        })
+        .catch((e) => {
+          // eslint-disable-next-line no-console
+          console.error("consumeReadableStream:writeFn", e);
+        });
+    })
+    .catch((e) => {
+      // eslint-disable-next-line no-console
+      console.error("consumeReadableStream:read", e);
+    });
+}
+
+function CFWriteableStream(writeFn: (chunk: Uint8Array) => Promise<void>): WritableStream<Uint8Array> {
+  const ts = new TransformStream<Uint8Array, Uint8Array>();
+  consumeReadableStream(ts.readable.getReader(), writeFn);
+  return ts.writable;
+}
+
+const baseSysAbstraction = new ResolveOnce<BaseBasicSysAbstraction>();
+export function CFBasicSysAbstraction(param?: WrapperBasicSysAbstractionParams): BasicSysAbstraction {
+  const my = baseSysAbstraction.once(() => {
+    return new BaseBasicSysAbstraction({
+      TxtEnDecoder: param?.TxtEnDecoder || TxtEnDecoderSingleton(),
+    });
+  });
+  return new WrapperBasicSysAbstraction(my, {
+    basicRuntimeService: new CFRuntimeService(param?.TxtEnDecoder ?? my._txtEnDe),
+    ...param,
+  });
+}

package/src/cf/index.ts

@@ -1,2 +1,2 @@
-export * from "./cf-sys-abstraction.js";
+export * from "./cf-basic-sys-abstraction.js";
 export * from "./cf-env-actions.js";

package/src/cf-test-main.ts

@@ -1,5 +1,14 @@
+import { LoggerImpl } from "@adviser/cement";
+
 export default {
   fetch(): Response {
-    return new Response("Hello World!");
+    // console.log(">>>>enter");
+    const logger = new LoggerImpl();
+    for (let i = 0; i < 10; i++) {
+      logger.Error().Any({ i }).Msg("Hello Logger World!");
+    }
+    const ret = new Response("Hello World!");
+    // console.log(">>>>exit");
+    return ret;
   },
 };

package/src/deno/deno-basic-sys-abstraction.ts

@@ -0,0 +1,39 @@
+import { BaseBasicSysAbstraction, WrapperBasicSysAbstraction, WrapperBasicSysAbstractionParams } from "../base-sys-abstraction.js";
+import { ResolveOnce } from "../resolve-once.js";
+import { BasicRuntimeService, BasicSysAbstraction } from "../sys-abstraction.js";
+import { Env, envFactory } from "../sys-env.js";
+import { TxtEnDecoder, TxtEnDecoderSingleton } from "../txt-en-decoder.js";
+
+export class DenoRuntimeService implements BasicRuntimeService {
+  readonly _txtEnDe: TxtEnDecoder;
+  constructor(ende: TxtEnDecoder) {
+    this._txtEnDe = ende;
+  }
+  Env(): Env {
+    return envFactory();
+  }
+
+  Args(): string[] {
+    return globalThis.Deno.args;
+  }
+
+  Stdout(): WritableStream<Uint8Array> {
+    return globalThis.Deno.stdout.writable;
+  }
+  Stderr(): WritableStream<Uint8Array> {
+    return globalThis.Deno.stderr.writable;
+  }
+}
+
+const baseSysAbstraction = new ResolveOnce<BaseBasicSysAbstraction>();
+export function DenoBasicSysAbstraction(param?: WrapperBasicSysAbstractionParams): BasicSysAbstraction {
+  const my = baseSysAbstraction.once(() => {
+    return new BaseBasicSysAbstraction({
+      TxtEnDecoder: param?.TxtEnDecoder || TxtEnDecoderSingleton(),
+    });
+  });
+  return new WrapperBasicSysAbstraction(my, {
+    basicRuntimeService: new DenoRuntimeService(param?.TxtEnDecoder ?? my._txtEnDe),
+    ...param,
+  });
+}

package/src/deno/deno-file-service.ts

@@ -1,5 +1,5 @@
 import * as path from "node:path";
-import { FileService, NamedWritableStream } from "../file-service.js";
+import type { FileService, NamedWritableStream } from "../file-service.js";
 import { TxtEnDecoder, TxtEnDecoderSingleton } from "../txt-en-decoder.js";
 
 const Deno = (globalThis as unknown as { Deno: unknown }).Deno as {

package/src/deno/deno-sys-abstraction.ts

@@ -2,12 +2,13 @@ import {
   ExitService,
   ExitHandler,
   BaseSysAbstraction,
-  WrapperSysAbstractionParams,
-  WrapperSysAbstraction,
+  WrapperBasicSysAbstractionParams,
+  WrapperRuntimeSysAbstraction,
 } from "../base-sys-abstraction.js";
-import { SysAbstraction, SystemService, VoidFunc } from "../sys-abstraction.js";
-import { Env, envFactory } from "../sys-env.js";
+import { ResolveOnce } from "../resolve-once.js";
+import { RuntimeSysAbstraction, SystemService, VoidFunc } from "../sys-abstraction.js";
 import { TxtEnDecoderSingleton } from "../txt-en-decoder.js";
+import { DenoBasicSysAbstraction } from "./deno-basic-sys-abstraction.js";
 // import * as process from "node:process";
 import { DenoFileService } from "./deno-file-service.js";
 
@@ -97,14 +98,6 @@ export class DenoSystemService implements SystemService {
     this._exitService.injectExitHandlers(DenoSystemService._exitHandlers);
   }
 
-  Env(): Env {
-    return envFactory();
-  }
-
-  Args(): string[] {
-    return Deno.args;
-  }
-
   OnExit(hdl: VoidFunc): VoidFunc {
     const id = crypto.randomUUID();
     DenoSystemService._exitHandlers.push({ hdl, id });
@@ -121,14 +114,18 @@ export class DenoSystemService implements SystemService {
   }
 }
 
-let my: BaseSysAbstraction | undefined = undefined;
-export function DenoSysAbstraction(param?: WrapperSysAbstractionParams): SysAbstraction {
-  if (!my) {
-    my = new BaseSysAbstraction({
-      TxtEnDecoder: param?.TxtEnDecoder || TxtEnDecoderSingleton(),
-      FileSystem: new DenoFileService(),
-      SystemService: new DenoSystemService(),
-    });
-  }
-  return new WrapperSysAbstraction(my, param);
+const baseSysAbstraction = new ResolveOnce<BaseSysAbstraction>();
+export function DenoSysAbstraction(param?: WrapperBasicSysAbstractionParams): RuntimeSysAbstraction {
+  const my = baseSysAbstraction.once(
+    () =>
+      new BaseSysAbstraction({
+        TxtEnDecoder: param?.TxtEnDecoder || TxtEnDecoderSingleton(),
+        FileSystem: new DenoFileService(),
+        SystemService: new DenoSystemService(),
+      }),
+  );
+  return new WrapperRuntimeSysAbstraction(my, {
+    basicRuntimeService: DenoBasicSysAbstraction(param),
+    ...param,
+  });
 }

package/src/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@adviser/cement",
-  "version": "0.3.19",
+  "version": "0.4.0",
   "exports": {
     ".": "./index.ts",
     "./web": "./web/index.ts",

package/src/log-writer-impl.ts

@@ -2,8 +2,12 @@ export class LogWriterStream {
   readonly _out: WritableStream<Uint8Array>;
   readonly _toFlush: (() => Promise<void>)[] = [];
 
+  readonly _id: number;
+
   constructor(out: WritableStream<Uint8Array>) {
     this._out = out;
+    this._id = Math.random();
+    // console.log(">>>My:constructor:", this._id);
   }
 
   write(encoded: Uint8Array): void {
@@ -11,10 +15,12 @@ export class LogWriterStream {
       // const val = Math.random();
       // console.log(">>>My:", encoded)
       try {
+        // console.log(">>>My:getWriter:get:", this._id);
         const writer = this._out.getWriter();
         await writer.ready;
         await writer.write(encoded);
         writer.releaseLock();
+        // console.log(">>>My:getWriter:release", this._id);
       } catch (err) {
         // eslint-disable-next-line no-console
         console.error("Chunk error:", err);

package/src/logger-impl.ts

@@ -19,15 +19,13 @@ import {
   HttpType,
   LogValueState,
 } from "./logger.js";
-import { WebSysAbstraction } from "./web/web-sys-abstraction.js";
-import { SysAbstraction } from "./sys-abstraction.js";
+import { BasicSysAbstraction } from "./sys-abstraction.js";
 import { Result } from "./result.js";
 import { CoerceURI, URI } from "./uri.js";
-import { runtimeFn } from "./runtime.js";
-import { ConsoleWriterStream } from "./utils/console-write-stream.js";
 import { LogWriterStream } from "./log-writer-impl.js";
 import { TxtEnDecoder, TxtEnDecoderSingleton } from "./txt-en-decoder.js";
 import { LevelHandlerSingleton } from "./log-level-impl.js";
+import { BasicSysAbstractionFactory } from "./base-sys-abstraction.js";
 
 function getLen(value: unknown, lvs: LogValueState): LogValue {
   if (Array.isArray(value)) {
@@ -93,7 +91,7 @@ export class YAMLFormatter implements LogFormatter {
 export interface LoggerImplParams {
   readonly out?: WritableStream<Uint8Array>;
   readonly logWriter?: LogWriterStream;
-  readonly sys?: SysAbstraction;
+  readonly sys?: BasicSysAbstraction;
   readonly withAttributes?: LogSerializable;
   readonly levelHandler?: LevelHandler;
   readonly txtEnDe?: TxtEnDecoder;
@@ -107,7 +105,7 @@ function toLogValueCtx(lvh: LevelHandler): LogValueState {
 }
 
 export class LoggerImpl implements Logger {
-  readonly _sys: SysAbstraction;
+  readonly _sys: BasicSysAbstraction;
   readonly _attributes: LogSerializable = {};
   readonly _withAttributes: LogSerializable;
   readonly _logWriter: LogWriterStream;
@@ -121,7 +119,7 @@ export class LoggerImpl implements Logger {
       params = {};
     }
     if (!params.sys) {
-      this._sys = WebSysAbstraction();
+      this._sys = BasicSysAbstractionFactory();
     } else {
       this._sys = params.sys;
     }
@@ -140,18 +138,18 @@ export class LoggerImpl implements Logger {
       this._logWriter = params.logWriter;
     } else {
       if (!params.out) {
-        const rt = runtimeFn();
-        let stream: WritableStream<Uint8Array>;
-        if (rt.isBrowser) {
-          stream = new ConsoleWriterStream();
-        } else {
-          if (rt.isNodeIsh || rt.isReactNative || rt.isDeno || rt.isCFWorker) {
-            stream = this._sys.Stdout();
-          } else {
-            throw new Error("No output defined for runtime");
-          }
-        }
-        this._logWriter = new LogWriterStream(stream);
+        // const rt = runtimeFn();
+        // let stream: WritableStream<Uint8Array>;
+        // if (rt.isBrowser) {
+        //   stream = new ConsoleWriterStream();
+        // } else {
+        //   if (rt.isNodeIsh || rt.isReactNative || rt.isDeno || rt.isCFWorker) {
+        //     stream = this._sys.Stdout();
+        //   } else {
+        //     throw new Error("No output defined for runtime");
+        //   }
+        // }
+        this._logWriter = new LogWriterStream(this._sys.Stdout());
       } else {
         this._logWriter = new LogWriterStream(params.out);
       }

package/src/node/node-basic-sys-abstraction.ts

@@ -0,0 +1,59 @@
+import { BaseBasicSysAbstraction, WrapperBasicSysAbstraction, WrapperBasicSysAbstractionParams } from "../base-sys-abstraction.js";
+import { ResolveOnce } from "../resolve-once.js";
+import { BasicRuntimeService, BasicSysAbstraction } from "../sys-abstraction.js";
+import { Env, envFactory } from "../sys-env.js";
+import { TxtEnDecoder, TxtEnDecoderSingleton } from "../txt-en-decoder.js";
+
+export class NodeRuntimeService implements BasicRuntimeService {
+  readonly _txtEnDe: TxtEnDecoder;
+  readonly _gthis: {
+    process: {
+      argv: string[];
+      stdout: {
+        write(chunk: Uint8Array): void;
+      };
+      stderr: {
+        write(chunk: Uint8Array): void;
+      };
+    };
+  };
+  constructor(ende: TxtEnDecoder) {
+    this._txtEnDe = ende;
+    this._gthis = globalThis as unknown as NodeRuntimeService["_gthis"];
+  }
+  Env(): Env {
+    return envFactory();
+  }
+
+  Args(): string[] {
+    return this._gthis.process.argv;
+  }
+
+  Stdout(): WritableStream<Uint8Array> {
+    return new WritableStream({
+      write: (chunk: Uint8Array): void => {
+        this._gthis.process.stdout.write(chunk);
+      },
+    });
+  }
+  Stderr(): WritableStream<Uint8Array> {
+    return new WritableStream<Uint8Array>({
+      write: (chunk: Uint8Array): void => {
+        this._gthis.process.stderr.write(chunk);
+      },
+    });
+  }
+}
+
+const baseSysAbstraction = new ResolveOnce<BaseBasicSysAbstraction>();
+export function NodeBasicSysAbstraction(param?: WrapperBasicSysAbstractionParams): BasicSysAbstraction {
+  const my = baseSysAbstraction.once(() => {
+    return new BaseBasicSysAbstraction({
+      TxtEnDecoder: param?.TxtEnDecoder || TxtEnDecoderSingleton(),
+    });
+  });
+  return new WrapperBasicSysAbstraction(my, {
+    basicRuntimeService: new NodeRuntimeService(param?.TxtEnDecoder ?? my._txtEnDe),
+    ...param,
+  });
+}