deepspace 0.3.9 → 0.3.11

package/dist/worker.js

@@ -239,6 +239,14 @@ var MSG = {
   CRON_PAUSE: "cron.pause",
   CRON_RESUME: "cron.resume",
   CRON_STATUS: "cron.status",
+  // ---- JobRoom ---------------------------------------------------------
+  // Background-job queue with durable, alarm-driven execution. See
+  // server/rooms/job-room.ts. Clients enqueue and subscribe to updates;
+  // the room broadcasts JOB_UPDATE for every status transition.
+  JOB_ENQUEUE: "job.enqueue",
+  JOB_CANCEL: "job.cancel",
+  JOB_RETRY: "job.retry",
+  JOB_UPDATE: "job.update",
   // ---- PresenceRoom ----------------------------------------------------
   PRESENCE_SYNC: "presence.sync",
   PRESENCE_JOIN: "presence.join",
@@ -934,6 +942,13 @@ var clientBuild = {
   cronTrigger: (taskName) => ({ type: MSG.CRON_TRIGGER, payload: { taskName } }),
   cronPause: (taskName) => ({ type: MSG.CRON_PAUSE, payload: { taskName } }),
   cronResume: (taskName) => ({ type: MSG.CRON_RESUME, payload: { taskName } }),
+  // Jobs
+  jobEnqueue: (requestId, type, payload, maxAttempts) => ({
+    type: MSG.JOB_ENQUEUE,
+    payload: { requestId, type, payload, maxAttempts }
+  }),
+  jobCancel: (jobId) => ({ type: MSG.JOB_CANCEL, payload: { jobId } }),
+  jobRetry: (jobId) => ({ type: MSG.JOB_RETRY, payload: { jobId } }),
   // Presence
   presenceUpdate: (state) => ({ type: MSG.PRESENCE_UPDATE, payload: state }),
   // Gateway
@@ -988,6 +1003,17 @@ var serverBuild = {
   cronTasks: (tasks) => ({ type: MSG.CRON_TASKS, payload: { tasks } }),
   cronHistory: (history) => ({ type: MSG.CRON_HISTORY, payload: { history } }),
   cronStatus: (tasks, recentHistory) => ({ type: MSG.CRON_STATUS, payload: { tasks, recentHistory } }),
+  // Jobs
+  jobSnapshot: (jobs) => ({ type: MSG.JOB_UPDATE, payload: { kind: "snapshot", jobs } }),
+  jobEnqueued: (job, requestId) => ({
+    type: MSG.JOB_UPDATE,
+    payload: { kind: "enqueued", job, requestId }
+  }),
+  jobProgress: (job) => ({ type: MSG.JOB_UPDATE, payload: { kind: "progress", job } }),
+  jobSucceeded: (job) => ({ type: MSG.JOB_UPDATE, payload: { kind: "succeeded", job } }),
+  jobFailed: (job) => ({ type: MSG.JOB_UPDATE, payload: { kind: "failed", job } }),
+  jobCanceled: (job) => ({ type: MSG.JOB_UPDATE, payload: { kind: "canceled", job } }),
+  jobRetried: (job) => ({ type: MSG.JOB_UPDATE, payload: { kind: "retried", job } }),
   // Presence
   presenceSync: (peers) => ({ type: MSG.PRESENCE_SYNC, payload: { peers } }),
   presenceJoin: (peer) => ({ type: MSG.PRESENCE_JOIN, payload: { peer } }),
@@ -4275,6 +4301,543 @@ function cronMatches(parsed, timezone, date) {
   return parsed.minute.has(minute) && parsed.hour.has(hour) && parsed.dayOfMonth.has(dayOfMonth) && parsed.month.has(month) && parsed.dayOfWeek.has(dayOfWeek);
 }
 
+// src/server/rooms/job-room.ts
+var RUNNING_STALE_MS = 16 * 60 * 1e3;
+var DEFAULT_RETENTION_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_SNAPSHOT_LIMIT = 100;
+var JobRoom = class extends BaseRoom {
+  initialized = false;
+  defaultMaxAttempts;
+  retentionMs;
+  snapshotLimit;
+  retryBackoffMs;
+  /** In-flight jobs in this isolate; lets same-isolate JOB_CANCEL fire the signal. */
+  inFlight = /* @__PURE__ */ new Map();
+  /** Set by `ctx.continue` inside `executeJob`; reset before every run. */
+  continueState = null;
+  constructor(state, env, config = {}) {
+    super(state, env);
+    this.defaultMaxAttempts = Math.max(1, config.defaultMaxAttempts ?? 1);
+    this.retentionMs = Math.max(0, config.retentionMs ?? DEFAULT_RETENTION_MS);
+    this.snapshotLimit = Math.max(1, config.snapshotLimit ?? DEFAULT_SNAPSHOT_LIMIT);
+    this.retryBackoffMs = Math.max(0, config.retryBackoffMs ?? 1e3);
+  }
+  ensureInitialized() {
+    if (this.initialized) return;
+    this.initialized = true;
+    this.sql.exec(`
+      CREATE TABLE IF NOT EXISTS jobs (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL,
+        status TEXT NOT NULL,
+        payload TEXT,
+        result TEXT,
+        error TEXT,
+        progress REAL,
+        progress_message TEXT,
+        checkpoint TEXT,
+        attempts INTEGER NOT NULL DEFAULT 0,
+        max_attempts INTEGER NOT NULL DEFAULT 1,
+        enqueued_at TEXT NOT NULL,
+        started_at TEXT,
+        completed_at TEXT,
+        enqueued_by TEXT,
+        next_run_at TEXT
+      )
+    `);
+    this.sql.exec(
+      `CREATE INDEX IF NOT EXISTS jobs_status_next_run ON jobs (status, next_run_at)`
+    );
+    this.sql.exec(
+      `CREATE INDEX IF NOT EXISTS jobs_completed_at ON jobs (completed_at)`
+    );
+    this.recoverStuckRunning();
+    this.scheduleNextAlarm();
+  }
+  // ==========================================================================
+  // BaseRoom Lifecycle
+  // ==========================================================================
+  async fetch(request) {
+    this.ensureInitialized();
+    return super.fetch(request);
+  }
+  onConnect(ws, user) {
+    this.ensureInitialized();
+    this.sendTo(ws, serverBuild.jobSnapshot(this.getRecentJobs(this.snapshotLimit)));
+    return user;
+  }
+  async onMessage(ws, user, message) {
+    this.ensureInitialized();
+    const { type, payload } = message;
+    switch (type) {
+      case MSG.JOB_ENQUEUE: {
+        const requestId = String(payload.requestId ?? "");
+        const jobType = String(payload.type ?? "");
+        if (!jobType) {
+          this.sendTo(ws, serverBuild.error("JOB_ENQUEUE missing type"));
+          return;
+        }
+        const job = this.insertJob({
+          type: jobType,
+          payload: payload.payload,
+          maxAttempts: typeof payload.maxAttempts === "number" ? Math.max(1, Math.floor(payload.maxAttempts)) : void 0,
+          enqueuedBy: user.userId
+        });
+        this.sendTo(ws, serverBuild.jobEnqueued(job, requestId));
+        this.broadcast(serverBuild.jobEnqueued(job), ws);
+        this.scheduleNextAlarm();
+        break;
+      }
+      case MSG.JOB_CANCEL: {
+        const jobId = String(payload.jobId ?? "");
+        if (!jobId) {
+          this.sendTo(ws, serverBuild.error("JOB_CANCEL missing jobId"));
+          return;
+        }
+        this.cancelJob(jobId);
+        break;
+      }
+      case MSG.JOB_RETRY: {
+        const jobId = String(payload.jobId ?? "");
+        if (!jobId) {
+          this.sendTo(ws, serverBuild.error("JOB_RETRY missing jobId"));
+          return;
+        }
+        this.retryJob(jobId);
+        break;
+      }
+      default:
+        this.sendTo(ws, serverBuild.error(`Unknown job message type: ${type}`));
+    }
+  }
+  async onAlarm() {
+    this.ensureInitialized();
+    await this.drainDueJobs();
+    this.pruneExpired();
+    this.scheduleNextAlarm();
+  }
+  // ==========================================================================
+  // HTTP — internal enqueue path for cross-isolate callers
+  // ==========================================================================
+  /**
+   * One internal endpoint, `POST /enqueue`, used by the `enqueueJob`
+   * helper at the bottom of this file. The room is not meant to be
+   * reachable from the public internet; callers route through the app
+   * worker (or call `this.enqueue(...)` directly from a subclass).
+   *
+   * Subclasses overriding `onRequest` should call `super.onRequest(req)`
+   * for paths they don't handle.
+   */
+  async onRequest(request) {
+    this.ensureInitialized();
+    const url = new URL(request.url);
+    if (request.method !== "POST" || !url.pathname.endsWith("/enqueue")) {
+      return new Response("Not Found", { status: 404 });
+    }
+    const body = await request.json().catch(() => null);
+    if (!body || typeof body.type !== "string" || !body.type) {
+      return new Response(JSON.stringify({ error: "type required" }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    const job = this.insertJob({
+      type: body.type,
+      payload: body.payload,
+      maxAttempts: typeof body.maxAttempts === "number" ? Math.max(1, Math.floor(body.maxAttempts)) : void 0,
+      enqueuedBy: typeof body.enqueuedBy === "string" ? body.enqueuedBy : void 0
+    });
+    this.broadcast(serverBuild.jobEnqueued(job));
+    this.scheduleNextAlarm();
+    return new Response(JSON.stringify({ job }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  // ==========================================================================
+  // Public enqueue surface (server-side callers in the same isolate)
+  // ==========================================================================
+  /**
+   * Synchronously persist a new job and arm the alarm. Returns the new
+   * job. This is the in-isolate path — useful for a subclass `onJob`
+   * that wants to chain follow-up work without paying a fetch hop:
+   *
+   *   protected async onJob(job: Job, ctx: JobContext) {
+   *     // ... do work ...
+   *     if (needsFollowup) this.enqueue('followup', { parent: job.id })
+   *   }
+   *
+   * Workers code that lives outside the DO isolate (HTTP routes, cron
+   * tasks, server actions) cannot call this directly — they must go
+   * through the `enqueueJob` helper at the bottom of this file, which
+   * routes via the DO's `/enqueue` HTTP endpoint.
+   */
+  enqueue(type, payload, options) {
+    this.ensureInitialized();
+    const job = this.insertJob({
+      type,
+      payload,
+      maxAttempts: options?.maxAttempts,
+      enqueuedBy: options?.enqueuedBy
+    });
+    this.broadcast(serverBuild.jobEnqueued(job));
+    this.scheduleNextAlarm();
+    return job;
+  }
+  // ==========================================================================
+  // Mutation helpers
+  // ==========================================================================
+  insertJob(input) {
+    const id = crypto.randomUUID();
+    const enqueuedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const maxAttempts = Math.max(1, input.maxAttempts ?? this.defaultMaxAttempts);
+    const payloadJson = input.payload === void 0 ? null : safeStringify(input.payload);
+    this.sql.exec(
+      `INSERT INTO jobs (id, type, status, payload, attempts, max_attempts, enqueued_at, enqueued_by, next_run_at)
+       VALUES (?, ?, 'queued', ?, 0, ?, ?, ?, ?)`,
+      id,
+      input.type,
+      payloadJson,
+      maxAttempts,
+      enqueuedAt,
+      input.enqueuedBy ?? null,
+      enqueuedAt
+    );
+    return this.getJobById(id);
+  }
+  cancelJob(jobId) {
+    const row = this.sql.exec(`SELECT status FROM jobs WHERE id = ?`, jobId).toArray()[0];
+    if (!row) return;
+    if (row.status === "succeeded" || row.status === "failed" || row.status === "canceled") {
+      return;
+    }
+    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.sql.exec(
+      `UPDATE jobs
+         SET status = 'canceled',
+             completed_at = ?,
+             checkpoint = NULL,
+             next_run_at = NULL
+       WHERE id = ?`,
+      completedAt,
+      jobId
+    );
+    const controller = this.inFlight.get(jobId);
+    if (controller) controller.abort();
+    const job = this.getJobById(jobId);
+    if (job) this.broadcast(serverBuild.jobCanceled(job));
+  }
+  retryJob(jobId) {
+    const row = this.sql.exec(`SELECT status, attempts, max_attempts FROM jobs WHERE id = ?`, jobId).toArray()[0];
+    if (!row) return;
+    if (row.status !== "failed" && row.status !== "canceled") return;
+    const newMax = Math.max(row.max_attempts, row.attempts + 1);
+    this.sql.exec(
+      `UPDATE jobs
+         SET status = 'queued',
+             max_attempts = ?,
+             error = NULL,
+             result = NULL,
+             completed_at = NULL,
+             next_run_at = ?
+       WHERE id = ?`,
+      newMax,
+      (/* @__PURE__ */ new Date()).toISOString(),
+      jobId
+    );
+    const job = this.getJobById(jobId);
+    if (job) this.broadcast(serverBuild.jobRetried(job));
+    this.scheduleNextAlarm();
+  }
+  // ==========================================================================
+  // Alarm / execution
+  // ==========================================================================
+  /**
+   * Drain due jobs in FIFO order. All due jobs share the alarm's
+   * 15-min wall budget (a CF property, not a per-job allocation).
+   */
+  async drainDueJobs() {
+    const cutoff = (/* @__PURE__ */ new Date()).toISOString();
+    while (true) {
+      const row = this.sql.exec(
+        `SELECT * FROM jobs
+            WHERE status = 'queued'
+              AND (next_run_at IS NULL OR next_run_at <= ?)
+            ORDER BY enqueued_at ASC
+            LIMIT 1`,
+        cutoff
+      ).toArray()[0];
+      if (!row) return;
+      await this.executeJob(row);
+    }
+  }
+  async executeJob(row) {
+    const startedAt = row.started_at ?? (/* @__PURE__ */ new Date()).toISOString();
+    const attemptsBefore = row.attempts;
+    const attempt = attemptsBefore + 1;
+    this.sql.exec(
+      `UPDATE jobs SET status = 'running', started_at = ?, attempts = ? WHERE id = ?`,
+      startedAt,
+      attempt,
+      row.id
+    );
+    const controller = new AbortController();
+    this.inFlight.set(row.id, controller);
+    this.continueState = null;
+    const job = {
+      ...rowToJobView(row),
+      status: "running",
+      attempts: attempt,
+      startedAt
+    };
+    let outcome = "succeeded";
+    let result;
+    let errorMessage;
+    try {
+      const ctx = this.makeContext(row.id, controller.signal);
+      result = await this.onJob(job, ctx);
+      if (this.continueState) outcome = "continued";
+    } catch (e) {
+      outcome = "failed";
+      errorMessage = e instanceof Error ? e.message : String(e);
+      console.error(`[JobRoom] Job "${row.type}" (${row.id}) failed:`, e);
+    } finally {
+      this.inFlight.delete(row.id);
+    }
+    const currentStatus = this.readStatus(row.id);
+    if (currentStatus === "canceled") {
+      this.continueState = null;
+      return;
+    }
+    if (outcome === "continued") {
+      const state = this.continueState;
+      this.continueState = null;
+      const nextRunAt = new Date(Date.now() + Math.max(0, state.afterMs)).toISOString();
+      this.sql.exec(
+        `UPDATE jobs
+           SET status = 'queued',
+               checkpoint = ?,
+               next_run_at = ?
+         WHERE id = ?`,
+        safeStringify(state.checkpoint),
+        nextRunAt,
+        row.id
+      );
+      const updated2 = this.getJobById(row.id);
+      if (updated2) this.broadcast(serverBuild.jobProgress(updated2));
+      return;
+    }
+    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (outcome === "succeeded") {
+      this.sql.exec(
+        `UPDATE jobs
+           SET status = 'succeeded',
+               result = ?,
+               completed_at = ?,
+               error = NULL,
+               checkpoint = NULL,
+               next_run_at = NULL,
+               progress = NULL,
+               progress_message = NULL
+         WHERE id = ?`,
+        result === void 0 ? null : safeStringify(result),
+        completedAt,
+        row.id
+      );
+      const updated2 = this.getJobById(row.id);
+      if (updated2) this.broadcast(serverBuild.jobSucceeded(updated2));
+      return;
+    }
+    if (attempt < row.max_attempts) {
+      const nextRunAt = new Date(Date.now() + this.retryBackoffMs).toISOString();
+      this.sql.exec(
+        `UPDATE jobs
+           SET status = 'queued',
+               error = ?,
+               next_run_at = ?,
+               started_at = NULL,
+               progress = NULL,
+               progress_message = NULL
+         WHERE id = ?`,
+        errorMessage ?? "unknown error",
+        nextRunAt,
+        row.id
+      );
+      const updated2 = this.getJobById(row.id);
+      if (updated2) this.broadcast(serverBuild.jobRetried(updated2));
+      return;
+    }
+    this.sql.exec(
+      `UPDATE jobs
+         SET status = 'failed',
+             error = ?,
+             completed_at = ?,
+             checkpoint = NULL,
+             next_run_at = NULL,
+             progress = NULL,
+             progress_message = NULL
+       WHERE id = ?`,
+      errorMessage ?? "unknown error",
+      completedAt,
+      row.id
+    );
+    const updated = this.getJobById(row.id);
+    if (updated) this.broadcast(serverBuild.jobFailed(updated));
+  }
+  makeContext(jobId, signal) {
+    return {
+      progress: (value, message) => {
+        const clamped = Math.max(0, Math.min(1, value));
+        this.sql.exec(
+          `UPDATE jobs SET progress = ?, progress_message = ? WHERE id = ?`,
+          clamped,
+          message ?? null,
+          jobId
+        );
+        const updated = this.getJobById(jobId);
+        if (updated) this.broadcast(serverBuild.jobProgress(updated));
+      },
+      continue: (state, options) => {
+        this.continueState = {
+          checkpoint: state,
+          afterMs: Math.max(0, options?.afterMs ?? 0)
+        };
+      },
+      signal
+    };
+  }
+  readStatus(jobId) {
+    const row = this.sql.exec(`SELECT status FROM jobs WHERE id = ?`, jobId).toArray()[0];
+    return row?.status ?? null;
+  }
+  // ==========================================================================
+  // Scheduling / recovery / pruning
+  // ==========================================================================
+  scheduleNextAlarm() {
+    const row = this.sql.exec(
+      `SELECT next_run_at FROM jobs
+          WHERE status = 'queued'
+          ORDER BY (next_run_at IS NULL) ASC, next_run_at ASC
+          LIMIT 1`
+    ).toArray()[0];
+    if (!row) return;
+    const now = Date.now();
+    const target = row.next_run_at ? Math.max(now, new Date(row.next_run_at).getTime()) : now;
+    this.state.storage.setAlarm(Math.max(target, now + 50));
+  }
+  recoverStuckRunning() {
+    const cutoff = new Date(Date.now() - RUNNING_STALE_MS).toISOString();
+    const stuck = this.sql.exec(
+      `SELECT id, attempts, max_attempts FROM jobs
+          WHERE status = 'running' AND started_at < ?`,
+      cutoff
+    ).toArray();
+    for (const r of stuck) {
+      if (r.attempts >= r.max_attempts) {
+        this.sql.exec(
+          `UPDATE jobs
+             SET status = 'failed',
+                 error = 'Isolate recycled or wall time exceeded',
+                 completed_at = ?,
+                 checkpoint = NULL,
+                 next_run_at = NULL
+           WHERE id = ?`,
+          (/* @__PURE__ */ new Date()).toISOString(),
+          r.id
+        );
+      } else {
+        this.sql.exec(
+          `UPDATE jobs
+             SET status = 'queued',
+                 started_at = NULL,
+                 next_run_at = ?,
+                 error = 'Previous attempt killed mid-run; retrying',
+                 progress = NULL,
+                 progress_message = NULL
+           WHERE id = ?`,
+          (/* @__PURE__ */ new Date()).toISOString(),
+          r.id
+        );
+      }
+    }
+  }
+  pruneExpired() {
+    if (this.retentionMs === 0) return;
+    const cutoff = new Date(Date.now() - this.retentionMs).toISOString();
+    this.sql.exec(
+      `DELETE FROM jobs
+        WHERE status IN ('succeeded', 'failed', 'canceled')
+          AND completed_at IS NOT NULL
+          AND completed_at < ?`,
+      cutoff
+    );
+  }
+  // ==========================================================================
+  // Read helpers
+  // ==========================================================================
+  getRecentJobs(limit) {
+    const rows = this.sql.exec(
+      `SELECT * FROM jobs
+          ORDER BY (status IN ('queued','running')) DESC, enqueued_at DESC
+          LIMIT ?`,
+      limit
+    ).toArray();
+    return rows.map(rowToJobView);
+  }
+  getJobById(id) {
+    const row = this.sql.exec(`SELECT * FROM jobs WHERE id = ?`, id).toArray()[0];
+    return row ? rowToJobView(row) : null;
+  }
+};
+async function enqueueJob(namespace, roomId, type, payload, options) {
+  const stub = namespace.get(namespace.idFromName(roomId));
+  const res = await stub.fetch(
+    new Request("https://job-room.internal/enqueue", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        type,
+        payload,
+        maxAttempts: options?.maxAttempts,
+        enqueuedBy: options?.enqueuedBy
+      })
+    })
+  );
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`enqueueJob failed: ${res.status} ${text}`);
+  }
+  const data = await res.json();
+  if (!data.job?.id) throw new Error("enqueueJob: malformed response");
+  return data.job.id;
+}
+function rowToJobView(row) {
+  return {
+    id: row.id,
+    type: row.type,
+    status: row.status,
+    payload: row.payload == null ? void 0 : JSON.parse(row.payload),
+    result: row.result == null ? void 0 : JSON.parse(row.result),
+    error: row.error ?? void 0,
+    progress: row.progress ?? void 0,
+    progressMessage: row.progress_message ?? void 0,
+    attempts: row.attempts,
+    maxAttempts: row.max_attempts,
+    enqueuedAt: row.enqueued_at,
+    startedAt: row.started_at,
+    completedAt: row.completed_at,
+    enqueuedBy: row.enqueued_by,
+    resumeFrom: row.checkpoint == null ? void 0 : JSON.parse(row.checkpoint)
+  };
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return JSON.stringify({ __unserializable__: String(value) });
+  }
+}
+
 // src/server/rooms/do-manifest.ts
 var DEFAULT_DO_MANIFEST = [
   { binding: "RECORD_ROOMS", className: "AppRecordRoom", sqlite: true },
@@ -5198,6 +5761,20 @@ function sanitizeSubpath(raw) {
 function isKeyWithinPrefix(key, prefix) {
   return key.startsWith(prefix);
 }
+var DANGEROUS_MIME_TYPES = /* @__PURE__ */ new Set([
+  "text/html",
+  "application/xhtml+xml",
+  "image/svg+xml",
+  "application/xml",
+  "text/xml",
+  "application/javascript",
+  "text/javascript",
+  "application/ecmascript",
+  "text/ecmascript"
+]);
+function normalizeMimeType(raw) {
+  return raw.split(";")[0].trim().toLowerCase();
+}
 function createScopedR2Handler(config) {
   const requireAuthForMutations = config.requireAuthForMutations ?? true;
   return async (request, url, bucket, auth) => {
@@ -5287,6 +5864,13 @@ async function handleUpload(request, url, bucket, prefix, userId) {
       fileName = body.name;
       mimeType = body.mimeType || "application/octet-stream";
     }
+    mimeType = normalizeMimeType(mimeType) || "application/octet-stream";
+    if (DANGEROUS_MIME_TYPES.has(mimeType)) {
+      return Response.json(
+        { error: `Unsupported media type: ${mimeType}` },
+        { status: 415, headers: CORS_HEADERS3 }
+      );
+    }
     const requestedKey = url.searchParams.get("key");
     let key;
     if (requestedKey !== null) {
@@ -5351,6 +5935,7 @@ async function handleDownload(bucket, key) {
   }
   const headers = new Headers();
   headers.set("Content-Type", object.httpMetadata?.contentType || "application/octet-stream");
+  headers.set("X-Content-Type-Options", "nosniff");
   headers.set("Cache-Control", "public, max-age=31536000, immutable");
   headers.set("Access-Control-Allow-Origin", "*");
   if (object.customMetadata?.originalName) {
@@ -5612,7 +6197,7 @@ function createDeepSpaceAuth(config) {
 }
 
 // src/server/utils/cron.ts
-var DEFAULT_API_BASE_URL = "https://deepspace-api.eudaimonicincorporated.workers.dev";
+var DEFAULT_API_BASE_URL = "https://api-worker.deep.space";
 function buildCronContext(env, ownerUserId, roomId = "default") {
   const hmacSecret = env.INTERNAL_STORAGE_HMAC_SECRET;
   const apiBase = env.API_BASE_URL || DEFAULT_API_BASE_URL;
@@ -6384,6 +6969,7 @@ export {
   GLOBAL_DO_TYPES,
   GLOBAL_DO_TYPE_NAMES,
   GameRoom,
+  JobRoom,
   MESSAGES_SCHEMA,
   MSG,
   MSG_AWARENESS,
@@ -6447,6 +7033,7 @@ export {
   encodeSyncStep1,
   encodeSyncStep2,
   encodeUpdate,
+  enqueueJob,
   getChat,
   getGlobalDOSchemas,
   getGlobalDOType,