@adviser/cement 0.4.80 → 0.4.81

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

@@ -1,5 +1,6 @@
 import * as path from "node:path";
-import type { FileService, NamedWritableStream, TxtEnDecoder } from "@adviser/cement";
+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 {
   cwd(): string;
@@ -11,7 +12,7 @@ const Deno = (globalThis as unknown as { Deno: unknown }).Deno as {
 export class DenoFileService implements FileService {
   readonly baseDir: string;
   readonly txtEnde: TxtEnDecoder;
-  constructor(txtEnde: TxtEnDecoder, baseDir: string = Deno.cwd()) {
+  constructor(baseDir: string = Deno.cwd(), txtEnde: TxtEnDecoder = TxtEnDecoderSingleton()) {
     this.baseDir = this.abs(baseDir);
     this.txtEnde = txtEnde;
   }
@@ -63,7 +64,7 @@ export class DenoFileService implements FileService {
     return path.isAbsolute(fname);
   }
 
-  async writeFileString(fname: string, content: string, ende: TxtEnDecoder = this.txtEnde): Promise<void> {
+  async writeFileString(fname: string, content: string, ende: TxtEnDecoder = TxtEnDecoderSingleton()): Promise<void> {
     const o = await this.create(fname);
     const wr = o.stream.getWriter();
     await wr.write(ende.encode(content));

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

@@ -1,12 +1,13 @@
-import type {
+import {
   ExitService,
   ExitHandler,
   BaseSysAbstraction,
-  RuntimeSysAbstraction,
-  SystemService,
-  VoidFunc,
-  WithCementWrapperSysAbstractionParams,
-} from "@adviser/cement";
+  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";
 import { DenoBasicSysAbstraction } from "./deno-basic-sys-abstraction.js";
 // import * as process from "node:process";
 import { DenoFileService } from "./deno-file-service.js";
@@ -113,17 +114,17 @@ export class DenoSystemService implements SystemService {
   }
 }
 
-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, {
+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/deno/index.ts

@@ -1,4 +1,2 @@
 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.cjs.ts

@@ -28,7 +28,7 @@ export * from "./is-promise.js";
 export * from "./app-context.js";
 
 // ugly
-// export * as utils from "@adviser/cement/utils"
+export * as utils from "./utils/index.js";
 // import * as utils from "./utils/index.js";
 
 // export const param = utils.param;

package/src/index.ts

@@ -35,18 +35,4 @@ export * from "./promise-sleep.js";
 export * from "./keyed-ng.js";
 
 // ugly not really esm but how could that work otherwise?
-// 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 * as utils from "./utils/index.js";

package/src/log-level-impl.ts

@@ -1,6 +1,5 @@
-import { LevelHandler } from "./logger.js";
+import { LevelHandler, Level } 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,12 +2,17 @@
 import YAML from "yaml";
 import {
   AsError,
+  FnSerialized,
+  LogSerializable,
+  Level,
   Logger,
   logValue,
+  Serialized,
   WithLogger,
   // sanitizeSerialize,
   Sized,
   Lengthed,
+  LogValue,
   LevelHandler,
   LogFormatter,
   LogValueArg,
@@ -21,7 +26,6 @@ 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,7 +7,35 @@ 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";
-import { FnSerialized, Level, LogSerializable, LogValue, Serialized } from "./types.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>>;
 
 // 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 "./types.js";
+import { hasHostPartProtocols } from "./uri.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/index.ts

@@ -1,5 +1,3 @@
 export * from "./node-file-service.js";
 export * from "./node-sys-abstraction.js";
 export * from "./mock-file-service.js";
-export * from "./node-env-actions.js";
-export * from "./node-basic-sys-abstraction.js";

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

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

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

@@ -1,16 +1,11 @@
-import type {
-  BaseBasicSysAbstraction,
-  BasicRuntimeService,
-  BasicSysAbstraction,
-  Env,
-  EnvFactory,
-  TxtEnDecoder,
-  WithCementWrapperSysAbstractionParams,
-} from "@adviser/cement";
+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 _envFactory: EnvFactory;
   readonly _gthis: {
     process: {
       argv: string[];
@@ -22,13 +17,12 @@ export class NodeRuntimeService implements BasicRuntimeService {
       };
     };
   };
-  constructor(ende: TxtEnDecoder, envFactory: EnvFactory) {
+  constructor(ende: TxtEnDecoder) {
     this._txtEnDe = ende;
-    this._envFactory = envFactory;
     this._gthis = globalThis as unknown as NodeRuntimeService["_gthis"];
   }
   Env(): Env {
-    return this._envFactory();
+    return envFactory();
   }
 
   Args(): string[] {
@@ -51,17 +45,15 @@ export class NodeRuntimeService implements BasicRuntimeService {
   }
 }
 
-let baseSysAbstraction: BaseBasicSysAbstraction | undefined = undefined;
-
-export function NodeBasicSysAbstraction(param: WithCementWrapperSysAbstractionParams): BasicSysAbstraction {
-  const ende = param.TxtEnDecoder ?? param.cement.TxtEnDecoderSingleton();
-  baseSysAbstraction =
-    baseSysAbstraction ??
-    new param.cement.BaseBasicSysAbstraction({
-      TxtEnDecoder: ende,
+const baseSysAbstraction = new ResolveOnce<BaseBasicSysAbstraction>();
+export function NodeBasicSysAbstraction(param?: WrapperBasicSysAbstractionParams): BasicSysAbstraction {
+  const my = baseSysAbstraction.once(() => {
+    return new BaseBasicSysAbstraction({
+      TxtEnDecoder: param?.TxtEnDecoder || TxtEnDecoderSingleton(),
     });
-  return new param.cement.WrapperBasicSysAbstraction(baseSysAbstraction, {
-    basicRuntimeService: new NodeRuntimeService(ende, param.cement.envFactory),
+  });
+  return new WrapperBasicSysAbstraction(my, {
+    basicRuntimeService: new NodeRuntimeService(param?.TxtEnDecoder ?? my._txtEnDe),
     ...param,
   });
 }

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

@@ -1,4 +1,6 @@
-import type { Env, EnvActions, EnvFactoryOpts, WithCement } from "@adviser/cement";
+import { ResolveOnce } from "../resolve-once.js";
+import { runtimeFn } from "../runtime.js";
+import { Env, EnvActions, EnvFactoryOpts } from "../sys-env.js";
 
 // export interface ImportMetaEnv {
 //   import?: {
@@ -7,22 +9,57 @@ import type { Env, EnvActions, EnvFactoryOpts, WithCement } from "@adviser/cemen
 //     };
 //   };
 // }
-
-let once: NodeEnvActions | undefined = undefined;
-
 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 _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;
+  // }
+
+  // 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 };
+  // }
 
-  static new(opts: WithCement<Partial<EnvFactoryOpts>>): EnvActions {
-    once = once ?? new NodeEnvActions(opts);
-    return once;
+  static new(opts: Partial<EnvFactoryOpts>): EnvActions {
+    return NodeEnvActions.once.once(() => new NodeEnvActions(opts));
   }
 
-  readonly opts: WithCement<Partial<EnvFactoryOpts>>;
-  private constructor(opts: WithCement<Partial<EnvFactoryOpts>>) {
+  readonly opts: Partial<EnvFactoryOpts>;
+  private constructor(opts: Partial<EnvFactoryOpts>) {
     this.opts = opts;
-    this._env = this.active() ? this.#node.process.env : {};
   }
 
   register(env: Env): Env {
@@ -33,8 +70,10 @@ export class NodeEnvActions implements EnvActions {
   }
 
   active(): boolean {
-    return this.opts.cement.runtimeFn().isNodeIsh;
+    return runtimeFn().isNodeIsh;
+    // typeof this.#node === "object" && typeof this.#node.process === "object" && typeof this.#node.process.env === "object";
   }
+  readonly _env: Record<string, string> = this.active() ? this.#node.process.env : {};
   keys(): string[] {
     return Object.keys(this._env);
   }
@@ -44,6 +83,7 @@ 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,14 +1,13 @@
 import path from "node:path";
 import fs from "node:fs";
 import process from "node:process";
-import type { FileService, NamedWritableStream, TxtEnDecoder } from "@adviser/cement";
+import { FileService, NamedWritableStream } from "../file-service.js";
+import { TxtEnDecoder, TxtEnDecoderSingleton } from "../txt-en-decoder.js";
 
 export class NodeFileService implements FileService {
   readonly baseDir: string;
-  readonly defTxtEnde: TxtEnDecoder;
-  constructor(defTxtEncode: TxtEnDecoder, baseDir: string = process.cwd()) {
+  constructor(baseDir: string = process.cwd()) {
     this.baseDir = this.abs(baseDir);
-    this.defTxtEnde = defTxtEncode;
   }
 
   // nodeImport(fname: string): string {
@@ -58,7 +57,7 @@ export class NodeFileService implements FileService {
     return path.isAbsolute(fname);
   }
 
-  async writeFileString(fname: string, content: string, ende: TxtEnDecoder = this.defTxtEnde): Promise<void> {
+  async writeFileString(fname: string, content: string, ende: TxtEnDecoder = TxtEnDecoderSingleton()): 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,14 +1,15 @@
-import type {
-  RuntimeSysAbstraction,
-  SystemService,
-  VoidFunc,
+import { RuntimeSysAbstraction, SystemService, VoidFunc } from "../sys-abstraction.js";
+import {
   BaseSysAbstraction,
   ExitHandler,
   ExitService,
-  WithCementWrapperSysAbstractionParams,
-} from "@adviser/cement";
+  WrapperBasicSysAbstractionParams,
+  WrapperRuntimeSysAbstraction,
+} from "../base-sys-abstraction.js";
 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 {
@@ -100,17 +101,17 @@ export class NodeSystemService implements SystemService {
   }
 }
 
-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, {
+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),
     ...param,
   });

package/src/resolve-once.ts

@@ -15,7 +15,8 @@
  */
 
 import { Future } from "./future.js";
-import { UnPromisify, isPromise } from "./is-promise.js";
+import { UnPromisify } from "./is-promise.js";
+import { isPromise } from "./is-promise.js";
 import { UnregFn } from "./lru-map-set.js";
 import { Result } from "./result.js";
 import { Option } from "./option.js";
@@ -640,6 +641,7 @@ 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,13 +1,11 @@
-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 { 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 { KeyedResolvOnce } from "./resolve-once.js";
 import { Result } from "./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";
+import { wrapImportMetaEnv, ImportMetaEnv } from "@adviser/cement/import-meta-env";
 
 export type EnvTuple = ([string, string] | [string, string][] | Record<string, string> | Iterator<[string, string]>)[];
 
@@ -42,13 +40,13 @@ export interface Env extends EnvMap {
   sets(...keys: EnvTuple): void;
 }
 
-export type EnvFactoryFn = (opts: WithCement<Partial<EnvFactoryOpts>>) => EnvActions;
+export type EnvFactoryFn = (opts: Partial<EnvFactoryOpts>) => EnvActions;
 
 const envActions: { id: string; fn: EnvFactoryFn }[] = [
-  { 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) },
+  { 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) },
 ];
 
 /**
@@ -122,16 +120,14 @@ 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 withCement = addCement(opts);
-  const found = envActions.find((fi) => fi.fn(withCement).active());
+  const found = envActions.find((fi) => fi.fn(opts).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(withCement));
-    const ret = new EnvImpl(action, withCement);
+    const action = wrapImportMetaEnv(found.fn(opts));
+    const ret = new EnvImpl(action, opts);
     action.register(ret);
     return ret;
   });
@@ -156,7 +152,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,4 +1,6 @@
-import { FanoutWriteStream, Future, type TxtEnDecoder, TxtEnDecoderSingleton } from "@adviser/cement";
+import { FanoutWriteStream } from "../utils/fanout-write-stream.js";
+import { Future } from "../future.js";
+import { TxtEnDecoder, TxtEnDecoderSingleton } from "../txt-en-decoder.js";
 
 export class LogWriteStream implements WritableStreamDefaultWriter<Uint8Array> {
   private readonly _bufferArr: Uint8Array[];

package/src/test/mock-logger.ts

@@ -1,5 +1,8 @@
-import { LevelHandlerImpl, type Logger, LoggerImpl, type BasicSysAbstraction } from "@adviser/cement";
+import { LevelHandlerImpl } from "../log-level-impl.js";
+import { Logger } from "../logger.js";
+import { LoggerImpl } from "../logger-impl.js";
 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 { ToUInt8, coerceIntoUint8 } from "./utils/coerce-uint8.js";
+import { coerceIntoUint8, ToUInt8 } 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,48 +17,3 @@ 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 { ReadonlyURL, URLSearchParamsEntries, WritableURL } from "./mutable-url.js";
-import { KeyedResolvOnce } from "./resolve-once.js";
-import { KeysParam, getParamsResult, hasHostPartProtocols } from "./index.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 { param } from "./types.js";
 
 type NullOrUndef = null | undefined;
@@ -528,6 +528,8 @@ 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 "@adviser/cement";
+import { Result } from "../result.js";
 
 // Tested in txt-en-decoder.test.ts