@adviser/cement 0.4.81 → 0.5.1

package/src/{deno → deno-fs}/deno-sys-abstraction.ts

@@ -1,13 +1,12 @@
-import {
+import type {
   ExitService,
   ExitHandler,
   BaseSysAbstraction,
-  WrapperBasicSysAbstractionParams,
-  WrapperRuntimeSysAbstraction,
-} from "../base-sys-abstraction.js";
-import { ResolveOnce } from "../resolve-once.js";
-import { RuntimeSysAbstraction, SystemService, VoidFunc } from "../sys-abstraction.js";
-import { TxtEnDecoderSingleton } from "../txt-en-decoder.js";
+  RuntimeSysAbstraction,
+  SystemService,
+  VoidFunc,
+  WithCementWrapperSysAbstractionParams,
+} from "@adviser/cement";
 import { DenoBasicSysAbstraction } from "./deno-basic-sys-abstraction.js";
 // import * as process from "node:process";
 import { DenoFileService } from "./deno-file-service.js";
@@ -114,17 +113,17 @@ export class DenoSystemService implements SystemService {
   }
 }
 
-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, {
+let baseSysAbstraction: BaseSysAbstraction | undefined = undefined;
+export function DenoSysAbstraction(param: WithCementWrapperSysAbstractionParams): RuntimeSysAbstraction {
+  const ende = param?.TxtEnDecoder ?? param.cement.TxtEnDecoderSingleton();
+  baseSysAbstraction =
+    baseSysAbstraction ??
+    new param.cement.BaseSysAbstraction({
+      TxtEnDecoder: ende,
+      FileSystem: new DenoFileService(ende),
+      SystemService: new DenoSystemService(),
+    });
+  return new param.cement.WrapperRuntimeSysAbstraction(baseSysAbstraction, {
     basicRuntimeService: DenoBasicSysAbstraction(param),
     ...param,
   });

package/src/deno-fs/index.ts

@@ -0,0 +1,4 @@
+export * from "./deno-sys-abstraction.js";
+export * from "./deno-file-service.js";
+export * from "./deno-env-actions.js";
+export * from "./deno-basic-sys-abstraction.js";

package/src/index.ts

@@ -35,4 +35,20 @@ export * from "./promise-sleep.js";
 export * from "./keyed-ng.js";
 
 // ugly not really esm but how could that work otherwise?
-export * as utils from "./utils/index.js";
+// export * as utils from "@adviser/cement/utils"
+
+export * from "./utils/rebuffer.js";
+export * from "./utils/stream-map.js";
+export * from "./utils/stream2string.js";
+export * from "./utils/string2stream.js";
+export * from "./utils/console-write-stream.js";
+export * from "./utils/fanout-write-stream.js";
+export * from "./utils/get-params-result.js";
+export * from "./utils/stripper.js";
+export * from "./utils/sorted-object.js";
+export * from "./utils/uint8array-equal.js";
+export * from "./utils/coerce-uint8.js";
+export * from "./utils/consume.js";
+export * from "./utils/to-sorted.js";
+
+export * from "./node-env/index.js";

package/src/log-level-impl.ts

@@ -1,5 +1,6 @@
-import { LevelHandler, Level } from "./logger.js";
+import { LevelHandler } from "./logger.js";
 import { Option } from "./option.js";
+import { Level } from "./types.js";
 
 export class LevelHandlerImpl implements LevelHandler {
   readonly _globalLevels: Set<Level> = new Set<Level>([Level.INFO, Level.ERROR, Level.WARN]);

package/src/logger-impl.ts

@@ -2,17 +2,12 @@
 import YAML from "yaml";
 import {
   AsError,
-  FnSerialized,
-  LogSerializable,
-  Level,
   Logger,
   logValue,
-  Serialized,
   WithLogger,
   // sanitizeSerialize,
   Sized,
   Lengthed,
-  LogValue,
   LevelHandler,
   LogFormatter,
   LogValueArg,
@@ -26,6 +21,7 @@ import { TxtEnDecoder, TxtEnDecoderSingleton } from "./txt-en-decoder.js";
 import { LevelHandlerSingleton } from "./log-level-impl.js";
 import { BasicSysAbstractionFactory } from "./base-sys-abstraction.js";
 import { LogWriterStream } from "./log-writer-impl.js";
+import { LogValue, LogSerializable, Level, FnSerialized, Serialized } from "./types.js";
 
 function getLen(value: unknown, lvs: LogValueState): LogValue {
   if (Array.isArray(value)) {

package/src/logger.ts

@@ -7,35 +7,7 @@ import { TxtEnDecoder, TxtEnDecoderSingleton } from "./txt-en-decoder.js";
 import { CoerceURI } from "./uri.js";
 import { isJSON } from "./is-json.js";
 import { ReadonlyURL } from "./mutable-url.js";
-
-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>>;
+import { FnSerialized, Level, LogSerializable, LogValue, Serialized } from "./types.js";
 
 // export function sanitizeSerialize(lineEnd?: string): (key: unknown, val: unknown) => unknown {
 //   const cache = new Set();

package/src/mutable-url.ts

@@ -1,5 +1,5 @@
 import { exception2Result, Result } from "./result.js";
-import { hasHostPartProtocols } from "./uri.js";
+import { hasHostPartProtocols } from "./types.js";
 
 // due to that the System URL class is has a strange behavior
 // on different platforms, we need to implement our own URL class

package/src/node-env/index.ts

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

package/src/{node → node-env}/node-basic-sys-abstraction.ts

@@ -1,11 +1,15 @@
-import { BaseBasicSysAbstraction, WrapperBasicSysAbstraction, WrapperBasicSysAbstractionParams } from "../base-sys-abstraction.js";
-import { ResolveOnce } from "../resolve-once.js";
+import {
+  BaseBasicRuntimeSysAbstractionParams,
+  BaseBasicSysAbstraction,
+  WrapperBasicSysAbstraction,
+} from "../base-sys-abstraction.js";
 import { BasicRuntimeService, BasicSysAbstraction } from "../sys-abstraction.js";
-import { Env, envFactory } from "../sys-env.js";
+import { Env, envFactory, EnvFactory } from "../sys-env.js";
 import { TxtEnDecoder, TxtEnDecoderSingleton } from "../txt-en-decoder.js";
 
 export class NodeRuntimeService implements BasicRuntimeService {
   readonly _txtEnDe: TxtEnDecoder;
+  readonly _envFactory: EnvFactory;
   readonly _gthis: {
     process: {
       argv: string[];
@@ -17,12 +21,13 @@ export class NodeRuntimeService implements BasicRuntimeService {
       };
     };
   };
-  constructor(ende: TxtEnDecoder) {
+  constructor(ende: TxtEnDecoder, envFactory: EnvFactory) {
     this._txtEnDe = ende;
+    this._envFactory = envFactory;
     this._gthis = globalThis as unknown as NodeRuntimeService["_gthis"];
   }
   Env(): Env {
-    return envFactory();
+    return this._envFactory();
   }
 
   Args(): string[] {
@@ -45,15 +50,17 @@ export class NodeRuntimeService implements BasicRuntimeService {
   }
 }
 
-const baseSysAbstraction = new ResolveOnce<BaseBasicSysAbstraction>();
-export function NodeBasicSysAbstraction(param?: WrapperBasicSysAbstractionParams): BasicSysAbstraction {
-  const my = baseSysAbstraction.once(() => {
-    return new BaseBasicSysAbstraction({
-      TxtEnDecoder: param?.TxtEnDecoder || TxtEnDecoderSingleton(),
+let baseSysAbstraction: BaseBasicSysAbstraction | undefined = undefined;
+
+export function NodeBasicSysAbstraction(param: Partial<BaseBasicRuntimeSysAbstractionParams> = {}): BasicSysAbstraction {
+  const ende = param.TxtEnDecoder ?? TxtEnDecoderSingleton();
+  baseSysAbstraction =
+    baseSysAbstraction ??
+    new BaseBasicSysAbstraction({
+      TxtEnDecoder: ende,
     });
-  });
-  return new WrapperBasicSysAbstraction(my, {
-    basicRuntimeService: new NodeRuntimeService(param?.TxtEnDecoder ?? my._txtEnDe),
+  return new WrapperBasicSysAbstraction(baseSysAbstraction, {
+    basicRuntimeService: new NodeRuntimeService(ende, envFactory),
     ...param,
   });
 }

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

@@ -0,0 +1,46 @@
+import { runtimeFn } from "../runtime.js";
+import { Env, EnvActions, EnvFactoryOpts } from "../sys-env.js";
+
+let once: NodeEnvActions | undefined = undefined;
+
+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 {
+    once = once ?? new NodeEnvActions(opts);
+    return once;
+  }
+
+  readonly opts: Partial<EnvFactoryOpts>;
+  private constructor(opts: Partial<EnvFactoryOpts>) {
+    this.opts = opts;
+    this._env = this.active() ? this.#node.process.env : {};
+  }
+
+  register(env: Env): Env {
+    for (const key of env.keys()) {
+      this._env[key] = env.get(key) || "";
+    }
+    return env;
+  }
+
+  active(): boolean {
+    return runtimeFn().isNodeIsh;
+  }
+  keys(): string[] {
+    return Object.keys(this._env);
+  }
+  get(key: string): string | undefined {
+    return this._env[key];
+  }
+  set(key: string, value?: string): void {
+    if (value) {
+      this._env[key] = value;
+    }
+  }
+  delete(key: string): void {
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+    delete this._env[key];
+  }
+}

package/src/{node → node-fs}/mock-file-service.ts

@@ -1,5 +1,4 @@
-import { NamedWritableStream } from "../file-service.js";
-import { TxtEnDecoderSingleton } from "../txt-en-decoder.js";
+import type { NamedWritableStream } from "@adviser/cement";
 import { NodeFileService } from "./node-file-service.js";
 
 export interface FileCollector {
@@ -26,7 +25,7 @@ export class MockFileService extends NodeFileService {
     };
     this.files[oName] = fc;
     this.files[fname] = fc;
-    const decoder = TxtEnDecoderSingleton();
+    const decoder = this.defTxtEnde;
 
     return Promise.resolve({
       name: oName,

package/src/{node → node-fs}/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-fs}/node-sys-abstraction.ts

@@ -1,16 +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 {
   constructor() {
@@ -101,18 +99,18 @@ 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, {
-    basicRuntimeService: NodeBasicSysAbstraction(param),
+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: param.cement.NodeBasicSysAbstraction(param),
     ...param,
   });
 }

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";
@@ -641,7 +640,6 @@ export class ResolveOnce<T, CTX = void> implements ResolveOnceIf<T, CTX> {
       const state = this.#state;
       try {
         state.setProcessing();
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
         let prev: T | undefined = undefined;
         if (this.#syncOrAsync.IsSome()) {
           prev = this.#syncOrAsync.Unwrap().value as 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 "./deno-env/index.js";
+import { NodeEnvActions } from "./node-env/index.js";
+import { BrowserEnvActions } from "./web-env/index.js";
+import { CFEnvActions } from "./cf-env/index.js";
 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,49 @@ 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;
+    readonly NodeBasicSysAbstraction: typeof import("./node-env/index.js").NodeBasicSysAbstraction;
+  };
+};
+
+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 → web-env}/index.ts

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

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

@@ -0,0 +1,56 @@
+import {
+  BaseBasicRuntimeSysAbstractionParams,
+  BaseBasicSysAbstraction,
+  WrapperBasicSysAbstraction,
+} from "../base-sys-abstraction.js";
+import { BasicRuntimeService, BasicSysAbstraction } from "../sys-abstraction.js";
+import { Env, envFactory, EnvFactory } from "../sys-env.js";
+import { TxtEnDecoder, TxtEnDecoderSingleton } from "../txt-en-decoder.js";
+import { ConsoleWriterStream } from "../utils/console-write-stream.js";
+
+class WebSystemService implements BasicRuntimeService {
+  readonly _txtEnDe: 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 this._envFactory();
+  }
+  Args(): string[] {
+    throw new Error("Args-Method not implemented.");
+  }
+  Stdout(): WritableStream<Uint8Array> {
+    return this._stdoutFactory();
+  }
+  Stderr(): WritableStream<Uint8Array> {
+    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.error(decoded.trimEnd());
+          resolve();
+        });
+      },
+    });
+  }
+}
+
+let baseBasicSysAbstraction: BaseBasicSysAbstraction | undefined = undefined;
+export function WebBasicSysAbstraction(param: Partial<BaseBasicRuntimeSysAbstractionParams>): BasicSysAbstraction {
+  const ende = param.TxtEnDecoder ?? TxtEnDecoderSingleton();
+  baseBasicSysAbstraction =
+    baseBasicSysAbstraction ??
+    new BaseBasicSysAbstraction({
+      TxtEnDecoder: ende,
+    });
+  return new WrapperBasicSysAbstraction(baseBasicSysAbstraction, {
+    basicRuntimeService: new WebSystemService(ende, envFactory, () => new ConsoleWriterStream()),
+    ...param,
+  });
+}