@porulle/core 0.1.0

package/dist/kernel/jobs/reaper.js

@@ -0,0 +1,62 @@
+import { and, eq, lt, sql } from "drizzle-orm";
+import { commerceJobs } from "./schema.js";
+export function getJobReapThresholdMs() {
+    const raw = process.env.JOB_REAP_THRESHOLD_MS;
+    if (raw === undefined || raw === "")
+        return 300_000;
+    const n = Number.parseInt(raw, 10);
+    return Number.isFinite(n) && n > 0 ? n : 300_000;
+}
+export function getJobsReaperIntervalMs() {
+    const raw = process.env.JOBS_REAPER_INTERVAL_MS;
+    if (raw === undefined || raw === "")
+        return 60_000;
+    const n = Number.parseInt(raw, 10);
+    return Number.isFinite(n) && n > 0 ? n : 60_000;
+}
+export async function runStaleJobReaper(db, thresholdMs, logger) {
+    const cutoff = new Date(Date.now() - thresholdMs);
+    return db.transaction(async (tx) => {
+        const stuck = await tx
+            .select({
+            id: commerceJobs.id,
+            taskSlug: commerceJobs.taskSlug,
+            processingStartedAt: commerceJobs.processingStartedAt,
+            attempts: commerceJobs.attempts,
+        })
+            .from(commerceJobs)
+            .where(and(eq(commerceJobs.status, "processing"), sql `${commerceJobs.processingStartedAt} IS NOT NULL`, lt(commerceJobs.processingStartedAt, cutoff)))
+            .for("update");
+        let reapedCount = 0;
+        for (const row of stuck) {
+            const newAttempts = Math.max(row.attempts - 1, 0);
+            const updated = await tx
+                .update(commerceJobs)
+                .set({
+                status: "pending",
+                processingStartedAt: null,
+                attempts: newAttempts,
+                updatedAt: new Date(),
+            })
+                .where(and(eq(commerceJobs.id, row.id), eq(commerceJobs.status, "processing"), lt(commerceJobs.processingStartedAt, cutoff)))
+                .returning({ id: commerceJobs.id });
+            if (updated.length === 0)
+                continue;
+            reapedCount++;
+            logger.info("Reaped stale processing job", {
+                id: row.id,
+                taskSlug: row.taskSlug,
+                processingStartedAt: row.processingStartedAt,
+                attemptsAfter: newAttempts,
+            });
+        }
+        return { reapedCount };
+    });
+}
+export const staleJobReaperTask = {
+    slug: "jobs/reap-stale",
+    async handler({ ctx }) {
+        const reaped = await runStaleJobReaper(ctx.db, getJobReapThresholdMs(), ctx.logger);
+        return { output: { reapedCount: reaped.reapedCount } };
+    },
+};

package/dist/kernel/jobs/runner.d.ts

@@ -0,0 +1,24 @@
+import type { DrizzleDatabase } from "../database/drizzle-db.js";
+import type { Logger, ServiceContainer } from "../hooks/types.js";
+import type { TaskDefinition } from "./types.js";
+export interface RunPendingJobsArgs {
+    db: DrizzleDatabase;
+    tasks: Map<string, TaskDefinition>;
+    queue?: string;
+    limit?: number;
+    logger: Logger;
+    services: ServiceContainer;
+}
+/**
+ * Claims and processes pending jobs from the `commerce_jobs` table.
+ *
+ * Uses `FOR UPDATE SKIP LOCKED` to allow multiple runners to process
+ * jobs in parallel without conflicts. Each runner claims a batch,
+ * marks them as processing, then executes handlers outside the
+ * claim transaction.
+ */
+export declare function runPendingJobs(args: RunPendingJobsArgs): Promise<{
+    processed: number;
+    failed: number;
+}>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/kernel/jobs/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../../src/kernel/jobs/runner.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAGjD,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,eAAe,CAAC;IACpB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,kBAAkB,GACvB,OAAO,CAAC;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAmIhD"}

package/dist/kernel/jobs/runner.js

@@ -0,0 +1,118 @@
+import { eq, and, sql } from "drizzle-orm";
+import { commerceJobs } from "./schema.js";
+/**
+ * Claims and processes pending jobs from the `commerce_jobs` table.
+ *
+ * Uses `FOR UPDATE SKIP LOCKED` to allow multiple runners to process
+ * jobs in parallel without conflicts. Each runner claims a batch,
+ * marks them as processing, then executes handlers outside the
+ * claim transaction.
+ */
+export async function runPendingJobs(args) {
+    const { db, tasks, queue = "default", limit = 10, logger, services, } = args;
+    let processed = 0;
+    let failed = 0;
+    // Phase 1: Claim jobs atomically
+    const claimed = await db.transaction(async (tx) => {
+        const pending = await tx
+            .select()
+            .from(commerceJobs)
+            .where(and(eq(commerceJobs.status, "pending"), eq(commerceJobs.queue, queue), sql `(${commerceJobs.waitUntil} IS NULL OR ${commerceJobs.waitUntil} <= now())`))
+            .orderBy(commerceJobs.createdAt)
+            .limit(limit)
+            .for("update", { skipLocked: true });
+        for (const job of pending) {
+            await tx
+                .update(commerceJobs)
+                .set({
+                status: "processing",
+                processingStartedAt: new Date(),
+                updatedAt: new Date(),
+            })
+                .where(eq(commerceJobs.id, job.id));
+        }
+        return pending;
+    });
+    // Phase 2: Execute each claimed job outside the claim transaction
+    for (const job of claimed) {
+        const task = tasks.get(job.taskSlug);
+        if (!task) {
+            logger.warn("Unknown task slug — job marked as failed. Register the task handler in config.jobs.tasks.", {
+                taskSlug: job.taskSlug,
+                jobId: job.id,
+            });
+            await db
+                .update(commerceJobs)
+                .set({
+                status: "failed",
+                error: `Unknown task slug: ${job.taskSlug}`,
+                updatedAt: new Date(),
+                completedAt: new Date(),
+            })
+                .where(eq(commerceJobs.id, job.id));
+            failed++;
+            continue;
+        }
+        try {
+            const result = await task.handler({
+                input: job.input,
+                ctx: { logger, db, services },
+                job: {
+                    attemptNumber: job.attempts + 1,
+                    maxAttempts: job.maxAttempts,
+                },
+            });
+            await db
+                .update(commerceJobs)
+                .set({
+                status: "succeeded",
+                output: result.output,
+                attempts: job.attempts + 1,
+                updatedAt: new Date(),
+                completedAt: new Date(),
+            })
+                .where(eq(commerceJobs.id, job.id));
+            processed++;
+        }
+        catch (err) {
+            logger.error("Job handler failed", {
+                taskSlug: job.taskSlug,
+                jobId: job.id,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            const attempts = job.attempts + 1;
+            const maxAttempts = job.maxAttempts;
+            if (attempts >= maxAttempts) {
+                await db
+                    .update(commerceJobs)
+                    .set({
+                    status: "failed",
+                    error: err instanceof Error ? err.message : String(err),
+                    attempts,
+                    updatedAt: new Date(),
+                    completedAt: new Date(),
+                })
+                    .where(eq(commerceJobs.id, job.id));
+                failed++;
+            }
+            else {
+                // Compute backoff delay
+                const retries = task.retries;
+                const delay = retries?.backoff?.type === "exponential"
+                    ? retries.backoff.delay * Math.pow(2, attempts - 1)
+                    : (retries?.backoff?.delay ?? 1000);
+                await db
+                    .update(commerceJobs)
+                    .set({
+                    status: "pending",
+                    error: err instanceof Error ? err.message : String(err),
+                    attempts,
+                    waitUntil: new Date(Date.now() + delay),
+                    updatedAt: new Date(),
+                })
+                    .where(eq(commerceJobs.id, job.id));
+            }
+        }
+    }
+    return { processed, failed };
+}

package/dist/kernel/jobs/schema.d.ts

@@ -0,0 +1,280 @@
+export declare const commerceJobs: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "commerce_jobs";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "commerce_jobs";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        organizationId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "organization_id";
+            tableName: "commerce_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        queue: import("drizzle-orm/pg-core").PgColumn<{
+            name: "queue";
+            tableName: "commerce_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        taskSlug: import("drizzle-orm/pg-core").PgColumn<{
+            name: "task_slug";
+            tableName: "commerce_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        input: import("drizzle-orm/pg-core").PgColumn<{
+            name: "input";
+            tableName: "commerce_jobs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        output: import("drizzle-orm/pg-core").PgColumn<{
+            name: "output";
+            tableName: "commerce_jobs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "commerce_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: "pending" | "processing" | "succeeded" | "failed";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["pending", "processing", "succeeded", "failed"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        attempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempts";
+            tableName: "commerce_jobs";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        maxAttempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "max_attempts";
+            tableName: "commerce_jobs";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        error: import("drizzle-orm/pg-core").PgColumn<{
+            name: "error";
+            tableName: "commerce_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        waitUntil: import("drizzle-orm/pg-core").PgColumn<{
+            name: "wait_until";
+            tableName: "commerce_jobs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        concurrencyKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "concurrency_key";
+            tableName: "commerce_jobs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "commerce_jobs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "commerce_jobs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        processingStartedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "processing_started_at";
+            tableName: "commerce_jobs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        completedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "completed_at";
+            tableName: "commerce_jobs";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/kernel/jobs/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/kernel/jobs/schema.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCtB,CAAC"}

package/dist/kernel/jobs/schema.js

@@ -0,0 +1,37 @@
+import { pgTable, uuid, text, jsonb, integer, timestamp, index, } from "drizzle-orm/pg-core";
+import { organization } from "../../auth/auth-schema.js";
+export const commerceJobs = pgTable("commerce_jobs", {
+    id: uuid("id").primaryKey().defaultRandom(),
+    organizationId: text("organization_id")
+        .notNull()
+        .references(() => organization.id, { onDelete: "cascade" }),
+    queue: text("queue").notNull().default("default"),
+    taskSlug: text("task_slug").notNull(),
+    input: jsonb("input").notNull().default("{}"),
+    output: jsonb("output"),
+    status: text("status", {
+        enum: ["pending", "processing", "succeeded", "failed"],
+    })
+        .notNull()
+        .default("pending"),
+    attempts: integer("attempts").notNull().default(0),
+    maxAttempts: integer("max_attempts").notNull().default(1),
+    error: text("error"),
+    waitUntil: timestamp("wait_until", { withTimezone: true }),
+    concurrencyKey: text("concurrency_key"),
+    createdAt: timestamp("created_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true })
+        .notNull()
+        .defaultNow(),
+    processingStartedAt: timestamp("processing_started_at", {
+        withTimezone: true,
+    }),
+    completedAt: timestamp("completed_at", { withTimezone: true }),
+}, (table) => ({
+    statusQueueIdx: index("idx_jobs_status_queue").on(table.status, table.queue),
+    taskSlugIdx: index("idx_jobs_task_slug").on(table.taskSlug),
+    waitUntilIdx: index("idx_jobs_wait_until").on(table.waitUntil),
+    orgIdx: index("idx_jobs_org").on(table.organizationId),
+}));

package/dist/kernel/jobs/types.d.ts

@@ -0,0 +1,40 @@
+import type { Logger, ServiceContainer } from "../hooks/types.js";
+import type { DrizzleDatabase } from "../database/drizzle-db.js";
+export declare const BUILTIN_JOB_TASK_SLUGS: {
+    readonly webhookDeliver: "webhooks/deliver";
+    readonly staleJobReaper: "jobs/reap-stale";
+};
+export interface TaskContext {
+    logger: Logger;
+    db: DrizzleDatabase;
+    services: ServiceContainer;
+}
+export interface TaskRetryConfig {
+    attempts: number;
+    backoff?: {
+        type: "fixed" | "exponential";
+        delay: number;
+    };
+}
+/** Present when the handler is invoked by `runPendingJobs` (not for ad-hoc calls). */
+export interface TaskJobMeta {
+    attemptNumber: number;
+    maxAttempts: number;
+}
+export interface TaskDefinition<TInput extends Record<string, unknown> = Record<string, unknown>, TOutput extends Record<string, unknown> = Record<string, unknown>> {
+    slug: string;
+    handler: (args: {
+        input: TInput;
+        ctx: TaskContext;
+        job?: TaskJobMeta;
+    }) => Promise<{
+        output: TOutput;
+    }>;
+    retries?: TaskRetryConfig;
+    concurrency?: {
+        key: (input: TInput) => string;
+        exclusive?: boolean;
+        supersedes?: boolean;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/kernel/jobs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/kernel/jobs/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAEjE,eAAO,MAAM,sBAAsB;;;CAGzB,CAAC;AAEX,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,eAAe,CAAC;IACpB,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,OAAO,GAAG,aAAa,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAC5D;AAED,sFAAsF;AACtF,MAAM,WAAW,WAAW;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc,CAC7B,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChE,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAEjE,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,CAAC,IAAI,EAAE;QACd,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,WAAW,CAAC;QACjB,GAAG,CAAC,EAAE,WAAW,CAAC;KACnB,KAAK,OAAO,CAAC;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACnC,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,WAAW,CAAC,EAAE;QACZ,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;QAC/B,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,UAAU,CAAC,EAAE,OAAO,CAAC;KACtB,CAAC;CACH"}

package/dist/kernel/jobs/types.js

@@ -0,0 +1,4 @@
+export const BUILTIN_JOB_TASK_SLUGS = {
+    webhookDeliver: "webhooks/deliver",
+    staleJobReaper: "jobs/reap-stale",
+};