@infuro/cms-core 1.0.33 → 1.0.35

package/dist/chunk-XDSNZUW7.js

@@ -0,0 +1,564 @@
+import { queueEmail } from './chunk-5ELSW2UP.js';
+import { __name } from './chunk-SHUYVCID.js';
+
+// src/plugins/email/templates/types.ts
+function normalizeSocialLinkItem(o) {
+  const url = String(o.url ?? "").trim();
+  if (!url) return null;
+  let iconUrl = String(o.iconUrl ?? o.icon_image ?? "").trim();
+  let icon = String(o.icon ?? "").trim();
+  if (!iconUrl && /^https?:\/\//i.test(icon)) {
+    iconUrl = icon;
+    icon = "";
+  }
+  const item = {
+    url
+  };
+  if (iconUrl) item.iconUrl = iconUrl;
+  if (icon) item.icon = icon;
+  return item;
+}
+__name(normalizeSocialLinkItem, "normalizeSocialLinkItem");
+function parseSocialLinksJson(raw) {
+  if (raw == null || raw.trim() === "") return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return void 0;
+    const out = [];
+    for (const item of parsed) {
+      if (item && typeof item === "object" && "url" in item) {
+        const n = normalizeSocialLinkItem(item);
+        if (n) out.push(n);
+      }
+    }
+    return out.length ? out : void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(parseSocialLinksJson, "parseSocialLinksJson");
+function mergeEmailLayoutCompanyDetails(branding, emailSettings) {
+  const fromBranding = getCompanyDetailsFromSettings(branding);
+  const pick = /* @__PURE__ */ __name((emailVal, fallback) => {
+    const t = emailVal?.trim();
+    return t || fallback?.trim() || void 0;
+  }, "pick");
+  const logoUrl = pick(emailSettings.logoUrl ?? emailSettings.emailLogoUrl, fromBranding.logoUrl);
+  const companyName = pick(emailSettings.companyName ?? emailSettings.emailCompanyName, fromBranding.companyName);
+  const supportEmail = pick(emailSettings.supportEmail ?? emailSettings.emailSupportEmail, fromBranding.supportEmail);
+  const supportPhone = pick(emailSettings.supportPhone, void 0);
+  const footerDisclaimer = pick(emailSettings.footerDisclaimer, void 0);
+  const followUsTitle = pick(emailSettings.followUsTitle, "Follow Us") || "Follow Us";
+  const socialFromEmail = parseSocialLinksJson(emailSettings.socialLinks);
+  const socialLinks = socialFromEmail?.length ? socialFromEmail : fromBranding.socialLinks;
+  return {
+    logoUrl,
+    companyName,
+    supportEmail,
+    supportPhone,
+    socialLinks,
+    footerDisclaimer,
+    followUsTitle
+  };
+}
+__name(mergeEmailLayoutCompanyDetails, "mergeEmailLayoutCompanyDetails");
+function getCompanyDetailsFromSettings(settingsGroup) {
+  const logoUrl = settingsGroup.logo ?? settingsGroup.logoUrl ?? "";
+  const companyName = settingsGroup.companyName ?? settingsGroup.company_name ?? "";
+  const supportEmail = settingsGroup.supportEmail ?? settingsGroup.support_email ?? "";
+  let socialLinks = [];
+  const raw = settingsGroup.socialLinks ?? settingsGroup.social_links;
+  if (typeof raw === "string") {
+    try {
+      const arr = JSON.parse(raw);
+      if (Array.isArray(arr)) {
+        for (const item of arr) {
+          if (item && typeof item === "object") {
+            const n = normalizeSocialLinkItem(item);
+            if (n) socialLinks.push(n);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return {
+    logoUrl: logoUrl || void 0,
+    companyName: companyName || void 0,
+    supportEmail: supportEmail || void 0,
+    socialLinks: socialLinks.length ? socialLinks : void 0
+  };
+}
+__name(getCompanyDetailsFromSettings, "getCompanyDetailsFromSettings");
+
+// src/lib/email-recipients.ts
+function parseEmailRecipientsFromConfig(raw) {
+  if (raw == null || raw === "") return [];
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (Array.isArray(parsed)) {
+        return parsed.map((e) => String(e).trim()).filter(Boolean);
+      }
+    } catch {
+    }
+  }
+  return trimmed.split(/[,;]+/).map((s) => s.trim()).filter(Boolean);
+}
+__name(parseEmailRecipientsFromConfig, "parseEmailRecipientsFromConfig");
+function serializeEmailRecipients(emails) {
+  return JSON.stringify(emails);
+}
+__name(serializeEmailRecipients, "serializeEmailRecipients");
+function joinRecipientsForSend(emails) {
+  if (!emails.length) return null;
+  return emails.join(", ");
+}
+__name(joinRecipientsForSend, "joinRecipientsForSend");
+
+// src/plugins/llm/chat-email-intent.ts
+var NONE_INTENT = "NONE";
+var CHAT_EMAIL_LOG = "[chat-email-tool]";
+function logChatEmail(step, data) {
+  if (data && Object.keys(data).length > 0) {
+    console.info(CHAT_EMAIL_LOG, step, data);
+  } else {
+    console.info(CHAT_EMAIL_LOG, step);
+  }
+}
+__name(logChatEmail, "logChatEmail");
+function normalizeIntentKey(raw) {
+  return raw.trim().toUpperCase().replace(/[^A-Z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+__name(normalizeIntentKey, "normalizeIntentKey");
+function parseIntentsJson(raw) {
+  if (!raw?.trim()) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return null;
+    const out = [];
+    for (const row of parsed) {
+      if (!row || typeof row !== "object") continue;
+      const o = row;
+      const intent = normalizeIntentKey(String(o.intent ?? o.id ?? ""));
+      const description = String(o.description ?? "").trim();
+      const emailTo = String(o.emailTo ?? o.email ?? "").trim();
+      if (!intent || !description || !emailTo) continue;
+      out.push({
+        intent,
+        description,
+        emailTo
+      });
+    }
+    return out.length > 0 ? out : null;
+  } catch {
+    return null;
+  }
+}
+__name(parseIntentsJson, "parseIntentsJson");
+function dedupeIntents(intents) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const row of intents) {
+    const key = normalizeIntentKey(row.intent);
+    if (!key || seen.has(key)) continue;
+    seen.add(key);
+    out.push({
+      intent: key,
+      description: row.description.trim(),
+      emailTo: row.emailTo.trim()
+    });
+  }
+  return out;
+}
+__name(dedupeIntents, "dedupeIntents");
+function parseChatEmailToolSettings(map) {
+  const fromJson = parseIntentsJson(map.emailIntents);
+  const intents = dedupeIntents(fromJson ?? []);
+  const legacyPositive = map.emailIntentPrompt?.trim() ?? "";
+  const legacyNegative = map.emailNegativeIntentPrompt?.trim() ?? "";
+  let classifierInstructions = map.emailClassifierInstructions?.trim() ?? "";
+  if (!classifierInstructions && (legacyPositive || legacyNegative)) {
+    const parts = [];
+    if (legacyPositive) parts.push(`Legacy positive signals:
+${legacyPositive}`);
+    if (legacyNegative) parts.push(`Do NOT assign an intent when:
+${legacyNegative}`);
+    classifierInstructions = parts.join("\n\n");
+  }
+  return {
+    enabled: map.emailToolEnabled === "true",
+    intents,
+    classifierInstructions,
+    toolPrompt: map.emailToolPrompt ?? ""
+  };
+}
+__name(parseChatEmailToolSettings, "parseChatEmailToolSettings");
+var EMAIL_TOOL_VALIDATION_KEY = "emailTool";
+function parseEmailToolObject(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const o = raw;
+  const intentsRaw = o.intents;
+  let intents;
+  if (Array.isArray(intentsRaw)) {
+    const parsed = parseIntentsJson(JSON.stringify(intentsRaw));
+    if (parsed?.length) intents = parsed;
+  }
+  return {
+    enabled: o.enabled === true,
+    classifierInstructions: typeof o.classifierInstructions === "string" ? o.classifierInstructions.trim() : void 0,
+    toolPrompt: typeof o.toolPrompt === "string" ? o.toolPrompt.trim() : void 0,
+    intents
+  };
+}
+__name(parseEmailToolObject, "parseEmailToolObject");
+function parseEmailToolFromAgentValidationRules(validationRulesText) {
+  const raw = validationRulesText?.trim();
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    const emailTool = parsed[EMAIL_TOOL_VALIDATION_KEY];
+    return parseEmailToolObject(emailTool);
+  } catch {
+    return null;
+  }
+}
+__name(parseEmailToolFromAgentValidationRules, "parseEmailToolFromAgentValidationRules");
+function resolveChatEmailToolSettings(configMap, sources) {
+  const fromConfig = parseChatEmailToolSettings(configMap);
+  const resolved = typeof sources === "string" || sources == null ? {
+    chatbotValidationRules: typeof sources === "string" ? sources : null
+  } : sources;
+  const fromChatbot = parseEmailToolFromAgentValidationRules(resolved.chatbotValidationRules);
+  const fromNotify = resolved.notifyAgent ? parseEmailToolFromAgentValidationRules(resolved.notifyAgent.validationRules) : null;
+  const notifySystem = resolved.notifyAgent?.systemInstruction?.trim() ?? "";
+  const intents = fromNotify?.intents?.length ? fromNotify.intents : fromChatbot?.intents?.length ? fromChatbot.intents : fromConfig.intents;
+  const classifierParts = [
+    notifySystem,
+    fromNotify?.classifierInstructions?.trim(),
+    fromChatbot?.classifierInstructions?.trim(),
+    fromConfig.classifierInstructions.trim()
+  ].filter(Boolean);
+  const toolPrompt = fromNotify?.toolPrompt?.trim() || fromChatbot?.toolPrompt?.trim() || fromConfig.toolPrompt?.trim() || "";
+  return {
+    enabled: fromConfig.enabled,
+    intents,
+    classifierInstructions: classifierParts.join("\n\n"),
+    toolPrompt
+  };
+}
+__name(resolveChatEmailToolSettings, "resolveChatEmailToolSettings");
+function intentByKey(intents, key) {
+  if (!key) return null;
+  const norm = normalizeIntentKey(key);
+  return intents.find((i) => i.intent === norm) ?? null;
+}
+__name(intentByKey, "intentByKey");
+function buildIntentTableForPrompt(intents) {
+  return intents.map((i) => `- ${i.intent}: ${i.description} \u2192 notify ${i.emailTo}`).join("\n");
+}
+__name(buildIntentTableForPrompt, "buildIntentTableForPrompt");
+function buildIntentClassifierSystem(config, agentClassifierInstructions) {
+  const table = buildIntentTableForPrompt(config.intents);
+  const extra = [
+    agentClassifierInstructions?.trim(),
+    config.classifierInstructions.trim()
+  ].filter(Boolean).join("\n\n");
+  const intentKeys = config.intents.map((i) => i.intent).join(", ");
+  return `You classify a chat visitor into exactly one lead intent for email routing.
+
+Available intents (pick the best match):
+${table}
+
+If the visitor is not ready for a lead email (general FAQ, greetings only, spam, off-topic, no clear business need), use intent "${NONE_INTENT}".
+
+Allowed intent values: ${intentKeys}, or ${NONE_INTENT}.
+
+${extra ? `Additional instructions:
+${extra}
+` : ""}
+Reply with ONLY valid JSON, no markdown:
+{"intent":"INTENT_KEY","reason":"short explanation"}
+Use "${NONE_INTENT}" when no intent applies.`;
+}
+__name(buildIntentClassifierSystem, "buildIntentClassifierSystem");
+function buildChatEmailAgentContext(settings) {
+  if (!settings.enabled) return "";
+  const classifier = settings.classifierInstructions.trim();
+  const extra = settings.toolPrompt?.trim() ?? "";
+  const parts = [];
+  if (settings.intents.length > 0) {
+    parts.push("## Lead email routing", "When a visitor message clearly matches an intent below, the system sends one team notification email (per conversation). Continue the conversation normally in all cases.");
+    if (classifier) parts.push(`### Routing rules
+${classifier}`);
+    parts.push(`### Intent catalog
+${buildIntentTableForPrompt(settings.intents)}`);
+  } else if (classifier) {
+    parts.push(`## Lead email routing
+${classifier}`);
+  }
+  if (extra) parts.push(`### Assistant behavior
+${extra}`);
+  return parts.join("\n\n");
+}
+__name(buildChatEmailAgentContext, "buildChatEmailAgentContext");
+function buildChatbotSystemPromptWithEmailTool(baseSystemInstruction, guardrailsForPrompt, emailSettings) {
+  let prompt = (baseSystemInstruction ?? "").trim();
+  const guard = guardrailsForPrompt?.trim();
+  if (guard) prompt = [
+    prompt,
+    guard
+  ].filter(Boolean).join("\n\n");
+  if (emailSettings.enabled) {
+    const emailCtx = buildChatEmailAgentContext(emailSettings);
+    if (emailCtx) prompt = [
+      prompt,
+      emailCtx
+    ].filter(Boolean).join("\n\n");
+  }
+  return prompt;
+}
+__name(buildChatbotSystemPromptWithEmailTool, "buildChatbotSystemPromptWithEmailTool");
+function formatTranscript(history, latestMessage, maxChars = 4e3) {
+  const lines = [];
+  for (const m of history) {
+    const role = m.role === "assistant" ? "Assistant" : m.role === "user" ? "Visitor" : "System";
+    lines.push(`${role}: ${m.content}`);
+  }
+  const last = history[history.length - 1];
+  if (!last || last.role !== "user" || last.content !== latestMessage) {
+    lines.push(`Visitor: ${latestMessage}`);
+  }
+  let text = lines.join("\n");
+  if (text.length > maxChars) text = text.slice(-maxChars);
+  return text;
+}
+__name(formatTranscript, "formatTranscript");
+function parseIntentJson(raw, intents) {
+  const trimmed = raw.trim();
+  const fence = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  const candidate = (fence?.[1] ?? trimmed).trim();
+  const tryParse = /* @__PURE__ */ __name((s) => {
+    const o = JSON.parse(s);
+    let intentRaw = null;
+    if (typeof o.intent === "string") intentRaw = o.intent;
+    else if (o.interested === false) intentRaw = NONE_INTENT;
+    else if (o.interested === true && intents[0]) intentRaw = intents[0].intent;
+    if (intentRaw == null) return null;
+    const reason = typeof o.reason === "string" && o.reason.trim() ? o.reason.trim() : "Classified from conversation";
+    return {
+      intent: normalizeIntentKey(intentRaw),
+      reason
+    };
+  }, "tryParse");
+  try {
+    return tryParse(candidate);
+  } catch {
+    const m = candidate.match(/\{[\s\S]*\}/);
+    if (!m) return null;
+    try {
+      return tryParse(m[0]);
+    } catch {
+      return null;
+    }
+  }
+}
+__name(parseIntentJson, "parseIntentJson");
+async function detectChatLeadIntent(llm, params) {
+  if (!params.settings.intents.length) {
+    logChatEmail("classify skipped", {
+      reason: "no_intents_configured"
+    });
+    return {
+      intent: null,
+      intentLabel: "NONE",
+      reason: "No lead intents configured",
+      emailTo: null
+    };
+  }
+  logChatEmail("classify start", {
+    intentCount: params.settings.intents.length,
+    intentKeys: params.settings.intents.map((i) => i.intent),
+    model: params.model?.trim() || "(gateway default)",
+    messageChars: params.message.length,
+    historyTurns: params.history.length,
+    hasClassifierInstructions: Boolean(params.agentClassifierInstructions?.trim() || params.settings.classifierInstructions.trim())
+  });
+  const transcript = formatTranscript(params.history, params.message);
+  const contactLines = [
+    params.contact.name?.trim() ? `Name: ${params.contact.name.trim()}` : null,
+    params.contact.email?.trim() ? `Email: ${params.contact.email.trim()}` : null,
+    params.contact.phone?.trim() ? `Phone: ${params.contact.phone.trim()}` : null
+  ].filter(Boolean).join("\n");
+  const userPrompt = `Customer:
+${contactLines || "(unknown)"}
+
+Conversation:
+${transcript}
+
+Pick the single best intent for the visitor's latest message.`;
+  const res = await llm.chatAgent({
+    systemPrompt: buildIntentClassifierSystem(params.settings, params.agentClassifierInstructions),
+    userPrompt,
+    temperature: 0.1,
+    max_tokens: 256,
+    ...params.model?.trim() ? {
+      model: params.model.trim()
+    } : {}
+  });
+  const rawContent = res.content ?? "";
+  logChatEmail("classify llm response", {
+    responseChars: rawContent.length,
+    responsePreview: rawContent.slice(0, 280) + (rawContent.length > 280 ? "\u2026" : "")
+  });
+  const parsed = parseIntentJson(rawContent, params.settings.intents);
+  if (!parsed) {
+    logChatEmail("classify result", {
+      matched: false,
+      outcome: "parse_failed",
+      emailWillSend: false
+    });
+    return {
+      intent: null,
+      intentLabel: "Unclassified",
+      reason: "Could not parse intent classifier response",
+      emailTo: null
+    };
+  }
+  if (parsed.intent === NONE_INTENT) {
+    logChatEmail("classify result", {
+      matched: false,
+      outcome: NONE_INTENT,
+      reason: parsed.reason,
+      emailWillSend: false
+    });
+    return {
+      intent: null,
+      intentLabel: NONE_INTENT,
+      reason: parsed.reason,
+      emailTo: null
+    };
+  }
+  const matched = intentByKey(params.settings.intents, parsed.intent);
+  if (!matched) {
+    logChatEmail("classify result", {
+      matched: false,
+      outcome: "unknown_intent",
+      parsedIntent: parsed.intent,
+      reason: parsed.reason,
+      emailWillSend: false
+    });
+    return {
+      intent: null,
+      intentLabel: parsed.intent,
+      reason: `Unknown intent "${parsed.intent}": ${parsed.reason}`,
+      emailTo: null
+    };
+  }
+  logChatEmail("classify result", {
+    matched: true,
+    outcome: "intent_found",
+    intent: matched.intent,
+    emailTo: matched.emailTo,
+    reason: parsed.reason,
+    emailWillSend: true
+  });
+  return {
+    intent: matched.intent,
+    intentLabel: `${matched.intent} \u2014 ${matched.description}`,
+    reason: parsed.reason,
+    emailTo: matched.emailTo
+  };
+}
+__name(detectChatLeadIntent, "detectChatLeadIntent");
+function buildTranscriptForLeadEmail(history, latestMessage) {
+  return formatTranscript(history, latestMessage);
+}
+__name(buildTranscriptForLeadEmail, "buildTranscriptForLeadEmail");
+function parseIntentRecipientEmails(emailTo) {
+  return emailTo.split(/[,;]+/).map((s) => s.trim()).filter((s) => s.length > 0 && s.includes("@"));
+}
+__name(parseIntentRecipientEmails, "parseIntentRecipientEmails");
+
+// src/plugins/email/chat-lead-email.ts
+function resolveLeadRecipients(emailPlugin, emailSettings) {
+  const fromCrm = parseEmailRecipientsFromConfig(emailSettings.crmEmails ?? emailSettings.crmEmail ?? "");
+  if (fromCrm.length > 0) return fromCrm;
+  const fallback = emailPlugin.getDefaultTo?.() ?? "";
+  if (fallback.trim()) return [
+    fallback.trim()
+  ];
+  return [];
+}
+__name(resolveLeadRecipients, "resolveLeadRecipients");
+async function sendChatLeadEmail(cms, emailSettings, brandingSettings, input) {
+  console.info(CHAT_EMAIL_LOG, "send start", {
+    conversationId: input.conversationId,
+    intentCode: input.intentCode ?? null,
+    contactEmail: input.contactEmail,
+    contactName: input.contactName,
+    explicitRecipients: input.recipients?.length ?? 0
+  });
+  const email = cms.getPlugin("email");
+  if (!email?.send || !email.renderTemplate) {
+    console.warn(CHAT_EMAIL_LOG, "send failed", {
+      conversationId: input.conversationId,
+      reason: "email_plugin_disabled"
+    });
+    return {
+      sent: false,
+      recipients: [],
+      error: "Email plugin is not enabled"
+    };
+  }
+  const recipients = input.recipients?.filter((r) => r.trim().includes("@")).map((r) => r.trim()) ?? resolveLeadRecipients(email, emailSettings);
+  if (recipients.length === 0) {
+    console.warn(CHAT_EMAIL_LOG, "send failed", {
+      conversationId: input.conversationId,
+      reason: "no_recipients"
+    });
+    return {
+      sent: false,
+      recipients: [],
+      error: "No lead email recipients (configure intent Email To, CRM emails, or SMTP default To)"
+    };
+  }
+  console.info(CHAT_EMAIL_LOG, "send recipients resolved", {
+    conversationId: input.conversationId,
+    recipients,
+    source: input.recipients?.length ? "intent_email_to" : "crm_or_smtp_fallback"
+  });
+  const companyDetails = mergeEmailLayoutCompanyDetails(brandingSettings, emailSettings);
+  const ctx = {
+    ...input,
+    companyDetails: input.companyDetails ?? companyDetails
+  };
+  let anySent = false;
+  for (const to of recipients) {
+    await queueEmail(cms, {
+      to,
+      templateName: "chatLead",
+      ctx
+    });
+    console.info(CHAT_EMAIL_LOG, "send queued", {
+      conversationId: input.conversationId,
+      to,
+      template: "chatLead"
+    });
+    anySent = true;
+  }
+  console.info(CHAT_EMAIL_LOG, "send complete", {
+    conversationId: input.conversationId,
+    sent: anySent,
+    recipientCount: recipients.length
+  });
+  return {
+    sent: anySent,
+    recipients
+  };
+}
+__name(sendChatLeadEmail, "sendChatLeadEmail");
+
+export { CHAT_EMAIL_LOG, buildChatbotSystemPromptWithEmailTool, buildTranscriptForLeadEmail, detectChatLeadIntent, getCompanyDetailsFromSettings, joinRecipientsForSend, mergeEmailLayoutCompanyDetails, parseEmailRecipientsFromConfig, parseIntentRecipientEmails, resolveChatEmailToolSettings, sendChatLeadEmail, serializeEmailRecipients };

package/dist/chunk-XQ3QUHWR.cjs

@@ -0,0 +1,83 @@
+'use strict';
+
+var chunkUSNT2KNT_cjs = require('./chunk-USNT2KNT.cjs');
+var PgBoss = require('pg-boss');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var PgBoss__default = /*#__PURE__*/_interopDefault(PgBoss);
+
+var JOB_RUNNER_QUEUE = "job-runner";
+var PgBossService = class {
+  static {
+    chunkUSNT2KNT_cjs.__name(this, "PgBossService");
+  }
+  boss;
+  started = false;
+  workRegistered = /* @__PURE__ */ new Set();
+  constructor(connectionString, schema) {
+    this.boss = new PgBoss__default.default({
+      connectionString,
+      ...schema?.trim() ? {
+        schema: schema.trim()
+      } : {},
+      schedule: true
+    });
+    this.boss.on("error", (err) => {
+      console.error("[pg-boss]", err);
+    });
+  }
+  async start() {
+    if (this.started) return;
+    await this.boss.start();
+    await this.ensureQueue(JOB_RUNNER_QUEUE);
+    this.started = true;
+  }
+  async stop() {
+    if (!this.started) return;
+    await this.boss.stop({
+      graceful: true,
+      timeout: 1e4
+    });
+    this.started = false;
+    this.workRegistered.clear();
+  }
+  get raw() {
+    return this.boss;
+  }
+  async ensureQueue(name) {
+    const existing = await this.boss.getQueue(name);
+    if (!existing) {
+      await this.boss.createQueue(name);
+    }
+  }
+  async send(queue, data) {
+    await this.ensureQueue(queue);
+    return this.boss.send(queue, data, {
+      retryLimit: 2
+    });
+  }
+  async schedule(name, cron, data, options) {
+    await this.ensureQueue(name);
+    await this.boss.schedule(name, cron, data, options);
+  }
+  async unschedule(name) {
+    try {
+      await this.boss.unschedule(name);
+    } catch {
+    }
+  }
+  async registerWork(queue, handler) {
+    if (this.workRegistered.has(queue)) return;
+    await this.ensureQueue(queue);
+    await this.boss.work(queue, async (jobs) => {
+      for (const job of jobs) {
+        await handler(job.data);
+      }
+    });
+    this.workRegistered.add(queue);
+  }
+};
+
+exports.JOB_RUNNER_QUEUE = JOB_RUNNER_QUEUE;
+exports.PgBossService = PgBossService;