npm - @nexpress/core - Versions diffs - 0.1.0 - Mend

@nexpress/core 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (171) hide show

package/LICENSE +21 -0
package/README.md +69 -0
package/dist/audit-54XLVCWD.js +14 -0
package/dist/audit-54XLVCWD.js.map +1 -0
package/dist/auth.d.ts +640 -0
package/dist/auth.js +94 -0
package/dist/auth.js.map +1 -0
package/dist/can-YLUHRJAB.js +19 -0
package/dist/can-YLUHRJAB.js.map +1 -0
package/dist/chunk-2G264RCD.js +68 -0
package/dist/chunk-2G264RCD.js.map +1 -0
package/dist/chunk-2YDGE7YX.js +92 -0
package/dist/chunk-2YDGE7YX.js.map +1 -0
package/dist/chunk-473S4TER.js +538 -0
package/dist/chunk-473S4TER.js.map +1 -0
package/dist/chunk-4ZLMEKFX.js +18 -0
package/dist/chunk-4ZLMEKFX.js.map +1 -0
package/dist/chunk-55FU6WED.js +179 -0
package/dist/chunk-55FU6WED.js.map +1 -0
package/dist/chunk-6YI5K2TI.js +1959 -0
package/dist/chunk-6YI5K2TI.js.map +1 -0
package/dist/chunk-BHK3AD3Q.js +41 -0
package/dist/chunk-BHK3AD3Q.js.map +1 -0
package/dist/chunk-CRUQBZUF.js +39 -0
package/dist/chunk-CRUQBZUF.js.map +1 -0
package/dist/chunk-CTSQ7BRI.js +175 -0
package/dist/chunk-CTSQ7BRI.js.map +1 -0
package/dist/chunk-DK2JBJH7.js +81 -0
package/dist/chunk-DK2JBJH7.js.map +1 -0
package/dist/chunk-DP2PREDU.js +597 -0
package/dist/chunk-DP2PREDU.js.map +1 -0
package/dist/chunk-EQ2Z3KMD.js +24 -0
package/dist/chunk-EQ2Z3KMD.js.map +1 -0
package/dist/chunk-FZ7O6DWI.js +305 -0
package/dist/chunk-FZ7O6DWI.js.map +1 -0
package/dist/chunk-ISLYFQWL.js +1270 -0
package/dist/chunk-ISLYFQWL.js.map +1 -0
package/dist/chunk-JJL74ZPK.js +68 -0
package/dist/chunk-JJL74ZPK.js.map +1 -0
package/dist/chunk-JKXAPSU4.js +24 -0
package/dist/chunk-JKXAPSU4.js.map +1 -0
package/dist/chunk-KU5M27ZC.js +24 -0
package/dist/chunk-KU5M27ZC.js.map +1 -0
package/dist/chunk-LSHHRDVR.js +34 -0
package/dist/chunk-LSHHRDVR.js.map +1 -0
package/dist/chunk-M43PGOQY.js +715 -0
package/dist/chunk-M43PGOQY.js.map +1 -0
package/dist/chunk-MEJAHXIO.js +150 -0
package/dist/chunk-MEJAHXIO.js.map +1 -0
package/dist/chunk-NUCGHWCF.js +101 -0
package/dist/chunk-NUCGHWCF.js.map +1 -0
package/dist/chunk-OK5HOCQI.js +845 -0
package/dist/chunk-OK5HOCQI.js.map +1 -0
package/dist/chunk-OROPGO65.js +13 -0
package/dist/chunk-OROPGO65.js.map +1 -0
package/dist/chunk-PPAS4SZR.js +176 -0
package/dist/chunk-PPAS4SZR.js.map +1 -0
package/dist/chunk-PPBWRKO2.js +171 -0
package/dist/chunk-PPBWRKO2.js.map +1 -0
package/dist/chunk-PZ5AY32C.js +10 -0
package/dist/chunk-PZ5AY32C.js.map +1 -0
package/dist/chunk-QO7LAQZH.js +321 -0
package/dist/chunk-QO7LAQZH.js.map +1 -0
package/dist/chunk-QVJ2HCAX.js +225 -0
package/dist/chunk-QVJ2HCAX.js.map +1 -0
package/dist/chunk-RIPHIRPP.js +68 -0
package/dist/chunk-RIPHIRPP.js.map +1 -0
package/dist/chunk-S27S42QY.js +134 -0
package/dist/chunk-S27S42QY.js.map +1 -0
package/dist/chunk-SBCVAC2Z.js +40 -0
package/dist/chunk-SBCVAC2Z.js.map +1 -0
package/dist/chunk-TFJ4MKPH.js +694 -0
package/dist/chunk-TFJ4MKPH.js.map +1 -0
package/dist/chunk-THX3SHYA.js +75 -0
package/dist/chunk-THX3SHYA.js.map +1 -0
package/dist/chunk-UGQSQO5B.js +222 -0
package/dist/chunk-UGQSQO5B.js.map +1 -0
package/dist/chunk-V2UNHGAP.js +26 -0
package/dist/chunk-V2UNHGAP.js.map +1 -0
package/dist/chunk-VGTPQXNQ.js +2790 -0
package/dist/chunk-VGTPQXNQ.js.map +1 -0
package/dist/chunk-VNIHXQ7W.js +194 -0
package/dist/chunk-VNIHXQ7W.js.map +1 -0
package/dist/chunk-WV272MPW.js +31 -0
package/dist/chunk-WV272MPW.js.map +1 -0
package/dist/chunk-X5KKBOUS.js +26 -0
package/dist/chunk-X5KKBOUS.js.map +1 -0
package/dist/chunk-XANPEOJC.js +17 -0
package/dist/chunk-XANPEOJC.js.map +1 -0
package/dist/chunk-XPVQIHAQ.js +83 -0
package/dist/chunk-XPVQIHAQ.js.map +1 -0
package/dist/chunk-ZCINJSS4.js +75 -0
package/dist/chunk-ZCINJSS4.js.map +1 -0
package/dist/community.d.ts +1425 -0
package/dist/community.js +206 -0
package/dist/community.js.map +1 -0
package/dist/config-2GDU7PCK.js +32 -0
package/dist/config-2GDU7PCK.js.map +1 -0
package/dist/context-MNZ4QXPC.js +16 -0
package/dist/context-MNZ4QXPC.js.map +1 -0
package/dist/db-schema.d.ts +4 -0
package/dist/db-schema.js +102 -0
package/dist/db-schema.js.map +1 -0
package/dist/db.d.ts +7 -0
package/dist/db.js +117 -0
package/dist/db.js.map +1 -0
package/dist/digest-SY42GQSU.js +17 -0
package/dist/digest-SY42GQSU.js.map +1 -0
package/dist/errors-5OS3S2J3.js +22 -0
package/dist/errors-5OS3S2J3.js.map +1 -0
package/dist/host-OBOI4MJK.js +51 -0
package/dist/host-OBOI4MJK.js.map +1 -0
package/dist/i18n.d.ts +301 -0
package/dist/i18n.js +68 -0
package/dist/i18n.js.map +1 -0
package/dist/index-B6-_vr_m.d.ts +590 -0
package/dist/index-CY55LC0u.d.ts +4722 -0
package/dist/index-CeiTvwbp.d.ts +168 -0
package/dist/index-XwP1ET8b.d.ts +61 -0
package/dist/index.d.ts +2037 -0
package/dist/index.js +2205 -0
package/dist/index.js.map +1 -0
package/dist/job-log-VZXWQUDK.js +24 -0
package/dist/job-log-VZXWQUDK.js.map +1 -0
package/dist/jobs.d.ts +4 -0
package/dist/jobs.js +76 -0
package/dist/jobs.js.map +1 -0
package/dist/logger-DqGaOU_j.d.ts +29 -0
package/dist/logger-S7REWDNE.js +16 -0
package/dist/logger-S7REWDNE.js.map +1 -0
package/dist/media.d.ts +5 -0
package/dist/media.js +41 -0
package/dist/media.js.map +1 -0
package/dist/mentions-2IHFVSHW.js +23 -0
package/dist/mentions-2IHFVSHW.js.map +1 -0
package/dist/mutes-EWAE5FZR.js +21 -0
package/dist/mutes-EWAE5FZR.js.map +1 -0
package/dist/notification-prefs-VPJDU7I6.js +21 -0
package/dist/notification-prefs-VPJDU7I6.js.map +1 -0
package/dist/observability.d.ts +156 -0
package/dist/observability.js +32 -0
package/dist/observability.js.map +1 -0
package/dist/profanity-adapter-NU2JQSLX.js +12 -0
package/dist/profanity-adapter-NU2JQSLX.js.map +1 -0
package/dist/queue-XE5BC75T.js +14 -0
package/dist/queue-XE5BC75T.js.map +1 -0
package/dist/rate-limit.d.ts +99 -0
package/dist/rate-limit.js +14 -0
package/dist/rate-limit.js.map +1 -0
package/dist/registry-XIXDEPVI.js +31 -0
package/dist/registry-XIXDEPVI.js.map +1 -0
package/dist/reputation-JRL2YQHM.js +11 -0
package/dist/reputation-JRL2YQHM.js.map +1 -0
package/dist/routes.d.ts +43 -0
package/dist/routes.js +12 -0
package/dist/routes.js.map +1 -0
package/dist/scheduled-CIQM57HT.js +20 -0
package/dist/scheduled-CIQM57HT.js.map +1 -0
package/dist/seo.d.ts +410 -0
package/dist/seo.js +44 -0
package/dist/seo.js.map +1 -0
package/dist/settings-FOBIESPB.js +17 -0
package/dist/settings-FOBIESPB.js.map +1 -0
package/dist/spam-adapter-XX3G737Z.js +12 -0
package/dist/spam-adapter-XX3G737Z.js.map +1 -0
package/dist/strings-VAE47B2C.js +29 -0
package/dist/strings-VAE47B2C.js.map +1 -0
package/dist/templates-IFVJMCJ6.js +12 -0
package/dist/templates-IFVJMCJ6.js.map +1 -0
package/dist/types-TlsbXS0T.d.ts +871 -0
package/package.json +129 -0

package/dist/chunk-ISLYFQWL.js ADDED Viewed

@@ -0,0 +1,1270 @@
+import {
+  recordJobLog,
+  runInJobContext
+} from "./chunk-DK2JBJH7.js";
+import {
+  getEmailAdapter
+} from "./chunk-LSHHRDVR.js";
+import {
+  reportError
+} from "./chunk-WV272MPW.js";
+import {
+  setJobQueue
+} from "./chunk-V2UNHGAP.js";
+import {
+  readEnvPositiveInt
+} from "./chunk-OROPGO65.js";
+import {
+  getLogger
+} from "./chunk-JJL74ZPK.js";
+import {
+  getDb
+} from "./chunk-XANPEOJC.js";
+import {
+  npSettings,
+  npWorkerHeartbeats
+} from "./chunk-M43PGOQY.js";
+// src/jobs/handlers.ts
+var handlers = /* @__PURE__ */ new Map();
+function registerJobHandler(type, handler) {
+  handlers.set(type, handler);
+}
+function getJobHandler(type) {
+  return handlers.get(type);
+}
+function getAllJobHandlers() {
+  return handlers;
+}
+// src/email/templates.ts
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function wrap(siteName, contentHtml) {
+  return `<!doctype html>
+<html>
+<body style="margin:0;padding:24px;background:#f5f5f5;font-family:system-ui,-apple-system,Segoe UI,sans-serif;color:#111;">
+  <table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="max-width:560px;margin:0 auto;background:#fff;border-radius:12px;padding:32px;border:1px solid #e5e5e5;">
+    <tr>
+      <td>
+        <h1 style="margin:0 0 16px;font-size:20px;font-weight:600;">${escapeHtml(siteName)}</h1>
+        ${contentHtml}
+        <p style="margin-top:32px;font-size:12px;color:#777;">If you didn't expect this email you can ignore it.</p>
+      </td>
+    </tr>
+  </table>
+</body>
+</html>`;
+}
+function buildInviteEmail(data) {
+  const subject = `You're invited to ${data.siteName}`;
+  const text = `Hi ${data.name},
+You've been invited to ${data.siteName}. Set your password to activate your account:
+${data.resetUrl}
+This link expires in 7 days.`;
+  const html = wrap(
+    data.siteName,
+    `
+    <p style="margin:0 0 16px;">Hi ${escapeHtml(data.name)},</p>
+    <p style="margin:0 0 24px;">You've been invited to ${escapeHtml(data.siteName)}. Set your password to activate your account:</p>
+    <p style="margin:0 0 24px;"><a href="${escapeHtml(data.resetUrl)}" style="display:inline-block;background:#111;color:#fff;text-decoration:none;padding:10px 20px;border-radius:8px;font-weight:500;">Set my password</a></p>
+    <p style="margin:0 0 8px;font-size:13px;color:#555;">Or copy the link:</p>
+    <p style="margin:0;font-size:13px;color:#555;word-break:break-all;">${escapeHtml(data.resetUrl)}</p>
+    <p style="margin-top:24px;font-size:13px;color:#555;">This link expires in 7 days.</p>
+    `
+  );
+  return { subject, text, html };
+}
+function buildMemberVerifyEmail(data) {
+  const subject = `Confirm your ${data.siteName} account`;
+  const text = `Hi ${data.displayName},
+Welcome to ${data.siteName}. Confirm your email so we can activate your account:
+${data.verifyUrl}
+This link expires in 24 hours. If you didn't sign up, you can ignore this email.`;
+  const html = wrap(
+    data.siteName,
+    `
+    <p style="margin:0 0 16px;">Hi ${escapeHtml(data.displayName)},</p>
+    <p style="margin:0 0 24px;">Welcome to ${escapeHtml(data.siteName)}. Confirm your email so we can activate your account:</p>
+    <p style="margin:0 0 24px;"><a href="${escapeHtml(data.verifyUrl)}" style="display:inline-block;background:#111;color:#fff;text-decoration:none;padding:10px 20px;border-radius:8px;font-weight:500;">Confirm my email</a></p>
+    <p style="margin:0 0 8px;font-size:13px;color:#555;">Or copy the link:</p>
+    <p style="margin:0;font-size:13px;color:#555;word-break:break-all;">${escapeHtml(data.verifyUrl)}</p>
+    <p style="margin-top:24px;font-size:13px;color:#555;">This link expires in 24 hours. If you didn't sign up, you can ignore this email.</p>
+    `
+  );
+  return { subject, text, html };
+}
+function buildResetEmail(data) {
+  const subject = `Reset your ${data.siteName} password`;
+  const text = `Hi ${data.name},
+Someone requested a password reset for your ${data.siteName} account. If that was you, use this link to set a new one:
+${data.resetUrl}
+This link expires in 1 hour. If you didn't request it, you can ignore this email.`;
+  const html = wrap(
+    data.siteName,
+    `
+    <p style="margin:0 0 16px;">Hi ${escapeHtml(data.name)},</p>
+    <p style="margin:0 0 24px;">Someone requested a password reset for your ${escapeHtml(data.siteName)} account. If that was you, use this link to set a new one:</p>
+    <p style="margin:0 0 24px;"><a href="${escapeHtml(data.resetUrl)}" style="display:inline-block;background:#111;color:#fff;text-decoration:none;padding:10px 20px;border-radius:8px;font-weight:500;">Reset password</a></p>
+    <p style="margin:0 0 8px;font-size:13px;color:#555;">Or copy the link:</p>
+    <p style="margin:0;font-size:13px;color:#555;word-break:break-all;">${escapeHtml(data.resetUrl)}</p>
+    <p style="margin-top:24px;font-size:13px;color:#555;">This link expires in 1 hour. If you didn't request it you can ignore this email.</p>
+    `
+  );
+  return { subject, text, html };
+}
+// src/jobs/builtin-handlers.ts
+var builtinJobContext = {};
+function configureBuiltinJobContext(context) {
+  Object.assign(builtinJobContext, context);
+}
+function registerBuiltinHandlers() {
+  registerJobHandler("content:afterSave", handleContentAfterSave);
+  registerJobHandler("content:afterDelete", handleContentAfterDelete);
+  registerJobHandler("content:publishScheduled", handleContentPublishScheduled);
+  registerJobHandler("media:processImage", handleMediaProcessImage);
+  registerJobHandler("media:cleanup", handleMediaCleanup);
+  registerJobHandler("plugin:scheduledTask", handlePluginScheduledTask);
+  registerJobHandler("system:revisionPrune", handleRevisionPrune);
+  registerJobHandler("system:sessionCleanup", handleSessionCleanup);
+  registerJobHandler("system:jobLogPrune", handleJobLogPrune);
+  registerJobHandler("auth:sendPasswordReset", handleAuthSendPasswordReset);
+  registerJobHandler("members:sendVerifyEmail", handleMemberSendVerifyEmail);
+  registerJobHandler("members:sendPasswordReset", handleMemberSendPasswordReset);
+  registerJobHandler("notifications:sendDigest", handleNotificationsSendDigest);
+}
+async function handleContentPublishScheduled(_) {
+  const { publishScheduledDocuments } = await import("./scheduled-CIQM57HT.js");
+  const result = await publishScheduledDocuments();
+  if (result.published > 0) {
+    console.info(
+      `[nexpress] content:publishScheduled flipped ${result.published} document(s)`,
+      result.byCollection
+    );
+  }
+}
+async function handleContentAfterSave(data) {
+  const jobData = asContentJobData(data);
+  await revalidateCollectionTags(jobData.collection, jobData.documentId);
+  const context = await builtinJobContext.resolveContentAfterSaveContext?.(jobData);
+  if (!context) {
+    return;
+  }
+  const hooks = jobData.operation === "create" ? context.collectionConfig.hooks?.afterCreate : context.collectionConfig.hooks?.afterUpdate;
+  await runCollectionHooks(hooks, {
+    data: context.data,
+    user: context.user,
+    principal: context.principal,
+    collection: context.collectionConfig.slug,
+    originalDoc: context.originalDoc
+  });
+}
+async function handleContentAfterDelete(data) {
+  const jobData = asContentDeleteJobData(data);
+  await revalidateCollectionTags(jobData.collection, jobData.documentId);
+  const context = await builtinJobContext.resolveContentAfterDeleteContext?.(jobData);
+  if (!context) {
+    return;
+  }
+  await runCollectionHooks(context.collectionConfig.hooks?.afterDelete, {
+    data: context.data,
+    user: context.user,
+    principal: context.principal,
+    collection: context.collectionConfig.slug
+  });
+}
+async function handleMediaProcessImage(data) {
+  await builtinJobContext.processImage?.(data);
+}
+async function handleMediaCleanup(data) {
+  await builtinJobContext.cleanupMedia?.(data);
+}
+async function handlePluginScheduledTask(data) {
+  if (isRecord(data) && typeof data.pluginId === "string" && typeof data.taskId === "string") {
+    try {
+      const { runPluginScheduledTask } = await import("./host-OBOI4MJK.js");
+      await runPluginScheduledTask(data.pluginId, data.taskId);
+      return;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (!/no scheduled task/.test(message) && !/is not registered/.test(message)) {
+        throw err;
+      }
+    }
+  }
+  await builtinJobContext.runScheduledPluginTask?.(data);
+}
+async function handleRevisionPrune(_) {
+  await builtinJobContext.pruneRevisions?.();
+}
+async function handleSessionCleanup(_) {
+  await builtinJobContext.cleanupSessions?.();
+}
+async function handleJobLogPrune(_) {
+  const { pruneJobLogsOlderThan: pruneJobLogsOlderThan2, DEFAULT_JOB_LOG_RETENTION_MS: DEFAULT_JOB_LOG_RETENTION_MS2 } = await import("./job-log-VZXWQUDK.js");
+  const cutoff = new Date(Date.now() - DEFAULT_JOB_LOG_RETENTION_MS2);
+  const deleted = await pruneJobLogsOlderThan2(cutoff);
+  if (deleted > 0) {
+    console.info(`[nexpress] system:jobLogPrune deleted ${deleted} log row(s)`);
+  }
+}
+async function handleAuthSendPasswordReset(data) {
+  if (builtinJobContext.sendPasswordReset) {
+    await builtinJobContext.sendPasswordReset(data);
+    return;
+  }
+  const payload = asPasswordResetJobData(data);
+  const templateData = {
+    siteName: payload.siteName ?? "your site",
+    name: payload.name,
+    resetUrl: payload.resetUrl
+  };
+  const template = payload.purpose === "invite" ? buildInviteEmail(templateData) : buildResetEmail(templateData);
+  await getEmailAdapter().send({
+    to: payload.email,
+    subject: template.subject,
+    text: template.text,
+    html: template.html
+  });
+}
+function asPasswordResetJobData(data) {
+  if (!isRecord(data)) {
+    throw new Error("Invalid auth:sendPasswordReset job payload.");
+  }
+  return {
+    email: asString(data.email, "email"),
+    name: asString(data.name, "name"),
+    token: asString(data.token, "token"),
+    siteName: typeof data.siteName === "string" && data.siteName.length > 0 ? data.siteName : void 0,
+    purpose: asResetPurpose(data.purpose),
+    resetUrl: asString(data.resetUrl, "resetUrl")
+  };
+}
+function asResetPurpose(value) {
+  if (value === "invite" || value === "reset") {
+    return value;
+  }
+  throw new Error("Invalid password reset purpose.");
+}
+async function runCollectionHooks(hooks, args) {
+  if (!hooks || hooks.length === 0) {
+    return;
+  }
+  for (const hook of hooks) {
+    await hook(args);
+  }
+}
+async function revalidateCollectionTags(collection, documentId) {
+  try {
+    const revalidateTag = await loadRevalidateTag();
+    if (!revalidateTag) {
+      return;
+    }
+    revalidateTag(`nx:${collection}`);
+    revalidateTag(`nx:${collection}:${documentId}`);
+  } catch {
+    return;
+  }
+}
+async function loadRevalidateTag() {
+  const moduleId = "next/cache";
+  let importedModule;
+  try {
+    importedModule = await import(moduleId);
+  } catch {
+    return null;
+  }
+  if (!isRecord(importedModule)) {
+    return null;
+  }
+  const revalidateTag = importedModule.revalidateTag;
+  if (typeof revalidateTag !== "function") {
+    return null;
+  }
+  return (tag) => {
+    if (revalidateTag.length >= 2) {
+      revalidateTag(tag, "default");
+    } else {
+      revalidateTag(tag);
+    }
+  };
+}
+function asContentJobData(data) {
+  if (!isRecord(data)) {
+    throw new Error("Invalid content:afterSave job payload.");
+  }
+  return {
+    collection: asString(data.collection, "collection"),
+    documentId: asString(data.documentId, "documentId"),
+    operation: asContentOperation(data.operation),
+    userId: asString(data.userId, "userId")
+  };
+}
+function asContentDeleteJobData(data) {
+  if (!isRecord(data)) {
+    throw new Error("Invalid content:afterDelete job payload.");
+  }
+  return {
+    collection: asString(data.collection, "collection"),
+    documentId: asString(data.documentId, "documentId"),
+    userId: asString(data.userId, "userId")
+  };
+}
+function asContentOperation(value) {
+  if (value === "create" || value === "update") {
+    return value;
+  }
+  throw new Error("Invalid content operation.");
+}
+function asString(value, fieldName) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Invalid ${fieldName} field.`);
+  }
+  return value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function handleMemberSendVerifyEmail(data) {
+  if (builtinJobContext.sendMemberVerifyEmail) {
+    await builtinJobContext.sendMemberVerifyEmail(data);
+    return;
+  }
+  if (!isRecord(data)) throw new Error("Invalid members:sendVerifyEmail job payload.");
+  const payload = {
+    email: asString(data.email, "email"),
+    displayName: asString(data.displayName, "displayName"),
+    verifyUrl: asString(data.verifyUrl, "verifyUrl"),
+    siteName: typeof data.siteName === "string" && data.siteName.length > 0 ? data.siteName : void 0
+  };
+  const template = buildMemberVerifyEmail({
+    siteName: payload.siteName ?? "your site",
+    displayName: payload.displayName,
+    verifyUrl: payload.verifyUrl
+  });
+  await getEmailAdapter().send({
+    to: payload.email,
+    subject: template.subject,
+    text: template.text,
+    html: template.html
+  });
+}
+async function handleMemberSendPasswordReset(data) {
+  if (builtinJobContext.sendMemberPasswordReset) {
+    await builtinJobContext.sendMemberPasswordReset(data);
+    return;
+  }
+  if (!isRecord(data)) throw new Error("Invalid members:sendPasswordReset job payload.");
+  const payload = {
+    email: asString(data.email, "email"),
+    displayName: asString(data.displayName, "displayName"),
+    resetUrl: asString(data.resetUrl, "resetUrl"),
+    siteName: typeof data.siteName === "string" && data.siteName.length > 0 ? data.siteName : void 0
+  };
+  const template = buildResetEmail({
+    siteName: payload.siteName ?? "your site",
+    name: payload.displayName,
+    resetUrl: payload.resetUrl
+  });
+  await getEmailAdapter().send({
+    to: payload.email,
+    subject: template.subject,
+    text: template.text,
+    html: template.html
+  });
+}
+async function handleNotificationsSendDigest(data) {
+  const cadence = isRecord(data) && (data.cadence === "daily" || data.cadence === "weekly") ? data.cadence : "daily";
+  const siteName = isRecord(data) && typeof data.siteName === "string" ? data.siteName : void 0;
+  const { runDigestSweep } = await import("./digest-SY42GQSU.js");
+  const result = await runDigestSweep({ cadence, siteName });
+  console.info(
+    `[nexpress] notifications:sendDigest cadence=${cadence} considered=${result.considered} sent=${result.sent} skipped=${result.skipped} failed=${result.failed}`
+  );
+}
+// src/jobs/heartbeat.ts
+import { hostname } from "os";
+import { randomUUID } from "crypto";
+import { desc, eq, gt, lt } from "drizzle-orm";
+var WORKER_HEARTBEAT_INTERVAL_MS = readEnvPositiveInt("NP_WORKER_HEARTBEAT_SECONDS", 30) * 1e3;
+var WORKER_STALE_THRESHOLD_MS = readEnvPositiveInt("NP_WORKER_STALE_THRESHOLD_SECONDS", 90) * 1e3;
+function generateWorkerId() {
+  try {
+    const host = hostname();
+    return `${host}:${process.pid}`;
+  } catch {
+    return randomUUID();
+  }
+}
+async function recordHeartbeat(workerId, meta = {}) {
+  const db = getDb();
+  const now = /* @__PURE__ */ new Date();
+  await db.insert(npWorkerHeartbeats).values({
+    id: workerId,
+    status: "running",
+    startedAt: now,
+    lastSeenAt: now,
+    meta
+  }).onConflictDoUpdate({
+    target: npWorkerHeartbeats.id,
+    set: { lastSeenAt: now, status: "running", meta }
+  });
+}
+async function markWorkerStopped(workerId) {
+  const db = getDb();
+  await db.update(npWorkerHeartbeats).set({ status: "stopped", lastSeenAt: /* @__PURE__ */ new Date() }).where(eq(npWorkerHeartbeats.id, workerId));
+}
+async function listWorkerHealth(now = /* @__PURE__ */ new Date()) {
+  const db = getDb();
+  const rows = await db.select().from(npWorkerHeartbeats).orderBy(desc(npWorkerHeartbeats.lastSeenAt));
+  let aliveCount = 0;
+  const decorated = rows.map((row) => {
+    const lastSeenAgoMs = Math.max(0, now.getTime() - row.lastSeenAt.getTime());
+    const alive = row.status === "running" && lastSeenAgoMs < WORKER_STALE_THRESHOLD_MS;
+    if (alive) aliveCount += 1;
+    return { ...row, alive, lastSeenAgoMs };
+  });
+  return {
+    workers: decorated,
+    aliveCount,
+    totalCount: rows.length,
+    newestHeartbeat: rows[0]?.lastSeenAt.toISOString() ?? null
+  };
+}
+function startHeartbeatLoop(meta = {}, intervalMs = WORKER_HEARTBEAT_INTERVAL_MS) {
+  const workerId = generateWorkerId();
+  const log = getLogger();
+  const beat = async () => {
+    try {
+      await recordHeartbeat(workerId, meta);
+    } catch (err) {
+      log.warn("worker heartbeat failed", {
+        workerId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  };
+  void beat();
+  const timer = setInterval(() => {
+    void beat();
+  }, intervalMs);
+  if (typeof timer.unref === "function") timer.unref();
+  return {
+    workerId,
+    async stop() {
+      clearInterval(timer);
+      try {
+        await markWorkerStopped(workerId);
+      } catch (err) {
+        log.warn("worker heartbeat stop failed to mark row", {
+          workerId,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  };
+}
+async function purgeStaleWorkers(olderThan = new Date(Date.now() - WORKER_STALE_THRESHOLD_MS * 10)) {
+  const db = getDb();
+  const deleted = await db.delete(npWorkerHeartbeats).where(lt(npWorkerHeartbeats.lastSeenAt, olderThan)).returning({ id: npWorkerHeartbeats.id });
+  return deleted.length;
+}
+async function countAliveWorkers(now = /* @__PURE__ */ new Date()) {
+  const db = getDb();
+  const cutoff = new Date(now.getTime() - WORKER_STALE_THRESHOLD_MS);
+  const rows = await db.select({ id: npWorkerHeartbeats.id }).from(npWorkerHeartbeats).where(gt(npWorkerHeartbeats.lastSeenAt, cutoff));
+  return rows.length;
+}
+// src/jobs/pause-state.ts
+import { and, eq as eq2 } from "drizzle-orm";
+var SYSTEM_SITE_ID = "_system";
+var JOBS_PAUSED_KEY = "jobs.paused";
+var DEFAULT_STATE = {
+  paused: false,
+  changedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+  changedByUserId: null,
+  reason: null
+};
+async function getJobsPauseState() {
+  const db = getDb();
+  const rows = await db.select().from(npSettings).where(and(eq2(npSettings.siteId, SYSTEM_SITE_ID), eq2(npSettings.key, JOBS_PAUSED_KEY))).limit(1);
+  const row = rows[0];
+  if (!row) return DEFAULT_STATE;
+  const value = row.value;
+  if (!value || typeof value.paused !== "boolean") return DEFAULT_STATE;
+  return {
+    paused: value.paused,
+    changedAt: typeof value.changedAt === "string" ? value.changedAt : DEFAULT_STATE.changedAt,
+    changedByUserId: typeof value.changedByUserId === "string" ? value.changedByUserId : null,
+    reason: typeof value.reason === "string" ? value.reason : null
+  };
+}
+async function setJobsPauseState(input) {
+  const db = getDb();
+  const next = {
+    paused: input.paused,
+    changedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    changedByUserId: input.changedByUserId ?? null,
+    reason: input.reason ?? null
+  };
+  await db.insert(npSettings).values({
+    siteId: SYSTEM_SITE_ID,
+    key: JOBS_PAUSED_KEY,
+    value: next
+  }).onConflictDoUpdate({
+    target: [npSettings.siteId, npSettings.key],
+    set: {
+      value: next,
+      updatedAt: /* @__PURE__ */ new Date()
+    }
+  });
+  return next;
+}
+var PAUSE_SYNC_INTERVAL_MS = 3e4;
+var PAUSE_SYNC_ESCALATE_AFTER = 3;
+function startPauseSyncLoop(queue, intervalMs = PAUSE_SYNC_INTERVAL_MS) {
+  const log = getLogger();
+  let consecutiveFailures = 0;
+  let escalated = false;
+  const tick = async () => {
+    try {
+      const persisted = await getJobsPauseState();
+      const localPaused = typeof queue.isProcessingPaused === "function" ? queue.isProcessingPaused() : false;
+      if (persisted.paused && !localPaused && typeof queue.pauseProcessing === "function") {
+        await queue.pauseProcessing();
+        log.info("Pause sync: applied paused=true from settings", {
+          changedAt: persisted.changedAt
+        });
+      } else if (!persisted.paused && localPaused && typeof queue.resumeProcessing === "function") {
+        await queue.resumeProcessing();
+        log.info("Pause sync: applied paused=false from settings", {
+          changedAt: persisted.changedAt
+        });
+      }
+      if (consecutiveFailures > 0) {
+        log.info("Pause sync: recovered after consecutive failures", {
+          previousFailures: consecutiveFailures
+        });
+        consecutiveFailures = 0;
+        escalated = false;
+      }
+    } catch (err) {
+      consecutiveFailures += 1;
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      log.warn("Pause sync tick failed", {
+        error: errorMessage,
+        consecutiveFailures
+      });
+      if (consecutiveFailures >= PAUSE_SYNC_ESCALATE_AFTER && !escalated) {
+        escalated = true;
+        const reportable = err instanceof Error ? err : new Error(errorMessage);
+        await reportError(reportable, {
+          tags: { source: "worker", subsystem: "pause-sync" },
+          extra: { consecutiveFailures }
+        });
+      }
+    }
+  };
+  void tick();
+  const timer = setInterval(() => {
+    void tick();
+  }, intervalMs);
+  if (typeof timer.unref === "function") timer.unref();
+  return {
+    stop() {
+      clearInterval(timer);
+    }
+  };
+}
+// src/jobs/pg-boss-adapter.ts
+import { PgBoss } from "pg-boss";
+function toQueueName(type) {
+  return type.replace(/:/g, ".");
+}
+var PgBossAdapter = class {
+  boss;
+  /**
+   * Phase 20.2 — every queue we've called `boss.work()` on, plus
+   * the function that re-registers it. We need both because
+   * `pauseProcessing()` calls `boss.offWork(name)` (drops the
+   * worker) and `resumeProcessing()` has to re-call the original
+   * `boss.work(...)` to bring it back. Order is preserved so
+   * resume registers in the same order as start did.
+   */
+  workRegistrations = [];
+  paused = false;
+  /**
+   * Flips `true` after `start()` runs (full worker mode). `startProducer()`
+   * doesn't set it. Used by `reconcilePluginSchedules()` to tell admins
+   * whether this process owns the `boss.work()` loops for plugin schedules
+   * — the same boss instance can act as producer-only in the web server
+   * and full worker in the worker process.
+   */
+  workerStarted = false;
+  constructor(connectionString, options) {
+    this.boss = new PgBoss({ connectionString, ...options });
+  }
+  async enqueue(type, data) {
+    const jobId = await this.boss.send(toQueueName(type), asJobPayload(data));
+    if (!jobId) {
+      throw new Error(`Failed to enqueue job: ${type}`);
+    }
+    return jobId;
+  }
+  /**
+   * Opens the pg-boss connection and runs its migrations. Safe to call from a
+   * non-worker process (e.g. the Next.js server) so it can enqueue jobs.
+   */
+  async startProducer() {
+    await this.boss.start();
+  }
+  /**
+   * Full start: opens the connection (idempotent with startProducer) and
+   * registers `boss.work()` loops for every handler in the registry. Call
+   * this from the dedicated worker process.
+   */
+  async start() {
+    await this.boss.start();
+    for (const [type, handler] of getAllJobHandlers()) {
+      const queueName = toQueueName(type);
+      await this.boss.createQueue(queueName);
+      const register = async () => {
+        await this.boss.work(queueName, async (jobs) => {
+          for (const job of jobs) {
+            await runInJobContext(job.id, async () => {
+              try {
+                await handler(job.data);
+              } catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                getLogger().error("Job handler threw", {
+                  type,
+                  jobId: job.id,
+                  error: err.message,
+                  stack: err.stack
+                });
+                await recordJobLog("error", `Job handler threw: ${err.message}`, {
+                  type,
+                  stack: err.stack
+                });
+                void reportError(err, {
+                  tags: { source: "worker", jobType: type },
+                  extra: { jobId: job.id }
+                });
+                throw err;
+              }
+            });
+          }
+        });
+      };
+      this.workRegistrations.push({ queueName, register });
+      await register();
+    }
+    const { getRegisteredPluginSchedules, runPluginScheduledTask } = await import("./host-OBOI4MJK.js");
+    for (const schedule of getRegisteredPluginSchedules()) {
+      const queueName = `${toQueueName("plugin:scheduledTask")}.${schedule.pluginId}.${schedule.taskId}`;
+      await this.boss.createQueue(queueName);
+      const register = async () => {
+        await this.boss.work(queueName, async (jobs) => {
+          for (const job of jobs) {
+            await runInJobContext(job.id, async () => {
+              try {
+                await runPluginScheduledTask(schedule.pluginId, schedule.taskId);
+              } catch (error) {
+                const err = error instanceof Error ? error : new Error(String(error));
+                getLogger().error("Plugin scheduled task threw", {
+                  pluginId: schedule.pluginId,
+                  taskId: schedule.taskId,
+                  jobId: job.id,
+                  error: err.message,
+                  stack: err.stack
+                });
+                await recordJobLog("error", `Plugin scheduled task threw: ${err.message}`, {
+                  pluginId: schedule.pluginId,
+                  taskId: schedule.taskId,
+                  stack: err.stack
+                });
+                void reportError(err, {
+                  tags: {
+                    source: "worker",
+                    pluginId: schedule.pluginId,
+                    taskId: schedule.taskId
+                  },
+                  extra: { jobId: job.id }
+                });
+                throw err;
+              }
+            });
+          }
+        });
+      };
+      this.workRegistrations.push({ queueName, register });
+      await register();
+    }
+    this.workerStarted = true;
+  }
+  /**
+   * Phase 20.2 — drop every registered worker so the boss stops
+   * claiming new jobs. The pg-boss connection stays open; the
+   * producer can keep enqueueing while paused. In-flight jobs
+   * picked up before pause finish normally because pg-boss only
+   * cancels the polling loop, not the fetch already in flight.
+   */
+  async pauseProcessing() {
+    if (this.paused) return;
+    for (const { queueName } of this.workRegistrations) {
+      await this.boss.offWork(queueName);
+    }
+    this.paused = true;
+    getLogger().info("Job processing paused", {
+      queues: this.workRegistrations.length
+    });
+  }
+  /** Phase 20.2 — re-run every captured `boss.work()` registration. Idempotent. */
+  async resumeProcessing() {
+    if (!this.paused) return;
+    for (const { register } of this.workRegistrations) {
+      await register();
+    }
+    this.paused = false;
+    getLogger().info("Job processing resumed", {
+      queues: this.workRegistrations.length
+    });
+  }
+  isProcessingPaused() {
+    return this.paused;
+  }
+  /**
+   * Phase 22.4 — readiness probe round-trip. `boss.isInstalled()`
+   * issues a single SELECT against `pgboss.version`, so a true
+   * answer proves both that the DB connection is alive AND that
+   * pg-boss's schema migrations have applied. Any throw — pool
+   * dead, schema missing, permissions revoked — is caught and
+   * reported as `false`; the readiness probe never sees an
+   * exception bubble out of the queue check.
+   */
+  async isHealthy() {
+    try {
+      return await this.boss.isInstalled();
+    } catch {
+      return false;
+    }
+  }
+  async stop() {
+    await this.boss.stop({ graceful: true, timeout: 3e4 });
+  }
+  async scheduleRecurring() {
+    await this.boss.schedule(toQueueName("system:revisionPrune"), "0 3 * * *", {});
+    await this.boss.schedule(toQueueName("system:sessionCleanup"), "0 * * * *", {});
+    await this.boss.schedule(toQueueName("system:jobLogPrune"), "30 3 * * *", {});
+    const digestQueue = toQueueName("notifications:sendDigest");
+    await this.boss.unschedule(digestQueue).catch(() => {
+    });
+    await this.boss.schedule(digestQueue, "0 8 * * *", { cadence: "daily" }, { key: "daily" });
+    await this.boss.schedule(digestQueue, "0 8 * * 1", { cadence: "weekly" }, { key: "weekly" });
+    const { getRegisteredPluginSchedules } = await import("./host-OBOI4MJK.js");
+    for (const schedule of getRegisteredPluginSchedules()) {
+      const pgBossName = `${toQueueName("plugin:scheduledTask")}.${schedule.pluginId}.${schedule.taskId}`;
+      await this.boss.schedule(pgBossName, schedule.cron, {
+        pluginId: schedule.pluginId,
+        taskId: schedule.taskId
+      });
+    }
+  }
+  getBoss() {
+    return this.boss;
+  }
+  /**
+   * Phase 13 — admin job introspection. Joins pgboss.job
+   * (pending / active / retry) and pgboss.archive (completed
+   * / failed / expired) into one unified list.
+   *
+   * Phase 13.2 — `since` filter for time-bounded queries
+   * ("last 24 hours") and accurate `total` via a parallel
+   * COUNT(*) so the admin pagination shows the right count.
+   * The COUNT runs against the same UNION; the per-page
+   * SELECT still gets the row data.
+   */
+  async listJobs(options) {
+    const limit = Math.min(Math.max(1, options.limit ?? 50), 200);
+    const offset = Math.max(0, options.offset ?? 0);
+    const db = this.boss.db;
+    const params = [];
+    const where = [];
+    if (options.name) {
+      params.push(options.name);
+      where.push(`name = $${params.length}`);
+    }
+    if (options.state) {
+      params.push(options.state);
+      where.push(`state = $${params.length}`);
+    }
+    if (options.since) {
+      params.push(options.since.toISOString());
+      where.push(`created_on >= $${params.length}`);
+    }
+    const whereSql = where.length ? `WHERE ${where.join(" AND ")}` : "";
+    const liveSelect = `
+      SELECT id, name, state, data, retry_count,
+             output::text AS output, created_on, started_on, completed_on,
+             'live' AS source
+        FROM pgboss.job`;
+    const archiveSelect = `
+      SELECT id, name, state, data, retry_count,
+             output::text AS output, created_on, started_on, completed_on,
+             'archive' AS source
+        FROM pgboss.archive`;
+    const innerUnion = options.source === "live" ? liveSelect : options.source === "archive" ? archiveSelect : `${liveSelect}
+        UNION ALL${archiveSelect}`;
+    const listSql = `
+      SELECT id, name, state::text AS state, data, retry_count,
+             output, created_on, started_on, completed_on, source
+      FROM (
+        ${innerUnion}
+      ) jobs
+      ${whereSql}
+      ORDER BY created_on DESC
+      LIMIT ${limit} OFFSET ${offset}
+    `;
+    const liveCount = `SELECT id, name, state, data, created_on, 'live' AS source FROM pgboss.job`;
+    const archiveCount = `SELECT id, name, state, data, created_on, 'archive' AS source FROM pgboss.archive`;
+    const countUnion = options.source === "live" ? liveCount : options.source === "archive" ? archiveCount : `${liveCount} UNION ALL ${archiveCount}`;
+    const countSql = `
+      SELECT COUNT(*)::bigint AS total
+      FROM (
+        ${countUnion}
+      ) jobs
+      ${whereSql}
+    `;
+    const [listResult, countResult] = await Promise.all([
+      db.executeSql(listSql, params),
+      db.executeSql(countSql, params)
+    ]);
+    const rows = listResult.rows ?? [];
+    const totalRaw = countResult.rows?.[0]?.total;
+    const total = typeof totalRaw === "number" ? totalRaw : typeof totalRaw === "string" ? Number.parseInt(totalRaw, 10) : 0;
+    return {
+      jobs: rows.map(rowToSummary),
+      total: Number.isFinite(total) ? total : 0
+    };
+  }
+  /**
+   * Phase 13.2 — list every cron schedule registered in the
+   * queue. Reads from `pgboss.schedule`, which is the table
+   * pg-boss writes to on each `boss.schedule()` call. Sorted
+   * by name for stable display.
+   */
+  async listSchedules() {
+    const db = this.boss.db;
+    const result = await db.executeSql(
+      `SELECT name, key, cron, timezone, data, created_on, updated_on
+         FROM pgboss.schedule
+        ORDER BY name ASC, key ASC`
+    );
+    return (result.rows ?? []).map(scheduleRowToSummary);
+  }
+  /**
+   * Phase 4.2 — pulls per-(pluginId, taskId) execution stats from the
+   * union of `pgboss.job` (in-flight + recently-completed) and
+   * `pgboss.archive` (rolled-over history). One row per taskId so the
+   * caller can index without a second pass.
+   *
+   * The window default is 7 days because longer windows force the
+   * archive table into the hot path and admins typically want recent
+   * health, not lifetime totals. Increase via `windowDays` if surfacing
+   * a "30-day reliability" widget.
+   */
+  async getPluginScheduleStats(pluginId, options) {
+    const windowDays = Math.max(1, Math.min(365, options?.windowDays ?? 7));
+    const db = this.boss.db;
+    const result = await db.executeSql(
+      `WITH plugin_jobs AS (
+         SELECT state, completed_on, data
+           FROM pgboss.job
+          WHERE (name = 'plugin.scheduledTask' OR name LIKE 'plugin.scheduledTask.%')
+            AND data->>'pluginId' = $1
+            AND completed_on > NOW() - ($2 || ' days')::interval
+         UNION ALL
+         SELECT state, completed_on, data
+           FROM pgboss.archive
+          WHERE (name = 'plugin.scheduledTask' OR name LIKE 'plugin.scheduledTask.%')
+            AND data->>'pluginId' = $1
+            AND completed_on > NOW() - ($2 || ' days')::interval
+       )
+       SELECT data->>'taskId' AS task_id,
+              MAX(completed_on) AS last_run,
+              MAX(CASE WHEN state = 'completed' THEN completed_on END) AS last_success,
+              MAX(CASE WHEN state = 'failed' THEN completed_on END) AS last_failure,
+              SUM(CASE WHEN state = 'completed' THEN 1 ELSE 0 END) AS completed_count,
+              SUM(CASE WHEN state = 'failed' THEN 1 ELSE 0 END) AS failed_count
+         FROM plugin_jobs
+        WHERE data->>'taskId' IS NOT NULL
+        GROUP BY data->>'taskId'`,
+      [pluginId, String(windowDays)]
+    );
+    return (result.rows ?? []).filter((row) => typeof row.task_id === "string").map((row) => ({
+      taskId: row.task_id,
+      lastRunAt: toIso(row.last_run),
+      lastSuccessAt: toIso(row.last_success),
+      lastFailureAt: toIso(row.last_failure),
+      completedCount: Number(row.completed_count) || 0,
+      failedCount: Number(row.failed_count) || 0,
+      windowDays
+    }));
+  }
+  /**
+   * Issue #461 — diff the in-memory plugin schedule registry against the
+   * `pgboss.schedule` rows whose name starts with `plugin.scheduledTask.*`
+   * and bring pg-boss in line. Without this, `reloadPlugins()` only
+   * rebuilt the in-process registry and pg-boss kept firing the old set
+   * of crons until the worker process restarted — the admin "Reload all"
+   * toast was promising behavior the system didn't deliver.
+   *
+   * Worker `boss.work()` registrations stay untouched. In production the
+   * worker is a separate process with its own boss instance; the web
+   * process can't add or drop work loops there. We surface that via
+   * `workerOwnsRegistrations` so the admin UI can warn the operator.
+   */
+  async reconcilePluginSchedules() {
+    const { getRegisteredPluginSchedules } = await import("./host-OBOI4MJK.js");
+    const wantedList = getRegisteredPluginSchedules();
+    const wantedByName = /* @__PURE__ */ new Map();
+    for (const schedule of wantedList) {
+      const name = `${toQueueName("plugin:scheduledTask")}.${schedule.pluginId}.${schedule.taskId}`;
+      wantedByName.set(name, {
+        pluginId: schedule.pluginId,
+        taskId: schedule.taskId,
+        cron: schedule.cron
+      });
+    }
+    const existingAll = await this.listSchedules();
+    const existingByName = /* @__PURE__ */ new Map();
+    for (const entry of existingAll) {
+      if (entry.name.startsWith("plugin.scheduledTask.")) {
+        existingByName.set(entry.name, entry);
+      }
+    }
+    let added = 0;
+    let updated = 0;
+    let removed = 0;
+    for (const [name, want] of wantedByName) {
+      const existing = existingByName.get(name);
+      if (!existing) {
+        await this.boss.schedule(name, want.cron, {
+          pluginId: want.pluginId,
+          taskId: want.taskId
+        });
+        added++;
+        continue;
+      }
+      if (existing.cron !== want.cron) {
+        await this.boss.unschedule(name).catch(() => {
+        });
+        await this.boss.schedule(name, want.cron, {
+          pluginId: want.pluginId,
+          taskId: want.taskId
+        });
+        updated++;
+      }
+    }
+    for (const [name] of existingByName) {
+      if (!wantedByName.has(name)) {
+        await this.boss.unschedule(name).catch(() => {
+        });
+        removed++;
+      }
+    }
+    return {
+      added,
+      updated,
+      removed,
+      workerOwnsRegistrations: this.workerStarted
+    };
+  }
+  /**
+   * Phase 23.5 — `GROUP BY state` across the union of pgboss.job
+   * (live) and pgboss.archive (rolled). Returns a fully-populated
+   * record so callers can index without optional chaining.
+   *
+   * Uses `created_on` for the optional `since` filter. Both tables
+   * carry the same column, so the union pre-filter is a single
+   * predicate.
+   */
+  async countByState(options) {
+    const db = this.boss.db;
+    const params = [];
+    let whereSql = "";
+    if (options?.since) {
+      params.push(options.since.toISOString());
+      whereSql = `WHERE created_on >= $${params.length}`;
+    }
+    const result = await db.executeSql(
+      `SELECT state::text AS state, COUNT(*)::bigint AS count
+         FROM (
+           SELECT state, created_on FROM pgboss.job
+           UNION ALL
+           SELECT state, created_on FROM pgboss.archive
+         ) jobs
+         ${whereSql}
+        GROUP BY state`,
+      params
+    );
+    const counts = {
+      created: 0,
+      active: 0,
+      completed: 0,
+      failed: 0,
+      retry: 0,
+      cancelled: 0,
+      expired: 0
+    };
+    for (const row of result.rows ?? []) {
+      const key = row.state;
+      if (key in counts) {
+        const value = typeof row.count === "number" ? row.count : Number.parseInt(row.count, 10);
+        counts[key] = Number.isFinite(value) ? value : 0;
+      }
+    }
+    return counts;
+  }
+  async retryJob(id) {
+    const db = this.boss.db;
+    const result = await db.executeSql(
+      `SELECT id, name, state::text AS state, data, retry_count,
+              output::text AS output, created_on, started_on, completed_on
+       FROM pgboss.job WHERE id = $1
+       UNION ALL
+       SELECT id, name, state, data, retry_count,
+              output::text AS output, created_on, started_on, completed_on
+       FROM pgboss.archive WHERE id = $1
+       LIMIT 1`,
+      [id]
+    );
+    const row = result.rows?.[0];
+    if (!row) {
+      throw new Error(`Job ${id} not found`);
+    }
+    const newId = await this.boss.send(row.name, row.data ?? {});
+    if (!newId) {
+      throw new Error(`Failed to re-enqueue ${row.name}`);
+    }
+    return newId;
+  }
+  async cancelJob(id) {
+    const db = this.boss.db;
+    const result = await db.executeSql(`SELECT name FROM pgboss.job WHERE id = $1`, [id]);
+    const row = result.rows?.[0];
+    if (!row) {
+      throw new Error(`Job ${id} not found or already terminal`);
+    }
+    await this.boss.cancel(row.name, id);
+  }
+};
+function scheduleRowToSummary(row) {
+  return {
+    name: row.name,
+    key: row.key ?? "",
+    cron: row.cron,
+    timezone: row.timezone ?? null,
+    data: row.data ?? null,
+    createdOn: toIso(row.created_on) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    updatedOn: toIso(row.updated_on)
+  };
+}
+function rowToSummary(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    state: row.state,
+    data: row.data,
+    retryCount: typeof row.retry_count === "number" ? row.retry_count : void 0,
+    output: row.output ?? null,
+    createdOn: toIso(row.created_on) ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    startedOn: toIso(row.started_on),
+    completedOn: toIso(row.completed_on),
+    source: row.source === "archive" ? "archive" : row.source === "live" ? "live" : void 0
+  };
+}
+function toIso(value) {
+  if (!value) return null;
+  if (value instanceof Date) return value.toISOString();
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed.toISOString();
+}
+function asJobPayload(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    return { payload: data };
+  }
+  return data;
+}
+// src/jobs/worker.ts
+var workerAdapter = null;
+var producerAdapter = null;
+var heartbeatHandle = null;
+var pauseSyncHandle = null;
+var signalHandlersInstalled = false;
+var installedSignalHandlers = /* @__PURE__ */ new Map();
+function installShutdownSignalHandlers() {
+  if (signalHandlersInstalled) return;
+  signalHandlersInstalled = true;
+  for (const signal of ["SIGINT", "SIGTERM"]) {
+    const handler = () => {
+      void (async () => {
+        try {
+          await stopWorker();
+        } catch (err) {
+          getLogger().warn("Worker shutdown handler failed", {
+            signal,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        } finally {
+          process.exit(0);
+        }
+      })();
+    };
+    process.on(signal, handler);
+    installedSignalHandlers.set(signal, handler);
+  }
+}
+function removeShutdownSignalHandlers() {
+  if (!signalHandlersInstalled) return;
+  for (const [signal, handler] of installedSignalHandlers) {
+    process.off(signal, handler);
+  }
+  installedSignalHandlers.clear();
+  signalHandlersInstalled = false;
+}
+async function startWorker(connectionString, options) {
+  if (workerAdapter) {
+    return;
+  }
+  registerBuiltinHandlers();
+  workerAdapter = new PgBossAdapter(connectionString, {
+    schema: options?.schema ?? "public"
+  });
+  setJobQueue(workerAdapter);
+  try {
+    await workerAdapter.start();
+    await workerAdapter.scheduleRecurring();
+    try {
+      const pauseState = await getJobsPauseState();
+      if (pauseState.paused) {
+        await workerAdapter.pauseProcessing();
+        getLogger().info("Worker booted in paused state", {
+          changedAt: pauseState.changedAt,
+          reason: pauseState.reason
+        });
+      }
+    } catch (err) {
+      getLogger().warn("Could not read jobs pause state on worker boot", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+    const heartbeatOpt = options?.heartbeat ?? true;
+    if (heartbeatOpt !== false) {
+      const meta = typeof heartbeatOpt === "object" ? heartbeatOpt.meta ?? {} : {};
+      heartbeatHandle = startHeartbeatLoop(meta);
+      pauseSyncHandle = startPauseSyncLoop(workerAdapter);
+    }
+    if (options?.installSignalHandlers !== false) {
+      installShutdownSignalHandlers();
+    }
+  } catch (err) {
+    if (heartbeatHandle) {
+      try {
+        await heartbeatHandle.stop();
+      } catch {
+      }
+      heartbeatHandle = null;
+    }
+    if (pauseSyncHandle) {
+      try {
+        pauseSyncHandle.stop();
+      } catch {
+      }
+      pauseSyncHandle = null;
+    }
+    if (workerAdapter) {
+      try {
+        await workerAdapter.stop();
+      } catch {
+      }
+      workerAdapter = null;
+    }
+    removeShutdownSignalHandlers();
+    throw err;
+  }
+}
+async function startProducer(connectionString, options) {
+  if (producerAdapter) {
+    return;
+  }
+  producerAdapter = new PgBossAdapter(connectionString, {
+    schema: options?.schema ?? "public"
+  });
+  setJobQueue(producerAdapter);
+  await producerAdapter.startProducer();
+}
+async function stopWorker() {
+  if (!workerAdapter) {
+    return;
+  }
+  if (heartbeatHandle) {
+    await heartbeatHandle.stop();
+    heartbeatHandle = null;
+  }
+  if (pauseSyncHandle) {
+    pauseSyncHandle.stop();
+    pauseSyncHandle = null;
+  }
+  await workerAdapter.stop();
+  workerAdapter = null;
+  removeShutdownSignalHandlers();
+}
+async function stopProducer() {
+  if (!producerAdapter) {
+    return;
+  }
+  await producerAdapter.stop();
+  producerAdapter = null;
+}
+export {
+  registerJobHandler,
+  getJobHandler,
+  getAllJobHandlers,
+  buildInviteEmail,
+  buildResetEmail,
+  configureBuiltinJobContext,
+  registerBuiltinHandlers,
+  WORKER_HEARTBEAT_INTERVAL_MS,
+  WORKER_STALE_THRESHOLD_MS,
+  recordHeartbeat,
+  markWorkerStopped,
+  listWorkerHealth,
+  purgeStaleWorkers,
+  countAliveWorkers,
+  getJobsPauseState,
+  setJobsPauseState,
+  PAUSE_SYNC_INTERVAL_MS,
+  PgBossAdapter,
+  startWorker,
+  startProducer,
+  stopWorker,
+  stopProducer
+};
+//# sourceMappingURL=chunk-ISLYFQWL.js.map