Run prettier, add zed settings

18 files changed, 195 insertions, 234 deletions

diff --git a/u/fn/callable.ts b/u/fn/callable.ts
index fc6ea81..cfb7d00 100644
--- a/u/fn/callable.ts
+++ b/u/fn/callable.ts
@@ -15,8 +15,6 @@ export interface BiMapper<T, U, R> extends Callable {
   (t: T, u: U): R;
 }
 
-export interface SideEffect<T> extends Mapper<T, void> {
-}
+export interface SideEffect<T> extends Mapper<T, void> {}
 
-export interface BiSideEffect<T, U> extends BiMapper<T, U, void> {
-}
+export interface BiSideEffect<T, U> extends BiMapper<T, U, void> {}
diff --git a/u/leftpadesque/debug.ts b/u/leftpadesque/debug.ts
index a9da1f3..e50b2e0 100644
--- a/u/leftpadesque/debug.ts
+++ b/u/leftpadesque/debug.ts
@@ -6,6 +6,8 @@ const _env: "development" | "production" =
     : "development";
 export const isProd = () => _env === "production";
 
-const _debug = !isProd() || (_hasEnv &&
-  ["y", "t"].some((Deno.env.get("DEBUG") ?? "").toLowerCase().startsWith));
+const _debug =
+  !isProd() ||
+  (_hasEnv &&
+    ["y", "t"].some((Deno.env.get("DEBUG") ?? "").toLowerCase().startsWith));
 export const isDebug = () => _debug;
diff --git a/u/leftpadesque/prepend.ts b/u/leftpadesque/prepend.ts
index 9b77aff..0f1ce30 100644
--- a/u/leftpadesque/prepend.ts
+++ b/u/leftpadesque/prepend.ts
@@ -1,4 +1,5 @@
 export const prependWith = (arr: string[], prep: string) =>
-  Array(arr.length * 2).fill(0)
+  Array(arr.length * 2)
+    .fill(0)
     .map((_, i) => i % 2 === 0)
-    .map((isPrep, i) => isPrep ? prep : arr[i]);
+    .map((isPrep, i) => (isPrep ? prep : arr[i]));
diff --git a/u/process/env.ts b/u/process/env.ts
index 0e41b4f..c0d893c 100644
--- a/u/process/env.ts
+++ b/u/process/env.ts
@@ -1,17 +1,15 @@
 import { Either, type IEither } from "@emprespresso/pengueno";
 
 export const getRequiredEnv = <V extends string>(name: V): IEither<Error, V> =>
-  Either
-    .fromFailable<Error, V>(() => Deno.env.get(name) as V) // could throw when no permission.
-    .flatMap((v) =>
-      (v && Either.right(v)) ||
-      Either.left(
-        new Error(`environment variable "${name}" is required D:`),
-      )
+  Either.fromFailable<Error, V>(() => Deno.env.get(name) as V) // could throw when no permission.
+    .flatMap(
+      (v) =>
+        (v && Either.right(v)) ||
+        Either.left(new Error(`environment variable "${name}" is required D:`)),
     );
 
 type ObjectFromList<T extends ReadonlyArray<string>, V = string> = {
-  [K in (T extends ReadonlyArray<infer U> ? U : never)]: V;
+  [K in T extends ReadonlyArray<infer U> ? U : never]: V;
 };
 
 export const getRequiredEnvVars = <V extends string>(vars: ReadonlyArray<V>) =>
@@ -24,11 +22,12 @@ export const getRequiredEnvVars = <V extends string>(vars: ReadonlyArray<V>) =>
       ) => {
         const [envVar, eitherVal] = x;
         return acc.flatMap((args) => {
-          return eitherVal.mapRight((envValue) =>
-            ({
-              ...args,
-              [envVar]: envValue,
-            }) as ObjectFromList<typeof vars>
+          return eitherVal.mapRight(
+            (envValue) =>
+              ({
+                ...args,
+                [envVar]: envValue,
+              }) as ObjectFromList<typeof vars>,
           );
         });
       },
diff --git a/u/process/run.ts b/u/process/run.ts
index 4954438..8004f75 100644
--- a/u/process/run.ts
+++ b/u/process/run.ts
@@ -17,11 +17,12 @@ export const getStdout = <Trace>(
   c: ITraceable<Command, Trace>,
   options: Deno.CommandOptions = {},
 ): Promise<IEither<Error, string>> =>
-  c.bimap(TraceUtil.withFunctionTrace(getStdout))
+  c
+    .bimap(TraceUtil.withFunctionTrace(getStdout))
     .map((tCmd) => {
       const cmd = tCmd.get();
       tCmd.trace.trace(`:> im gonna run this command! ${cmd}`);
-      const [exec, ...args] = (typeof cmd === "string") ? cmd.split(" ") : cmd;
+      const [exec, ...args] = typeof cmd === "string" ? cmd.split(" ") : cmd;
       return new Deno.Command(exec, {
         args,
         stdout: "piped",
@@ -30,35 +31,33 @@ export const getStdout = <Trace>(
       }).output();
     })
     .map((tOut) =>
-      Either.fromFailableAsync<Error, Deno.CommandOutput>(tOut.get())
+      Either.fromFailableAsync<Error, Deno.CommandOutput>(tOut.get()),
     )
     .map(
       TraceUtil.promiseify((tEitherOut) =>
         tEitherOut.get().flatMap(({ code, stderr, stdout }) =>
-          Either
-            .fromFailable<Error, CommandOutputDecoded>(() => {
-              const stdoutText = new TextDecoder().decode(stdout);
-              const stderrText = new TextDecoder().decode(stderr);
-              return { code, stdoutText, stderrText };
-            })
+          Either.fromFailable<Error, CommandOutputDecoded>(() => {
+            const stdoutText = new TextDecoder().decode(stdout);
+            const stderrText = new TextDecoder().decode(stderr);
+            return { code, stdoutText, stderrText };
+          })
             .mapLeft((e) => {
               tEitherOut.trace.addTrace(LogLevel.ERROR).trace(`o.o wat ${e}`);
               return new Error(`${e}`);
             })
             .flatMap((decodedOutput): Either<Error, string> => {
               const { code, stdoutText, stderrText } = decodedOutput;
-              tEitherOut.trace.addTrace(LogLevel.DEBUG).trace(
-                `stderr hehehe ${stderrText}`,
-              );
+              tEitherOut.trace
+                .addTrace(LogLevel.DEBUG)
+                .trace(`stderr hehehe ${stderrText}`);
               if (code !== 0) {
-                const msg =
-                  `i weceived an exit code of ${code} i wanna zewoooo :<`;
+                const msg = `i weceived an exit code of ${code} i wanna zewoooo :<`;
                 tEitherOut.trace.addTrace(LogLevel.ERROR).trace(msg);
                 return Either.left(new Error(msg));
               }
               return Either.right(stdoutText);
-            })
-        )
+            }),
+        ),
       ),
     )
     .get();
diff --git a/u/process/validate_identifier.ts b/u/process/validate_identifier.ts
index 32952a6..4e93728 100644
--- a/u/process/validate_identifier.ts
+++ b/u/process/validate_identifier.ts
@@ -1,7 +1,7 @@
 import { Either, type IEither } from "@emprespresso/pengueno";
 
 export const validateIdentifier = (token: string) => {
-  return (/^[a-zA-Z0-9_\-:. \/]+$/).test(token) && !token.includes("..");
+  return /^[a-zA-Z0-9_\-:. \/]+$/.test(token) && !token.includes("..");
 };
 
 // ensure {@param obj} is a Record<string, string> with stuff that won't
@@ -12,13 +12,12 @@ export const validateExecutionEntries = <
   K extends symbol | number | string = symbol | number | string,
 >(
   obj: Record<K, T>,
-): IEither<
-  Array<InvalidEntry<K, T>>,
-  Record<string, string>
-> => {
-  const invalidEntries = <Array<InvalidEntry<K, T>>> Object.entries(obj).filter(
-    (e) => !e.every((x) => typeof x === "string" && validateIdentifier(x)),
+): IEither<Array<InvalidEntry<K, T>>, Record<string, string>> => {
+  const invalidEntries = <Array<InvalidEntry<K, T>>>(
+    Object.entries(obj).filter(
+      (e) => !e.every((x) => typeof x === "string" && validateIdentifier(x)),
+    )
   );
   if (invalidEntries.length > 0) return Either.left(invalidEntries);
-  return Either.right(<Record<string, string>> obj);
+  return Either.right(<Record<string, string>>obj);
 };
diff --git a/u/server/activity/fourohfour.ts b/u/server/activity/fourohfour.ts
index 6449abd..c09aef6 100644
--- a/u/server/activity/fourohfour.ts
+++ b/u/server/activity/fourohfour.ts
@@ -23,13 +23,9 @@ export interface IFourOhFourActivity {
 }
 
 export class FourOhFourActivityImpl implements IFourOhFourActivity {
-  public fourOhFour(
-    req: ITraceable<PenguenoRequest, ServerTrace>,
-  ) {
+  public fourOhFour(req: ITraceable<PenguenoRequest, ServerTrace>) {
     return req
-      .move(
-        new JsonResponse(req, randomFourOhFour(), { status: 404 }),
-      )
+      .move(new JsonResponse(req, randomFourOhFour(), { status: 404 }))
       .map((resp) => Promise.resolve(resp.get()))
       .get();
   }
diff --git a/u/server/activity/health.ts b/u/server/activity/health.ts
index 0f54a99..83be399 100644
--- a/u/server/activity/health.ts
+++ b/u/server/activity/health.ts
@@ -23,45 +23,47 @@ export interface IHealthCheckActivity {
 }
 
 const healthCheckMetric = Metric.fromName("Health");
-export interface HealthChecker extends
-  Mapper<
+export interface HealthChecker
+  extends Mapper<
     ITraceable<HealthCheckInput, ServerTrace>,
     Promise<IEither<Error, HealthCheckOutput>>
   > {}
 export class HealthCheckActivityImpl implements IHealthCheckActivity {
-  constructor(
-    private readonly check: HealthChecker,
-  ) {}
+  constructor(private readonly check: HealthChecker) {}
 
   public checkHealth(req: ITraceable<PenguenoRequest, ServerTrace>) {
     return req
       .bimap(TraceUtil.withFunctionTrace(this.checkHealth))
       .bimap(TraceUtil.withMetricTrace(healthCheckMetric))
       .flatMap((r) => r.move(HealthCheckInput.CHECK).map(this.check))
-      .peek(TraceUtil.promiseify((h) =>
-        h.get().fold((err) => {
-          if (err) {
-            h.trace.trace(healthCheckMetric.failure);
-            h.trace.addTrace(LogLevel.ERROR).trace(`${err}`);
-            return;
-          }
-          h.trace.trace(healthCheckMetric.success);
-        })
-      ))
-      .map(TraceUtil.promiseify((h) =>
-        h.get()
-          .mapBoth(
-            () => "oh no, i need to eat more vegetables (｡•́︿•̀｡)...",
-            () => "think im healthy!! (✿˘◡˘) ready to do work~",
-          )
-          .fold((errMsg, okMsg) =>
-            new JsonResponse(
-              req,
-              errMsg ?? okMsg,
-              { status: errMsg ? 500 : 200 },
+      .peek(
+        TraceUtil.promiseify((h) =>
+          h.get().fold((err) => {
+            if (err) {
+              h.trace.trace(healthCheckMetric.failure);
+              h.trace.addTrace(LogLevel.ERROR).trace(`${err}`);
+              return;
+            }
+            h.trace.trace(healthCheckMetric.success);
+          }),
+        ),
+      )
+      .map(
+        TraceUtil.promiseify((h) =>
+          h
+            .get()
+            .mapBoth(
+              () => "oh no, i need to eat more vegetables (｡•́︿•̀｡)...",
+              () => "think im healthy!! (✿˘◡˘) ready to do work~",
             )
-          )
-      ))
+            .fold(
+              (errMsg, okMsg) =>
+                new JsonResponse(req, errMsg ?? okMsg, {
+                  status: errMsg ? 500 : 200,
+                }),
+            ),
+        ),
+      )
       .get();
   }
 }
diff --git a/u/server/filter/json.ts b/u/server/filter/json.ts
index 4a2961e..79eabac 100644
--- a/u/server/filter/json.ts
+++ b/u/server/filter/json.ts
@@ -16,36 +16,39 @@ export interface JsonTransformer<R, ParsedJson = unknown> {
 }
 
 const ParseJsonMetric = Metric.fromName("JsonParse");
-export const jsonModel = <MessageT>(
-  jsonTransformer: JsonTransformer<MessageT>,
-): RequestFilter<MessageT> =>
-(r: ITraceable<PenguenoRequest, ServerTrace>) =>
-  r.bimap(TraceUtil.withMetricTrace(ParseJsonMetric))
-    .map((j) =>
-      Either.fromFailableAsync<Error, MessageT>(j.get().json())
-        .then((either) =>
-          either.mapLeft((errReason) => {
-            j.trace.addTrace(LogLevel.WARN).trace(`${errReason}`);
-            return new PenguenoError(
-              "seems to be invalid JSON (>//<) can you fix?",
-              400,
-            );
-          })
-        )
-    )
-    .peek(
-      TraceUtil.promiseify((traceableEither) =>
-        traceableEither.get().mapBoth(
-          () => traceableEither.trace.trace(ParseJsonMetric.failure),
-          () => traceableEither.trace.trace(ParseJsonMetric.success),
-        )
-      ),
-    )
-    .map(
-      TraceUtil.promiseify((traceableEitherJson) =>
-        traceableEitherJson.get()
-          .mapRight(traceableEitherJson.move)
-          .flatMap(jsonTransformer)
-      ),
-    )
-    .get();
+export const jsonModel =
+  <MessageT>(
+    jsonTransformer: JsonTransformer<MessageT>,
+  ): RequestFilter<MessageT> =>
+  (r: ITraceable<PenguenoRequest, ServerTrace>) =>
+    r
+      .bimap(TraceUtil.withMetricTrace(ParseJsonMetric))
+      .map((j) =>
+        Either.fromFailableAsync<Error, MessageT>(j.get().json()).then(
+          (either) =>
+            either.mapLeft((errReason) => {
+              j.trace.addTrace(LogLevel.WARN).trace(`${errReason}`);
+              return new PenguenoError(
+                "seems to be invalid JSON (>//<) can you fix?",
+                400,
+              );
+            }),
+        ),
+      )
+      .peek(
+        TraceUtil.promiseify((traceableEither) =>
+          traceableEither.get().mapBoth(
+            () => traceableEither.trace.trace(ParseJsonMetric.failure),
+            () => traceableEither.trace.trace(ParseJsonMetric.success),
+          ),
+        ),
+      )
+      .map(
+        TraceUtil.promiseify((traceableEitherJson) =>
+          traceableEitherJson
+            .get()
+            .mapRight(traceableEitherJson.move)
+            .flatMap(jsonTransformer),
+        ),
+      )
+      .get();
diff --git a/u/server/filter/method.ts b/u/server/filter/method.ts
index 6b0419d..9901c6f 100644
--- a/u/server/filter/method.ts
+++ b/u/server/filter/method.ts
@@ -20,22 +20,24 @@ type HttpMethod =
   | "TRACE"
   | "PATCH";
 
-export const requireMethod = (
-  methods: Array<HttpMethod>,
-): RequestFilter<HttpMethod> =>
-(req: ITraceable<PenguenoRequest, ServerTrace>) =>
-  req.bimap(TraceUtil.withFunctionTrace(requireMethod))
-    .move(Promise.resolve(req.get()))
-    .map(TraceUtil.promiseify((t) => {
-      const { method: _method } = t.get();
-      const method = <HttpMethod> _method;
-      if (!methods.includes(method)) {
-        const msg = "that's not how you pet me (⋟﹏⋞)~";
-        t.trace.addTrace(LogLevel.WARN).trace(msg);
-        return Either.left<PenguenoError, HttpMethod>(
-          new PenguenoError(msg, 405),
-        );
-      }
-      return Either.right<PenguenoError, HttpMethod>(method);
-    }))
-    .get();
+export const requireMethod =
+  (methods: Array<HttpMethod>): RequestFilter<HttpMethod> =>
+  (req: ITraceable<PenguenoRequest, ServerTrace>) =>
+    req
+      .bimap(TraceUtil.withFunctionTrace(requireMethod))
+      .move(Promise.resolve(req.get()))
+      .map(
+        TraceUtil.promiseify((t) => {
+          const { method: _method } = t.get();
+          const method = <HttpMethod>_method;
+          if (!methods.includes(method)) {
+            const msg = "that's not how you pet me (⋟﹏⋞)~";
+            t.trace.addTrace(LogLevel.WARN).trace(msg);
+            return Either.left<PenguenoError, HttpMethod>(
+              new PenguenoError(msg, 405),
+            );
+          }
+          return Either.right<PenguenoError, HttpMethod>(method);
+        }),
+      )
+      .get();
diff --git a/u/server/filter/mod.ts b/u/server/filter/mod.ts
index bbf37df..3b247fc 100644
--- a/u/server/filter/mod.ts
+++ b/u/server/filter/mod.ts
@@ -13,11 +13,13 @@ export enum ErrorSource {
 
 export class PenguenoError extends Error {
   public readonly source: ErrorSource;
-  constructor(message: string, public readonly status: number) {
+  constructor(
+    message: string,
+    public readonly status: number,
+  ) {
     super(message);
-    this.source = Math.floor(status / 100) === 4
-      ? ErrorSource.USER
-      : ErrorSource.SYSTEM;
+    this.source =
+      Math.floor(status / 100) === 4 ? ErrorSource.USER : ErrorSource.SYSTEM;
   }
 }
 
diff --git a/u/server/request.ts b/u/server/request.ts
index 7aa9917..480ee69 100644
--- a/u/server/request.ts
+++ b/u/server/request.ts
@@ -33,25 +33,16 @@ export class PenguenoRequest extends Request {
       ServerResponseTime,
       DeltaTime,
       Hai: penguenoGreeting(),
-    }).reduce((acc, [key, val]) => ({ ...acc, [key]: (val.toString()) }), {});
+    }).reduce((acc, [key, val]) => ({ ...acc, [key]: val.toString() }), {});
   }
 
-  public static from(
-    request: Request,
-  ): LogMetricTraceable<PenguenoRequest> {
+  public static from(request: Request): LogMetricTraceable<PenguenoRequest> {
     const id = crypto.randomUUID();
     const url = new URL(request.url);
     const { pathname } = url;
     const traceSupplier = () => `[${id} <- ${request.method}'d @ ${pathname}]`;
-    return LogMetricTraceable
-      .from(
-        new PenguenoRequest(
-          url,
-          { ...request },
-          id,
-          new Date(),
-        ),
-      )
-      .bimap((_request) => [_request.get(), traceSupplier]);
+    return LogMetricTraceable.from(
+      new PenguenoRequest(url, { ...request }, id, new Date()),
+    ).bimap((_request) => [_request.get(), traceSupplier]);
   }
 }
diff --git a/u/server/response.ts b/u/server/response.ts
index c21819a..9022fed 100644
--- a/u/server/response.ts
+++ b/u/server/response.ts
@@ -20,19 +20,19 @@ const getResponse = (
   return {
     ...opts,
     headers: {
-      ...(req.baseResponseHeaders()),
-      ...(opts?.headers),
-      "Content-Type": (opts?.headers?.["Content-Type"] ?? "text/plain") +
-        "; charset=utf-8",
+      ...req.baseResponseHeaders(),
+      ...opts?.headers,
+      "Content-Type":
+        (opts?.headers?.["Content-Type"] ?? "text/plain") + "; charset=utf-8",
     },
   };
 };
 
 const ResponseCodeMetrics = [1, 2, 3, 4, 5].map((x) =>
-  Metric.fromName(`response.${x}xx`)
+  Metric.fromName(`response.${x}xx`),
 );
 export const getResponseMetric = (status: number) => {
-  const index = (Math.floor(status / 100)) + 1;
+  const index = Math.floor(status / 100) + 1;
   return ResponseCodeMetrics[index] ?? ResponseCodeMetrics[5 - 1];
 };
 
@@ -67,7 +67,7 @@ export class JsonResponse extends PenguenoResponse {
       super(
         req,
         JSON.stringify(
-          e.fold((err, ok) => err ? ({ error: err! }) : ({ ok: ok! })),
+          e.fold((err, ok) => (err ? { error: err! } : { ok: ok! })),
         ),
         optsWithJsonContentType,
       );
@@ -76,7 +76,7 @@ export class JsonResponse extends PenguenoResponse {
     super(
       req,
       JSON.stringify(
-        (Math.floor(opts.status / 100) < 4) ? { ok: e } : { error: e },
+        Math.floor(opts.status / 100) < 4 ? { ok: e } : { error: e },
       ),
       optsWithJsonContentType,
     );
diff --git a/u/trace/itrace.ts b/u/trace/itrace.ts
index e6189d3..ed707c5 100644
--- a/u/trace/itrace.ts
+++ b/u/trace/itrace.ts
@@ -9,12 +9,7 @@ export interface ITrace<TraceWith> {
 }
 
 export type ITraceableTuple<T, TraceWith> = [T, BaseTraceWith | TraceWith];
-export type ITraceableMapper<
-  T,
-  U,
-  TraceWith,
-  W = ITraceable<T, TraceWith>,
-> = (
+export type ITraceableMapper<T, U, TraceWith, W = ITraceable<T, TraceWith>> = (
   w: W,
 ) => U;
 
@@ -22,9 +17,7 @@ export interface ITraceable<T, Trace = BaseTraceWith> {
   readonly trace: ITrace<Trace>;
   get: Supplier<T>;
   move: <U>(u: U) => ITraceable<U, Trace>;
-  map: <U>(
-    mapper: ITraceableMapper<T, U, Trace>,
-  ) => ITraceable<U, Trace>;
+  map: <U>(mapper: ITraceableMapper<T, U, Trace>) => ITraceable<U, Trace>;
   bimap: <U>(
     mapper: ITraceableMapper<
       T,
@@ -47,29 +40,19 @@ export class TraceableImpl<T, TraceWith> implements ITraceable<T, TraceWith> {
     public readonly trace: ITrace<TraceWith>,
   ) {}
 
-  public map<U>(
-    mapper: ITraceableMapper<T, U, TraceWith>,
-  ) {
+  public map<U>(mapper: ITraceableMapper<T, U, TraceWith>) {
     const result = mapper(this);
     return new TraceableImpl(result, this.trace);
   }
 
   public flatMap<U>(
-    mapper: ITraceableMapper<
-      T,
-      ITraceable<U, TraceWith>,
-      TraceWith
-    >,
+    mapper: ITraceableMapper<T, ITraceable<U, TraceWith>, TraceWith>,
   ): ITraceable<U, TraceWith> {
     return mapper(this);
   }
 
   public flatMapAsync<U>(
-    mapper: ITraceableMapper<
-      T,
-      Promise<ITraceable<U, TraceWith>>,
-      TraceWith
-    >,
+    mapper: ITraceableMapper<T, Promise<ITraceable<U, TraceWith>>, TraceWith>,
   ): ITraceable<Promise<U>, TraceWith> {
     return new TraceableImpl(
       mapper(this).then((t) => t.get()),
diff --git a/u/trace/logger.ts b/u/trace/logger.ts
index a5739c8..5890545 100644
--- a/u/trace/logger.ts
+++ b/u/trace/logger.ts
@@ -26,7 +26,7 @@ const logLevelOrder: Array<LogLevel> = [
   LogLevel.ERROR,
 ];
 export const isLogLevel = (l: string): l is LogLevel =>
-  logLevelOrder.some((level) => <string> level === l);
+  logLevelOrder.some((level) => <string>level === l);
 
 const defaultAllowedLevels = () =>
   [
@@ -62,11 +62,11 @@ export class LogTrace implements ITrace<LogTraceSupplier> {
   constructor(
     private readonly logger: ILogger = LoggerImpl,
     private readonly traces: Array<LogTraceSupplier> = [defaultTrace],
-    private readonly allowedLevels: Supplier<Array<LogLevel>> =
-      defaultAllowedLevels,
+    private readonly allowedLevels: Supplier<
+      Array<LogLevel>
+    > = defaultAllowedLevels,
     private readonly defaultLevel: LogLevel = LogLevel.INFO,
-  ) {
-  }
+  ) {}
 
   public addTrace(trace: LogTraceSupplier): ITrace<LogTraceSupplier> {
     return new LogTrace(
@@ -95,10 +95,7 @@ export class LogTrace implements ITrace<LogTraceSupplier> {
             level: Math.max(logLevelOrder.indexOf(val), acc.level),
           };
         }
-        const prefix = [
-          acc.line,
-          val,
-        ].join(" ");
+        const prefix = [acc.line, val].join(" ");
         return { ...acc, prefix };
       },
       { line: "", level: -1 },
diff --git a/u/trace/metrics.ts b/u/trace/metrics.ts
index 4ddde06..f57b725 100644
--- a/u/trace/metrics.ts
+++ b/u/trace/metrics.ts
@@ -32,8 +32,10 @@ export interface IEmittableMetric {
 }
 
 export class EmittableMetric implements IEmittableMetric {
-  constructor(public readonly name: string, public readonly unit: Unit) {
-  }
+  constructor(
+    public readonly name: string,
+    public readonly unit: Unit,
+  ) {}
 
   public withValue(value: number): MetricValue {
     return {
@@ -105,16 +107,16 @@ export class MetricsTrace implements ITrace<MetricsTraceSupplier> {
       return this;
     }
 
-    const foundMetricValues = this.tracing.flatMap((
-      [tracing, startedTracing],
-    ) =>
-      [tracing, ...tracing.children()]
-        .filter((_tracing) => metric === _tracing)
-        .flatMap((metric) => [
-          this.addMetric(metric, startedTracing),
-          this.addMetric(tracing, startedTracing),
-        ])
-    ).flatMap((values) => values);
+    const foundMetricValues = this.tracing
+      .flatMap(([tracing, startedTracing]) =>
+        [tracing, ...tracing.children()]
+          .filter((_tracing) => metric === _tracing)
+          .flatMap((metric) => [
+            this.addMetric(metric, startedTracing),
+            this.addMetric(tracing, startedTracing),
+          ]),
+      )
+      .flatMap((values) => values);
 
     if (foundMetricValues.length === 0) {
       return this._nowTracing(metric);
diff --git a/u/trace/trace.ts b/u/trace/trace.ts
index e942066..03605c2 100644
--- a/u/trace/trace.ts
+++ b/u/trace/trace.ts
@@ -19,11 +19,13 @@ export class LogTraceable<T> extends TraceableImpl<T, LogTraceSupplier> {
 
 const getEmbeddedMetricConsumer =
   (logTrace: LogTrace) => (metrics: Array<MetricValue>) =>
-    logTrace.addTrace("<metrics>").trace(
-      JSON.stringify(metrics, null, 2) + "</metrics>",
-    );
-export class EmbeddedMetricsTraceable<T>
-  extends TraceableImpl<T, MetricsTraceSupplier> {
+    logTrace
+      .addTrace("<metrics>")
+      .trace(JSON.stringify(metrics, null, 2) + "</metrics>");
+export class EmbeddedMetricsTraceable<T> extends TraceableImpl<
+  T,
+  MetricsTraceSupplier
+> {
   public static MetricsTrace = new MetricsTrace(
     getEmbeddedMetricConsumer(LogTraceable.LogTrace),
   );
@@ -66,17 +68,16 @@ export class LogMetricTrace implements ITrace<LogMetricTraceSupplier> {
   }
 }
 
-export class LogMetricTraceable<T>
-  extends TraceableImpl<T, MetricsTraceSupplier | LogTraceSupplier> {
+export class LogMetricTraceable<T> extends TraceableImpl<
+  T,
+  MetricsTraceSupplier | LogTraceSupplier
+> {
   public static LogMetricTrace = new LogMetricTrace(
     LogTraceable.LogTrace,
     EmbeddedMetricsTraceable.MetricsTrace,
   );
 
   static from<T>(t: T) {
-    return new LogMetricTraceable(
-      t,
-      LogMetricTraceable.LogMetricTrace,
-    );
+    return new LogMetricTraceable(t, LogMetricTraceable.LogMetricTrace);
   }
 }
diff --git a/u/trace/util.ts b/u/trace/util.ts
index 302c8e4..3f9e5b8 100644
--- a/u/trace/util.ts
+++ b/u/trace/util.ts
@@ -9,41 +9,25 @@ import type {
 export class TraceUtil {
   static withTrace<T, Trace>(
     trace: string,
-  ): ITraceableMapper<
-    T,
-    ITraceableTuple<T, Trace | Array<Trace>>,
-    Trace
-  > {
+  ): ITraceableMapper<T, ITraceableTuple<T, Trace | Array<Trace>>, Trace> {
     return (t) => [t.get(), `[${trace}]`];
   }
 
   static withMetricTrace<T, Trace extends MetricsTraceSupplier>(
     metric: IMetric,
-  ): ITraceableMapper<
-    T,
-    ITraceableTuple<T, Trace | Array<Trace>>,
-    Trace
-  > {
+  ): ITraceableMapper<T, ITraceableTuple<T, Trace | Array<Trace>>, Trace> {
     return (t) => [t.get(), metric as Trace];
   }
 
   static withFunctionTrace<F extends Callable, T, Trace>(
     f: F,
-  ): ITraceableMapper<
-    T,
-    ITraceableTuple<T, Trace | Array<Trace>>,
-    Trace
-  > {
+  ): ITraceableMapper<T, ITraceableTuple<T, Trace | Array<Trace>>, Trace> {
     return TraceUtil.withTrace(f.name);
   }
 
   static withClassTrace<C extends object, T, Trace>(
     c: C,
-  ): ITraceableMapper<
-    T,
-    ITraceableTuple<T, Trace | Array<Trace>>,
-    Trace
-  > {
+  ): ITraceableMapper<T, ITraceableTuple<T, Trace | Array<Trace>>, Trace> {
     return TraceUtil.withTrace(c.constructor.name);
   }
 
@@ -51,8 +35,8 @@ export class TraceUtil {
     mapper: ITraceableMapper<T, U, Trace>,
   ): ITraceableMapper<Promise<T>, Promise<U>, Trace> {
     return (traceablePromise) =>
-      traceablePromise.flatMapAsync(async (t) =>
-        t.move(await t.get()).map(mapper)
-      ).get();
+      traceablePromise
+        .flatMapAsync(async (t) => t.move(await t.get()).map(mapper))
+        .get();
   }
 }