@adviser/cement 0.4.72 → 0.4.80

package/src/node/node-env-actions.ts

@@ -1,6 +1,4 @@
-import { ResolveOnce } from "../resolve-once.js";
-import { runtimeFn } from "../runtime.js";
-import { Env, EnvActions, EnvFactoryOpts } from "../sys-env.js";
+import type { Env, EnvActions, EnvFactoryOpts, WithCement } from "@adviser/cement";
 
 // export interface ImportMetaEnv {
 //   import?: {
@@ -9,57 +7,22 @@ import { Env, EnvActions, EnvFactoryOpts } from "../sys-env.js";
 //     };
 //   };
 // }
-export class NodeEnvActions implements EnvActions {
-  static once = new ResolveOnce<NodeEnvActions>();
-  // static cleanPrefixes = ["VITE_"];
-  // static addCleanPrefix(prefix: string): void {
-  //   if (!prefix.endsWith("_")) {
-  //     prefix += "_";
-  //   }
-  //   if (!NodeEnvActions.cleanPrefixes.includes(prefix)) {
-  //     NodeEnvActions.cleanPrefixes.push(prefix);
-  //   }
-  // }
-  readonly #node = globalThis as unknown as { process: { env: Record<string, string> } };
-  // readonly #importMetaEnv = globalThis as unknown as ImportMetaEnv;
 
-  // cleanImportMetaEnv(): Record<string, string> {
-  //   const metaEnv = this.#importMetaEnv.import?.meta?.env || {};
-  //   const cleaned: Record<string, string> = {};
-  //   for (const key of Object.keys(metaEnv)) {
-  //     const hasCleanPrefix = NodeEnvActions.cleanPrefixes.find((prefix) => key.startsWith(prefix));
-  //     if (hasCleanPrefix) {
-  //       const cleanedPrefix = key.replace(hasCleanPrefix, "");
-  //       const foundCleanPrefix = cleaned[cleanedPrefix];
-  //       if (!foundCleanPrefix) {
-  //         cleaned[cleanedPrefix] = metaEnv[key];
-  //       }
-  //     }
-  //     cleaned[key] = metaEnv[key];
-  //   }
-  //   return cleaned;
-  // }
+let once: NodeEnvActions | undefined = undefined;
 
-  // mergeEnv(): Record<string, string> {
-  //   // const importMetaEnv = this.cleanImportMetaEnv();
-  //   // console.debug("NodeEnvActions.mergeEnv", importMetaEnv);
-  //   const nodeEnv = Object.keys(this.#node.process.env).reduce(
-  //     (acc, key) => {
-  //       acc[key] = this.#node.process.env[key] || "";
-  //       return acc;
-  //     },
-  //     {} as Record<string, string>,
-  //   );
-  //   return { ...nodeEnv };
-  // }
+export class NodeEnvActions implements EnvActions {
+  readonly #node = globalThis as unknown as { process: { env: Record<string, string> } };
+  readonly _env: Record<string, string>;
 
-  static new(opts: Partial<EnvFactoryOpts>): EnvActions {
-    return NodeEnvActions.once.once(() => new NodeEnvActions(opts));
+  static new(opts: WithCement<Partial<EnvFactoryOpts>>): EnvActions {
+    once = once ?? new NodeEnvActions(opts);
+    return once;
   }
 
-  readonly opts: Partial<EnvFactoryOpts>;
-  private constructor(opts: Partial<EnvFactoryOpts>) {
+  readonly opts: WithCement<Partial<EnvFactoryOpts>>;
+  private constructor(opts: WithCement<Partial<EnvFactoryOpts>>) {
     this.opts = opts;
+    this._env = this.active() ? this.#node.process.env : {};
   }
 
   register(env: Env): Env {
@@ -70,10 +33,8 @@ export class NodeEnvActions implements EnvActions {
   }
 
   active(): boolean {
-    return runtimeFn().isNodeIsh;
-    // typeof this.#node === "object" && typeof this.#node.process === "object" && typeof this.#node.process.env === "object";
+    return this.opts.cement.runtimeFn().isNodeIsh;
   }
-  readonly _env: Record<string, string> = this.active() ? this.#node.process.env : {};
   keys(): string[] {
     return Object.keys(this._env);
   }
@@ -83,7 +44,6 @@ export class NodeEnvActions implements EnvActions {
   set(key: string, value?: string): void {
     if (value) {
       this._env[key] = value;
-      // this.#node.process.env[key] = value; // also set in process.env
     }
   }
   delete(key: string): void {

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

@@ -1,13 +1,14 @@
 import path from "node:path";
 import fs from "node:fs";
 import process from "node:process";
-import { FileService, NamedWritableStream } from "../file-service.js";
-import { TxtEnDecoder, TxtEnDecoderSingleton } from "../txt-en-decoder.js";
+import type { FileService, NamedWritableStream, TxtEnDecoder } from "@adviser/cement";
 
 export class NodeFileService implements FileService {
   readonly baseDir: string;
-  constructor(baseDir: string = process.cwd()) {
+  readonly defTxtEnde: TxtEnDecoder;
+  constructor(defTxtEncode: TxtEnDecoder, baseDir: string = process.cwd()) {
     this.baseDir = this.abs(baseDir);
+    this.defTxtEnde = defTxtEncode;
   }
 
   // nodeImport(fname: string): string {
@@ -57,7 +58,7 @@ export class NodeFileService implements FileService {
     return path.isAbsolute(fname);
   }
 
-  async writeFileString(fname: string, content: string, ende: TxtEnDecoder = TxtEnDecoderSingleton()): Promise<void> {
+  async writeFileString(fname: string, content: string, ende: TxtEnDecoder = this.defTxtEnde): Promise<void> {
     const o = await this.create(fname);
     const wr = o.stream.getWriter();
     await wr.write(ende.encode(content));

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

@@ -1,15 +1,14 @@
-import { RuntimeSysAbstraction, SystemService, VoidFunc } from "../sys-abstraction.js";
-import {
+import type {
+  RuntimeSysAbstraction,
+  SystemService,
+  VoidFunc,
   BaseSysAbstraction,
   ExitHandler,
   ExitService,
-  WrapperBasicSysAbstractionParams,
-  WrapperRuntimeSysAbstraction,
-} from "../base-sys-abstraction.js";
+  WithCementWrapperSysAbstractionParams,
+} from "@adviser/cement";
 import { NodeFileService } from "./node-file-service.js";
-import { TxtEnDecoderSingleton } from "../txt-en-decoder.js";
 import process from "node:process";
-import { ResolveOnce } from "../resolve-once.js";
 import { NodeBasicSysAbstraction } from "./node-basic-sys-abstraction.js";
 
 export class NodeExitServiceImpl implements ExitService {
@@ -101,17 +100,17 @@ export class NodeSystemService implements SystemService {
   }
 }
 
-const baseSysAbstraction = new ResolveOnce<BaseSysAbstraction>();
-export function NodeSysAbstraction(param?: WrapperBasicSysAbstractionParams): RuntimeSysAbstraction {
-  const my = baseSysAbstraction.once(
-    () =>
-      new BaseSysAbstraction({
-        TxtEnDecoder: param?.TxtEnDecoder || TxtEnDecoderSingleton(),
-        FileSystem: new NodeFileService(),
-        SystemService: new NodeSystemService(),
-      }),
-  );
-  return new WrapperRuntimeSysAbstraction(my, {
+let baseSysAbstraction: BaseSysAbstraction | undefined = undefined;
+export function NodeSysAbstraction(param: WithCementWrapperSysAbstractionParams): RuntimeSysAbstraction {
+  const ende = param?.TxtEnDecoder || param.cement.TxtEnDecoderSingleton();
+  baseSysAbstraction =
+    baseSysAbstraction ??
+    new param.cement.BaseSysAbstraction({
+      TxtEnDecoder: ende,
+      FileSystem: new NodeFileService(ende),
+      SystemService: new NodeSystemService(),
+    });
+  return new param.cement.WrapperRuntimeSysAbstraction(baseSysAbstraction, {
     basicRuntimeService: NodeBasicSysAbstraction(param),
     ...param,
   });

package/src/on-func.ts

@@ -56,7 +56,7 @@ export const OnFuncReturn: {
 export type OnFuncReturn = (typeof OnFuncReturn)[keyof typeof OnFuncReturn];
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-interface ReturnOnFunc<Args extends any[], X = unknown> {
+export interface ReturnOnFunc<Args extends any[], X = unknown> {
   (fn: (...a: Args) => OnFuncReturn | X): () => unknown; // returns unregister function
   invoke(...a: Args): void;
   invokeAsync(...a: Args): Promise<void>;

package/src/resolve-once.ts

@@ -15,8 +15,7 @@
  */
 
 import { Future } from "./future.js";
-import { UnPromisify } from "./is-promise.js";
-import { isPromise } from "./is-promise.js";
+import { UnPromisify, isPromise } from "./is-promise.js";
 import { UnregFn } from "./lru-map-set.js";
 import { Result } from "./result.js";
 import { Option } from "./option.js";
@@ -635,14 +634,17 @@ export class ResolveOnce<T, CTX = void> implements ResolveOnceIf<T, CTX> {
   //   this.#state = value;
   // }
 
-  once<R>(fn: (c: CTX) => R): ResultOnce<R> {
+  once<R>(fn: (c: CTX, prev?: T) => R): ResultOnce<R> {
     let resultFn: (ctx: CTX) => R;
     if (this.#state.isInitial()) {
       const state = this.#state;
       try {
         state.setProcessing();
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-        const isSyncOrAsync = fn(this._ctx ?? ({} as CTX)) as R;
+        let prev: T | undefined = undefined;
+        if (this.#syncOrAsync.IsSome()) {
+          prev = this.#syncOrAsync.Unwrap().value as T;
+        }
+        const isSyncOrAsync = fn(this._ctx ?? ({} as CTX), prev);
         if (isPromise(isSyncOrAsync)) {
           this.#syncOrAsync = Option.Some(new AsyncResolveOnce<T, CTX>(this, state, this.#syncOrAsync));
         } else {

package/src/result.ts

@@ -28,8 +28,8 @@ import { isPromise } from "./is-promise.js";
  * ```
  */
 export abstract class Result<T, E = Error> {
-  static Ok<T = void>(...args: T[]): Result<T, Error> {
-    return args.length >= 1 ? new ResultOK<T>(args[0]) : new ResultOK<T>(undefined as unknown as T);
+  static Ok<T = void, E = Error>(...args: T[]): Result<T, E> {
+    return args.length >= 1 ? new ResultOK<T, E>(args[0]) : new ResultOK<T, E>(undefined as unknown as T);
   }
   static Err<T, E extends Error = Error>(t: E | string | Result<unknown, E>): Result<T, E> {
     if (typeof t === "string") {
@@ -77,7 +77,7 @@ export abstract class Result<T, E = Error> {
   abstract unwrap_err(): E;
 }
 
-export class ResultOK<T> extends Result<T, Error> {
+export class ResultOK<T, E = unknown> extends Result<T, E> {
   private _t: T;
   constructor(t: T) {
     super();
@@ -89,7 +89,7 @@ export class ResultOK<T> extends Result<T, Error> {
   is_err(): boolean {
     return false;
   }
-  unwrap_err(): Error {
+  unwrap_err(): E {
     throw new Error("Result is Ok");
   }
   unwrap(): T {

package/src/sys-env.ts

@@ -1,11 +1,13 @@
-import { DenoEnvActions } from "./deno/deno-env-actions.js";
-import { NodeEnvActions } from "./node/node-env-actions.js";
-import { BrowserEnvActions } from "./web/web-env-actions.js";
-import { CFEnvActions } from "./cf/cf-env-actions.js";
+import { DenoEnvActions } from "@adviser/cement/deno";
+import { NodeEnvActions } from "@adviser/cement/node";
+import { BrowserEnvActions } from "@adviser/cement/web";
+import { CFEnvActions } from "@adviser/cement/cf";
 import { KeyedResolvOnce } from "./resolve-once.js";
 import { Result } from "./result.js";
-import { getParamsResult, KeysParam } from "./utils/get-params-result.js";
 import { wrapImportMetaEnv, ImportMetaEnv } from "@adviser/cement/import-meta-env";
+import { getParamsResult, KeysParam } from "./utils/get-params-result.js";
+import { WithCement } from "./types.js";
+import { addCement } from "./add-cement-do-not-export.js";
 
 export type EnvTuple = ([string, string] | [string, string][] | Record<string, string> | Iterator<[string, string]>)[];
 
@@ -40,13 +42,13 @@ export interface Env extends EnvMap {
   sets(...keys: EnvTuple): void;
 }
 
-export type EnvFactoryFn = (opts: Partial<EnvFactoryOpts>) => EnvActions;
+export type EnvFactoryFn = (opts: WithCement<Partial<EnvFactoryOpts>>) => EnvActions;
 
 const envActions: { id: string; fn: EnvFactoryFn }[] = [
-  { id: "cf", fn: (opts: Partial<EnvFactoryOpts>): EnvActions => CFEnvActions.new(opts) },
-  { id: "node", fn: (opts: Partial<EnvFactoryOpts>): EnvActions => NodeEnvActions.new(opts) },
-  { id: "deno", fn: (opts: Partial<EnvFactoryOpts>): EnvActions => DenoEnvActions.new(opts) },
-  { id: "browser", fn: (opts: Partial<EnvFactoryOpts>): EnvActions => BrowserEnvActions.new(opts) },
+  { id: "cf", fn: (opts: WithCement<Partial<EnvFactoryOpts>>): EnvActions => CFEnvActions.new(opts) },
+  { id: "node", fn: (opts: WithCement<Partial<EnvFactoryOpts>>): EnvActions => NodeEnvActions.new(opts) },
+  { id: "deno", fn: (opts: WithCement<Partial<EnvFactoryOpts>>): EnvActions => DenoEnvActions.new(opts) },
+  { id: "browser", fn: (opts: WithCement<Partial<EnvFactoryOpts>>): EnvActions => BrowserEnvActions.new(opts) },
 ];
 
 /**
@@ -120,14 +122,16 @@ const _envFactories = new KeyedResolvOnce<Env>();
  * }, 'API_KEY'); // Optional: filter by specific keys
  * ```
  */
+export type EnvFactory = (opts?: Partial<EnvFactoryOpts>) => Env;
 export function envFactory(opts: Partial<EnvFactoryOpts> = {}): Env {
-  const found = envActions.find((fi) => fi.fn(opts).active());
+  const withCement = addCement(opts);
+  const found = envActions.find((fi) => fi.fn(withCement).active());
   if (!found) {
     throw new Error("SysContainer:envFactory: no env available");
   }
   const res = _envFactories.get(opts.id ?? found.id).once(() => {
-    const action = wrapImportMetaEnv(found.fn(opts));
-    const ret = new EnvImpl(action, opts);
+    const action = wrapImportMetaEnv(found.fn(withCement));
+    const ret = new EnvImpl(action, withCement);
     action.register(ret);
     return ret;
   });
@@ -152,7 +156,7 @@ function isIterable(obj: unknown): obj is Iterable<[string, string]> {
 
 export class EnvImpl implements Env {
   readonly _map: EnvMap;
-  constructor(map: EnvMap, opts: Partial<EnvFactoryOpts> = {}) {
+  constructor(map: EnvMap, opts: Partial<EnvFactoryOpts>) {
     this._map = map;
     this._updatePresets(opts.presetEnv);
   }

package/src/test/log-write-stream.ts

@@ -1,6 +1,4 @@
-import { FanoutWriteStream } from "../utils/fanout-write-stream.js";
-import { Future } from "../future.js";
-import { TxtEnDecoder, TxtEnDecoderSingleton } from "../txt-en-decoder.js";
+import { FanoutWriteStream, Future, type TxtEnDecoder, TxtEnDecoderSingleton } from "@adviser/cement";
 
 export class LogWriteStream implements WritableStreamDefaultWriter<Uint8Array> {
   private readonly _bufferArr: Uint8Array[];

package/src/test/mock-logger.ts

@@ -1,8 +1,5 @@
-import { LevelHandlerImpl } from "../log-level-impl.js";
-import { Logger } from "../logger.js";
-import { LoggerImpl } from "../logger-impl.js";
+import { LevelHandlerImpl, type Logger, LoggerImpl, type BasicSysAbstraction } from "@adviser/cement";
 import { LogCollector } from "./log-write-stream.js";
-import { BasicSysAbstraction } from "../sys-abstraction.js";
 
 export interface MockLoggerReturn {
   readonly logger: Logger;

package/src/txt-en-decoder.ts

@@ -1,6 +1,6 @@
 import { Lazy } from "./resolve-once.js";
 import { Result } from "./result.js";
-import { coerceIntoUint8, ToUInt8 } from "./utils/coerce-uint8.js";
+import { ToUInt8, coerceIntoUint8 } from "./utils/coerce-uint8.js";
 
 export type ToDecoder = ToUInt8 | string | Result<string>;
 export type AsyncToDecoder = ToDecoder | Blob | Promise<ToDecoder | Blob>;

package/src/types.ts

@@ -17,3 +17,48 @@ export const param: {
   OPTIONAL: new _Optional(),
 };
 export type param = (typeof param)[keyof typeof param];
+
+export type WithCement<T> = T & {
+  readonly cement: {
+    readonly runtimeFn: typeof import("./runtime.js").runtimeFn;
+    // readonly WrapperBasicSysAbstractionFactory: typeof import("./base-sys-abstraction.js").WrapperBasicSysAbstractionFactory;
+    readonly WrapperBasicSysAbstraction: typeof import("./base-sys-abstraction.js").WrapperBasicSysAbstraction;
+    readonly WrapperRuntimeSysAbstraction: typeof import("./base-sys-abstraction.js").WrapperRuntimeSysAbstraction;
+    readonly TxtEnDecoderSingleton: typeof import("./txt-en-decoder.js").TxtEnDecoderSingleton;
+    readonly ConsoleWriterStream: typeof import("./utils/console-write-stream.js").ConsoleWriterStream;
+    readonly envFactory: typeof import("./sys-env.js").envFactory;
+    readonly BaseBasicSysAbstraction: typeof import("./base-sys-abstraction.js").BaseBasicSysAbstraction;
+    readonly BaseSysAbstraction: typeof import("./base-sys-abstraction.js").BaseSysAbstraction;
+  };
+};
+
+export const hasHostPartProtocols: Set<string> = new Set<string>(["http", "https", "ws", "wss"]);
+
+export const Level = {
+  WARN: "warn",
+  DEBUG: "debug",
+  INFO: "info",
+  ERROR: "error",
+};
+
+export type Level = (typeof Level)[keyof typeof Level];
+
+export type Serialized = string | number | boolean;
+export type FnSerialized = () => Serialized | Serialized[];
+
+export class LogValue {
+  constructor(readonly fn: FnSerialized) {}
+  value(): Serialized | Serialized[] {
+    try {
+      // console.log("LogValue.value", this.fn.toString());
+      return this.fn();
+    } catch (e) {
+      return `LogValue:${(e as Error).message}`;
+    }
+  }
+  toJSON(): Serialized | Serialized[] {
+    return this.value();
+  }
+}
+
+export type LogSerializable = Record<string, LogValue | Promise<LogValue>>;

package/src/uri.ts

@@ -1,10 +1,10 @@
 import type { DeepWritable } from "ts-essentials";
 import { exception2Result, Result } from "./result.js";
-import { getParamsResult, KeysParam } from "./utils/get-params-result.js";
-import { relativePath } from "./utils/relative-path.js";
-import { StripCommand, stripper } from "./utils/stripper.js";
 import { ReadonlyURL, URLSearchParamsEntries, WritableURL } from "./mutable-url.js";
 import { KeyedResolvOnce } from "./resolve-once.js";
+import { KeysParam, getParamsResult, hasHostPartProtocols } from "./index.js";
+import { relativePath } from "./utils/relative-path.js";
+import { StripCommand, stripper } from "./utils/stripper.js";
 // import { param } from "./types.js";
 
 type NullOrUndef = null | undefined;
@@ -528,8 +528,6 @@ export function isCoerceURI(value: unknown): value is CoerceURI {
   return false;
 }
 
-export const hasHostPartProtocols: Set<string> = new Set<string>(["http", "https", "ws", "wss"]);
-
 const uriInstances = new KeyedResolvOnce<URI>({
   lru: { maxEntries: 1000 },
 });

package/src/utils/coerce-uint8.ts

@@ -1,4 +1,4 @@
-import { Result } from "../result.js";
+import { Result } from "@adviser/cement";
 
 // Tested in txt-en-decoder.test.ts
 

package/src/utils/consume.ts

@@ -1,4 +1,4 @@
-import { isPromise } from "../is-promise.js";
+import { isPromise } from "@adviser/cement";
 
 /**
  * Consumes a ReadableStream, applying a callback to each chunk and collecting results.

package/src/utils/get-params-result.ts

@@ -1,5 +1,4 @@
-import { Result } from "../result.js";
-import { param } from "../types.js";
+import { Result, param } from "@adviser/cement";
 
 export type MsgFn = (...keys: string[]) => string;
 export type KeysParam = (string | MsgFn | Record<string, param | number | string | boolean | undefined | null>)[];

package/src/web/index.ts

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

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

@@ -1,80 +1,30 @@
-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";
-import { ConsoleWriterStream } from "../utils/console-write-stream.js";
-
-// export class WebFileService implements FileService {
-//   get baseDir(): string {
-//     throw new Error("basedir-Method not implemented.");
-//   }
-//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-//   create(fname: string): Promise<NamedWritableStream> {
-//     throw new Error("create-Method not implemented.");
-//   }
-//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-//   readFileString(fname: string): Promise<string> {
-//     throw new Error("readFileString-Method not implemented.");
-//   }
-//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-//   writeFileString(fname: string, content: string): Promise<void> {
-//     throw new Error("writeFileString-Method not implemented.");
-//   }
-//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-//   abs(fname: string): string {
-//     throw new Error("abs-Method not implemented.");
-//   }
-//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-//   join(...paths: string[]): string {
-//     throw new Error("join-Method not implemented.");
-//   }
-//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-//   relative(from: string, to?: string): string {
-//     throw new Error("relative-Method not implemented.");
-//   }
-//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-//   dirname(fname: string): string {
-//     throw new Error("dirname-Method not implemented.");
-//   }
-//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-//   basename(fname: string): string {
-//     throw new Error("basename-Method not implemented.");
-//   }
-//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-//   nodeImport(fname: string): string {
-//     throw new Error("nodeImport-Method not implemented.");
-//   }
-//   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-//   isAbsolute(fname: string): boolean {
-//     throw new Error("isAbsolute-Method not implemented.");
-//   }
-// }
+import type {
+  WithCementWrapperSysAbstractionParams,
+  BasicRuntimeService,
+  BaseBasicSysAbstraction,
+  TxtEnDecoder,
+  EnvFactory,
+  Env,
+  BasicSysAbstraction,
+} from "@adviser/cement";
 
 class WebSystemService implements BasicRuntimeService {
   readonly _txtEnDe: TxtEnDecoder;
-  constructor(ende: TxtEnDecoder) {
+  readonly _envFactory: EnvFactory;
+  readonly _stdoutFactory: () => WritableStream<Uint8Array>;
+  constructor(ende: TxtEnDecoder, envFactory: EnvFactory, stdoutFactory: () => WritableStream<Uint8Array>) {
     this._txtEnDe = ende;
+    this._envFactory = envFactory;
+    this._stdoutFactory = stdoutFactory;
   }
   Env(): Env {
-    return envFactory();
+    return this._envFactory();
   }
   Args(): string[] {
     throw new Error("Args-Method not implemented.");
   }
   Stdout(): WritableStream<Uint8Array> {
-    return new ConsoleWriterStream();
-    // const decoder = this._txtEnDe;
-    // return 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();
-    //     });
-    //   },
-    // });
+    return this._stdoutFactory();
   }
   Stderr(): WritableStream<Uint8Array> {
     const decoder = this._txtEnDe;
@@ -91,15 +41,16 @@ class WebSystemService implements BasicRuntimeService {
   }
 }
 
-const baseSysAbstraction = new ResolveOnce<BaseBasicSysAbstraction>();
-export function WebBasicSysAbstraction(param?: WrapperBasicSysAbstractionParams): BasicSysAbstraction {
-  const my = baseSysAbstraction.once(() => {
-    return new BaseBasicSysAbstraction({
-      TxtEnDecoder: param?.TxtEnDecoder || TxtEnDecoderSingleton(),
+let baseBasicSysAbstraction: BaseBasicSysAbstraction | undefined = undefined;
+export function WebBasicSysAbstraction(param: WithCementWrapperSysAbstractionParams): BasicSysAbstraction {
+  const ende = param.TxtEnDecoder ?? param.cement.TxtEnDecoderSingleton();
+  baseBasicSysAbstraction =
+    baseBasicSysAbstraction ??
+    new param.cement.BaseBasicSysAbstraction({
+      TxtEnDecoder: ende,
     });
-  });
-  return new WrapperBasicSysAbstraction(my, {
-    basicRuntimeService: new WebSystemService(param?.TxtEnDecoder ?? my._txtEnDe),
+  return new param.cement.WrapperBasicSysAbstraction(baseBasicSysAbstraction, {
+    basicRuntimeService: new WebSystemService(ende, param.cement.envFactory, () => new param.cement.ConsoleWriterStream()),
     ...param,
   });
 }

package/src/web/web-env-actions.ts

@@ -1,13 +1,13 @@
-import { ResolveOnce } from "../resolve-once.js";
-import { EnvActions, EnvFactoryOpts, Env } from "../sys-env.js";
+import type { EnvActions, EnvFactoryOpts, Env } from "@adviser/cement";
 
-const once = new ResolveOnce<BrowserEnvActions>();
+let once: BrowserEnvActions | undefined = undefined;
 export class BrowserEnvActions implements EnvActions {
   readonly env: Map<string, string> = new Map<string, string>();
   readonly opts: Partial<EnvFactoryOpts>;
 
   static new(opts: Partial<EnvFactoryOpts>): EnvActions {
-    return once.once(() => new BrowserEnvActions(opts));
+    once = once ?? new BrowserEnvActions(opts);
+    return once;
   }
 
   private constructor(opts: Partial<EnvFactoryOpts>) {

package/ts/cjs/add-cement-do-not-export.d.ts

@@ -0,0 +1,3 @@
+import { WithCement } from "./types.js";
+export declare function addCement<T>(params: T): WithCement<T>;
+//# sourceMappingURL=add-cement-do-not-export.d.ts.map

package/ts/cjs/add-cement-do-not-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-cement-do-not-export.d.ts","sourceRoot":"","sources":["../../../src/add-cement-do-not-export.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAYxC,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAcrD"}

package/ts/cjs/add-cement-do-not-export.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCement = addCement;
+const runtime_js_1 = require("./runtime.js");
+const base_sys_abstraction_js_1 = require("./base-sys-abstraction.js");
+const txt_en_decoder_js_1 = require("./txt-en-decoder.js");
+const console_write_stream_js_1 = require("./utils/console-write-stream.js");
+const sys_env_js_1 = require("./sys-env.js");
+function addCement(params) {
+    return {
+        cement: {
+            runtimeFn: runtime_js_1.runtimeFn,
+            WrapperBasicSysAbstraction: base_sys_abstraction_js_1.WrapperBasicSysAbstraction,
+            WrapperRuntimeSysAbstraction: base_sys_abstraction_js_1.WrapperRuntimeSysAbstraction,
+            TxtEnDecoderSingleton: txt_en_decoder_js_1.TxtEnDecoderSingleton,
+            ConsoleWriterStream: console_write_stream_js_1.ConsoleWriterStream,
+            envFactory: sys_env_js_1.envFactory,
+            BaseBasicSysAbstraction: base_sys_abstraction_js_1.BaseBasicSysAbstraction,
+            BaseSysAbstraction: base_sys_abstraction_js_1.BaseSysAbstraction,
+        },
+        ...params,
+    };
+}
+//# sourceMappingURL=add-cement-do-not-export.js.map

package/ts/cjs/add-cement-do-not-export.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-cement-do-not-export.js","sourceRoot":"","sources":["../../../src/add-cement-do-not-export.ts"],"names":[],"mappings":";;;AACA,6CAAyC;AACzC,uEAKmC;AACnC,2DAA4D;AAC5D,6EAAsE;AACtE,6CAA0C;AAE1C,mBAA6B,MAAS,EAAiB;IACrD,OAAO;QACL,MAAM,EAAE;YACN,SAAS,EAAT,sBAAS;YACT,0BAA0B,EAA1B,oDAA0B;YAC1B,4BAA4B,EAA5B,sDAA4B;YAC5B,qBAAqB,EAArB,yCAAqB;YACrB,mBAAmB,EAAnB,6CAAmB;YACnB,UAAU,EAAV,uBAAU;YACV,uBAAuB,EAAvB,iDAAuB;YACvB,kBAAkB,EAAlB,4CAAkB;SACnB;QACD,GAAG,MAAM;KACV,CAAC;AAAA,CACH"}