@k2b/cloud 0.6.0-rc.0 → 0.7.0

package/src/workflows/ai/runtime.ts

@@ -1,3 +1,4 @@
+import { AiBackgroundAdmissionError, AiBackgroundCostError } from "../../ai/inference-calls";
 import { StructuredOutputError } from "@k2b/nessi";
 import type { Job, Worker } from "@k2b/sync";
 import { z } from "zod";
@@ -96,7 +97,7 @@ export const executeWorkflowAiRequest = async (task: WorkflowAiTask, runStructur
   const request = task.request;
   const common = {
     appId: task.appId,
-    attribution: { workflowRunId: task.runId, userId: task.usageUserId },
+    attribution: { workflowRunId: task.runId, stepKey: task.stepKey, userId: task.usageUserId },
     requestedModelId: task.modelProfileId,
     signal,
     temperature: 0,
@@ -159,12 +160,15 @@ export const executeWorkflowAiRequest = async (task: WorkflowAiTask, runStructur
 };
 
 const retryableError = (error: unknown): boolean => {
+  if (error instanceof AiBackgroundAdmissionError) return error.retryable;
+  if (error instanceof AiBackgroundCostError) return false;
   if (isAiSettingsError(error)) return false;
   if (error instanceof StructuredOutputError) return error.code === "loop_failed";
   return true;
 };
 
 const errorCode = (error: unknown): string => {
+  if (error instanceof AiBackgroundCostError || error instanceof AiBackgroundAdmissionError) return error.code;
   if (isAiSettingsError(error)) return error.aiError.code.toUpperCase();
   if (error instanceof StructuredOutputError) return `WORKFLOW_AI_${error.code.toUpperCase()}`;
   return "WORKFLOW_AI_PROVIDER_ERROR";

package/src/workflows/ai/store.ts

@@ -1,3 +1,4 @@
+import { notifyWorkflowWorker } from "../store/worker-runtime";
 import { type SQL, sql } from "bun";
 import type { WorkflowJsonValue } from "../contracts";
 import { wakeWorkflowRunsWaitingOn } from "../store/runs";
@@ -225,6 +226,7 @@ export const workflowAiTaskCancellationRequested = async (id: string, db: SQL =
 
 export const wakeWorkflowAiTask = async (task: Pick<WorkflowAiTask, "appId" | "id">): Promise<void> => {
   await wakeWorkflowRunsWaitingOn({ appId: task.appId, kind: WORKFLOW_AI_DEPENDENCY_KIND, key: task.id });
+  notifyWorkflowWorker(task.appId);
 };
 
 export const markWorkflowAiTaskCanceledIfRequested = async (id: string, db: SQL = sql): Promise<WorkflowAiTask | null> => {

package/src/workflows/ai-actions.ts

@@ -139,27 +139,27 @@ export const runWorkflowAiAction = async (
   }
 };
 
-export const planWorkflowAiAction = async (
+export const workflowAiActionCost = async (
   ctx: Pick<WorkflowActionContext, "effectKey">,
-  summary: string,
   injected?: Pick<WorkflowAiActionDependencies, "exists">,
-): Promise<WorkflowPlannedEffect> => {
+): Promise<Record<string, number>> => {
   const deps = injected ?? (await dependencies());
-  const exists = await deps.exists(ctx.effectKey);
-  return {
-    summary,
-    ...(exists ? {} : { consumes: { maxAiCalls: 1 } }),
-    issues: ["AI output is not available during a dry run."],
-  };
+  return (await deps.exists(ctx.effectKey)) ? {} : { maxAiCalls: 1 };
 };
 
+const planWorkflowAiAction = async (summary: string): Promise<WorkflowPlannedEffect> => ({
+  summary,
+  issues: ["AI output is not available during a dry run."],
+});
+
 export const AI_WORKFLOW_ACTIONS = {
   aiExtractData: workflowAction.idempotent<typeof extractDataConfig, WorkflowJsonValue>({
     label: "AI extract structured data",
     description: "Extracts one bounded, validated object from supplied input.",
     outputType: "core.value",
     config: extractDataConfig,
-    plan: (ctx) => planWorkflowAiAction(ctx, "Extract structured data with AI."),
+    cost: (ctx) => workflowAiActionCost(ctx),
+    plan: () => planWorkflowAiAction("Extract structured data with AI."),
     run: (ctx, values) =>
       runWorkflowAiAction(ctx, {
         kind: "extract_data",
@@ -190,7 +190,8 @@ export const AI_WORKFLOW_ACTIONS = {
         saveAs: identifier("Variable name for the generated text."),
       },
     },
-    plan: (ctx) => planWorkflowAiAction(ctx, "Generate text with AI."),
+    cost: (ctx) => workflowAiActionCost(ctx),
+    plan: () => planWorkflowAiAction("Generate text with AI."),
     run: (ctx, values) =>
       runWorkflowAiAction(ctx, {
         kind: "generate_text",
@@ -214,7 +215,8 @@ export const AI_WORKFLOW_ACTIONS = {
         saveAs: identifier("Variable name for the selected choice."),
       },
     },
-    plan: (ctx) => planWorkflowAiAction(ctx, "Classify one value with AI."),
+    cost: (ctx) => workflowAiActionCost(ctx),
+    plan: () => planWorkflowAiAction("Classify one value with AI."),
     run: (ctx, values) =>
       runWorkflowAiAction(ctx, {
         kind: "classify",
@@ -254,7 +256,8 @@ export const AI_WORKFLOW_ACTIONS = {
         saveAs: identifier("Variable name for the selected choices."),
       },
     },
-    plan: (ctx) => planWorkflowAiAction(ctx, "Classify multiple values with AI."),
+    cost: (ctx) => workflowAiActionCost(ctx),
+    plan: () => planWorkflowAiAction("Classify multiple values with AI."),
     run: (ctx, values) =>
       runWorkflowAiAction(ctx, {
         kind: "classify_many",

package/src/workflows/definition.ts

@@ -136,8 +136,6 @@ export type WorkflowActionResult<Output> =
 export type WorkflowPlannedEffect = {
   /** Human-readable summary shown in the dry-run view. */
   summary: string;
-  /** Counts consumed from the effect budget, keyed by budget dimension. */
-  consumes?: Record<string, number>;
   /**
    * What the step would produce.
    *
@@ -202,8 +200,10 @@ export type WorkflowActionContext = {
   tx?: SQL;
   /** Stable across replays of the same step — the key an idempotent effect uses. */
   effectKey: string;
-  /** Keeps a long-running action's lease alive. */
-  heartbeat(): Promise<void>;
+  /** Keeps a long-running action's lease alive. Pass the application's current
+   * transaction to fence its writes against cancellation and worker takeover
+   * until commit. Do not call an ambient heartbeat while holding that fence. */
+  heartbeat(tx?: SQL): Promise<void>;
 };
 
 // ─── Action definition ───────────────────────────────────────────────────────
@@ -218,6 +218,8 @@ type RunHook<Config, Output> = (ctx: WorkflowActionContext, config: Config) => P
  */
 type AuthorizeHook<Config> = (ctx: WorkflowActionContext, config: Config) => Promise<boolean>;
 type PlanHook<Config> = (ctx: WorkflowActionContext, config: Config) => Promise<WorkflowPlannedEffect>;
+/** Cheap, side-effect-free budget counts; shared by execution and dry runs. */
+type CostHook<Config> = (ctx: WorkflowActionContext, config: Config) => Record<string, number> | Promise<Record<string, number>>;
 
 /**
  * `NoInfer` because `run` alone defines what an action produces. Reconcile
@@ -238,6 +240,7 @@ export type WorkflowActionDefinition<Effect extends WorkflowEffectClass, Schema
   run: RunHook<FromFieldSchema<Schema>, Output>;
   /** What a dry run reports. Required for everything that leaves the process. */
   plan?: PlanHook<FromFieldSchema<Schema>>;
+  cost?: CostHook<FromFieldSchema<Schema>>;
   /** Asks afterwards whether an ambiguous effect landed. */
   reconcile?: ReconcileHook<Output>;
   /** Re-checks permission at the moment of the effect, on the effect's own handle. */
@@ -250,6 +253,7 @@ type ActionBase<Schema extends ObjectSchema> = {
   description: string;
   config: Schema;
   outputType?: string;
+  cost?: CostHook<FromFieldSchema<Schema>>;
 };
 
 /**
@@ -270,7 +274,7 @@ type ActionBase<Schema extends ObjectSchema> = {
 export const workflowAction = {
   /** Deterministic given inputs and prior outcomes. Reading mutable state is not pure. */
   pure: <const Schema extends ObjectSchema, Output = void>(
-    definition: ActionBase<Schema> & {
+    definition: Omit<ActionBase<Schema>, "cost"> & {
       run: RunHook<FromFieldSchema<Schema>, Output>;
     },
   ): WorkflowActionDefinition<"pure", Schema, Output> => ({ ...definition, effect: "pure" }),
@@ -327,6 +331,7 @@ export type ErasedWorkflowAction = {
   outputType?: string;
   run: RunHook<never, unknown>;
   plan?: PlanHook<never>;
+  cost?: CostHook<never>;
   reconcile?: ReconcileHook<unknown>;
   authorize?: AuthorizeHook<never>;
 };

package/src/workflows/store/actions.ts

@@ -7,13 +7,13 @@
  * started, settle it afterwards. Both apps did, slightly differently, which is
  * how one of them ended up with no budget at all.
  *
- * The budget is charged from the action's own `plan` hook — the same hook a dry
+ * The budget is charged from the action's own `cost` hook — the same hook a dry
  * run uses. That is the point: preflight and execution cannot disagree about
  * what an action costs, because one function answers for both. Mail's known
  * defect was exactly that divergence, and here it is not a bug to fix but a
  * shape that cannot occur.
  */
-import type { SQL } from "bun";
+import { SQL } from "bun";
 import { type WorkflowDependency, type WorkflowJsonValue, type WorkflowStepOutcome, workflowPathKey } from "../contracts";
 import type { ErasedWorkflowAction, WorkflowActionContext } from "../definition";
 import type { DefinedWorkflowModule } from "../module";
@@ -25,7 +25,16 @@ import type {
   WorkflowExecuteActionPort,
 } from "../runtime/ports";
 import { budgetError, budgetRootRunId, chargeWorkflowEffectBudget } from "./budget";
-import { beginWorkflowEffect, readWorkflowEffect, recordWorkflowEffect, settleWorkflowEffect } from "./runs";
+import {
+  beginWorkflowEffect,
+  markWorkflowStepBudgetCharged,
+  readWorkflowEffect,
+  recordWorkflowEffect,
+  renewWorkflowRunLease,
+  settleWorkflowEffect,
+  WorkflowLeaseLostError,
+  workflowStepBudgetCharged,
+} from "./runs";
 import { withTransaction } from "./transaction";
 
 /**
@@ -99,8 +108,14 @@ const actionContext = (
     resolveReference: (reference: string, ...path: Array<string | number>): Promise<WorkflowJsonValue | undefined> =>
       ctx.resolveReference(reference, configPath(path)),
     variableSnapshot: (): Record<string, WorkflowJsonValue> => ctx.variables.snapshot?.() ?? {},
-    heartbeat: async (): Promise<void> => {
+    heartbeat: async (transaction?: SQL): Promise<void> => {
+      if (!transaction) return ctx.heartbeat();
+      // The generation check and UPDATE lock live on the caller's transaction,
+      // so takeover/cancellation cannot interleave with its domain writes.
+      const lease = await renewWorkflowRunLease(ctx.run, { db: transaction });
+      if (lease.state === "active") return;
       await ctx.heartbeat();
+      throw new WorkflowLeaseLostError();
     },
   };
 };
@@ -170,7 +185,7 @@ export type WorkflowActionPortOptions = {
 /**
  * Runs one declared action, with everything its effect class implies.
  *
- * The order is the contract: plan, then charge, then mark, then act, then
+ * The order is the contract: estimate costs, charge, mark, act, then
  * settle. Charging before acting is the only ordering that cannot overspend,
  * and marking before acting is the only one that leaves evidence when the
  * process dies mid-effect.
@@ -186,20 +201,22 @@ const runDeclaredAction = async (
   const effectKey = workflowEffectKey(ctx.run.runId, ctx.step.key);
   const journal = options.journal ?? kernelEffectJournal(options.db);
 
-  /**
-   * Asks the action what it would do, and charges the run for it.
-   *
-   * Only reached when there is a budget to charge: the answer is otherwise
-   * discarded, and `plan` is allowed to be expensive — an HTTP action resolves
-   * its target to check it is safe to call.
-   */
+  /** Charge declared costs without building a dry-run preview. */
   const charge = async (db?: SQL): Promise<Extract<WorkflowStepOutcome, { state: "failed" }> | null> => {
-    if (options.budget === false || !action.plan) return null;
-    const planned = await action.plan(actionContext(ctx, step, effectKey), config as never);
-    if (!planned.consumes || Object.keys(planned.consumes).length === 0) return null;
+    if (options.budget === false || !action.cost) return null;
+    const consumes = await action.cost(actionContext(ctx, step, effectKey, db), config as never);
+    if (Object.keys(consumes).length === 0) return null;
     const handle = db ?? options.db;
-    const root = await budgetRootRunId(ctx.run.runId, { ...(handle ? { db: handle } : {}) });
-    const charged = await chargeWorkflowEffectBudget(root, planned.consumes, { ...(handle ? { db: handle } : {}) });
+    // Once per step, not once per attempt: a step that parked on a dependency
+    // runs again to observe the effect it already paid for, and charging that
+    // resume refuses the automation it already performed.
+    const charged = await withTransaction(handle, async (tx) => {
+      if (await workflowStepBudgetCharged(tx, journalStep)) return { state: "ok" as const, used: {} };
+      const root = await budgetRootRunId(ctx.run.runId, { db: tx });
+      const outcome = await chargeWorkflowEffectBudget(root, consumes, { db: tx });
+      if (outcome.state === "ok") await markWorkflowStepBudgetCharged(tx, journalStep);
+      return outcome;
+    });
     if (charged.state !== "exceeded") return null;
     const error = budgetError(charged);
     return {
@@ -282,6 +299,14 @@ const runDeclaredAction = async (
         return { state: "waiting", dependency: error.dependency } satisfies WorkflowStepOutcome;
       if (error instanceof WorkflowTransactionalFailure)
         return { state: "failed", error: reportedError(error.failure) } satisfies WorkflowStepOutcome;
+      // These PostgreSQL errors guarantee that this transaction did not commit.
+      // Classify only after rollback; connection failures have an ambiguous
+      // commit outcome and must not enter this retry path.
+      if (error instanceof SQL.PostgresError && (error.errno === "40001" || error.errno === "40P01"))
+        return {
+          state: "failed",
+          error: asError("Transaction conflicted; retrying the step.", true, "WORKFLOW_TRANSACTION_CONFLICT"),
+        } satisfies WorkflowStepOutcome;
       throw error;
     });
   }
@@ -405,13 +430,12 @@ export const createWorkflowDryRunPort = (module: DefinedWorkflowModule): Workflo
           if (!action.plan) return { state: "unsupported" as const, reason: `${name} cannot be planned` };
 
           const planned = await action.plan(context, config as never);
+          const consumes = await action.cost?.(context, config as never);
           applySaveAs(ctx, step, (planned.output ?? undefined) as WorkflowJsonValue | undefined);
           return {
             state: "planned" as const,
             output: (planned.output ?? null) as WorkflowJsonValue,
-            effects: [
-              { action: name, summary: planned.summary, ...(planned.consumes ? { consumes: planned.consumes } : {}) } as WorkflowJsonValue,
-            ],
+            effects: [{ action: name, summary: planned.summary, ...(consumes ? { consumes } : {}) } as WorkflowJsonValue],
             // An issue names the step it belongs to, so the dry-run view can point
             // at what could not be determined rather than listing loose strings.
             ...(planned.issues?.length

package/src/workflows/store/index.ts

@@ -105,3 +105,5 @@ export {
   type WorkflowWorkerOptions,
   type WorkflowWorkerOutcome,
 } from "./worker";
+
+export { createWorkflowWorker, notifyWorkflowWorker } from "./worker-runtime";

package/src/workflows/store/runs.ts

@@ -831,6 +831,42 @@ export const recordWorkflowEffect = async (
   if (rows.length === 0) throw new WorkflowLeaseLostError();
 };
 
+/**
+ * Whether this step's effect budget was already charged.
+ *
+ * A step is executed more than once by design: it parks on a dependency and
+ * runs again when that dependency fires, and the second attempt adopts the
+ * effect the first one performed instead of performing it again. Charging per
+ * attempt therefore refused exactly the automations whose allowance is sized
+ * per effect — `maxMoves: 1` was spent by the move, and the resume that only
+ * observed its result was rejected as overspending.
+ *
+ * A run whose journal lives outside this table — an app adopting declared
+ * actions before its runs do — has no row here and keeps the per-attempt
+ * behaviour rather than silently going uncharged.
+ */
+export const workflowStepBudgetCharged = async (db: SQL, step: { runId: string; key: string }): Promise<boolean> => {
+  const [row] = await db<{ budget_charged_at: Date | null }[]>`
+    SELECT budget_charged_at FROM workflows.step_outcome
+    WHERE run_id = ${step.runId}::uuid AND step_key = ${step.key}
+  `;
+  return Boolean(row?.budget_charged_at);
+};
+
+/**
+ * Records that this step paid for its effect.
+ *
+ * Written on the handle that charged, so a charge that unwinds — a
+ * transactional action that ends up waiting — takes this with it.
+ */
+export const markWorkflowStepBudgetCharged = async (db: SQL, step: { runId: string; key: string }): Promise<void> => {
+  await db`
+    UPDATE workflows.step_outcome
+    SET budget_charged_at = now(), updated_at = now()
+    WHERE run_id = ${step.runId}::uuid AND step_key = ${step.key} AND budget_charged_at IS NULL
+  `;
+};
+
 /** Settles an effect once its fate is known. `ambiguous` is a real answer, not a failure. */
 export const settleWorkflowEffect = async (
   step: { runId: string; key: string; executionGeneration: number },

package/src/workflows/store/worker-pool.ts

@@ -0,0 +1,55 @@
+/** Bounded claim loops. A free slot never waits for another slot's action. */
+export const createWorkflowWorkerPool = (options: {
+  concurrency: number;
+  /** True when a run was handled; false when no run was claimable. */
+  run(): Promise<boolean>;
+  onError(error: unknown): void;
+}) => {
+  if (!Number.isSafeInteger(options.concurrency) || options.concurrency < 1) {
+    throw new RangeError("Workflow concurrency must be a positive integer");
+  }
+  const tasks = new Set<Promise<void>>();
+  let accepting = false;
+  let generation = 0;
+
+  const wake = (): void => {
+    if (!accepting) return;
+    generation += 1;
+    while (tasks.size < options.concurrency) {
+      let observed = generation;
+      let failed = false;
+      const task = Promise.resolve().then(async () => {
+        try {
+          while (accepting) {
+            observed = generation;
+            const handled = await options.run();
+            // A wake received during an empty claim needs another attempt.
+            if (!handled && observed === generation) return;
+          }
+        } catch (error) {
+          failed = true;
+          options.onError(error);
+          // Recovery wakes us again; never spin on a failing database.
+        }
+      });
+      tasks.add(task);
+      const finished = () => {
+        tasks.delete(task);
+        if (!failed && observed !== generation) wake();
+      };
+      void task.then(finished, finished);
+    }
+  };
+
+  return {
+    start: (): void => {
+      accepting = true;
+      wake();
+    },
+    wake,
+    stop: async (): Promise<void> => {
+      accepting = false;
+      await Promise.allSettled([...tasks]);
+    },
+  };
+};

package/src/workflows/store/worker-runtime.ts

@@ -0,0 +1,90 @@
+import { lazySync } from "../../_internal/process-sync";
+import { logger } from "../../services/logging";
+import { createRuntimeLifecycle, superviseRuntimeTask } from "../../services/runtime-lifecycle";
+import { createWorkflowWorkerPool } from "./worker-pool";
+
+const log = logger("workflows:worker");
+const wakeTopic = lazySync((sync) =>
+  sync.topic<null>({
+    id: "cloud:workflow-wake",
+    owner: "cloud",
+    retention: { maxAgeMs: 120_000, maxBytes: 1_048_576 },
+    maxPayloadBytes: 2000,
+  }),
+);
+const localWorkers = new Map<string, Set<() => void>>();
+
+/** Call after the application's transaction commits. Postgres remains the work queue. */
+export const notifyWorkflowWorker = (appId: string): void => {
+  for (const wake of localWorkers.get(appId) ?? []) wake();
+  // Hints are best effort. Neither broker latency nor failure delays an accepted request.
+  void Promise.resolve()
+    .then(() => wakeTopic().publish({ tenantId: appId, data: null }))
+    .catch((error) => {
+      log.warn("Workflow wake notification failed", { appId, error: String(error) });
+    });
+};
+
+/** Event-driven claims plus a recovery scan for lost hints, deadlines and expired leases. */
+export const createWorkflowWorker = (options: {
+  appId: string;
+  concurrency: number;
+  run(): Promise<boolean>;
+  recover(): Promise<unknown>;
+}) => {
+  const report = (error: unknown) => log.warn("Workflow worker failed", { appId: options.appId, error: String(error) });
+  const pool = createWorkflowWorkerPool({ ...options, onError: report });
+  let controller: AbortController | undefined;
+  let reader: Promise<void> | undefined;
+  let timer: ReturnType<typeof setInterval> | undefined;
+  let recovery: Promise<void> | undefined;
+  let requested = 0;
+  const wake = () => {
+    if (!controller || controller.signal.aborted) return;
+    pool.wake();
+    requested += 1;
+    recovery ??= Promise.resolve().then(async () => {
+      try {
+        let observed: number;
+        do {
+          observed = requested;
+          await options.recover();
+          pool.wake();
+        } while (!controller?.signal.aborted && observed !== requested);
+      } catch (error) {
+        report(error);
+      } finally {
+        recovery = undefined;
+      }
+    });
+  };
+  return createRuntimeLifecycle({
+    start: async () => {
+      controller = new AbortController();
+      const workers = localWorkers.get(options.appId) ?? new Set();
+      workers.add(wake);
+      localWorkers.set(options.appId, workers);
+      pool.start();
+      reader = superviseRuntimeTask({
+        name: "Workflow wake reader",
+        signal: controller.signal,
+        onError: ({ error }) => report(error),
+        run: async (signal) => {
+          for await (const _event of wakeTopic().live({ tenantId: options.appId, signal })) wake();
+        },
+      });
+      // Keep the existing one-second recovery bound; execution does not wait for it.
+      timer = setInterval(wake, 1_000);
+      wake();
+    },
+    stop: async () => {
+      clearInterval(timer);
+      controller?.abort();
+      const workers = localWorkers.get(options.appId);
+      workers?.delete(wake);
+      if (workers?.size === 0) localWorkers.delete(options.appId);
+      await Promise.all([pool.stop(), recovery, reader]);
+      controller = undefined;
+    },
+  });
+};

package/scripts/app-favicon.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { renderAppFavicon, tablerIconName, writeAppFavicon } from "./app-favicon";
-
-describe("app favicon", () => {
-  test("extracts the documented Tabler icon class", () => {
-    expect(tablerIconName("ti ti-mail")).toBe("mail");
-    expect(() => tablerIconName("mail")).toThrow('such as "ti ti-mail"');
-    expect(() => tablerIconName("ti ti-mail extra")).toThrow('such as "ti ti-mail"');
-  });
-
-  test("renders a large icon with the Cloud gradient", () => {
-    const source = '<svg viewBox="0 0 24 24"><path d="M3 7h18" /></svg>';
-
-    const svg = renderAppFavicon(source);
-    expect(svg).toContain('<linearGradient id="cloud-icon"');
-    expect(svg).toContain(".start { stop-color: #3b82f6; }");
-    expect(svg).toContain(".end { stop-color: #1d4ed8; }");
-    expect(svg).toContain("@media (prefers-color-scheme: dark)");
-    expect(svg).toContain(".start { stop-color: #f0f6ff; }");
-    expect(svg).toContain(".end { stop-color: #1f8bff; }");
-    expect(svg).toContain('stroke="url(#cloud-icon)"');
-    expect(svg).toContain('stroke-width="2"');
-    expect(svg).not.toContain("<rect");
-    expect(svg).not.toContain("<filter");
-    expect(svg).toContain('<path d="M3 7h18" />');
-  });
-
-  test("writes a declared Tabler icon and rejects an unknown one", async () => {
-    const publicDir = await mkdtemp(join(tmpdir(), "cloud-app-favicon-"));
-    try {
-      const target = await writeAppFavicon({ publicDir, appId: "mail", icon: "ti ti-mail" });
-      const svg = await readFile(target, "utf8");
-      expect(svg).toContain('stroke="url(#cloud-icon)"');
-      expect(svg).toContain('d="M3 7l9 6l9 -6"');
-
-      const tableTarget = await writeAppFavicon({ publicDir, appId: "grids", icon: "ti ti-table" });
-      expect(await readFile(tableTarget, "utf8")).toContain('d="M3 10h18"');
-
-      await expect(writeAppFavicon({ publicDir, appId: "missing", icon: "ti ti-definitely-not-real" })).rejects.toThrow(
-        'Unknown Tabler app icon "ti ti-definitely-not-real"',
-      );
-    } finally {
-      await rm(publicDir, { recursive: true, force: true });
-    }
-  });
-});