Run prettier, add zed settings

32 files changed, 395 insertions, 368 deletions

diff --git a/.ci/ci.ts b/.ci/ci.ts
index 7c96b80..0b8e124 100644
--- a/.ci/ci.ts
+++ b/.ci/ci.ts
@@ -37,10 +37,7 @@ const getPipeline = () => {
     parallelJobs: [baseCiPackageBuild],
   });
 
-  const subPackages = [
-    "worker",
-    "hooks",
-  ].map((_package) => ({
+  const subPackages = ["worker", "hooks"].map((_package) => ({
     type: "build_docker_image",
     arguments: {
       ...commonBuildArgs,
@@ -74,7 +71,7 @@ const getPipeline = () => {
     },
   };
   [fetchAnsibleCode, thenDeploy].forEach((deploymentStage) =>
-    gitHookPipeline.addStage({ parallelJobs: [deploymentStage] })
+    gitHookPipeline.addStage({ parallelJobs: [deploymentStage] }),
   );
 
   return gitHookPipeline.build();
diff --git a/.zed/settings.json b/.zed/settings.json
new file mode 100644
index 0000000..5d2dc7a
--- /dev/null
+++ b/.zed/settings.json
@@ -0,0 +1,21 @@
+{
+  "lsp": {
+    "deno": {
+      "settings": {
+        "deno": {
+          "enable": true
+        }
+      }
+    }
+  },
+  "languages": {
+    "TypeScript": {
+      "language_servers": ["deno"],
+      "formatter": "prettier"
+    },
+    "TSX": {
+      "language_servers": ["deno"],
+      "formatter": "prettier"
+    }
+  }
+}
diff --git a/README.md b/README.md
index 5a8bffc..ab593af 100644
--- a/README.md
+++ b/README.md
@@ -8,4 +8,3 @@ this is my ci server, built on top of [laminar](https://laminar.ohwg.net/docs.ht
 2. add a `.ci/ci.json` with `{"worfklow": "<path_to_executable>"}`.
 3. push your code to src.liz.coffee.
 4. watch the magic happen!
-
diff --git a/deno.json b/deno.json
index 66bfe32..50ebd48 100644
--- a/deno.json
+++ b/deno.json
@@ -1,3 +1,3 @@
 {
-    "workspace": ["./model", "./u", "./worker", "./hooks"]
+  "workspace": ["./model", "./u", "./worker", "./hooks"]
 }
diff --git a/hooks/server/ci.ts b/hooks/server/ci.ts
index 8f06124..4f0d7ba 100644
--- a/hooks/server/ci.ts
+++ b/hooks/server/ci.ts
@@ -24,15 +24,16 @@ export class CiHookServer {
     healthCheck: HealthChecker = _healthCheck,
     jobQueuer: IJobQueuer<ITraceable<Job, ServerTrace>> = new LaminarJobQueuer(
       getRequiredEnv("LAMINAR_URL").fold((err, val) =>
-        err ? "https://ci.liz.coffee" : val
+        err ? "https://ci.liz.coffee" : val,
       ),
     ),
-    private readonly healthCheckActivity: IHealthCheckActivity =
-      new HealthCheckActivityImpl(healthCheck),
-    private readonly jobHookActivity: IJobHookActivity =
-      new JobHookActivityImpl(jobQueuer),
-    private readonly fourOhFourActivity: IFourOhFourActivity =
-      new FourOhFourActivityImpl(),
+    private readonly healthCheckActivity: IHealthCheckActivity = new HealthCheckActivityImpl(
+      healthCheck,
+    ),
+    private readonly jobHookActivity: IJobHookActivity = new JobHookActivityImpl(
+      jobQueuer,
+    ),
+    private readonly fourOhFourActivity: IFourOhFourActivity = new FourOhFourActivityImpl(),
   ) {}
 
   private route(req: ITraceable<PenguenoRequest, ServerTrace>) {
diff --git a/hooks/server/health.ts b/hooks/server/health.ts
index 2f67aa4..1acc074 100644
--- a/hooks/server/health.ts
+++ b/hooks/server/health.ts
@@ -13,13 +13,16 @@ import {
 export const healthCheck: HealthChecker = (
   input: ITraceable<HealthCheckInput, ServerTrace>,
 ): Promise<IEither<Error, HealthCheckOutput>> =>
-  input.bimap(TraceUtil.withFunctionTrace(healthCheck))
+  input
+    .bimap(TraceUtil.withFunctionTrace(healthCheck))
     .move(getRequiredEnv("LAMINAR_HOST"))
     // ensure LAMINAR_HOST is propagated to getStdout for other procedures
     .map((e) => e.get().moveRight(["laminarc", "show-jobs"]))
     .map((i) =>
-      i.get().mapRight(i.move.apply)
+      i
+        .get()
+        .mapRight(i.move.apply)
         .flatMapAsync(getStdout.apply)
-        .then((gotJobs) => gotJobs.moveRight(HealthCheckOutput.YAASSSLAYQUEEN))
+        .then((gotJobs) => gotJobs.moveRight(HealthCheckOutput.YAASSSLAYQUEEN)),
     )
     .get();
diff --git a/hooks/server/job/activity.ts b/hooks/server/job/activity.ts
index 14ea459..173cedf 100644
--- a/hooks/server/job/activity.ts
+++ b/hooks/server/job/activity.ts
@@ -22,7 +22,8 @@ const wellFormedJobMetric = Metric.fromName("Job.WellFormed");
 const jobJsonTransformer = (
   j: ITraceable<unknown, ServerTrace>,
 ): IEither<PenguenoError, Job> =>
-  j.bimap(TraceUtil.withMetricTrace(wellFormedJobMetric))
+  j
+    .bimap(TraceUtil.withMetricTrace(wellFormedJobMetric))
     .map((tJson) => {
       if (!isJob(tJson) || !validateExecutionEntries(tJson)) {
         const err = "seems like a pwetty mawfomed job \\(-.-)/";
@@ -33,10 +34,12 @@ const jobJsonTransformer = (
     })
     .peek((tJob) =>
       tJob.trace.trace(
-        tJob.get().fold((err) =>
-          err ? wellFormedJobMetric.failure : wellFormedJobMetric.success
-        ),
-      )
+        tJob
+          .get()
+          .fold((err) =>
+            err ? wellFormedJobMetric.failure : wellFormedJobMetric.success,
+          ),
+      ),
     )
     .get();
 
@@ -51,18 +54,19 @@ export class JobHookActivityImpl implements IJobHookActivity {
   ) {}
 
   private trace(r: ITraceable<PenguenoRequest, ServerTrace>) {
-    return r.bimap(TraceUtil.withClassTrace(this))
-      .bimap(
-        TraceUtil.withMetricTrace(jobHookRequestMetric),
-      );
+    return r
+      .bimap(TraceUtil.withClassTrace(this))
+      .bimap(TraceUtil.withMetricTrace(jobHookRequestMetric));
   }
 
   public processHook(r: ITraceable<PenguenoRequest, ServerTrace>) {
-    return this.trace(r).map(jsonModel(jobJsonTransformer))
+    return this.trace(r)
+      .map(jsonModel(jobJsonTransformer))
       .map(async (tEitherJobJson) => {
         const eitherJob = await tEitherJobJson.get();
         return eitherJob.flatMapAsync(async (job) => {
-          const eitherQueued = await tEitherJobJson.move(job)
+          const eitherQueued = await tEitherJobJson
+            .move(job)
             .map(this.queuer.queue)
             .get();
           return eitherQueued.mapLeft((e) => new PenguenoError(e.message, 500));
@@ -70,29 +74,35 @@ export class JobHookActivityImpl implements IJobHookActivity {
       })
       .peek(
         TraceUtil.promiseify((tJob) =>
-          tJob.get().fold(
-            (err: PenguenoError | undefined, _val: string | undefined) => {
-              if (!err) {
-                tJob.trace.trace(jobHookRequestMetric.success);
-                tJob.trace.trace(`all queued up and weady to go :D !! ${_val}`);
-                return;
-              }
-              tJob.trace.trace(
-                err.source === ErrorSource.SYSTEM
-                  ? jobHookRequestMetric.failure
-                  : jobHookRequestMetric.warn,
-              );
-              tJob.trace.addTrace(err.source).trace(`${err}`);
-            },
-          )
+          tJob
+            .get()
+            .fold(
+              (err: PenguenoError | undefined, _val: string | undefined) => {
+                if (!err) {
+                  tJob.trace.trace(jobHookRequestMetric.success);
+                  tJob.trace.trace(
+                    `all queued up and weady to go :D !! ${_val}`,
+                  );
+                  return;
+                }
+                tJob.trace.trace(
+                  err.source === ErrorSource.SYSTEM
+                    ? jobHookRequestMetric.failure
+                    : jobHookRequestMetric.warn,
+                );
+                tJob.trace.addTrace(err.source).trace(`${err}`);
+              },
+            ),
         ),
       )
       .map(
-        TraceUtil.promiseify((tEitherQueuedJob) =>
-          new JsonResponse(r, tEitherQueuedJob.get(), {
-            status: tEitherQueuedJob.get()
-              .fold(({ status }, _val) => _val ? 200 : status),
-          })
+        TraceUtil.promiseify(
+          (tEitherQueuedJob) =>
+            new JsonResponse(r, tEitherQueuedJob.get(), {
+              status: tEitherQueuedJob
+                .get()
+                .fold(({ status }, _val) => (_val ? 200 : status)),
+            }),
         ),
       )
       .get();
diff --git a/hooks/server/job/queuer.ts b/hooks/server/job/queuer.ts
index 6094183..069cca4 100644
--- a/hooks/server/job/queuer.ts
+++ b/hooks/server/job/queuer.ts
@@ -18,15 +18,14 @@ export interface IJobQueuer<TJob> {
 }
 
 export class LaminarJobQueuer
-  implements IJobQueuer<ITraceable<Job, ServerTrace>> {
-  constructor(
-    private readonly queuePositionPrefix: string,
-  ) {}
+  implements IJobQueuer<ITraceable<Job, ServerTrace>>
+{
+  constructor(private readonly queuePositionPrefix: string) {}
 
   private static GetJobTypeTrace = (jobType: string) =>
     `LaminarJobQueue.Queue.${jobType}`;
   private static JobTypeMetrics = memoize((jobType: string) =>
-    Metric.fromName(LaminarJobQueuer.GetJobTypeTrace(jobType))
+    Metric.fromName(LaminarJobQueuer.GetJobTypeTrace(jobType)),
   );
 
   public queue(j: ITraceable<Job, ServerTrace>) {
@@ -50,29 +49,38 @@ export class LaminarJobQueuer
       .peek((c) =>
         c.trace.trace(
           `im so excited to see how this queue job will end!! (>ᴗ<): ${c.get().toString()}`,
-        )
+        ),
       )
       .map(getStdout)
       .peek(
         TraceUtil.promiseify((q) =>
           q.trace.trace(
-            q.get().fold((err, _val) => err ? metric.failure : metric.success),
-          )
+            q
+              .get()
+              .fold((err, _val) => (err ? metric.failure : metric.success)),
+          ),
         ),
       )
-      .map(TraceUtil.promiseify((q) =>
-        q.get().mapRight((stdout) => {
-          q.trace.addTrace(LogLevel.DEBUG).trace(`stdout ${stdout}`);
-          const [jobName, jobId] = stdout.split(":");
-          const jobUrl = `${this.queuePositionPrefix}/jobs/${jobName}/${jobId}`;
+      .map(
+        TraceUtil.promiseify((q) =>
+          q
+            .get()
+            .mapRight((stdout) => {
+              q.trace.addTrace(LogLevel.DEBUG).trace(`stdout ${stdout}`);
+              const [jobName, jobId] = stdout.split(":");
+              const jobUrl = `${this.queuePositionPrefix}/jobs/${jobName}/${jobId}`;
 
-          q.trace.trace(`all queued up and weady to go~ (˘ω˘) => ${jobUrl}`);
-          return jobUrl;
-        }).mapLeft((err) => {
-          q.trace.addTrace(LogLevel.ERROR).trace(err.toString());
-          return err;
-        })
-      ))
+              q.trace.trace(
+                `all queued up and weady to go~ (˘ω˘) => ${jobUrl}`,
+              );
+              return jobUrl;
+            })
+            .mapLeft((err) => {
+              q.trace.addTrace(LogLevel.ERROR).trace(err.toString());
+              return err;
+            }),
+        ),
+      )
       .get();
   }
 }
diff --git a/model/job.ts b/model/job.ts
index a3b52dd..52386eb 100644
--- a/model/job.ts
+++ b/model/job.ts
@@ -6,8 +6,14 @@ export interface Job {
   readonly arguments: JobArgT;
 }
 export const isJob = (j: unknown): j is Job =>
-  !!(isObject(j) && "arguments" in j && isObject(j.arguments) &&
-    "type" in j && typeof j.type === "string" && j);
+  !!(
+    isObject(j) &&
+    "arguments" in j &&
+    isObject(j.arguments) &&
+    "type" in j &&
+    typeof j.type === "string" &&
+    j
+  );
 
 export interface FetchCodeJobProps extends JobArgT {
   readonly remoteUrl: string;
diff --git a/model/pipeline.ts b/model/pipeline.ts
index b0db1b7..d7b6435 100644
--- a/model/pipeline.ts
+++ b/model/pipeline.ts
@@ -5,7 +5,9 @@ export interface PipelineStage {
   readonly parallelJobs: Array<Job>;
 }
 export const isPipelineStage = (t: unknown): t is PipelineStage =>
-  isObject(t) && "parallelJobs" in t && Array.isArray(t.parallelJobs) &&
+  isObject(t) &&
+  "parallelJobs" in t &&
+  Array.isArray(t.parallelJobs) &&
   t.parallelJobs.every((j) => isJob(j));
 
 export interface Pipeline {
@@ -13,7 +15,9 @@ export interface Pipeline {
   serialize(): string;
 }
 export const isPipeline = (t: unknown): t is Pipeline =>
-  isObject(t) && "serialJobs" in t && Array.isArray(t.serialJobs) &&
+  isObject(t) &&
+  "serialJobs" in t &&
+  Array.isArray(t.serialJobs) &&
   t.serialJobs.every((p) => isPipelineStage(p));
 
 export interface PipelineBuilder {
@@ -29,15 +33,13 @@ export class PipelineImpl implements Pipeline {
   }
 
   public static from(s: string): IEither<Error, Pipeline> {
-    return Either.fromFailable<Error, unknown>(() => JSON.parse(s)).flatMap<
-      Pipeline
-    >((
-      eitherPipelineJson,
-    ) =>
-      isPipeline(eitherPipelineJson)
-        ? Either.right(eitherPipelineJson)
-        : Either.left(new Error("oh noes D: its a bad pipewine :(("))
-    ).mapRight((pipeline) => new PipelineImpl(pipeline.serialJobs));
+    return Either.fromFailable<Error, unknown>(() => JSON.parse(s))
+      .flatMap<Pipeline>((eitherPipelineJson) =>
+        isPipeline(eitherPipelineJson)
+          ? Either.right(eitherPipelineJson)
+          : Either.left(new Error("oh noes D: its a bad pipewine :((")),
+      )
+      .mapRight((pipeline) => new PipelineImpl(pipeline.serialJobs));
   }
 }
 
@@ -64,7 +66,7 @@ export class DefaultGitHookPipelineBuilder extends BasePipelineBuilder {
 
     this.addStage({
       parallelJobs: [
-        <FetchCodeJob> {
+        <FetchCodeJob>{
           type: "fetch_code",
           arguments: {
             remoteUrl,
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();
   }
 }
diff --git a/worker/deno.json b/worker/deno.json
index 77c65de..90f50c9 100644
--- a/worker/deno.json
+++ b/worker/deno.json
@@ -1,4 +1,4 @@
 {
-    "name": "@emprespresso/ci-worker",
-    "exports": "./mod.ts"
+  "name": "@emprespresso/ci-worker",
+  "exports": "./mod.ts"
 }
diff --git a/worker/executor/job.ts b/worker/executor/job.ts
index 76f0e0c..ca7feed 100644
--- a/worker/executor/job.ts
+++ b/worker/executor/job.ts
@@ -12,31 +12,31 @@ import type { Job } from "@emprespresso/ci-model";
 
 const jobTypeMetric = memoize((type: string) => Metric.fromName(`run.${type}`));
 export const executeJob = (tJob: ITraceable<Job, LogMetricTraceSupplier>) =>
-  tJob.bimap(TraceUtil.withMetricTrace(jobTypeMetric(tJob.get().type)))
+  tJob
+    .bimap(TraceUtil.withMetricTrace(jobTypeMetric(tJob.get().type)))
     .peek((tJob) =>
-      tJob.trace.trace(
-        `let's do this little job ok!! ${tJob.get()}`,
-      )
+      tJob.trace.trace(`let's do this little job ok!! ${tJob.get()}`),
     )
     .map((tJob) =>
       validateExecutionEntries(tJob.get().arguments)
         .mapLeft((badEntries) => {
-          tJob.trace.addTrace(LogLevel.ERROR).trace(
-            badEntries.toString(),
-          );
+          tJob.trace.addTrace(LogLevel.ERROR).trace(badEntries.toString());
           return new Error("invalid job arguments");
         })
         .flatMapAsync((args) =>
-          getStdout(tJob.move(tJob.get().type), { env: args })
-        )
+          getStdout(tJob.move(tJob.get().type), { env: args }),
+        ),
     )
     .peek(
       TraceUtil.promiseify((q) =>
         q.trace.trace(
-          q.get().fold((err, _val) =>
-            jobTypeMetric(tJob.get().type)[err ? "failure" : "success"]
-          ),
-        )
+          q
+            .get()
+            .fold(
+              (err, _val) =>
+                jobTypeMetric(tJob.get().type)[err ? "failure" : "success"],
+            ),
+        ),
       ),
     )
     .get();
diff --git a/worker/executor/pipeline.ts b/worker/executor/pipeline.ts
index a1aa7c3..c8423b1 100644
--- a/worker/executor/pipeline.ts
+++ b/worker/executor/pipeline.ts
@@ -14,7 +14,8 @@ export const executePipeline = (
   tPipeline: ITraceable<Pipeline, LogMetricTraceSupplier>,
   baseEnv?: JobArgT,
 ): Promise<IEither<Error, void>> =>
-  tPipeline.bimap(TraceUtil.withFunctionTrace(executePipeline))
+  tPipeline
+    .bimap(TraceUtil.withFunctionTrace(executePipeline))
     .bimap(TraceUtil.withMetricTrace(pipelinesMetric))
     .map(async (tJobs): Promise<IEither<Error, void>> => {
       for (const [i, serialStage] of tJobs.get().serialJobs.entries()) {
@@ -23,22 +24,26 @@ export const executePipeline = (
         );
         const jobResults = await Promise.all(
           serialStage.parallelJobs.map((job) =>
-            tJobs.bimap((_) => [job, `stage ${i}`])
-              .map((tJob) =>
-                <Job> ({
-                  ...tJob.get(),
-                  arguments: { ...baseEnv, ...tJob.get().arguments },
-                })
+            tJobs
+              .bimap((_) => [job, `stage ${i}`])
+              .map(
+                (tJob) =>
+                  <Job>{
+                    ...tJob.get(),
+                    arguments: { ...baseEnv, ...tJob.get().arguments },
+                  },
               )
               .map(executeJob)
               .peek(
                 TraceUtil.promiseify((tEitherJobOutput) =>
-                  tEitherJobOutput.get().mapRight((stdout) =>
-                    tEitherJobOutput.trace.addTrace("STDOUT").trace(stdout)
-                  )
+                  tEitherJobOutput
+                    .get()
+                    .mapRight((stdout) =>
+                      tEitherJobOutput.trace.addTrace("STDOUT").trace(stdout),
+                    ),
                 ),
               )
-              .get()
+              .get(),
           ),
         );
         const failures = jobResults.filter((e) => e.fold((err) => !!err));
diff --git a/worker/secret/bitwarden.ts b/worker/secret/bitwarden.ts
index 0172a1b..7145f49 100644
--- a/worker/secret/bitwarden.ts
+++ b/worker/secret/bitwarden.ts
@@ -17,24 +17,27 @@ export class Bitwarden implements IVault<TClient, TKey, TItemId> {
   constructor(private readonly config: BitwardenConfig) {}
 
   public unlock(client: TClient) {
-    return client.move(this.config)
+    return client
+      .move(this.config)
       .bimap(TraceUtil.withMetricTrace(Bitwarden.loginMetric))
       .flatMap((tConfig) =>
-        tConfig.move(`bw config server ${tConfig.get().server}`).map(getStdout)
+        tConfig.move(`bw config server ${tConfig.get().server}`).map(getStdout),
       )
       .map(async (tEitherWithConfig) => {
         const eitherWithConfig = await tEitherWithConfig.get();
         tEitherWithConfig.trace.trace("logging in~ ^.^");
         return eitherWithConfig.flatMapAsync((_) =>
-          tEitherWithConfig.move("bw login --apikey --quiet").map(getStdout)
-            .get()
+          tEitherWithConfig
+            .move("bw login --apikey --quiet")
+            .map(getStdout)
+            .get(),
         );
       })
       .peek(async (tEitherWithAuthd) => {
         const eitherWithAuthd = await tEitherWithAuthd.get();
         return tEitherWithAuthd.trace.trace(
-          eitherWithAuthd.fold((err, _val) =>
-            Bitwarden.loginMetric[err ? "failure" : "success"]
+          eitherWithAuthd.fold(
+            (err, _val) => Bitwarden.loginMetric[err ? "failure" : "success"],
           ),
         );
       })
@@ -42,16 +45,18 @@ export class Bitwarden implements IVault<TClient, TKey, TItemId> {
         const eitherWithAuthd = await tEitherWithAuthd.get();
         tEitherWithAuthd.trace.trace("unlocking the secret vault~ (◕ᴗ◕✿)");
         return eitherWithAuthd.flatMapAsync((_) =>
-          tEitherWithAuthd.move("bw unlock --passwordenv BW_PASSWORD --raw")
+          tEitherWithAuthd
+            .move("bw unlock --passwordenv BW_PASSWORD --raw")
             .map(getStdout)
-            .get()
+            .get(),
         );
       })
       .peek(async (tEitherWithSession) => {
         const eitherWithAuthd = await tEitherWithSession.get();
         return tEitherWithSession.trace.trace(
-          eitherWithAuthd.fold((err, _val) =>
-            Bitwarden.unlockVaultMetric[err ? "failure" : "success"]
+          eitherWithAuthd.fold(
+            (err, _val) =>
+              Bitwarden.unlockVaultMetric[err ? "failure" : "success"],
           ),
         );
       })
@@ -63,21 +68,26 @@ export class Bitwarden implements IVault<TClient, TKey, TItemId> {
     key: string,
     item: string,
   ): Promise<IEither<Error, T>> {
-    return client.move(key)
+    return client
+      .move(key)
       .bimap(TraceUtil.withMetricTrace(Bitwarden.fetchSecretMetric))
       .peek((tSession) =>
-        tSession.trace.trace(`looking for your secret ${item} (⑅˘꒳˘)`)
+        tSession.trace.trace(`looking for your secret ${item} (⑅˘꒳˘)`),
       )
       .flatMap((tSession) =>
-        tSession.move("bw list items").map((listCmd) =>
-          getStdout(listCmd, { env: { BW_SESSION: tSession.get() } })
-        )
+        tSession
+          .move("bw list items")
+          .map((listCmd) =>
+            getStdout(listCmd, { env: { BW_SESSION: tSession.get() } }),
+          ),
       )
       .map(
         TraceUtil.promiseify((tEitherItemsJson) =>
-          tEitherItemsJson.get()
-            .flatMap((itemsJson): IEither<Error, Array<T & { name: string }>> =>
-              Either.fromFailable(() => JSON.parse(itemsJson))
+          tEitherItemsJson
+            .get()
+            .flatMap(
+              (itemsJson): IEither<Error, Array<T & { name: string }>> =>
+                Either.fromFailable(() => JSON.parse(itemsJson)),
             )
             .flatMap((itemsList): IEither<Error, T> => {
               const secret = itemsList.find(({ name }) => name === item);
@@ -87,14 +97,15 @@ export class Bitwarden implements IVault<TClient, TKey, TItemId> {
                 );
               }
               return Either.right(secret);
-            })
+            }),
         ),
       )
       .peek(async (tEitherWithSecret) => {
         const eitherWithSecret = await tEitherWithSecret.get();
         return tEitherWithSecret.trace.trace(
-          eitherWithSecret.fold((err, _val) =>
-            Bitwarden.fetchSecretMetric[err ? "failure" : "success"]
+          eitherWithSecret.fold(
+            (err, _val) =>
+              Bitwarden.fetchSecretMetric[err ? "failure" : "success"],
           ),
         );
       })
@@ -102,15 +113,18 @@ export class Bitwarden implements IVault<TClient, TKey, TItemId> {
   }
 
   public lock(client: TClient, key: TKey) {
-    return client.move(key)
+    return client
+      .move(key)
       .bimap(TraceUtil.withMetricTrace(Bitwarden.lockVaultMetric))
       .peek((tSession) =>
-        tSession.trace.trace(`taking care of locking the vault :3`)
+        tSession.trace.trace(`taking care of locking the vault :3`),
       )
       .flatMap((tSession) =>
-        tSession.move("bw lock").map((lockCmd) =>
-          getStdout(lockCmd, { env: { BW_SESSION: tSession.get() } })
-        )
+        tSession
+          .move("bw lock")
+          .map((lockCmd) =>
+            getStdout(lockCmd, { env: { BW_SESSION: tSession.get() } }),
+          ),
       )
       .peek(async (tEitherWithLocked) => {
         const eitherWithLocked = await tEitherWithLocked.get();