some cleanup and types

src/common/aborts.ts

···
     controller.abort(new DOMException("Operation timed out", "TimeoutError"));
   }, ms);
 
-  const cleanup = () => clearTimeout(timeout);
-  controller.signal.addEventListener("abort", cleanup);
+  const cleanup = () => {
+    clearTimeout(timeout);
+    controller.signal.removeEventListener("abort", cleanup);
+  };
 
+  controller.signal.addEventListener("abort", cleanup);
   return { signal: controller.signal, cleanup };
 }
 
 export function combineSignals(...signals: AbortSignal[]): AbortSignal {
   const controller = new AbortController();
+  const cleanups = [] as (() => void)[];
 
   for (const signal of signals) {
     if (signal.aborted) {
       controller.abort(signal.reason);
       return controller.signal;
     }
-    signal.addEventListener("abort", () => {
+
+    const handler = () => {
       if (!controller.signal.aborted) {
         controller.abort(signal.reason);
       }
-    });
+    };
+
+    signal.addEventListener("abort", handler);
+    cleanups.push(() => signal.removeEventListener("abort", handler));
   }
+
+  controller.signal.addEventListener("abort", () => {
+    cleanups.forEach((cb) => cb());
+  });
 
   return controller.signal;
 }

src/common/crypto-algos.ts

···
 // TODO, is there a better way of getting the algo type?
 export type Algo = Parameters<typeof crypto.subtle.importKey>[2];
 export const encrAlgo = { name: "AES-GCM", length: 256 } satisfies Algo;
-export const signAlgo = { name: "ECDSA", namedCurve: "P-256" } satisfies Algo;
+export const signAlgo = { name: "ES256" } satisfies Algo;

src/common/crypto-sig.ts

···
 
 export const serializedJwkPairSchema = z.object({
   __type: z.literal("jwkpair"),
-  publicJwk: z.any(),
-  privateJwk: z.any(),
+  publicKey: z.any(),
+  privateKey: z.any(),
 });
 
 export type SerializedJwkPair = z.infer<typeof serializedJwkPairSchema>;
···
 }
 
 export async function serializeJwkPair(jwks: CryptoKeyPair): Promise<SerializedJwkPair> {
-  const [publicJwk, privateJwk] = await Promise.all([
+  const [publicKey, privateKey] = await Promise.all([
     exportJWK(jwks.publicKey),
     exportJWK(jwks.privateKey),
   ]);
 
   return {
     __type: "jwkpair",
-    publicJwk,
-    privateJwk,
+    publicKey,
+    privateKey,
   };
 }
 
 export async function deserializeJwkPair(data: unknown): Promise<CryptoKeyPair> {
-  const { publicJwk, privateJwk } = serializedJwkPairSchema.parse(data);
-  const [publicKey, privateKey] = await Promise.all([
-    importJWK(publicJwk, signAlgo.name, { extractable: true }) as Promise<CryptoKey>,
-    importJWK(privateJwk, signAlgo.name, { extractable: true }) as Promise<CryptoKey>,
+  let { publicKey, privateKey } = serializedJwkPairSchema.parse(data);
+  [publicKey, privateKey] = await Promise.all([
+    importJWK(publicKey, signAlgo.name, { extractable: true }) as Promise<CryptoKey>,
+    importJWK(privateKey, signAlgo.name, { extractable: true }) as Promise<CryptoKey>,
   ]);
 
   return {

src/common/sleep.ts

···
+export function sleep(ms: number, signal?: AbortSignal) {
+  signal?.throwIfAborted();
+
+  const { resolve, reject, promise } = Promise.withResolvers<void>();
+  const timeout = setTimeout(resolve, ms);
+
+  if (signal) {
+    const abortHandler = () => {
+      clearTimeout(timeout);
+      reject(signal.reason);
+    };
+
+    signal.addEventListener("abort", abortHandler);
+    promise.finally(() => {
+      signal.removeEventListener("abort", abortHandler);
+    });
+  }
+
+  return promise;
+}

src/types/replace.ts

···
+/** replace a key with a different type */
+export type Replace<T, K extends keyof T, U> = Omit<T, K> & Record<K, U>;