alepha 0.22.0 → 0.24.0

package/src/api/jobs/__tests__/$job.spec.ts

@@ -1,4 +1,4 @@
-import { Alepha, AlephaError, t } from "alepha";
+import { Alepha, AlephaError, z } from "alepha";
 import { LockProvider, MemoryLockProvider } from "alepha/lock";
 import { $repository } from "alepha/orm";
 import { AlephaOrmPostgres } from "alepha/orm/postgres";
@@ -50,7 +50,7 @@ describe("$job — registration validation", () => {
     class App {
       bad = $job({
         cron: "* * * * *",
-        schema: t.object({ id: t.text() }),
+        schema: z.object({ id: z.text() }),
         handler: async () => {},
       });
     }
@@ -172,7 +172,7 @@ describe("$job — queue mode (outbox)", () => {
     class App {
       executions = $repository(jobExecutionEntity);
       work = $job({
-        schema: t.object({ n: t.integer() }),
+        schema: z.object({ n: z.integer() }),
         handler: async ({ payload }) => {
           received = payload;
         },
@@ -196,7 +196,7 @@ describe("$job — queue mode (outbox)", () => {
     class App {
       executions = $repository(jobExecutionEntity);
       work = $job({
-        schema: t.object({ n: t.integer() }),
+        schema: z.object({ n: z.integer() }),
         record: "all",
         handler: async () => {},
       });
@@ -219,7 +219,7 @@ describe("$job — queue mode (outbox)", () => {
     const alepha = makeApp();
     class App {
       work = $job({
-        schema: t.object({ v: t.integer() }),
+        schema: z.object({ v: z.integer() }),
         handler: async () => {},
       });
     }
@@ -246,7 +246,7 @@ describe("$job — queue mode (outbox)", () => {
     class App {
       executions = $repository(jobExecutionEntity);
       work = $job({
-        schema: t.object({ v: t.integer() }),
+        schema: z.object({ v: z.integer() }),
         handler: async () => {
           calls++;
         },
@@ -271,7 +271,7 @@ describe("$job — queue mode (outbox)", () => {
     const seen: number[] = [];
     class App {
       work = $job({
-        schema: t.object({ n: t.integer() }),
+        schema: z.object({ n: z.integer() }),
         handler: async ({ payload }) => {
           seen.push(payload.n);
         },
@@ -301,7 +301,7 @@ describe("$job — queue mode (outbox)", () => {
     class App {
       executions = $repository(jobExecutionEntity);
       work = $job({
-        schema: t.object({ v: t.integer() }),
+        schema: z.object({ v: z.integer() }),
         retry: { retries: 2 },
         handler: async () => {
           attempts++;
@@ -336,7 +336,7 @@ describe("$job — queue mode (outbox)", () => {
     class App {
       executions = $repository(jobExecutionEntity);
       work = $job({
-        schema: t.object({ v: t.integer() }),
+        schema: z.object({ v: z.integer() }),
         // no retry config → 1 attempt
         handler: async () => {
           throw new Error("dead");
@@ -365,7 +365,7 @@ describe("$job — cancel", () => {
     class App {
       executions = $repository(jobExecutionEntity);
       work = $job({
-        schema: t.object({ v: t.integer() }),
+        schema: z.object({ v: z.integer() }),
         handler: async () => {},
       });
     }
@@ -393,7 +393,7 @@ describe("$job — admin service", () => {
         handler: async () => {},
       });
       queueB = $job({
-        schema: t.object({ v: t.integer() }),
+        schema: z.object({ v: z.integer() }),
         handler: async () => {},
       });
     }
@@ -417,7 +417,7 @@ describe("$job — admin service", () => {
     const alepha = makeAppDirect();
     class App {
       worker = $job({
-        schema: t.object({ v: t.integer() }),
+        schema: z.object({ v: z.integer() }),
         handler: async () => {},
       });
     }
@@ -443,7 +443,7 @@ describe("$job — direct mode (no AlephaApiJobsQueue)", () => {
     class App {
       executions = $repository(jobExecutionEntity);
       work = $job({
-        schema: t.object({ n: t.integer() }),
+        schema: z.object({ n: z.integer() }),
         handler: async ({ payload }) => {
           received = payload;
         },
@@ -477,7 +477,7 @@ describe("$job — direct mode (no AlephaApiJobsQueue)", () => {
     class App {
       executions = $repository(jobExecutionEntity);
       work = $job({
-        schema: t.object({ n: t.integer() }),
+        schema: z.object({ n: z.integer() }),
         retry: { retries: 2 },
         handler: async () => {
           throw new Error("nope");
@@ -616,7 +616,7 @@ describe("$job — retry semantics", () => {
     class App {
       executions = $repository(jobExecutionEntity);
       work = $job({
-        schema: t.object({ v: t.integer() }),
+        schema: z.object({ v: z.integer() }),
         retry: { retries: 2 },
         handler: async () => {
           attempts++;
@@ -675,7 +675,7 @@ describe("$job — cancel race", () => {
     class App {
       executions = $repository(jobExecutionEntity);
       slow = $job({
-        schema: t.object({ v: t.integer() }),
+        schema: z.object({ v: z.integer() }),
         retry: { retries: 0 },
         handler: async ({ signal }) => {
           // Wait for cancellation, then throw — without the guard this throw
@@ -784,7 +784,7 @@ describe("$job — dispatchMany (queue mode)", () => {
     const alepha = makeApp();
     class App {
       bulk = $job({
-        schema: t.object({ n: t.integer() }),
+        schema: z.object({ n: z.integer() }),
         handler: async () => {},
       });
     }
@@ -828,7 +828,7 @@ describe("$job — admin resource shape", () => {
     const alepha = makeApp();
     class App {
       work = $job({
-        schema: t.object({ v: t.integer() }),
+        schema: z.object({ v: z.integer() }),
         priority: "high",
         record: "all",
         handler: async () => {},

package/src/api/jobs/controllers/AdminJobController.ts

@@ -1,4 +1,4 @@
-import { $inject, t } from "alepha";
+import { $inject, z } from "alepha";
 import { $secure } from "alepha/security";
 import { $action, okSchema } from "alepha/server";
 import { jobExecutionQuerySchema } from "../schemas/jobExecutionQuerySchema.ts";
@@ -20,7 +20,7 @@ export class AdminJobController {
     group: this.group,
     use: [$secure({ permissions: ["admin:job:read"] })],
     schema: {
-      response: t.array(jobRegistrationSchema),
+      response: z.array(jobRegistrationSchema),
     },
     handler: () => this.jobService.listJobs(),
   });
@@ -30,9 +30,9 @@ export class AdminJobController {
     group: this.group,
     use: [$secure({ permissions: ["admin:job:read"] })],
     schema: {
-      params: t.object({ name: t.text() }),
+      params: z.object({ name: z.text() }),
       query: jobExecutionQuerySchema,
-      response: t.array(jobExecutionResourceSchema),
+      response: z.array(jobExecutionResourceSchema),
     },
     handler: ({ params, query }) =>
       this.jobService.getExecutions(params.name, query),
@@ -43,7 +43,7 @@ export class AdminJobController {
     group: this.group,
     use: [$secure({ permissions: ["admin:job:read"] })],
     schema: {
-      params: t.object({ id: t.uuid() }),
+      params: z.object({ id: z.uuid() }),
       response: jobExecutionResourceSchema,
     },
     handler: ({ params }) => this.jobService.getExecution(params.id),
@@ -55,7 +55,7 @@ export class AdminJobController {
     group: this.group,
     use: [$secure({ permissions: ["admin:job:trigger"] })],
     schema: {
-      params: t.object({ name: t.text() }),
+      params: z.object({ name: z.text() }),
       body: triggerJobSchema,
       response: okSchema,
     },
@@ -73,7 +73,7 @@ export class AdminJobController {
     group: this.group,
     use: [$secure({ permissions: ["admin:job:trigger"] })],
     schema: {
-      params: t.object({ id: t.uuid() }),
+      params: z.object({ id: z.uuid() }),
       response: okSchema,
     },
     handler: ({ params, user }) =>
@@ -89,7 +89,7 @@ export class AdminJobController {
     group: this.group,
     use: [$secure({ permissions: ["admin:job:cancel"] })],
     schema: {
-      params: t.object({ id: t.uuid() }),
+      params: z.object({ id: z.uuid() }),
       response: okSchema,
     },
     handler: ({ params, user }) =>

package/src/api/jobs/entities/jobExecutionEntity.ts

@@ -1,4 +1,4 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 import { logEntrySchema } from "alepha/logger";
 import { $entity, db } from "alepha/orm";
 
@@ -21,36 +21,46 @@ import { $entity, db } from "alepha/orm";
  */
 export const jobExecutionEntity = $entity({
   name: "job_executions",
-  schema: t.object({
-    id: db.primaryKey(t.uuid()),
+  schema: z.object({
+    id: db.primaryKey(z.uuid()),
     createdAt: db.createdAt(),
     updatedAt: db.updatedAt(),
 
-    jobName: t.text(),
-    key: t.optional(t.nullable(t.text())),
+    jobName: z.text(),
+    key: z.text().nullable().optional(),
+
+    /**
+     * Owning tenant for this execution, when it was pushed in (or for) a tenant
+     * context. Used to org-scope tenant-facing views — notably the notification
+     * admin list, which is backed by this outbox. Nullable: cron / global / non-
+     * tenant pushes carry none. Deliberately NOT `db.organization()`: the job
+     * worker + sweep must see every org's rows, so this stays a plain,
+     * non-auto-scoping column rather than an auto-filtered one.
+     */
+    organizationId: z.uuid().nullable().optional(),
 
     status: db.default(
-      t.enum(["pending", "running", "scheduled", "ok", "error", "cancelled"]),
+      z.enum(["pending", "running", "scheduled", "ok", "error", "cancelled"]),
       "pending",
     ),
-    priority: db.default(t.integer({ minimum: 0, maximum: 3 }), 2),
+    priority: db.default(z.integer().min(0).max(3), 2),
 
-    attempt: db.default(t.integer(), 0),
-    maxAttempts: db.default(t.integer(), 1),
+    attempt: db.default(z.integer(), 0),
+    maxAttempts: db.default(z.integer(), 1),
 
-    payload: t.optional(t.record(t.text(), t.any())),
+    payload: z.record(z.text(), z.any()).optional(),
 
-    scheduledAt: t.optional(t.datetime()),
-    startedAt: t.optional(t.datetime()),
-    completedAt: t.optional(t.datetime()),
+    scheduledAt: z.datetime().optional(),
+    startedAt: z.datetime().optional(),
+    completedAt: z.datetime().optional(),
 
-    error: t.optional(t.text()),
-    logs: t.optional(t.array(logEntrySchema)),
+    error: z.text().optional(),
+    logs: z.array(logEntrySchema).optional(),
 
-    triggeredBy: t.optional(t.text()),
-    triggeredByName: t.optional(t.text()),
-    cancelledBy: t.optional(t.text()),
-    cancelledByName: t.optional(t.text()),
+    triggeredBy: z.text().optional(),
+    triggeredByName: z.text().optional(),
+    cancelledBy: z.text().optional(),
+    cancelledByName: z.text().optional(),
   }),
   indexes: [
     { columns: ["jobName", "status", "scheduledAt"] },

package/src/api/jobs/providers/JobProvider.ts

@@ -12,7 +12,11 @@ import { DateTimeProvider, type DurationLike } from "alepha/datetime";
 import { LockProvider } from "alepha/lock";
 import type { LogEntry } from "alepha/logger";
 import { $logger } from "alepha/logger";
-import { $repository, DbEntityNotFoundError } from "alepha/orm";
+import {
+  $repository,
+  DbConflictError,
+  DbEntityNotFoundError,
+} from "alepha/orm";
 import { CronProvider } from "alepha/scheduler";
 import {
   type JobStatus,
@@ -49,6 +53,13 @@ export interface PushOptions {
   scheduledAt?: Date;
   triggeredBy?: string;
   triggeredByName?: string;
+  /**
+   * Owning tenant for this execution. Persisted on the row so tenant-facing
+   * views (e.g. the notification admin list) can org-scope it. Plumbed through
+   * verbatim — callers in a tenant context pass it explicitly (the resolved
+   * tenant), cron/global pushes leave it undefined.
+   */
+  organizationId?: string;
 }
 
 export interface PushManyItem<T extends TSchema = TSchema> {
@@ -615,7 +626,7 @@ export class JobProvider {
       if (existing.length > 0) {
         return existing[0].id;
       }
-      const execution = await this.executions.create({
+      const { id: executionId, created } = await this.createKeyedExecution({
         jobName: name,
         key: options.key,
         payload: validated as Record<string, unknown>,
@@ -625,13 +636,18 @@ export class JobProvider {
         scheduledAt,
         triggeredBy: options.triggeredBy,
         triggeredByName: options.triggeredByName,
+        organizationId: options.organizationId,
       });
+      if (!created) {
+        // Lost the race to a concurrent same-key push — the winner dispatches.
+        return executionId;
+      }
       if (status === "pending") {
-        await this.dispatch(name, execution.id);
+        await this.dispatch(name, executionId);
       } else if (status === "scheduled" && scheduledAt) {
-        this.scheduleOptimisticDispatch(name, execution.id, scheduledAt);
+        this.scheduleOptimisticDispatch(name, executionId, scheduledAt);
       }
-      return execution.id;
+      return executionId;
     }
 
     const execution = await this.executions.create({
@@ -643,6 +659,7 @@ export class JobProvider {
       scheduledAt,
       triggeredBy: options?.triggeredBy,
       triggeredByName: options?.triggeredByName,
+      organizationId: options?.organizationId,
     });
 
     if (status === "pending") {
@@ -653,11 +670,94 @@ export class JobProvider {
     return execution.id;
   }
 
+  /**
+   * How long a `running` row may go without a lease renewal before the
+   * sweep assumes the instance running it crashed. Shared by the sweep's
+   * crash detection and the heartbeat cadence so the two can't drift.
+   */
+  protected crashThresholdMs(registration: JobRuntimeRegistration): number {
+    return registration.options.timeout
+      ? this.dt.duration(registration.options.timeout).as("milliseconds") * 2
+      : this.config.runTimeout;
+  }
+
+  /**
+   * While a handler runs, keep the row's `updatedAt` fresh so another
+   * instance's sweep can tell a long-running job from a crashed one — the
+   * sweep treats `max(startedAt, updatedAt)` as the lease. Self-stops when
+   * the row leaves `running` (finished, cancelled, swept elsewhere).
+   */
+  protected startLeaseHeartbeat(
+    executionId: string,
+    registration: JobRuntimeRegistration,
+  ): ReturnType<typeof setInterval> {
+    const intervalMs = Math.max(
+      250,
+      Math.floor(this.crashThresholdMs(registration) / 3),
+    );
+    const timer = setInterval(() => {
+      void (async () => {
+        try {
+          await this.executions.updateOne(
+            { id: { eq: executionId }, status: { eq: "running" } },
+            { status: "running" },
+          );
+        } catch {
+          clearInterval(timer);
+        }
+      })();
+    }, intervalMs);
+    return timer;
+  }
+
+  /**
+   * Insert a keyed execution row, resolving the dedup pre-check/insert
+   * race: a concurrent same-key push can land between the read and this
+   * insert, so a unique violation on (jobName, key) is settled by
+   * returning the winner's row instead of throwing.
+   */
+  protected async createKeyedExecution(fields: {
+    jobName: string;
+    key: string;
+    payload?: Record<string, unknown>;
+    status: JobStatus;
+    priority: number;
+    maxAttempts: number;
+    scheduledAt?: string;
+    triggeredBy?: string;
+    triggeredByName?: string;
+    organizationId?: string;
+  }): Promise<{ id: string; created: boolean }> {
+    try {
+      const execution = await this.executions.create(fields);
+      return { id: execution.id, created: true };
+    } catch (e) {
+      if (e instanceof DbConflictError) {
+        const winner = await this.executions.findMany({
+          where: { jobName: { eq: fields.jobName }, key: { eq: fields.key } },
+          limit: 1,
+        });
+        if (winner.length > 0) {
+          return { id: winner[0].id, created: false };
+        }
+      }
+      throw e;
+    }
+  }
+
+  /**
+   * Ceiling for the optimistic local timer. Past one day the sweep is the
+   * delivery mechanism anyway, and a 32-bit `setTimeout` overflows at
+   * ~24.85 days — an unclamped timer would fire immediately and run the
+   * job weeks early.
+   */
+  protected readonly maxOptimisticDelayMs = 24 * 60 * 60 * 1000;
+
   /**
    * Fire a local setTimeout so delayed/retrying rows dispatch as close to
    * `scheduledAt` as possible, rather than waiting for the next sweep tick.
-   * No-op on stateless runtimes where timers won't survive (the sweep
-   * handles those).
+   * No-op on stateless runtimes where timers won't survive, and for delays
+   * beyond `maxOptimisticDelayMs` (the sweep handles both).
    */
   protected scheduleOptimisticDispatch(
     jobName: string,
@@ -668,6 +768,9 @@ export class JobProvider {
       0,
       new Date(scheduledAt).getTime() - this.dt.nowMillis(),
     );
+    if (delayMs > this.maxOptimisticDelayMs) {
+      return;
+    }
     this.dt.createTimeout(() => {
       void this.dispatchScheduled(jobName, executionId);
     }, delayMs);
@@ -912,6 +1015,7 @@ export class JobProvider {
       const ms = this.dt.duration(opts.timeout).as("milliseconds");
       timeoutId = setTimeout(() => abortController.abort(), ms);
     }
+    const leaseTimer = this.startLeaseHeartbeat(executionId, registration);
 
     const now = this.dt.now();
 
@@ -988,6 +1092,7 @@ export class JobProvider {
         { context: contextId },
       );
     } finally {
+      clearInterval(leaseTimer);
       this.perExecutionLogs.delete(contextId);
     }
   }
@@ -1164,13 +1269,18 @@ export class JobProvider {
         const reg = this.jobs.get(exec.jobName);
         if (!reg) continue;
         if (this.abortControllers.has(exec.id)) continue; // still alive locally
-        const crashThresholdMs = reg.options.timeout
-          ? this.dt.duration(reg.options.timeout).as("milliseconds") * 2
-          : this.config.runTimeout;
+        const crashThresholdMs = this.crashThresholdMs(reg);
         const startedAtMs = exec.startedAt
           ? new Date(exec.startedAt).getTime()
           : 0;
-        if (startedAtMs > 0 && nowMs - startedAtMs > crashThresholdMs) {
+        // The lease is whichever is fresher: the claim (startedAt) or the
+        // last heartbeat (updatedAt). A legitimately long-running job on
+        // another instance keeps renewing; only a stale lease is a crash.
+        const heartbeatMs = exec.updatedAt
+          ? new Date(exec.updatedAt).getTime()
+          : 0;
+        const lastAliveMs = Math.max(startedAtMs, heartbeatMs);
+        if (lastAliveMs > 0 && nowMs - lastAliveMs > crashThresholdMs) {
           this.log.warn(
             `Sweep: marking crashed ${exec.jobName} (${exec.id}) as failed`,
           );
@@ -1200,6 +1310,8 @@ export class JobProvider {
    * Move a row from `scheduled` → `pending` and dispatch it.
    * Used by the optimistic retry/delay timer. If the sweep has already moved
    * the row, or another worker has claimed it, the UPDATE guard fails silently.
+   * The `scheduledAt <= now` condition keeps a stray early timer (clock skew,
+   * timer overflow) from promoting a row ahead of schedule.
    */
   protected async dispatchScheduled(
     jobName: string,
@@ -1208,7 +1320,11 @@ export class JobProvider {
     if (this.stopping) return;
     try {
       await this.executions.updateOne(
-        { id: { eq: executionId }, status: { eq: "scheduled" } },
+        {
+          id: { eq: executionId },
+          status: { eq: "scheduled" },
+          scheduledAt: { lte: this.dt.nowISOString() },
+        },
         { status: "pending" },
       );
       await this.dispatchSafe(jobName, executionId);

package/src/api/jobs/providers/JobQueueProvider.ts

@@ -1,4 +1,4 @@
-import { $inject, Alepha, t } from "alepha";
+import { $inject, Alepha, z } from "alepha";
 import { $queue } from "alepha/queue";
 import { JobDispatcher } from "./JobDispatcher.ts";
 import { JobProvider } from "./JobProvider.ts";
@@ -31,7 +31,7 @@ export class JobQueueProvider extends JobDispatcher {
 
   protected readonly queue = $queue({
     name: "api:jobs:dispatch",
-    schema: t.object({ jobName: t.text(), executionId: t.text() }),
+    schema: z.object({ jobName: z.text(), executionId: z.text() }),
     handler: async (msg) => {
       await this.getJobProvider().processExecution(
         msg.payload.jobName,

package/src/api/jobs/schemas/jobConfigAtom.ts

@@ -1,37 +1,37 @@
-import { $atom, type Static, t } from "alepha";
+import { $atom, type Static, z } from "alepha";
 
 export const jobConfig = $atom({
   name: "alepha.jobs",
   description: "Configuration for the $job primitive.",
-  schema: t.object({
-    sweepCron: t.text({
+  schema: z.object({
+    sweepCron: z.text({
       description:
         "Cron expression for the sweep tick. Must be minute-granular at minimum (cron resolution). On Cloudflare Workers this expression is emitted into wrangler.jsonc by the build.",
     }),
-    trimCron: t.text({
+    trimCron: z.text({
       description:
         "Cron expression for the ring-buffer trim tick (per-job keepLastSuccess/keepLastError enforcement). Decoupled from `sweepCron` because trim is bounded by job execution rate, not retry latency — running it every sweep is wasted work for most apps.",
     }),
-    staleThreshold: t.integer({
-      description: "Pending age (ms) before the sweep re-dispatches it.",
-    }),
-    runTimeout: t.integer({
-      description:
+    staleThreshold: z
+      .integer()
+      .describe("Pending age (ms) before the sweep re-dispatches it."),
+    runTimeout: z
+      .integer()
+      .describe(
         "Running age (ms) before assumed crash (fallback when no per-job timeout).",
-    }),
-    keepLastSuccess: t.integer({
-      description:
+      ),
+    keepLastSuccess: z
+      .integer()
+      .describe(
         "Max successful rows to keep per job. Set 0 to disable and delete on success.",
-    }),
-    keepLastError: t.integer({
-      description: "Max error rows to keep per job.",
-    }),
-    logMaxEntries: t.integer({
-      description: "Max log entries captured per execution.",
-    }),
-    drainTimeout: t.integer({
-      description: "Max time (ms) to wait for in-flight jobs during shutdown.",
-    }),
+      ),
+    keepLastError: z.integer().describe("Max error rows to keep per job."),
+    logMaxEntries: z
+      .integer()
+      .describe("Max log entries captured per execution."),
+    drainTimeout: z
+      .integer()
+      .describe("Max time (ms) to wait for in-flight jobs during shutdown."),
   }),
   default: {
     sweepCron: "*/15 * * * *",

package/src/api/jobs/schemas/jobExecutionQuerySchema.ts

@@ -1,10 +1,10 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 
-export const jobExecutionQuerySchema = t.object({
-  status: t.optional(
-    t.enum(["pending", "running", "scheduled", "ok", "error", "cancelled"]),
-  ),
-  limit: t.optional(t.integer({ minimum: 1, maximum: 200, default: 20 })),
+export const jobExecutionQuerySchema = z.object({
+  status: z
+    .enum(["pending", "running", "scheduled", "ok", "error", "cancelled"])
+    .optional(),
+  limit: z.integer().min(1).max(200).default(20).optional(),
 });
 
 export type JobExecutionQuery = Static<typeof jobExecutionQuerySchema>;

package/src/api/jobs/schemas/jobExecutionResourceSchema.ts

@@ -1,4 +1,4 @@
-import { type Static, t } from "alepha";
+import { type Static, z } from "alepha";
 import { jobExecutionEntity } from "../entities/jobExecutionEntity.ts";
 
 /**
@@ -11,22 +11,18 @@ import { jobExecutionEntity } from "../entities/jobExecutionEntity.ts";
  *   `JobService` is responsible for the int → string transform.
  * - `can` derives the available admin actions from the row's status.
  */
-export const jobExecutionResourceSchema = t.extend(
-  // `t.extend` composes (interface-extends), it does not override: the base
-  // `priority` (integer) would still be enforced alongside the enum below and
-  // reject the int→string transform. Drop it from the base first.
-  t.omit(jobExecutionEntity.schema, ["priority"]),
-  {
-    priority: t.enum(["critical", "high", "normal", "low"]),
-    can: t.object({
-      retry: t.boolean(),
-      cancel: t.boolean(),
+export const jobExecutionResourceSchema = jobExecutionEntity.schema
+  .omit({ priority: true })
+  .extend({
+    priority: z.enum(["critical", "high", "normal", "low"]),
+    can: z.object({
+      retry: z.boolean(),
+      cancel: z.boolean(),
     }),
-  },
-  {
+  })
+  .meta({
     title: "JobExecutionResource",
     description: "A job execution row with derived actions.",
-  },
-);
+  });
 
 export type JobExecutionResource = Static<typeof jobExecutionResourceSchema>;