@adviser/cement 0.3.4 → 0.3.6

package/src/logger.ts

@@ -75,7 +75,7 @@ function logValueInternal(val: LogValueArg, ctx: LogValueStateInternal): LogValu
       return new LogValue(val);
     case "string": {
       try {
-        const ret = JSON.parse(val);
+        const ret = JSON.parse(val) as LogValueArg;
         if (typeof ret === "object" && ret !== null) {
           return logValueInternal(ret, ctx);
         }
@@ -108,7 +108,7 @@ function logValueInternal(val: LogValueArg, ctx: LogValueStateInternal): LogValu
           // should be injected
           const decoder = new TextDecoder();
           const asStr = decoder.decode(val);
-          const obj = JSON.parse(asStr);
+          const obj = JSON.parse(asStr) as LogValueArg;
           return logValueInternal(obj, ctx);
           // eslint-disable-next-line @typescript-eslint/no-unused-vars
         } catch (e) {
@@ -239,7 +239,7 @@ export interface LoggerInterface<R> {
   Log(): R;
   WithLevel(level: Level): R;
 
-  Err(err: unknown | Result<unknown> | Error): R; // could be Error, or something which coerces to string
+  Err<T>(err: T | Result<T> | Error): R; // could be Error, or something which coerces to string
   Info(): R;
   Timestamp(): R;
   Dur(key: string, nsec: number): R;
@@ -266,8 +266,7 @@ export function IsLogger(obj: unknown): obj is Logger {
       "Dur",
       "Uint64",
     ]
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      .map((fn) => typeof (obj as any)[fn] === "function")
+      .map((fn) => typeof (obj as Record<string, unknown>)[fn] === "function")
       .reduce((a, b) => a && b, true)
   );
 }

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

@@ -13,10 +13,10 @@ export class MockFileService extends NodeFileService {
   //   return this.join("/mock/", fname);
   // }
 
-  override async create(fname: string): Promise<NamedWritableStream> {
+  override create(fname: string): Promise<NamedWritableStream> {
     let oName = fname;
     if (!this.isAbsolute(fname)) {
-      oName = await this.abs(fname);
+      oName = this.abs(fname);
     }
 
     const fc = {
@@ -27,7 +27,7 @@ export class MockFileService extends NodeFileService {
     this.files[fname] = fc;
     const decoder = new TextDecoder();
 
-    return {
+    return Promise.resolve({
       name: oName,
       stream: new WritableStream<Uint8Array>({
         write(chunk): void {
@@ -40,6 +40,6 @@ export class MockFileService extends NodeFileService {
           throw new Error("not implemented");
         },
       }),
-    };
+    });
   }
 }

package/src/resolve-once.ts

@@ -14,10 +14,10 @@ export class ResolveSeq<T, C = void> {
   reset(): void {
     /* noop */
   }
-  async _step(item?: ResolveSeqItem<T, C> | undefined): Promise<void> {
+  _step(item?: ResolveSeqItem<T, C>): Promise<void> {
     if (!item) {
       // done
-      return;
+      return Promise.resolve();
     }
     item
       .fn(this.ctx)
@@ -25,15 +25,16 @@ export class ResolveSeq<T, C = void> {
       .catch((e) => item.future.reject(e as Error))
       .finally(() => {
         this._seqFutures.shift();
-        this._step(this._seqFutures[0]);
+        void this._step(this._seqFutures[0]);
       });
+    return Promise.resolve();
   }
   readonly _seqFutures: ResolveSeqItem<T, C>[] = [];
   async add(fn: (c: C) => Promise<T>, id?: number): Promise<T> {
     const future = new Future<T>();
     this._seqFutures.push({ future, fn, id });
     if (this._seqFutures.length === 1) {
-      this._step(this._seqFutures[0]);
+      void this._step(this._seqFutures[0]);
     }
     return future.asPromise();
   }
@@ -99,7 +100,7 @@ export class ResolveOnce<T, CTX = void> {
         this._onceFutures.length = 0;
       };
       const catchFn = (e: Error): void => {
-        this._onceError = e as Error;
+        this._onceError = e;
         this._onceOk = false;
         this._onceValue = undefined;
         this._onceDone = true;

package/src/runtime.ts

@@ -6,14 +6,13 @@ export interface Runtime {
   isCFWorker: boolean;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function isSet(value: string, ref: any = globalThis): boolean {
+function isSet(value: string, ref: Record<string, unknown> = globalThis): boolean {
   const [head, ...tail] = value.split(".");
   if (["object", "function"].includes(typeof ref) && ref && ["object", "function"].includes(typeof ref[head]) && ref[head]) {
     if (tail.length <= 1) {
       return true;
     }
-    return isSet(tail.join("."), ref[head]);
+    return isSet(tail.join("."), ref[head] as Record<string, unknown>);
   }
   return false;
 }
@@ -24,6 +23,7 @@ export function runtimeFn(): Runtime {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const gt: any = globalThis;
   let isReactNative =
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     isSet("navigator.product") && typeof gt["navigator"] === "object" && gt["navigator"]["product"] === "ReactNative";
   let isNodeIsh = false;
   if (!isSet("Deno")) {

package/src/sys-env.ts

@@ -3,6 +3,10 @@ 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 { getParamsResult, KeysParam } from "./utils/get-params-result.js";
+
+export type EnvTuple = ([string, string] | [string, string][] | Record<string, string> | Iterator<[string, string]>)[];
 
 export interface EnvMap {
   get(key: string): string | undefined;
@@ -28,6 +32,9 @@ export interface OnSetItem {
 
 export interface Env extends EnvMap {
   onSet(fn: OnSetFn, ...filter: string[]): void;
+
+  gets(...kparams: KeysParam): Result<Record<string, string>>;
+  sets(...keys: EnvTuple): void;
 }
 
 export type EnvFactoryFn = (opts: Partial<EnvFactoryOpts>) => EnvActions;
@@ -66,12 +73,65 @@ export function envFactory(opts: Partial<EnvFactoryOpts> = {}): Env {
   });
 }
 
+function isIterable(obj: unknown): obj is Iterable<[string, string]> {
+  // checks for null and undefined
+  if (obj == null) {
+    return false;
+  }
+  return typeof (obj as Record<symbol, unknown>)[Symbol.iterator] === "function";
+}
+
 export class EnvImpl implements Env {
   readonly _map: EnvMap;
   constructor(map: EnvMap, opts: Partial<EnvFactoryOpts> = {}) {
     this._map = map;
     this._updatePresets(opts.presetEnv);
   }
+  gets(...kparams: KeysParam): Result<Record<string, string>> {
+    return getParamsResult(kparams, {
+      getParam: (k) => this.get(k),
+    });
+  }
+  sets(...keys: EnvTuple): void {
+    keys.forEach((key) => {
+      if (Array.isArray(key)) {
+        if (key.length === 2) {
+          const [k, v] = key;
+          if (typeof k === "string" && typeof v === "string") {
+            this.set(k, v);
+            return;
+          }
+        }
+        for (const item of key) {
+          if (Array.isArray(item)) {
+            // [string, string]
+            if (item.length === 2) {
+              const [k, v] = item;
+              if (typeof k === "string" && typeof v === "string") {
+                this.set(k, v);
+              }
+            }
+          }
+        }
+      } else {
+        if (isIterable(key)) {
+          for (const [k, v] of key) {
+            if (typeof k === "string" && typeof v === "string") {
+              this.set(k, v);
+            }
+          }
+        } else {
+          const rKey = key as Record<string, string>;
+          for (const k in rKey) {
+            const v = rKey[k];
+            if (typeof k === "string" && typeof v === "string") {
+              this.set(k, v);
+            }
+          }
+        }
+      }
+    });
+  }
   _updatePresets(presetEnv?: Map<string, string>): void {
     if (!presetEnv) {
       return;

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

@@ -61,7 +61,7 @@ export class LogCollector implements WritableStream<Uint8Array> {
 
   getWriter(): WritableStreamDefaultWriter<Uint8Array> {
     if (!this._writer) {
-      const dests: WritableStreamDefaultWriter[] = [new LogWriteStream(this._bufferArr)];
+      const dests: WritableStreamDefaultWriter<Uint8Array>[] = [new LogWriteStream(this._bufferArr)];
       if (this._pass) {
         dests.push(this._pass);
       }
@@ -87,6 +87,7 @@ export class LogCollector implements WritableStream<Uint8Array> {
     if (!notJsonLine) {
       const splitStr = jsonNlStr.split("\n");
       const filterStr = splitStr.filter((a) => a.length);
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
       const mapStr = filterStr.map((a) => JSON.parse(a));
       return mapStr;
     }

package/src/tracer.ts

@@ -38,14 +38,12 @@ export class Metric<T> {
   add<R extends number | ArrayLike<T>>(value: R): void {
     if (typeof value === "number") {
       if (this.value === undefined) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.value = 0 as any;
+        this.value = 0 as T;
       }
-      (this.value as number) = ((this.value as number) + value) as number;
+      this.value = ((this.value as number) + value) as T;
     } else if (Array.isArray(value)) {
       if (!Array.isArray(this.value)) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.value = [] as any;
+        this.value = [] as T;
       }
       (this.value as T[]).push(...value);
     } else {
@@ -145,7 +143,7 @@ export class TraceNode {
     const spanRefs = this.metrics.toJSON.call({ map: this.metrics.spanRefs });
     const metricsRefs = Object.keys(spanRefs).length > 0 ? { metricRefs: spanRefs } : {};
     return {
-      ctx: cleanCtx as CleanCtx,
+      ctx: cleanCtx,
       invokations: this.invokations,
       ...metricsRefs,
     };

package/src/uri.ts

@@ -1,4 +1,5 @@
 import { exception2Result, Result } from "./result.js";
+import { getParamsResult, KeysParam, param } from "./utils/get-params-result.js";
 import { relativePath } from "./utils/relative-path.js";
 import { StripCommand, stripper } from "./utils/stripper.js";
 
@@ -6,30 +7,14 @@ type NullOrUndef = null | undefined;
 
 type OneKey<K extends string, V = string> = Record<K, V>;
 
-export type MsgFn = (...keys: string[]) => string;
+/** @deprecated use param from get-params-result */
+export const key = param;
+
 /*
   if KeyParam is a Object
      if the right side is a string, it is the default value
      if the right side is a !string | REQUIRED, it is required
 */
-class _REQUIRED {
-  readonly val = "REQUIRED";
-}
-class _OPTIONAL {
-  readonly val = "OPTIONAL";
-}
-
-interface _key {
-  readonly REQUIRED: _REQUIRED;
-  readonly OPTIONAL: _OPTIONAL;
-}
-
-export const key: _key = {
-  REQUIRED: new _REQUIRED(),
-  OPTIONAL: new _OPTIONAL(),
-};
-
-export type KeysParam = (string | MsgFn | Record<string, _REQUIRED | _OPTIONAL | unknown>)[];
 
 // type ReturnType<T extends (...args: KeysParam) => unknown> = T extends (...args: KeysParam) => infer R ? R : unknown;
 
@@ -272,56 +257,6 @@ function getParamResult(
   return Result.Ok(val);
 }
 
-function getParamsResult(
-  keys: KeysParam,
-  getParam: { getParam: (key: string) => string | undefined },
-): Result<Record<string, string>> {
-  const keyDef = keys.flat().reduce(
-    (acc, i) => {
-      if (typeof i === "string") {
-        acc.push({ key: i, def: undefined, isOptional: false });
-      } else if (typeof i === "object") {
-        acc.push(
-          ...Object.keys(i).map((k) => ({
-            key: k,
-            def: typeof i[k] === "string" ? i[k] : undefined,
-            isOptional: i[k] instanceof _OPTIONAL,
-          })),
-        );
-      }
-      return acc;
-    },
-    [] as { key: string; def?: string; isOptional: boolean }[],
-  );
-  //.filter((k) => typeof k === "string");
-  const msgFn =
-    keys.find((k) => typeof k === "function") ||
-    ((...keys: string[]): string => {
-      const msg = keys.join(",");
-      return `missing parameters: ${msg}`;
-    });
-  const errors: string[] = [];
-  const result: Record<string, string> = {};
-  for (const kd of keyDef) {
-    const val = getParam.getParam(kd.key);
-    if (val === undefined) {
-      if (typeof kd.def === "string") {
-        result[kd.key] = kd.def;
-      } else {
-        if (!kd.isOptional) {
-          errors.push(kd.key);
-        }
-      }
-    } else {
-      result[kd.key] = val;
-    }
-  }
-  if (errors.length) {
-    return Result.Err(msgFn(...errors));
-  }
-  return Result.Ok(result);
-}
-
 export class BuildURI implements URIInterface<BuildURI> {
   _url: MutableURL; // pathname needs this
   private constructor(url: MutableURL) {

package/src/utils/console-write-stream.ts

@@ -23,7 +23,7 @@ export class ConsoleWriterStreamDefaultWriter implements WritableStreamDefaultWr
     this.ready = Promise.resolve(undefined);
     this.closed = Promise.resolve(undefined);
   }
-  async write(chunk?: Uint8Array | undefined): Promise<void> {
+  write(chunk?: Uint8Array): Promise<void> {
     let strObj: string | { level: string } = this.decoder.decode(chunk).trimEnd();
     let output = "log";
     try {
@@ -46,6 +46,7 @@ export class ConsoleWriterStreamDefaultWriter implements WritableStreamDefaultWr
         // eslint-disable-next-line no-console
         console.log(strObj);
     }
+    return Promise.resolve();
   }
 }
 
@@ -56,8 +57,8 @@ export class ConsoleWriterStream implements WritableStream<Uint8Array> {
   abort(reason?: any): Promise<void> {
     throw new Error("Method not implemented.");
   }
-  async close(): Promise<void> {
-    return;
+  close(): Promise<void> {
+    return Promise.resolve();
   }
   getWriter(): WritableStreamDefaultWriter<Uint8Array> {
     if (this.locked) {

package/src/utils/fanout-write-stream.ts

@@ -24,7 +24,7 @@ export class FanoutWriteStream implements WritableStreamDefaultWriter<Uint8Array
     this._writers.map((w) => w.releaseLock());
   }
 
-  write(chunk?: Uint8Array | undefined): Promise<void> {
+  write(chunk?: Uint8Array): Promise<void> {
     return Promise.all(this._writers.map((w) => w.write(chunk))).then(() => {
       /* do nothing */
     });

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

@@ -0,0 +1,71 @@
+import { Result } from "../result.js";
+
+class _REQUIRED {
+  readonly val = "REQUIRED";
+}
+class _OPTIONAL {
+  readonly val = "OPTIONAL";
+}
+
+export interface Param {
+  readonly REQUIRED: _REQUIRED;
+  readonly OPTIONAL: _OPTIONAL;
+}
+
+export const param: Param = {
+  REQUIRED: new _REQUIRED(),
+  OPTIONAL: new _OPTIONAL(),
+};
+
+export type MsgFn = (...keys: string[]) => string;
+export type KeysParam = (string | MsgFn | Record<string, _REQUIRED | _OPTIONAL | number | string | boolean | undefined | null>)[];
+
+export function getParamsResult(
+  keys: KeysParam,
+  getParam: { getParam: (key: string) => string | undefined },
+): Result<Record<string, string>> {
+  const keyDef = keys.flat().reduce(
+    (acc, i) => {
+      if (typeof i === "string") {
+        acc.push({ key: i, def: undefined, isOptional: false });
+      } else if (typeof i === "object") {
+        acc.push(
+          ...Object.keys(i).map((k) => ({
+            key: k,
+            def: typeof i[k] === "string" ? i[k] : undefined,
+            isOptional: i[k] === param.OPTIONAL,
+          })),
+        );
+      }
+      return acc;
+    },
+    [] as { key: string; def?: string; isOptional: boolean }[],
+  );
+  //.filter((k) => typeof k === "string");
+  const msgFn =
+    keys.find((k) => typeof k === "function") ||
+    ((...keys: string[]): string => {
+      const msg = keys.join(",");
+      return `missing parameters: ${msg}`;
+    });
+  const errors: string[] = [];
+  const result: Record<string, string> = {};
+  for (const kd of keyDef) {
+    const val = getParam.getParam(kd.key);
+    if (val === undefined) {
+      if (typeof kd.def === "string") {
+        result[kd.key] = kd.def;
+      } else {
+        if (!kd.isOptional) {
+          errors.push(kd.key);
+        }
+      }
+    } else {
+      result[kd.key] = val;
+    }
+  }
+  if (errors.length) {
+    return Result.Err(msgFn(...errors));
+  }
+  return Result.Ok(result);
+}

package/src/utils/index.ts

@@ -4,3 +4,5 @@ export * from "./stream2string.js";
 export * from "./string2stream.js";
 export * from "./console-write-stream.js";
 export * from "./fanout-write-stream.js";
+export * from "./get-params-result.js";
+export * from "./stripper.js";

package/src/utils/rebuffer.ts

@@ -33,29 +33,35 @@ interface pumpState {
 }
 
 function pump(ps: pumpState, controller: ReadableStreamDefaultController<Uint8Array>, next: () => void): void {
-  ps.reader.read().then(({ done, value }) => {
-    if (done) {
-      if (ps.tmpLen > 0) {
-        controller.enqueue(reChunk(ps.tmp, ps.tmpLen).chunk);
+  ps.reader
+    .read()
+    .then(({ done, value }) => {
+      if (done) {
+        if (ps.tmpLen > 0) {
+          controller.enqueue(reChunk(ps.tmp, ps.tmpLen).chunk);
+        }
+        controller.close();
+        next();
+        return;
       }
-      controller.close();
-      next();
-      return;
-    }
-    if (ps.tmpLen + value.length > ps.chunkSize) {
-      ps.tmp.push(value);
-      const res = reChunk(ps.tmp, ps.chunkSize);
-      controller.enqueue(res.chunk);
-      ps.tmp = [res.rest];
-      ps.tmpLen = res.rest.length;
+      if (ps.tmpLen + value.length > ps.chunkSize) {
+        ps.tmp.push(value);
+        const res = reChunk(ps.tmp, ps.chunkSize);
+        controller.enqueue(res.chunk);
+        ps.tmp = [res.rest];
+        ps.tmpLen = res.rest.length;
+        next();
+        return;
+      } else if (value.length) {
+        ps.tmp.push(value);
+        ps.tmpLen += value.length;
+      }
+      pump(ps, controller, next);
+    })
+    .catch((err) => {
+      controller.error(err);
       next();
-      return;
-    } else if (value.length) {
-      ps.tmp.push(value);
-      ps.tmpLen += value.length;
-    }
-    pump(ps, controller, next);
-  });
+    });
 }
 
 export function rebuffer(a: ReadableStream<Uint8Array>, chunkSize: number): ReadableStream<Uint8Array> {

package/src/utils/relative-path.ts

@@ -38,7 +38,7 @@ export class Path {
     if (this.parts.includes(PartType.Root) && part === PartType.Root) {
       throw new Error("Cannot add absolute part to absolute path");
     }
-    const last = this.parts[this.parts.length - 1] as number;
+    const last = this.parts[this.parts.length - 1] as PartType;
     if (last & PartType.Slash && part === PartType.Slash) {
       return;
     }

package/src/utils/stream2string.ts

@@ -19,7 +19,7 @@ export async function stream2string(stream?: ReadableStream<Uint8Array> | null,
       rSize += read.value.length;
       res += block;
     } catch (err) {
-      return Promise.reject(err);
+      return Promise.reject(err as Error);
     }
   }
   return Promise.resolve(res);
@@ -40,7 +40,7 @@ export async function stream2uint8array(stream?: ReadableStream<Uint8Array> | nu
       }
       res = new Uint8Array([...res, ...value]);
     } catch (err) {
-      return Promise.reject(err);
+      return Promise.reject(err as Error);
     }
   }
   return Promise.resolve(res);

package/src/utils/stripper.ts

@@ -1,6 +1,6 @@
 export type StripCommand = string | RegExp;
 
-export function stripper<T extends unknown | ArrayLike<unknown>>(
+export function stripper<T extends ArrayLike<S> | S, S>(
   strip: StripCommand | StripCommand[],
   obj: T,
 ): T extends ArrayLike<unknown> ? Record<string, unknown>[] : Record<string, unknown> {
@@ -49,7 +49,7 @@ function localStripper<T>(path: string | undefined, restrips: RegExp[], obj: T):
       }
       if (typeof ret[key] === "object") {
         if (Array.isArray(ret[key])) {
-          ret[key] = ret[key].reduce((acc, v, i) => {
+          ret[key] = ret[key].reduce((acc: unknown[], v, i) => {
             const toDelete = matcher(key, `${nextPath}[${i}]`);
             if (!toDelete) {
               acc.push(localStripper(`${nextPath}[${i}]`, restrips, v));

package/src/version.ts

@@ -1,3 +1,3 @@
-export const VERSION = Object.keys({
+export const VERSION: string = Object.keys({
   __packageVersion__: "xxxx",
-})[0] as string;
+})[0];

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

@@ -29,7 +29,7 @@ export class WebFileService implements FileService {
     throw new Error("join-Method not implemented.");
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  relative(from: string, to?: string | undefined): string {
+  relative(from: string, to?: string): string {
     throw new Error("relative-Method not implemented.");
   }
   // eslint-disable-next-line @typescript-eslint/no-unused-vars

package/stripper-BpBUUZ9p.d.cts

@@ -0,0 +1,4 @@
+type StripCommand = string | RegExp;
+declare function stripper<T extends ArrayLike<S> | S, S>(strip: StripCommand | StripCommand[], obj: T): T extends ArrayLike<unknown> ? Record<string, unknown>[] : Record<string, unknown>;
+
+export { type StripCommand as S, stripper as s };

package/stripper-BpBUUZ9p.d.ts

@@ -0,0 +1,4 @@
+type StripCommand = string | RegExp;
+declare function stripper<T extends ArrayLike<S> | S, S>(strip: StripCommand | StripCommand[], obj: T): T extends ArrayLike<unknown> ? Record<string, unknown>[] : Record<string, unknown>;
+
+export { type StripCommand as S, stripper as s };

package/{sys-abstraction-Coxu8BjZ.d.cts → sys-abstraction-BRDT_TIU.d.cts}

@@ -1,3 +1,5 @@
+import { K as KeysParam, R as Result } from './get-params-result-Bhy5997x.cjs';
+
 interface NamedWritableStream {
     readonly name: string;
     readonly stream: WritableStream<Uint8Array>;
@@ -15,6 +17,7 @@ interface FileService {
     isAbsolute(fname: string): boolean;
 }
 
+type EnvTuple = ([string, string] | [string, string][] | Record<string, string> | Iterator<[string, string]>)[];
 interface EnvMap {
     get(key: string): string | undefined;
     set(key: string, value?: string): void;
@@ -36,6 +39,8 @@ interface OnSetItem {
 }
 interface Env extends EnvMap {
     onSet(fn: OnSetFn, ...filter: string[]): void;
+    gets(...kparams: KeysParam): Result<Record<string, string>>;
+    sets(...keys: EnvTuple): void;
 }
 type EnvFactoryFn = (opts: Partial<EnvFactoryOpts>) => EnvActions;
 declare function registerEnvAction(fn: EnvFactoryFn): () => void;
@@ -43,6 +48,8 @@ declare function envFactory(opts?: Partial<EnvFactoryOpts>): Env;
 declare class EnvImpl implements Env {
     readonly _map: EnvMap;
     constructor(map: EnvMap, opts?: Partial<EnvFactoryOpts>);
+    gets(...kparams: KeysParam): Result<Record<string, string>>;
+    sets(...keys: EnvTuple): void;
     _updatePresets(presetEnv?: Map<string, string>): void;
     _applyOnSet(onSet: OnSetItem[], key?: string, value?: string): void;
     readonly _onSet: OnSetItem[];
@@ -99,4 +106,4 @@ interface SysAbstraction {
     FileSystem(): FileService;
 }
 
-export { type Duration as D, type Env as E, type FileService as F, IDMode as I, type NamedWritableStream as N, type OnSetItem as O, RandomMode as R, type SystemService as S, Time as T, type VoidFunc as V, type SysAbstraction as a, TimeMode as b, String2TimeMode as c, type EnvMap as d, type EnvActions as e, type EnvFactoryOpts as f, type EnvFactoryFn as g, envFactory as h, EnvImpl as i, TimeUnits as j, registerEnvAction as r };
+export { type Duration as D, type Env as E, type FileService as F, IDMode as I, type NamedWritableStream as N, type OnSetItem as O, RandomMode as R, type SystemService as S, Time as T, type VoidFunc as V, type SysAbstraction as a, TimeMode as b, String2TimeMode as c, type EnvTuple as d, type EnvMap as e, type EnvActions as f, type EnvFactoryOpts as g, type EnvFactoryFn as h, envFactory as i, EnvImpl as j, TimeUnits as k, registerEnvAction as r };