akanjs 3.0.0-beta.2 → 3.0.0-beta.20

package/service/predefinedAdaptor/openaiDialect.ts

@@ -1,13 +1,22 @@
-import type { AgentWireMessage, LlmAccepts, LlmTurnAnswer, LlmTurnRequest } from "./llm.adaptor";
+import type { AgentWireMessage, LlmAccepts, LlmTurnAnswer, LlmTurnRequest, LlmUsage } from "./llm.adaptor";
+import { eachSseData } from "./sseData";
 
 export interface OpenaiToolCall {
   id?: string;
   function?: { name?: string; arguments?: string };
 }
+interface OpenaiUsage {
+  prompt_tokens?: number;
+  completion_tokens?: number;
+  prompt_tokens_details?: { cached_tokens?: number } | null;
+  prompt_cache_hit_tokens?: number;
+}
 export interface OpenaiAnswer {
   choices?: { message?: { content?: string | null; tool_calls?: OpenaiToolCall[] }; finish_reason?: string }[];
+  usage?: OpenaiUsage | null;
 }
 interface OpenaiStreamChunk {
+  usage?: OpenaiUsage | null;
   choices?: {
     delta?: {
       content?: string | null;
@@ -24,16 +33,11 @@ export interface OpenaiMessage {
   tool_call_id?: string;
 }
 
-/**
- * The OpenAI chat-completions wire format, which several providers speak — OpenAI's own endpoint, DeepSeek, and
- * every gateway that copied it. It lives apart from any one of them because a protocol fix belongs in one place:
- * the SSE tool-call assembly below is the subtle part, and two copies of it drift silently.
- *
- * `accepts` decides the shape of a user turn, and nothing else here reads it. A provider that takes no image gets
- * one string, exactly as before, because `AgentService.readable` has already reduced every attachment it cannot
- * read to a note in the text.
- */
+/** The chat-completions wire that OpenAI, DeepSeek and every gateway copying them speak. */
 export class OpenaiDialect {
+  /** Apart from Anthropic's identical set: each is one provider's list, and an unlisted type is a refused request. */
+  static readonly imageTypes = new Set(["image/jpeg", "image/png", "image/gif", "image/webp"]);
+
   static requestBody(
     model: string,
     request: LlmTurnRequest,
@@ -41,7 +45,8 @@ export class OpenaiDialect {
   ) {
     return {
       model,
-      ...(stream ? { stream: true } : {}),
+      
+      ...(stream ? { stream: true, stream_options: { include_usage: true } } : {}),
       messages: [
         { role: "system" as const, content: OpenaiDialect.systemPrompt(request) },
         ...request.messages.flatMap((message) => OpenaiDialect.providerMessages(message, accepts)),
@@ -64,7 +69,7 @@ export class OpenaiDialect {
 
   /** Context rides below the instructions framed as data — screen state must never read as directives. */
   static systemPrompt({ instructions, context }: LlmTurnRequest) {
-
+    
     const base =
       instructions ??
       "You are an in-page assistant. Use the published tools to read and drive the screen the user is looking at.";
@@ -73,7 +78,7 @@ export class OpenaiDialect {
   }
 
   static providerMessages(message: AgentWireMessage, accepts?: LlmAccepts): OpenaiMessage[] {
-
+    
     if (message.summary)
       return [
         {
@@ -110,33 +115,36 @@ export class OpenaiDialect {
     return [{ role: "user" as const, content: OpenaiDialect.userContent(message, accepts) }];
   }
 
-  /**
-   * Text attachments are labelled into the message, because a model handed two unlabelled documents can no longer
-   * cite either one. Images become their own parts only when the provider said it reads them; the dialect carries
-   * one as a `data:` URL, which is the same encoding whether the bytes were inlined or already addressable, so
-   * both carriers take one branch.
-   */
   static userContent(message: AgentWireMessage, accepts?: LlmAccepts): string | OpenaiContentPart[] {
     const attachments = message.attachments ?? [];
+    const notes: string[] = [];
+    
     const blocks = attachments.flatMap((attachment) =>
       attachment.text ? [`--- attachment: ${attachment.name} (${attachment.mimeType}) ---\n${attachment.text}`] : [],
     );
-    const text = [message.text, ...blocks].filter(Boolean).join("\n\n");
-    if (!accepts?.image) return text;
-    const images = attachments.flatMap((attachment) => {
-      if (!attachment.mimeType.startsWith("image/")) return [];
-      const url = attachment.url ?? (attachment.data ? `data:${attachment.mimeType};base64,${attachment.data}` : "");
-      return url ? [{ type: "image_url" as const, image_url: { url } }] : [];
-    });
+    const images = !accepts?.image
+      ? []
+      : attachments.flatMap((attachment) => {
+          if (attachment.text) return [];
+          
+          const mimeType = attachment.mimeType.split(";")[0].trim().toLowerCase();
+          
+          if (!mimeType.startsWith("image/")) return [];
+          if (!OpenaiDialect.imageTypes.has(mimeType)) {
+            notes.push(
+              `[Attachment not read: ${attachment.name} (${attachment.mimeType}) — this API reads no image of that type.]`,
+            );
+            return [];
+          }
+          
+          const url = attachment.data ? `data:${mimeType};base64,${attachment.data}` : (attachment.url ?? "");
+          return url ? [{ type: "image_url" as const, image_url: { url } }] : [];
+        });
+    const text = [message.text, ...blocks, ...notes].filter(Boolean).join("\n\n");
     if (!images.length) return text;
     return [...(text ? [{ type: "text" as const, text }] : []), ...images];
   }
 
-  /**
-   * The dialect streams `data: {chunk}` SSE lines ending with `data: [DONE]`. Tool calls arrive fragmented — the
-   * first fragment of an index carries id/name, later ones append to the arguments string — so they are assembled
-   * by index and parsed once at the end; only assistant text is worth reporting as it arrives.
-   */
   static async consumeStream(
     body: ReadableStream<Uint8Array>,
     onDelta: (delta: string) => void,
@@ -144,13 +152,11 @@ export class OpenaiDialect {
     const calls = new Map<number, { id?: string; name?: string; args: string }>();
     let text = "";
     let finish: string | null = null;
-    let buffer = "";
-    const decoder = new TextDecoder();
-    const feed = (line: string) => {
-      if (!line.startsWith("data:")) return;
-      const payload = line.slice(5).trim();
-      if (!payload || payload === "[DONE]") return;
+    let usage: LlmUsage | undefined;
+    await eachSseData(body, (payload) => {
+      if (payload === "[DONE]") return;
       const chunk = JSON.parse(payload) as OpenaiStreamChunk;
+      if (chunk.usage) usage = OpenaiDialect.usageOf(chunk.usage);
       const choice = chunk.choices?.[0];
       if (!choice) return;
       if (choice.delta?.content) {
@@ -166,25 +172,7 @@ export class OpenaiDialect {
         calls.set(index, call);
       }
       if (choice.finish_reason) finish = choice.finish_reason;
-    };
-    /** A frame the provider mangled costs that frame. Throwing would lose the whole answer, text already streamed
-     * and all, over one line of a protocol the caller cannot fix. */
-    const tolerate = (line: string) => {
-      try {
-        feed(line);
-      } catch {
-      }
-    };
-    for await (const piece of body) {
-      buffer += decoder.decode(piece as Uint8Array, { stream: true });
-      let cut = buffer.indexOf("\n");
-      while (cut !== -1) {
-        tolerate(buffer.slice(0, cut).trimEnd());
-        buffer = buffer.slice(cut + 1);
-        cut = buffer.indexOf("\n");
-      }
-    }
-    tolerate(buffer.trimEnd());
+    });
     const toolCalls = [...calls.entries()]
       .sort(([a], [b]) => a - b)
       .flatMap(([, call]) =>
@@ -194,13 +182,19 @@ export class OpenaiDialect {
       ...(text ? { text } : {}),
       ...(toolCalls.length ? { toolCalls } : {}),
       stop: OpenaiDialect.stopOf(finish, toolCalls.length),
+      ...(usage ? { usage } : {}),
+    };
+  }
+
+  static usageOf(usage: OpenaiUsage): LlmUsage {
+    return {
+      inputTokens: usage.prompt_tokens ?? 0,
+      outputTokens: usage.completion_tokens ?? 0,
+      cachedTokens: usage.prompt_tokens_details?.cached_tokens ?? usage.prompt_cache_hit_tokens ?? 0,
     };
   }
 
-  /**
-   * The ceiling wins over the calls that did arrive. A turn the provider cut short is one whose last call may be
-   * missing, so running the batch it did finish is acting on half an intention.
-   */
+  /** The ceiling wins over the calls that did arrive: a cut-off turn's last call may be missing. */
   static stopOf(finish: string | null | undefined, calls: number): LlmTurnAnswer["stop"] {
     if (finish === "length") return "length";
     return finish === "tool_calls" || calls ? "toolUse" : "end";
@@ -216,6 +210,7 @@ export class OpenaiDialect {
       ...(choice?.message?.content ? { text: choice.message.content } : {}),
       ...(toolCalls.length ? { toolCalls } : {}),
       stop: OpenaiDialect.stopOf(choice?.finish_reason, toolCalls.length),
+      ...(answer.usage ? { usage: OpenaiDialect.usageOf(answer.usage) } : {}),
     };
   }
 
@@ -230,10 +225,7 @@ export class OpenaiDialect {
     }
   }
 
-  /**
-   * The dialect answers a refusal as `{ error: { message } }`, and that sentence is the useful half — a request
-   * past the context window says exactly which limit it passed.
-   */
+  /** The dialect refuses as `{ error: { message } }`, and that sentence names the limit a long prompt passed. */
   static async reasonOf(response: Response): Promise<string> {
     try {
       const body = (await response.json()) as { error?: { message?: unknown } | string };

package/service/predefinedAdaptor/openaiLlm.ts

@@ -1,32 +1,33 @@
-import { Err } from "akanjs/dictionary";
 import { adapt } from "../adapt";
-import type { LlmAccepts, LlmAdaptor, LlmOption, LlmTurnAnswer, LlmTurnRequest } from "./llm.adaptor";
+import type { LlmAccepts, LlmAdaptor, LlmLimits, LlmOption, LlmTurnAnswer, LlmTurnRequest } from "./llm.adaptor";
+import { LlmOverflow } from "./llmOverflow";
 import { type OpenaiAnswer, OpenaiDialect } from "./openaiDialect";
 
 /**
- * OpenAI's chat-completions endpoint, and every gateway that serves the same dialect — `host` is what points it
- * at one. It is `DeepseekLlm`'s sibling rather than its replacement: same wire, and the difference that earns a
- * second class is that this one declares `accepts`, so an attached image reaches the model as an image part
- * instead of a note saying it could not be read.
- *
- * `model` is required and has no default. A default would be a model name that ages out of the provider's
- * catalogue into a 404 at the first turn, and — worse here than for a text-only adaptor — it would decide the
- * vision claim below on the app's behalf. Name the model in `option.setLlm({ model })`, and name
- * `accepts: { image: false }` beside it when that model is one of the provider's text-only ones.
+ * The default `LlmAdaptorRole` fill, for every host serving the chat-completions wire. `model` has no default: one
+ * would age into a 404 and decide the vision claim on the app's behalf.
  */
 export class OpenaiLlm
-  extends adapt("openaiLlm" as const, ({ use }) => ({
+  extends adapt("akanOpenaiLlm" as const, ({ use }) => ({
     llmOption: use<LlmOption>(),
   }))
   implements LlmAdaptor
 {
+  static readonly defaultHost = "https://api.openai.com/v1";
+
   get #host() {
-    return this.llmOption.host ?? "https://api.openai.com/v1";
+    return this.llmOption.host ?? OpenaiLlm.defaultHost;
+  }
+
+  /** No answer ceiling: the dialect sends none, so the provider's own default is the one that applies. */
+  get limits(): LlmLimits {
+    return this.llmOption.contextWindow ? { window: this.llmOption.contextWindow } : {};
   }
 
-  /** The endpoint takes image parts, so that is the provider's answer; a model that does not takes the override. */
-  get accepts(): LlmAccepts {
-    return this.llmOption.accepts ?? { image: true };
+  /** A named host is text-only until `setLlm({ accepts })` says otherwise: undecodable bytes fail the whole turn. */
+  get accepts(): LlmAccepts | undefined {
+    if (this.llmOption.accepts) return this.llmOption.accepts;
+    return this.llmOption.host ? undefined : { image: true };
   }
 
   async chat(request: LlmTurnRequest, onDelta?: (delta: string) => void): Promise<LlmTurnAnswer | null> {
@@ -44,16 +45,16 @@ export class OpenaiLlm
           "/chat/completions",
           OpenaiDialect.requestBody(model, request, { accepts }),
         );
-        return OpenaiDialect.turnAnswer(answer);
+        return { ...OpenaiDialect.turnAnswer(answer), model };
       }
       const body = await this.#apiStream(
         "/chat/completions",
         OpenaiDialect.requestBody(model, request, { accepts, stream: true }),
       );
-      return await OpenaiDialect.consumeStream(body, onDelta);
+      return { ...(await OpenaiDialect.consumeStream(body, onDelta)), model };
     } catch (error) {
       
-      this.logger.error(`OpenAI turn failed: ${error instanceof Error ? error.message : String(error)}`);
+      this.logger.error(`LLM turn failed: ${error instanceof Error ? error.message : String(error)}`);
       throw error;
     }
   }
@@ -66,7 +67,7 @@ export class OpenaiLlm
       
       signal: AbortSignal.timeout(120_000),
     });
-    if (!response.ok) throw await OpenaiLlm.refusal(response);
+    if (!response.ok) throw await OpenaiLlm.refusal(this.#host, response);
     return (await response.json()) as T;
   }
 
@@ -77,15 +78,11 @@ export class OpenaiLlm
       body: JSON.stringify(body),
       signal: AbortSignal.timeout(120_000),
     });
-    if (!response.ok || !response.body) throw await OpenaiLlm.refusal(response);
+    if (!response.ok || !response.body) throw await OpenaiLlm.refusal(this.#host, response);
     return response.body;
   }
 
-  /** Carried on the `Err` so the chat prints the provider's own sentence rather than a status number. */
-  static async refusal(response: Response): Promise<Error> {
-    return new Err("agent.error.openaiRequestFailed", {
-      status: String(response.status),
-      reason: await OpenaiDialect.reasonOf(response),
-    });
+  static async refusal(host: string, response: Response): Promise<Error> {
+    return LlmOverflow.refusal(host, response.status, await OpenaiDialect.reasonOf(response));
   }
 }

package/service/predefinedAdaptor/queue.adaptor.ts

@@ -1,20 +1,29 @@
-import { getEnv } from "akanjs/base";
+import type { Redis, RedisOptions } from "ioredis";
 import { adapt } from "../adapt";
 import type { AkanJob, AkanJobOptions, AkanWorker } from "../ipcTypes";
 import { RedisCache } from "./cache.adaptor";
 
-type QueueLike = {
+interface BullEmitter {
+  on(event: "error", listener: (error: Error) => void): unknown;
+  waitUntilReady(): Promise<unknown>;
+  close(): Promise<void>;
+}
+interface QueueLike extends BullEmitter {
   add(name: string, args: unknown[], options?: AkanJobOptions): Promise<unknown>;
-};
-type WorkerLike = AkanWorker;
+}
+type WorkerLike = AkanWorker & BullEmitter;
+interface BullOptions {
+  connection: Redis | RedisOptions;
+  prefix: string;
+}
 type WorkerConstructor = new (
   name: string,
   handler: (job: AkanJob) => Promise<unknown>,
-  options: { connection: unknown },
+  options: BullOptions,
 ) => WorkerLike;
 type QueueConstructor = new (
   name: string,
-  options: { connection: unknown; defaultJobOptions: { removeOnComplete: boolean; removeOnFail: boolean } },
+  options: BullOptions & { defaultJobOptions: AkanJobOptions | Record<string, unknown> },
 ) => QueueLike;
 type BullmqModule = {
   Queue: QueueConstructor;
@@ -28,16 +37,16 @@ export interface QueueAdaptor {
 }
 
 export class BullQueue
-  extends adapt("bullQueue", ({ plug, env }) => ({
+  extends adapt("bullQueue", ({ plug }) => ({
     redis: plug(RedisCache, (redisCache) => redisCache.getClient()),
-    prefix: env(() => {
-      const { repoName, appName, environment, operationMode } = getEnv();
-      return `queue-${repoName}-${appName}-${environment}-${operationMode}`;
-    }),
+    prefix: plug(RedisCache, (redisCache) => `${redisCache.keyPrefix}queue`),
   }))
   implements QueueAdaptor
 {
+  
+  static readonly #failedJobs = { age: 7 * 24 * 60 * 60, count: 1000 };
   #queues = new Map<string, QueueLike>();
+  #workers: WorkerLike[] = [];
   #Queue!: QueueConstructor;
   #Worker!: WorkerConstructor;
 
@@ -46,25 +55,35 @@ export class BullQueue
     this.#Queue = Queue;
     this.#Worker = Worker;
   }
-
-  #queueName(key: string) {
-    return `${this.prefix}:${key}`;
+  override async onDestroy() {
+    
+    const settle = async (worker: WorkerLike) => {
+      await Promise.race([worker.waitUntilReady().catch(() => undefined), Bun.sleep(2_000)]);
+      await worker.close();
+    };
+    await Promise.all(this.#workers.splice(0).map(settle));
+    await Promise.all([...this.#queues.values()].map(async (queue) => await queue.close()));
+    this.#queues.clear();
   }
+
   getQueue(key: string): QueueLike {
-    const name = this.#queueName(key);
-    const queue = this.#queues.get(name);
+    const queue = this.#queues.get(key);
     if (queue) return queue;
-    const newQueue = new this.#Queue(name, {
+    const newQueue = new this.#Queue(key, {
       connection: this.redis,
-      defaultJobOptions: { removeOnComplete: true, removeOnFail: true },
+      prefix: this.prefix,
+      defaultJobOptions: { removeOnComplete: true, removeOnFail: BullQueue.#failedJobs },
     });
-    this.#queues.set(name, newQueue);
+    newQueue.on("error", (error) => this.logger.warn(`Queue ${key} error: ${error.message}`));
+    this.#queues.set(key, newQueue);
     return newQueue;
   }
   registerProcessWorker(key: string, handler: (job: AkanJob) => Promise<unknown>): WorkerLike {
-    const worker = new this.#Worker(this.#queueName(key), handler, {
-      connection: this.redis,
-    });
+
+    const connection = { ...this.redis.options, maxRetriesPerRequest: null };
+    const worker = new this.#Worker(key, handler, { connection, prefix: this.prefix });
+    worker.on("error", (error) => this.logger.warn(`Worker ${key} error: ${error.message}`));
+    this.#workers.push(worker);
     return worker;
   }
   async registerProcessQueue(key: string, args: unknown[], jobOptions?: AkanJobOptions): Promise<AkanJob> {

package/service/predefinedAdaptor/schedule.adaptor.ts

@@ -1,3 +1,5 @@
+import { hostname } from "node:os";
+import { dayjs } from "akanjs/base";
 import { adapt } from "../adapt";
 import { CacheAdaptorRole } from "./role.adaptor";
 
@@ -28,7 +30,7 @@ export interface ScheduleAdaptor {
   ): NodeJS.Timeout;
   unregisterTimeout(key: string): void;
   getInit(key: string): (() => Promise<void>) | undefined;
-  registerInit(key: string, callback: () => Promise<void>): void;
+  registerInit(key: string, callback: () => Promise<void>, option?: { once?: boolean }): void;
   unregisterInit(key: string): void;
   _runInit(): Promise<void>;
   getDestroy(key: string): (() => Promise<void>) | undefined;
@@ -43,6 +45,11 @@ export class Scheduler
   }))
   implements ScheduleAdaptor
 {
+
+  static readonly #topic = "akan:schedule";
+  static readonly #minuteMs = 60_000;
+  static readonly #runningLeaseMs = 30_000;
+  readonly #owner = `${hostname()}-${process.pid}-${Bun.randomUUIDv7()}`;
   readonly lockMap = new Map<string, boolean>();
   readonly cronMap = new Map<string, AkanCronJob>();
   readonly intervalMap = new Map<string, NodeJS.Timeout>();
@@ -53,7 +60,7 @@ export class Scheduler
     return this.cronMap.get(key);
   }
   registerCron(key: string, cronStr: string, callback: () => Promise<void>, { lock = true }: { lock?: boolean } = {}) {
-
+    
     if (!lock) this.logger.warn(`Schedule ${key} requested lock:false, but Bun.cron never overlaps a job`);
     const cron = Bun.cron(cronStr, async () => {
       if (this.lockMap.get(key) && lock) {
@@ -62,10 +69,17 @@ export class Scheduler
       }
       try {
         this.lockMap.set(key, true);
+        
+        const tick = Math.round(Date.now() / Scheduler.#minuteMs) * Scheduler.#minuteMs;
+        const claimed = await this.cache.setIfAbsent(Scheduler.#topic, `cron:${key}@${tick}`, this.#owner, {
+          expireAt: dayjs(tick + 10 * Scheduler.#minuteMs),
+        });
+        if (!claimed) return;
         const now = Date.now();
         this.logger.debug(`Schedule ${key} started`);
-        await callback();
-        this.logger.debug(`Schedule ${key} finished ${Date.now() - now}ms`);
+        const ran = await this.#holding(`cron:${key}`, Scheduler.#runningLeaseMs, { release: true }, callback);
+        if (!ran) this.logger.warn(`Schedule ${key} is still running on another instance, skipped`);
+        else this.logger.debug(`Schedule ${key} finished ${Date.now() - now}ms`);
       } catch (e) {
         this.logger.error(`Schedule ${key} error: ${e}`);
       } finally {
@@ -98,9 +112,9 @@ export class Scheduler
       try {
         this.lockMap.set(key, true);
         const now = Date.now();
-        this.logger.debug(`Schedule interval ${key} started`);
-        await callback();
-        this.logger.debug(`Schedule interval ${key} finished ${Date.now() - now}ms`);
+        
+        const ran = await this.#holding(`interval:${key}`, scheduleTime, { release: false, renew: lock }, callback);
+        if (ran) this.logger.debug(`Schedule interval ${key} finished ${Date.now() - now}ms`);
       } catch (e) {
         this.logger.error(`Schedule interval ${key} error: ${e}`);
       } finally {
@@ -142,12 +156,13 @@ export class Scheduler
   getInit(key: string) {
     return this.initMap.get(key);
   }
-  registerInit(key: string, callback: () => Promise<void>) {
+  registerInit(key: string, callback: () => Promise<void>, { once = false }: { once?: boolean } = {}) {
     this.initMap.set(key, async () => {
       try {
         const now = Date.now();
         this.logger.debug(`Schedule init ${key} started`);
-        await callback();
+        if (once) await this.#once(key, callback);
+        else await callback();
         this.logger.debug(`Schedule init ${key} finished ${Date.now() - now}ms`);
       } catch (e) {
         this.logger.error(`Schedule init ${key} error: ${e}`);
@@ -181,6 +196,51 @@ export class Scheduler
   async _runDestroy() {
     await Promise.all([...this.destroyMap.values()].map((callback) => callback()));
   }
+  async #holding(
+    lease: string,
+    ttlMs: number,
+    { release, renew = true }: { release: boolean; renew?: boolean },
+    run: () => Promise<void>,
+  ) {
+    if (!(await this.cache.acquireLease(Scheduler.#topic, lease, this.#owner, ttlMs))) return false;
+    const stopRenewing = renew ? this.#renewing(lease, ttlMs) : null;
+    try {
+      await run();
+      return true;
+    } finally {
+      stopRenewing?.();
+      if (release) await this.cache.releaseLease(Scheduler.#topic, lease, this.#owner);
+    }
+  }
+  #renewing(lease: string, ttlMs: number) {
+    const timer = setInterval(
+      () => {
+        void this.cache
+          .renewLease(Scheduler.#topic, lease, this.#owner, ttlMs)
+          .catch((e: unknown) => this.logger.warn(`Schedule lease ${lease} was not renewed: ${String(e)}`));
+      },
+      Math.max(ttlMs / 3, 10),
+    );
+    return () => clearInterval(timer);
+  }
+  
+  async #once(key: string, run: () => Promise<void>) {
+    const lease = `init:${key}`;
+    let waited = false;
+    while (!(await this.cache.acquireLease(Scheduler.#topic, lease, this.#owner, Scheduler.#runningLeaseMs))) {
+      waited = true;
+      await Bun.sleep(250);
+    }
+    const stopRenewing = this.#renewing(lease, Scheduler.#runningLeaseMs);
+    try {
+      if (waited && (await this.cache.get(Scheduler.#topic, `${lease}:done`))) return;
+      await run();
+      await this.cache.set(Scheduler.#topic, `${lease}:done`, this.#owner, { expireAt: dayjs().add(1, "minute") });
+    } finally {
+      stopRenewing();
+      await this.cache.releaseLease(Scheduler.#topic, lease, this.#owner);
+    }
+  }
   override async onDestroy() {
     for (const cron of this.cronMap.values()) cron.stop();
     for (const interval of this.intervalMap.values()) clearInterval(interval);