@forgezero/runtime 0.1.0 → 0.1.2

package/dist/custody-share.js

@@ -0,0 +1,313 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/custody-crypto.ts
+import { gcm } from "@noble/ciphers/aes.js";
+import { x25519 } from "@noble/curves/ed25519.js";
+import { hkdf } from "@noble/hashes/hkdf.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+var KEY_BYTES = 32;
+var NONCE_BYTES = 12;
+var toBase64 = (bytes) => {
+  let binary = "";
+  for (const byte of bytes)
+    binary += String.fromCharCode(byte);
+  return btoa(binary);
+};
+var fromBase64 = (value) => {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0;index < binary.length; index += 1)
+    bytes[index] = binary.charCodeAt(index);
+  return bytes;
+};
+var utf8 = (value) => new TextEncoder().encode(value);
+function deriveKey(secret, salt, info, length = KEY_BYTES) {
+  return hkdf(sha256, secret, salt, utf8(info), length);
+}
+function sealWithKey(key, plaintext, aad) {
+  if (key.length !== KEY_BYTES)
+    throw new Error("custody: key must be 32 bytes");
+  const nonce = crypto.getRandomValues(new Uint8Array(NONCE_BYTES));
+  const sealed = gcm(key, nonce, utf8(aad)).encrypt(plaintext);
+  return { alg: "aes-256-gcm", nonce: toBase64(nonce), ciphertext: toBase64(sealed) };
+}
+function openWithKey(key, box, aad) {
+  if (key.length !== KEY_BYTES)
+    throw new Error("custody: key must be 32 bytes");
+  if (box.alg !== "aes-256-gcm")
+    throw new Error(`custody: unknown algorithm ${box.alg}`);
+  return gcm(key, fromBase64(box.nonce), utf8(aad)).decrypt(fromBase64(box.ciphertext));
+}
+var WRAP_INFO = "forgezero:custody:wrap:v1";
+var wrapKey = (shared, ephemeral, recipient) => hkdf(sha256, shared, concatBytes(ephemeral, recipient), utf8(WRAP_INFO), 32);
+function concatBytes(left, right) {
+  const out = new Uint8Array(left.length + right.length);
+  out.set(left, 0);
+  out.set(right, left.length);
+  return out;
+}
+function sealToKey(recipientPublicKey, plaintext, aad) {
+  const ephemeralSecret = x25519.utils.randomSecretKey();
+  const ephemeralPublic = x25519.getPublicKey(ephemeralSecret);
+  const shared = x25519.getSharedSecret(ephemeralSecret, recipientPublicKey);
+  const key = wrapKey(shared, ephemeralPublic, recipientPublicKey);
+  try {
+    return { ...sealWithKey(key, plaintext, aad), ephemeral: toBase64(ephemeralPublic) };
+  } finally {
+    key.fill(0);
+    ephemeralSecret.fill(0);
+  }
+}
+function openFromKey(recipientSecretKey, box, aad) {
+  const ephemeralPublic = fromBase64(box.ephemeral);
+  const recipientPublic = x25519.getPublicKey(recipientSecretKey);
+  const shared = x25519.getSharedSecret(recipientSecretKey, ephemeralPublic);
+  const key = wrapKey(shared, ephemeralPublic, recipientPublic);
+  try {
+    return openWithKey(key, box, aad);
+  } finally {
+    key.fill(0);
+  }
+}
+function wrappingKeyPair(factorMaterial, info) {
+  const secretKey = hkdf(sha256, factorMaterial, utf8("forgezero:custody:wrapkey:v1"), utf8(info), 32);
+  return { secretKey, publicKey: x25519.getPublicKey(secretKey) };
+}
+
+// src/phrase.ts
+import { entropyToMnemonic, mnemonicToSeedSync, validateMnemonic } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+import { hkdf as hkdf2 } from "@noble/hashes/hkdf.js";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { toHex } from "@forgezero/access/security";
+var ENCODER = new TextEncoder;
+var randomBytes = (length) => crypto.getRandomValues(new Uint8Array(length));
+var PHRASE_WORDS = 24;
+var ENTROPY_BYTES = 32;
+var PHRASE_SALT_BYTES = 16;
+var KEY_BYTES2 = 32;
+var KEY_INFO = "forgezero:custodian:phrase-key:v1";
+var VERIFIER_INFO = "forgezero:custodian:phrase-verifier:v1";
+function canonical(words) {
+  return words.map((word) => word.normalize("NFKD").trim().toLowerCase()).join(" ");
+}
+function shapeIsValid(words) {
+  if (!Array.isArray(words) || words.length !== PHRASE_WORDS)
+    return false;
+  return words.every((word) => typeof word === "string" && word.trim().length > 0);
+}
+function generatePhrase() {
+  const entropy = randomBytes(ENTROPY_BYTES);
+  try {
+    const words = entropyToMnemonic(entropy, wordlist).split(" ");
+    if (words.length !== PHRASE_WORDS) {
+      throw new Error("phrase: wordlist produced an unexpected phrase length");
+    }
+    return words;
+  } finally {
+    entropy.fill(0);
+  }
+}
+function validatePhrase(words) {
+  if (!shapeIsValid(words))
+    return false;
+  return validateMnemonic(canonical(words), wordlist);
+}
+function newSalt() {
+  return Uint8Array.from(randomBytes(PHRASE_SALT_BYTES));
+}
+function assertSalt(salt) {
+  if (!(salt instanceof Uint8Array) || salt.length < PHRASE_SALT_BYTES) {
+    throw new Error(`phrase: salt must be at least ${PHRASE_SALT_BYTES} bytes`);
+  }
+}
+function bip39Seed(words) {
+  if (!validatePhrase(words))
+    throw new Error("INVALID_PHRASE");
+  return mnemonicToSeedSync(canonical(words));
+}
+function phraseToKey(words, salt) {
+  assertSalt(salt);
+  const seed = bip39Seed(words);
+  try {
+    return hkdf2(sha2562, seed, salt, ENCODER.encode(KEY_INFO), KEY_BYTES2);
+  } finally {
+    seed.fill(0);
+  }
+}
+function phraseVerifier(words, salt) {
+  assertSalt(salt);
+  const seed = bip39Seed(words);
+  try {
+    return toHex(hkdf2(sha2562, seed, salt, ENCODER.encode(VERIFIER_INFO), KEY_BYTES2));
+  } finally {
+    seed.fill(0);
+  }
+}
+
+// src/custody-share.ts
+var KEY_BYTES3 = 32;
+var MIN_PRF_BYTES = 32;
+var PASSKEY_KEY_SALT = "forgezero:custodian:passkey:v1";
+var utf82 = (value) => new TextEncoder().encode(value);
+var toBase642 = (bytes) => {
+  let binary = "";
+  for (const byte of bytes)
+    binary += String.fromCharCode(byte);
+  return btoa(binary);
+};
+var fromBase642 = (value) => {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0;index < binary.length; index += 1)
+    bytes[index] = binary.charCodeAt(index);
+  return bytes;
+};
+function passkeyKey(custodianKey, prfOutput) {
+  if (!(prfOutput instanceof Uint8Array) || prfOutput.length < MIN_PRF_BYTES) {
+    throw new Error(`custody-share: PRF output must be at least ${MIN_PRF_BYTES} bytes`);
+  }
+  const info = `forgezero:custodian:passkey-key:v1:${custodianKey.length}:${custodianKey}`;
+  return deriveKey(prfOutput, utf82(PASSKEY_KEY_SALT), info, KEY_BYTES3);
+}
+function shareAad(custodianKey, kind, shareIndex) {
+  return `forgezero:share:v1:${kind}:${shareIndex}:${custodianKey.length}:${custodianKey}`;
+}
+function assertCustodianKey(custodianKey) {
+  if (typeof custodianKey !== "string" || custodianKey.length === 0) {
+    throw new Error("custody-share: custodianKey must be a non-empty string");
+  }
+}
+function shareIndexOf(share) {
+  if (share.length < 2)
+    throw new Error("custody-share: malformed share");
+  const x = share[0];
+  if (x < 1)
+    throw new Error("custody-share: share index 0 is reserved");
+  return x;
+}
+function sealShare(args) {
+  const { share, custodianKey, passkeyPrfOutput, phraseWords } = args;
+  assertCustodianKey(custodianKey);
+  const shareIndex = shareIndexOf(share);
+  if (!validatePhrase(phraseWords))
+    throw new Error("INVALID_PHRASE");
+  const salt = newSalt();
+  const keyFromPasskey = passkeyKey(custodianKey, passkeyPrfOutput);
+  const keyFromPhrase = phraseToKey(phraseWords, salt);
+  try {
+    return {
+      shareIndex,
+      passkeyEnvelope: sealWithKey(keyFromPasskey, share, shareAad(custodianKey, "passkey", shareIndex)),
+      phraseEnvelope: sealWithKey(keyFromPhrase, share, shareAad(custodianKey, "phrase", shareIndex)),
+      phraseSalt: toBase642(salt),
+      phraseVerifier: phraseVerifier(phraseWords, salt)
+    };
+  } finally {
+    keyFromPasskey.fill(0);
+    keyFromPhrase.fill(0);
+  }
+}
+function openShareWithPasskey(sealed, custodianKey, passkeyPrfOutput) {
+  assertCustodianKey(custodianKey);
+  const key = passkeyKey(custodianKey, passkeyPrfOutput);
+  try {
+    return openWithKey(key, sealed.passkeyEnvelope, shareAad(custodianKey, "passkey", sealed.shareIndex));
+  } finally {
+    key.fill(0);
+  }
+}
+function openShareWithPhrase(sealed, custodianKey, phraseWords) {
+  assertCustodianKey(custodianKey);
+  if (!validatePhrase(phraseWords))
+    throw new Error("INVALID_PHRASE");
+  const salt = fromBase642(sealed.phraseSalt);
+  const key = phraseToKey(phraseWords, salt);
+  try {
+    return openWithKey(key, sealed.phraseEnvelope, shareAad(custodianKey, "phrase", sealed.shareIndex));
+  } finally {
+    key.fill(0);
+  }
+}
+var wrapInfo = (custodianKey, kind) => `forgezero:custody:wrap:v1:${kind}:${custodianKey.length}:${custodianKey}`;
+function passkeyWrappingKey(custodianKey, passkeyPrfOutput) {
+  assertCustodianKey(custodianKey);
+  return wrappingKeyPair(passkeyKey(custodianKey, passkeyPrfOutput), wrapInfo(custodianKey, "passkey"));
+}
+function phraseWrappingKey(custodianKey, phraseWords, salt) {
+  assertCustodianKey(custodianKey);
+  if (!validatePhrase(phraseWords))
+    throw new Error("INVALID_PHRASE");
+  return wrappingKeyPair(phraseToKey(phraseWords, salt), wrapInfo(custodianKey, "phrase"));
+}
+function wrappingKeysFor(args) {
+  const salt = newSalt();
+  const passkey = passkeyWrappingKey(args.custodianKey, args.passkeyPrfOutput);
+  const phrase = phraseWrappingKey(args.custodianKey, args.phraseWords, salt);
+  try {
+    return {
+      passkeyPublicKey: toBase642(passkey.publicKey),
+      phrasePublicKey: toBase642(phrase.publicKey),
+      phraseSalt: toBase642(salt),
+      phraseVerifier: phraseVerifier(args.phraseWords, salt)
+    };
+  } finally {
+    passkey.secretKey.fill(0);
+    phrase.secretKey.fill(0);
+  }
+}
+function openSealedToFactor(args) {
+  const pair = args.factor === "passkey" ? passkeyWrappingKey(args.custodianKey, args.passkeyPrfOutput) : phraseWrappingKey(args.custodianKey, args.phraseWords, fromBase642(args.phraseSalt));
+  try {
+    return openFromKey(pair.secretKey, args.box, wrapInfo(args.custodianKey, args.factor));
+  } finally {
+    pair.secretKey.fill(0);
+  }
+}
+var factorWrapAad = (custodianKey, factor) => wrapInfo(custodianKey, factor);
+var PROBE_BYTES = 32;
+function joinProbeAndShare(probe, share) {
+  if (probe.length !== PROBE_BYTES)
+    throw new Error("custody-share: probe must be 32 bytes");
+  const out = new Uint8Array(probe.length + share.length);
+  out.set(probe, 0);
+  out.set(share, probe.length);
+  return out;
+}
+function splitProbeAndShare(opened) {
+  if (opened.length <= PROBE_BYTES)
+    throw new Error("custody-share: envelope is too short");
+  return { probe: opened.slice(0, PROBE_BYTES), share: opened.slice(PROBE_BYTES) };
+}
+function openFactorEnvelope(args) {
+  const box = args.factor === "passkey" ? args.sealed.passkeyEnvelope : args.sealed.phraseEnvelope;
+  return splitProbeAndShare(openSealedToFactor({
+    custodianKey: args.custodianKey,
+    factor: args.factor,
+    box,
+    passkeyPrfOutput: args.passkeyPrfOutput,
+    phraseWords: args.phraseWords,
+    phraseSalt: args.sealed.phraseSalt
+  }));
+}
+export {
+  wrappingKeysFor,
+  splitProbeAndShare,
+  shareIndexOf,
+  sealShare,
+  phraseWrappingKey,
+  passkeyWrappingKey,
+  openShareWithPhrase,
+  openShareWithPasskey,
+  openSealedToFactor,
+  openFactorEnvelope,
+  joinProbeAndShare,
+  factorWrapAad,
+  PROBE_BYTES
+};

package/dist/jobs.d.ts

@@ -15,11 +15,12 @@
  *
  * Each has a specific answer here: reschedule after completion rather than on
  * an interval, advance only on a fully successful batch, take a fenced lock,
- * and await in-flight work on stop.
+ * and submit every run through the common awaited queue, which drains on stop.
  *
  * Zero dependencies. The lock and the cursor store are interfaces, so this runs
  * against a database, Redis, or nothing at all in a test.
  */
+import { type DrainReport } from './queue';
 /** Injected so a test does not sleep and a resumed run is reproducible. */
 export interface Clock {
     now(): number;
@@ -122,7 +123,7 @@ export declare function createScheduler(options: SchedulerOptions): {
      * leaves a record half-written — the process exits mid-transaction and the
      * next boot finds state nothing can explain.
      */
-    stop(): Promise<void>;
+    stop(deadlineMs?: number): Promise<DrainReport>;
     /** Timers stop firing; in-flight work is left to finish. */
     pause(): void;
     resume(): void;

package/dist/jobs.js

@@ -6,6 +6,275 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// src/queue.ts
+class QueueStoppedError extends Error {
+  constructor() {
+    super("queue: stopped before this task could run");
+    this.name = "QueueStoppedError";
+  }
+}
+
+class QueueKeyStoppedError extends Error {
+  key;
+  constructor(key) {
+    super(`queue: key ${key} is stopped`);
+    this.key = key;
+    this.name = "QueueKeyStoppedError";
+  }
+}
+
+class TaskCancelledError extends Error {
+  constructor() {
+    super("queue: task cancelled");
+    this.name = "TaskCancelledError";
+  }
+}
+var DEFAULT_RETRY = {
+  attempts: 1,
+  backoffMs: (attempt) => Math.min(30000, 2 ** attempt * 100)
+};
+function createQueue(options = {}) {
+  const width = options.width ?? 8;
+  const retry = { ...DEFAULT_RETRY, ...options.retry };
+  if (!Number.isSafeInteger(width) || width < 1) {
+    throw new RangeError("queue: width must be a positive integer");
+  }
+  if (!Number.isSafeInteger(retry.attempts) || retry.attempts < 1) {
+    throw new RangeError("queue: retry attempts must be a positive integer");
+  }
+  const sleep = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const lanes = new Map;
+  const running = new Set;
+  const paused = new Set;
+  const stoppedKeys = new Set;
+  let sequence = 0;
+  let globallyPaused = false;
+  let accepting = true;
+  let aborted = false;
+  let completed = 0;
+  let failed = 0;
+  const idle = [];
+  const announceIdle = () => {
+    if (running.size > 0)
+      return;
+    for (const lane of lanes.values())
+      if (lane.length > 0)
+        return;
+    while (idle.length > 0)
+      idle.shift()();
+  };
+  function pump() {
+    if (globallyPaused || aborted) {
+      announceIdle();
+      return;
+    }
+    for (const [key, lane] of lanes) {
+      if (running.size >= width)
+        break;
+      if (running.has(key) || paused.has(key) || lane.length === 0)
+        continue;
+      execute(key);
+    }
+    announceIdle();
+  }
+  async function execute(key) {
+    running.add(key);
+    try {
+      const lane = lanes.get(key);
+      const entry = lane?.[0];
+      if (entry && !globallyPaused && !paused.has(key) && !aborted) {
+        lane.shift();
+        await attempt(entry);
+      }
+    } finally {
+      running.delete(key);
+      const remaining = lanes.get(key);
+      if (remaining?.length === 0)
+        lanes.delete(key);
+      else if (remaining) {
+        lanes.delete(key);
+        lanes.set(key, remaining);
+      }
+      pump();
+    }
+  }
+  async function attempt(entry) {
+    if (entry.cancelled) {
+      entry.reject(new TaskCancelledError);
+      return;
+    }
+    for (;; ) {
+      entry.attempt += 1;
+      try {
+        const value = await entry.run();
+        completed += 1;
+        entry.resolve(value);
+        return;
+      } catch (cause) {
+        if (entry.attempt >= retry.attempts || entry.cancelled || aborted) {
+          failed += 1;
+          entry.reject(cause);
+          return;
+        }
+        const delay = retry.backoffMs(entry.attempt);
+        if (!Number.isFinite(delay) || delay < 0) {
+          failed += 1;
+          entry.reject(new RangeError("queue: retry backoff must be a non-negative finite number"));
+          return;
+        }
+        await sleep(delay);
+      }
+    }
+  }
+  return {
+    run(key, handler, ...args) {
+      const id = `q_${++sequence}`;
+      if (!accepting || stoppedKeys.has(key)) {
+        const refused = Promise.reject(accepting ? new QueueKeyStoppedError(key) : new QueueStoppedError);
+        refused.catch(() => {
+          return;
+        });
+        return { id, key, result: refused };
+      }
+      let resolve;
+      let reject;
+      const result = new Promise((ok, no) => {
+        resolve = ok;
+        reject = no;
+      });
+      const entry = {
+        id,
+        key,
+        run: async () => handler(...args),
+        resolve,
+        reject,
+        attempt: 0,
+        cancelled: false
+      };
+      const lane = lanes.get(key);
+      if (lane)
+        lane.push(entry);
+      else
+        lanes.set(key, [entry]);
+      pump();
+      return { id, key, result };
+    },
+    cancel(id) {
+      for (const [key, lane] of lanes) {
+        const index = lane.findIndex((entry2) => entry2.id === id);
+        if (index === -1)
+          continue;
+        const [entry] = lane.splice(index, 1);
+        entry.cancelled = true;
+        entry.reject(new TaskCancelledError);
+        if (lane.length === 0 && !running.has(key))
+          lanes.delete(key);
+        announceIdle();
+        return true;
+      }
+      return false;
+    },
+    pauseKey(key) {
+      paused.add(key);
+    },
+    resumeKey(key) {
+      paused.delete(key);
+      pump();
+    },
+    stopKey(key) {
+      stoppedKeys.add(key);
+      paused.delete(key);
+      const lane = lanes.get(key);
+      if (!lane)
+        return 0;
+      let removed = 0;
+      for (const entry of lane.splice(0)) {
+        removed += 1;
+        entry.cancelled = true;
+        entry.reject(new QueueKeyStoppedError(key));
+      }
+      if (!running.has(key))
+        lanes.delete(key);
+      announceIdle();
+      return removed;
+    },
+    startKey(key) {
+      const changed = stoppedKeys.delete(key);
+      pump();
+      return changed;
+    },
+    pause() {
+      globallyPaused = true;
+    },
+    resume() {
+      globallyPaused = false;
+      pump();
+    },
+    snapshot() {
+      let queued = 0;
+      for (const lane of lanes.values())
+        queued += lane.length;
+      return {
+        running: running.size,
+        queued,
+        keys: lanes.size,
+        paused: globallyPaused,
+        pausedKeys: [...paused],
+        stoppedKeys: [...stoppedKeys],
+        completed,
+        failed
+      };
+    },
+    whenIdle() {
+      if (running.size === 0 && [...lanes.values()].every((lane) => lane.length === 0)) {
+        return Promise.resolve();
+      }
+      return new Promise((resolve) => idle.push(resolve));
+    },
+    async stop(deadlineMs = 30000) {
+      if (!Number.isSafeInteger(deadlineMs) || deadlineMs < 0) {
+        throw new RangeError("queue: stop deadline must be a non-negative integer");
+      }
+      accepting = false;
+      const before = { completed, failed };
+      globallyPaused = false;
+      paused.clear();
+      pump();
+      let timedOut = false;
+      let deadlineHandle;
+      const deadline = new Promise((resolve) => {
+        deadlineHandle = setTimeout(() => {
+          timedOut = true;
+          resolve();
+        }, deadlineMs);
+      });
+      await Promise.race([this.whenIdle(), deadline]);
+      if (!timedOut && deadlineHandle !== undefined)
+        clearTimeout(deadlineHandle);
+      if (timedOut)
+        aborted = true;
+      let abandoned = 0;
+      for (const lane of lanes.values()) {
+        abandoned += lane.length;
+        for (const entry of lane.splice(0))
+          entry.reject(new QueueStoppedError);
+      }
+      abandoned += running.size;
+      for (const [key, lane] of lanes) {
+        if (lane.length === 0 && !running.has(key))
+          lanes.delete(key);
+      }
+      announceIdle();
+      return {
+        completed: completed - before.completed,
+        failed: failed - before.failed,
+        abandoned,
+        timedOut
+      };
+    }
+  };
+}
+
 // src/jobs.ts
 var systemClock = {
   now: () => Date.now(),
@@ -83,10 +352,13 @@ function createScheduler(options) {
     { key: job.key, label: job.label, state: "stopped", consecutiveFailures: 0, runs: 0, skippedLocked: 0 }
   ]));
   const timers = new Map;
-  const inFlight = new Map;
+  let work = createQueue({ width: Math.max(1, jobs.size) });
+  let workStopped = false;
+  let restartBlocked = false;
   let controller = new AbortController;
   let paused = false;
   let running = false;
+  const submit = (job) => work.run(job.key, execute, job).result;
   async function execute(job) {
     const report = reports.get(job.key);
     const leaseMs = job.leaseMs ?? (job.every ? everyMs(job.every) * 4 : 60000);
@@ -132,17 +404,22 @@ function createScheduler(options) {
       timers.delete(job.key);
       if (!running || paused)
         return;
-      const work = execute(job).finally(() => {
-        inFlight.delete(job.key);
-        schedule(job, everyMs(job.every));
+      submit(job).then(() => schedule(job, everyMs(job.every)), () => {
+        return;
       });
-      inFlight.set(job.key, work);
     }, delayMs));
   }
   return {
     start() {
       if (running)
         return;
+      if (restartBlocked) {
+        throw new Error("scheduler: cannot restart after an incomplete drain while abandoned work may still run");
+      }
+      if (workStopped) {
+        work = createQueue({ width: Math.max(1, jobs.size) });
+        workStopped = false;
+      }
       running = true;
       paused = false;
       controller = new AbortController;
@@ -152,15 +429,18 @@ function createScheduler(options) {
         schedule(job, job.startDelayMs ?? spreadOf(job.key, Math.min(interval, 30000)));
       }
     },
-    async stop() {
+    async stop(deadlineMs = 30000) {
       running = false;
       controller.abort();
       for (const timer of timers.values())
         clearTimeout(timer);
       timers.clear();
-      await Promise.allSettled([...inFlight.values()]);
+      const drained = await work.stop(deadlineMs);
+      workStopped = true;
+      restartBlocked = drained.timedOut;
       for (const report of reports.values())
         report.state = "stopped";
+      return drained;
     },
     pause() {
       paused = true;
@@ -185,12 +465,7 @@ function createScheduler(options) {
       const job = jobs.get(key);
       if (!job)
         throw new Error(`No job named "${key}".`);
-      const existing = inFlight.get(key);
-      if (existing)
-        await existing;
-      const work = execute(job).finally(() => inFlight.delete(key));
-      inFlight.set(key, work);
-      await work;
+      await submit(job);
       return { ...reports.get(key) };
     },
     status: () => [...reports.values()].map((report) => ({ ...report })),