@spfn/notification 0.1.0-beta.17 → 0.1.0-beta.18

package/dist/server.js

@@ -138,19 +138,19 @@ async function getSESClient() {
     return sesClient;
   }
   try {
-    const { SESClient } = await import("@aws-sdk/client-ses");
-    sesClient = new SESClient({
+    const { SESv2Client } = await import("@aws-sdk/client-sesv2");
+    sesClient = new SESv2Client({
       region: env.AWS_REGION,
       credentials: env.AWS_ACCESS_KEY_ID && env.AWS_SECRET_ACCESS_KEY ? {
         accessKeyId: env.AWS_ACCESS_KEY_ID,
         secretAccessKey: env.AWS_SECRET_ACCESS_KEY
       } : void 0
     });
-    log.debug("SES client created", { region: env.AWS_REGION });
+    log.debug("SES v2 client created", { region: env.AWS_REGION });
     return sesClient;
   } catch {
     throw new Error(
-      "@aws-sdk/client-ses is not installed. Please install it: pnpm add @aws-sdk/client-ses"
+      "@aws-sdk/client-sesv2 is not installed. Please install it: pnpm add @aws-sdk/client-sesv2"
     );
   }
 }
@@ -159,29 +159,31 @@ var awsSesProvider = {
   async send(params) {
     try {
       const client = await getSESClient();
-      const { SendEmailCommand } = await import("@aws-sdk/client-ses");
+      const { SendEmailCommand } = await import("@aws-sdk/client-sesv2");
       const command = new SendEmailCommand({
-        Source: params.from,
+        FromEmailAddress: params.from,
         Destination: {
           ToAddresses: params.to
         },
         ReplyToAddresses: params.replyTo ? [params.replyTo] : void 0,
-        Message: {
-          Subject: {
-            Charset: "UTF-8",
-            Data: params.subject
-          },
-          Body: {
-            ...params.html && {
-              Html: {
-                Charset: "UTF-8",
-                Data: params.html
-              }
+        Content: {
+          Simple: {
+            Subject: {
+              Charset: "UTF-8",
+              Data: params.subject
             },
-            ...params.text && {
-              Text: {
-                Charset: "UTF-8",
-                Data: params.text
+            Body: {
+              ...params.html && {
+                Html: {
+                  Charset: "UTF-8",
+                  Data: params.html
+                }
+              },
+              ...params.text && {
+                Text: {
+                  Charset: "UTF-8",
+                  Data: params.text
+                }
               }
             }
           }
@@ -551,7 +553,7 @@ function registerBuiltinTemplates() {
 }
 
 // src/services/notification.service.ts
-import { create, findOne, findMany, updateOne, count } from "@spfn/core/db";
+import { create, createMany, findOne, findMany, updateOne, count } from "@spfn/core/db";
 import { desc, eq, and, gte, lte } from "drizzle-orm";
 
 // src/entities/schema.ts
@@ -694,6 +696,12 @@ async function createNotificationRecord(data) {
     status: "pending"
   });
 }
+async function createNotificationRecords(data) {
+  return await createMany(notifications, data.map((d) => ({
+    ...d,
+    status: "pending"
+  })));
+}
 async function createScheduledNotification(data) {
   return await create(notifications, {
     ...data,
@@ -817,749 +825,330 @@ async function findScheduledNotifications(options = {}) {
   });
 }
 
-// src/channels/email/index.ts
-import { logger as logger2 } from "@spfn/core/logger";
-var log2 = logger2.child("@spfn/notification:email");
-var providers = {
-  "aws-ses": awsSesProvider
-};
-function registerEmailProvider(provider) {
-  providers[provider.name] = provider;
-}
-function getProvider() {
-  const providerName = env.SPFN_NOTIFICATION_EMAIL_PROVIDER || "aws-ses";
-  const provider = providers[providerName];
-  if (!provider) {
-    throw new Error(`Email provider not found: ${providerName}`);
+// src/channels/concurrency.ts
+async function runWithConcurrency(items, fn, concurrency = 10) {
+  const results = new Array(items.length);
+  let cursor = 0;
+  async function worker() {
+    while (cursor < items.length) {
+      const i = cursor++;
+      results[i] = await fn(items[i]);
+    }
   }
-  return provider;
+  const workers = Array.from(
+    { length: Math.min(concurrency, items.length) },
+    () => worker()
+  );
+  await Promise.all(workers);
+  return results;
 }
-async function sendEmail(params) {
-  const recipients = Array.isArray(params.to) ? params.to : [params.to];
-  let subject = params.subject;
-  let text3 = params.text;
-  let html = params.html;
-  if (params.template) {
-    if (!hasTemplate(params.template)) {
-      log2.warn(`Template not found: ${params.template}`);
-      return {
-        success: false,
-        error: `Template not found: ${params.template}`
-      };
-    }
-    const rendered = renderTemplate(params.template, params.data || {}, "email");
-    if (rendered.email) {
-      subject = rendered.email.subject;
-      text3 = rendered.email.text;
-      html = rendered.email.html;
-    }
+
+// src/jobs/send-bulk-email-item.ts
+import { job } from "@spfn/core/job";
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
+var value_exports = {};
+__export(value_exports, {
+  HasPropertyKey: () => HasPropertyKey,
+  IsArray: () => IsArray,
+  IsAsyncIterator: () => IsAsyncIterator,
+  IsBigInt: () => IsBigInt,
+  IsBoolean: () => IsBoolean,
+  IsDate: () => IsDate,
+  IsFunction: () => IsFunction,
+  IsIterator: () => IsIterator,
+  IsNull: () => IsNull,
+  IsNumber: () => IsNumber,
+  IsObject: () => IsObject,
+  IsRegExp: () => IsRegExp,
+  IsString: () => IsString,
+  IsSymbol: () => IsSymbol,
+  IsUint8Array: () => IsUint8Array,
+  IsUndefined: () => IsUndefined
+});
+function HasPropertyKey(value, key) {
+  return key in value;
+}
+function IsAsyncIterator(value) {
+  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
+}
+function IsArray(value) {
+  return Array.isArray(value);
+}
+function IsBigInt(value) {
+  return typeof value === "bigint";
+}
+function IsBoolean(value) {
+  return typeof value === "boolean";
+}
+function IsDate(value) {
+  return value instanceof globalThis.Date;
+}
+function IsFunction(value) {
+  return typeof value === "function";
+}
+function IsIterator(value) {
+  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
+}
+function IsNull(value) {
+  return value === null;
+}
+function IsNumber(value) {
+  return typeof value === "number";
+}
+function IsObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function IsRegExp(value) {
+  return value instanceof globalThis.RegExp;
+}
+function IsString(value) {
+  return typeof value === "string";
+}
+function IsSymbol(value) {
+  return typeof value === "symbol";
+}
+function IsUint8Array(value) {
+  return value instanceof globalThis.Uint8Array;
+}
+function IsUndefined(value) {
+  return value === void 0;
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/clone/value.mjs
+function ArrayType(value) {
+  return value.map((value2) => Visit(value2));
+}
+function DateType(value) {
+  return new Date(value.getTime());
+}
+function Uint8ArrayType(value) {
+  return new Uint8Array(value);
+}
+function RegExpType(value) {
+  return new RegExp(value.source, value.flags);
+}
+function ObjectType(value) {
+  const result = {};
+  for (const key of Object.getOwnPropertyNames(value)) {
+    result[key] = Visit(value[key]);
   }
-  if (!subject) {
-    log2.warn("Email subject is required", { to: recipients });
-    return {
-      success: false,
-      error: "Email subject is required"
-    };
+  for (const key of Object.getOwnPropertySymbols(value)) {
+    result[key] = Visit(value[key]);
   }
-  if (!text3 && !html) {
-    log2.warn("Email content (text or html) is required", { to: recipients, subject });
-    return {
-      success: false,
-      error: "Email content (text or html) is required"
-    };
+  return result;
+}
+function Visit(value) {
+  return IsArray(value) ? ArrayType(value) : IsDate(value) ? DateType(value) : IsUint8Array(value) ? Uint8ArrayType(value) : IsRegExp(value) ? RegExpType(value) : IsObject(value) ? ObjectType(value) : value;
+}
+function Clone(value) {
+  return Visit(value);
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/clone/type.mjs
+function CloneType(schema, options) {
+  return options === void 0 ? Clone(schema) : Clone({ ...options, ...schema });
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/value/guard/guard.mjs
+function IsObject2(value) {
+  return value !== null && typeof value === "object";
+}
+function IsArray2(value) {
+  return globalThis.Array.isArray(value) && !globalThis.ArrayBuffer.isView(value);
+}
+function IsUndefined2(value) {
+  return value === void 0;
+}
+function IsNumber2(value) {
+  return typeof value === "number";
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/system/policy.mjs
+var TypeSystemPolicy;
+(function(TypeSystemPolicy2) {
+  TypeSystemPolicy2.InstanceMode = "default";
+  TypeSystemPolicy2.ExactOptionalPropertyTypes = false;
+  TypeSystemPolicy2.AllowArrayObject = false;
+  TypeSystemPolicy2.AllowNaN = false;
+  TypeSystemPolicy2.AllowNullVoid = false;
+  function IsExactOptionalProperty(value, key) {
+    return TypeSystemPolicy2.ExactOptionalPropertyTypes ? key in value : value[key] !== void 0;
   }
-  const internalParams = {
-    to: recipients,
-    from: params.from || getEmailFrom(),
-    replyTo: params.replyTo || getEmailReplyTo(),
-    subject,
-    text: text3,
-    html
-  };
-  const provider = getProvider();
-  let historyId;
-  if (isHistoryEnabled()) {
-    try {
-      const record = await createNotificationRecord({
-        channel: "email",
-        recipient: recipients.join(","),
-        templateName: params.template,
-        templateData: params.data,
-        subject,
-        content: text3,
-        providerName: provider.name
-      });
-      historyId = record.id;
-    } catch (error) {
-      log2.warn("Failed to create notification history record", error);
-    }
+  TypeSystemPolicy2.IsExactOptionalProperty = IsExactOptionalProperty;
+  function IsObjectLike(value) {
+    const isObject = IsObject2(value);
+    return TypeSystemPolicy2.AllowArrayObject ? isObject : isObject && !IsArray2(value);
   }
-  const shouldTrack = params.tracking ?? isTrackingEnabled();
-  const trackingBaseUrl = getTrackingBaseUrl();
-  if (shouldTrack && historyId && internalParams.html && trackingBaseUrl) {
-    try {
-      const { html: trackedHtml } = processTrackingHtml(internalParams.html, {
-        notificationId: historyId,
-        baseUrl: trackingBaseUrl
-      });
-      internalParams.html = trackedHtml;
-    } catch (error) {
-      log2.warn("Failed to apply tracking to email HTML", error);
-    }
+  TypeSystemPolicy2.IsObjectLike = IsObjectLike;
+  function IsRecordLike(value) {
+    return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
   }
-  const result = await provider.send(internalParams);
-  if (result.success) {
-    log2.info("Email sent", { to: recipients, subject, messageId: result.messageId });
-  } else {
-    log2.error("Email send failed", { to: recipients, subject, error: result.error });
+  TypeSystemPolicy2.IsRecordLike = IsRecordLike;
+  function IsNumberLike(value) {
+    return TypeSystemPolicy2.AllowNaN ? IsNumber2(value) : Number.isFinite(value);
   }
-  if (historyId && isHistoryEnabled()) {
-    try {
-      if (result.success) {
-        await markNotificationSent(historyId, result.messageId);
-      } else {
-        await markNotificationFailed(historyId, result.error || "Unknown error");
-      }
-    } catch (error) {
-      log2.warn("Failed to update notification history record", error);
-    }
+  TypeSystemPolicy2.IsNumberLike = IsNumberLike;
+  function IsVoidLike(value) {
+    const isUndefined = IsUndefined2(value);
+    return TypeSystemPolicy2.AllowNullVoid ? isUndefined || value === null : isUndefined;
   }
-  return result;
+  TypeSystemPolicy2.IsVoidLike = IsVoidLike;
+})(TypeSystemPolicy || (TypeSystemPolicy = {}));
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/create/immutable.mjs
+function ImmutableArray(value) {
+  return globalThis.Object.freeze(value).map((value2) => Immutable(value2));
 }
-async function sendEmailBulk(items) {
-  const results = [];
-  let successCount = 0;
-  let failureCount = 0;
-  for (const item of items) {
-    const result = await sendEmail(item);
-    results.push(result);
-    if (result.success) {
-      successCount++;
-    } else {
-      failureCount++;
-    }
-  }
-  return { results, successCount, failureCount };
-}
-
-// src/channels/sms/providers/aws-sns.ts
-import { logger as logger3 } from "@spfn/core/logger";
-var log3 = logger3.child("@spfn/notification:sns");
-var snsClient = null;
-async function getSNSClient() {
-  if (snsClient) {
-    return snsClient;
-  }
-  try {
-    const { SNSClient } = await import("@aws-sdk/client-sns");
-    snsClient = new SNSClient({
-      region: env.AWS_REGION,
-      credentials: env.AWS_ACCESS_KEY_ID && env.AWS_SECRET_ACCESS_KEY ? {
-        accessKeyId: env.AWS_ACCESS_KEY_ID,
-        secretAccessKey: env.AWS_SECRET_ACCESS_KEY
-      } : void 0
-    });
-    log3.debug("SNS client created", { region: env.AWS_REGION });
-    return snsClient;
-  } catch {
-    throw new Error(
-      "@aws-sdk/client-sns is not installed. Please install it: pnpm add @aws-sdk/client-sns"
-    );
-  }
-}
-var awsSnsProvider = {
-  name: "aws-sns",
-  async send(params) {
-    try {
-      const client = await getSNSClient();
-      const { PublishCommand } = await import("@aws-sdk/client-sns");
-      const command = new PublishCommand({
-        PhoneNumber: params.to,
-        Message: params.message,
-        MessageAttributes: {
-          "AWS.SNS.SMS.SMSType": {
-            DataType: "String",
-            StringValue: "Transactional"
-          }
-        }
-      });
-      const response = await client.send(command);
-      return {
-        success: true,
-        messageId: response.MessageId
-      };
-    } catch (error) {
-      const err = error;
-      log3.error("SNS send failed", err, { to: params.to });
-      return {
-        success: false,
-        error: err.message
-      };
-    }
-  }
-};
-
-// src/channels/sms/utils.ts
-function normalizePhoneNumber(phone, defaultCountryCode) {
-  let normalized = phone.replace(/[^\d+]/g, "");
-  if (!normalized.startsWith("+")) {
-    const countryCode = defaultCountryCode ?? getSmsDefaultCountryCode();
-    if (normalized.startsWith("0")) {
-      normalized = normalized.slice(1);
-    }
-    normalized = countryCode + normalized;
-  }
-  return normalized;
+function ImmutableDate(value) {
+  return value;
 }
-
-// src/channels/sms/index.ts
-import { logger as logger4 } from "@spfn/core/logger";
-var log4 = logger4.child("@spfn/notification:sms");
-var providers2 = {
-  "aws-sns": awsSnsProvider
-};
-function registerSMSProvider(provider) {
-  providers2[provider.name] = provider;
+function ImmutableUint8Array(value) {
+  return value;
 }
-function getProvider2() {
-  const providerName = env.SPFN_NOTIFICATION_SMS_PROVIDER || "aws-sns";
-  const provider = providers2[providerName];
-  if (!provider) {
-    throw new Error(`SMS provider not found: ${providerName}`);
-  }
-  return provider;
+function ImmutableRegExp(value) {
+  return value;
 }
-async function sendSMS(params) {
-  const recipients = Array.isArray(params.to) ? params.to : [params.to];
-  let message = params.message;
-  if (params.template) {
-    if (!hasTemplate(params.template)) {
-      log4.warn(`Template not found: ${params.template}`);
-      return {
-        success: false,
-        error: `Template not found: ${params.template}`
-      };
-    }
-    const rendered = renderTemplate(params.template, params.data || {}, "sms");
-    if (rendered.sms) {
-      message = rendered.sms.message;
-    }
-  }
-  if (!message) {
-    log4.warn("SMS message is required", { to: recipients });
-    return {
-      success: false,
-      error: "SMS message is required"
-    };
+function ImmutableObject(value) {
+  const result = {};
+  for (const key of Object.getOwnPropertyNames(value)) {
+    result[key] = Immutable(value[key]);
   }
-  const provider = getProvider2();
-  const results = [];
-  for (const recipient of recipients) {
-    const normalizedPhone = normalizePhoneNumber(recipient);
-    const internalParams = {
-      to: normalizedPhone,
-      message
-    };
-    let historyId;
-    if (isHistoryEnabled()) {
-      try {
-        const record = await createNotificationRecord({
-          channel: "sms",
-          recipient: normalizedPhone,
-          templateName: params.template,
-          templateData: params.data,
-          content: message,
-          providerName: provider.name
-        });
-        historyId = record.id;
-      } catch (error) {
-        log4.warn("Failed to create notification history record", error);
-      }
-    }
-    const result = await provider.send(internalParams);
-    if (result.success) {
-      log4.info("SMS sent", { to: normalizedPhone, messageId: result.messageId });
-    } else {
-      log4.error("SMS send failed", { to: normalizedPhone, error: result.error });
-    }
-    if (historyId && isHistoryEnabled()) {
-      try {
-        if (result.success) {
-          await markNotificationSent(historyId, result.messageId);
-        } else {
-          await markNotificationFailed(historyId, result.error || "Unknown error");
-        }
-      } catch (error) {
-        log4.warn("Failed to update notification history record", error);
-      }
-    }
-    results.push(result);
+  for (const key of Object.getOwnPropertySymbols(value)) {
+    result[key] = Immutable(value[key]);
   }
-  const allSuccess = results.every((r) => r.success);
-  const messageIds = results.filter((r) => r.messageId).map((r) => r.messageId).join(",");
-  const errors = results.filter((r) => r.error).map((r) => r.error).join("; ");
-  return {
-    success: allSuccess,
-    messageId: messageIds || void 0,
-    error: errors || void 0
-  };
+  return globalThis.Object.freeze(result);
 }
-async function sendSMSBulk(items) {
-  const results = [];
-  let successCount = 0;
-  let failureCount = 0;
-  for (const item of items) {
-    const result = await sendSMS(item);
-    results.push(result);
-    if (result.success) {
-      successCount++;
-    } else {
-      failureCount++;
-    }
+function Immutable(value) {
+  return IsArray(value) ? ImmutableArray(value) : IsDate(value) ? ImmutableDate(value) : IsUint8Array(value) ? ImmutableUint8Array(value) : IsRegExp(value) ? ImmutableRegExp(value) : IsObject(value) ? ImmutableObject(value) : value;
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/create/type.mjs
+function CreateType(schema, options) {
+  const result = options !== void 0 ? { ...options, ...schema } : schema;
+  switch (TypeSystemPolicy.InstanceMode) {
+    case "freeze":
+      return Immutable(result);
+    case "clone":
+      return Clone(result);
+    default:
+      return result;
   }
-  return { results, successCount, failureCount };
 }
 
-// src/channels/slack/providers/webhook.ts
-import { logger as logger5 } from "@spfn/core/logger";
-var log5 = logger5.child("@spfn/notification:slack-webhook");
-var webhookProvider = {
-  name: "webhook",
-  async send(params) {
-    try {
-      const res = await fetch(params.webhookUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          text: params.text,
-          blocks: params.blocks
-        })
-      });
-      return {
-        success: res.ok,
-        error: res.ok ? void 0 : await res.text()
-      };
-    } catch (error) {
-      const err = error;
-      log5.error("Webhook request failed", err);
-      return {
-        success: false,
-        error: err.message
-      };
-    }
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/error/error.mjs
+var TypeBoxError = class extends Error {
+  constructor(message) {
+    super(message);
   }
 };
 
-// src/channels/slack/index.ts
-import { logger as logger6 } from "@spfn/core/logger";
-var log6 = logger6.child("@spfn/notification:slack");
-var providers3 = {
-  "webhook": webhookProvider
-};
-function registerSlackProvider(provider) {
-  providers3[provider.name] = provider;
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs
+var TransformKind = Symbol.for("TypeBox.Transform");
+var ReadonlyKind = Symbol.for("TypeBox.Readonly");
+var OptionalKind = Symbol.for("TypeBox.Optional");
+var Hint = Symbol.for("TypeBox.Hint");
+var Kind = Symbol.for("TypeBox.Kind");
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/guard/kind.mjs
+function IsReadonly(value) {
+  return IsObject(value) && value[ReadonlyKind] === "Readonly";
 }
-function getProvider3() {
-  return providers3["webhook"];
+function IsOptional(value) {
+  return IsObject(value) && value[OptionalKind] === "Optional";
 }
-function resolveWebhookUrl(params) {
-  return params.webhookUrl || env.SPFN_NOTIFICATION_SLACK_WEBHOOK_URL;
+function IsAny(value) {
+  return IsKindOf(value, "Any");
 }
-async function sendSlack(params) {
-  const webhookUrl = resolveWebhookUrl(params);
-  if (!webhookUrl) {
-    log6.warn("Slack webhook URL is required");
-    return {
-      success: false,
-      error: "Slack webhook URL is required. Set SPFN_NOTIFICATION_SLACK_WEBHOOK_URL or pass webhookUrl."
-    };
-  }
-  let text3 = params.text;
-  let blocks = params.blocks;
-  if (params.template) {
-    if (!hasTemplate(params.template)) {
-      log6.warn(`Template not found: ${params.template}`);
-      return {
-        success: false,
-        error: `Template not found: ${params.template}`
-      };
-    }
-    const rendered = renderTemplate(params.template, params.data || {}, "slack");
-    if (rendered.slack) {
-      text3 = rendered.slack.text;
-      blocks = rendered.slack.blocks;
-    }
-  }
-  if (!text3 && !blocks) {
-    log6.warn("Slack message requires text or blocks");
-    return {
-      success: false,
-      error: "Slack message requires text or blocks"
-    };
-  }
-  const internalParams = {
-    webhookUrl,
-    text: text3,
-    blocks
-  };
-  const provider = getProvider3();
-  let historyId;
-  if (isHistoryEnabled()) {
-    try {
-      const record = await createNotificationRecord({
-        channel: "slack",
-        recipient: webhookUrl,
-        templateName: params.template,
-        templateData: params.data,
-        content: text3,
-        providerName: provider.name
-      });
-      historyId = record.id;
-    } catch (error) {
-      log6.warn("Failed to create notification history record", error);
-    }
-  }
-  const result = await provider.send(internalParams);
-  if (result.success) {
-    log6.info("Slack message sent");
-  } else {
-    log6.error("Slack send failed", { error: result.error });
-  }
-  if (historyId && isHistoryEnabled()) {
-    try {
-      if (result.success) {
-        await markNotificationSent(historyId, result.messageId);
-      } else {
-        await markNotificationFailed(historyId, result.error || "Unknown error");
-      }
-    } catch (error) {
-      log6.warn("Failed to update notification history record", error);
-    }
-  }
-  return result;
+function IsArgument(value) {
+  return IsKindOf(value, "Argument");
 }
-async function sendSlackBulk(items) {
-  const results = [];
-  let successCount = 0;
-  let failureCount = 0;
-  for (const item of items) {
-    const result = await sendSlack(item);
-    results.push(result);
-    if (result.success) {
-      successCount++;
-    } else {
-      failureCount++;
-    }
-  }
-  return { results, successCount, failureCount };
+function IsArray3(value) {
+  return IsKindOf(value, "Array");
 }
-
-// src/jobs/send-scheduled-email.ts
-import { job } from "@spfn/core/job";
-
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
-var value_exports = {};
-__export(value_exports, {
-  HasPropertyKey: () => HasPropertyKey,
-  IsArray: () => IsArray,
-  IsAsyncIterator: () => IsAsyncIterator,
-  IsBigInt: () => IsBigInt,
-  IsBoolean: () => IsBoolean,
-  IsDate: () => IsDate,
-  IsFunction: () => IsFunction,
-  IsIterator: () => IsIterator,
-  IsNull: () => IsNull,
-  IsNumber: () => IsNumber,
-  IsObject: () => IsObject,
-  IsRegExp: () => IsRegExp,
-  IsString: () => IsString,
-  IsSymbol: () => IsSymbol,
-  IsUint8Array: () => IsUint8Array,
-  IsUndefined: () => IsUndefined
-});
-function HasPropertyKey(value, key) {
-  return key in value;
+function IsAsyncIterator2(value) {
+  return IsKindOf(value, "AsyncIterator");
 }
-function IsAsyncIterator(value) {
-  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
+function IsBigInt2(value) {
+  return IsKindOf(value, "BigInt");
 }
-function IsArray(value) {
-  return Array.isArray(value);
+function IsBoolean2(value) {
+  return IsKindOf(value, "Boolean");
 }
-function IsBigInt(value) {
-  return typeof value === "bigint";
+function IsComputed(value) {
+  return IsKindOf(value, "Computed");
 }
-function IsBoolean(value) {
-  return typeof value === "boolean";
+function IsConstructor(value) {
+  return IsKindOf(value, "Constructor");
 }
-function IsDate(value) {
-  return value instanceof globalThis.Date;
+function IsDate2(value) {
+  return IsKindOf(value, "Date");
 }
-function IsFunction(value) {
-  return typeof value === "function";
+function IsFunction2(value) {
+  return IsKindOf(value, "Function");
 }
-function IsIterator(value) {
-  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
+function IsInteger(value) {
+  return IsKindOf(value, "Integer");
 }
-function IsNull(value) {
-  return value === null;
+function IsIntersect(value) {
+  return IsKindOf(value, "Intersect");
 }
-function IsNumber(value) {
-  return typeof value === "number";
+function IsIterator2(value) {
+  return IsKindOf(value, "Iterator");
 }
-function IsObject(value) {
-  return typeof value === "object" && value !== null;
+function IsKindOf(value, kind) {
+  return IsObject(value) && Kind in value && value[Kind] === kind;
 }
-function IsRegExp(value) {
-  return value instanceof globalThis.RegExp;
+function IsLiteralValue(value) {
+  return IsBoolean(value) || IsNumber(value) || IsString(value);
 }
-function IsString(value) {
-  return typeof value === "string";
+function IsLiteral(value) {
+  return IsKindOf(value, "Literal");
 }
-function IsSymbol(value) {
-  return typeof value === "symbol";
+function IsMappedKey(value) {
+  return IsKindOf(value, "MappedKey");
 }
-function IsUint8Array(value) {
-  return value instanceof globalThis.Uint8Array;
+function IsMappedResult(value) {
+  return IsKindOf(value, "MappedResult");
 }
-function IsUndefined(value) {
-  return value === void 0;
+function IsNever(value) {
+  return IsKindOf(value, "Never");
 }
-
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/clone/value.mjs
-function ArrayType(value) {
-  return value.map((value2) => Visit(value2));
+function IsNot(value) {
+  return IsKindOf(value, "Not");
 }
-function DateType(value) {
-  return new Date(value.getTime());
+function IsNull2(value) {
+  return IsKindOf(value, "Null");
 }
-function Uint8ArrayType(value) {
-  return new Uint8Array(value);
+function IsNumber3(value) {
+  return IsKindOf(value, "Number");
 }
-function RegExpType(value) {
-  return new RegExp(value.source, value.flags);
+function IsObject3(value) {
+  return IsKindOf(value, "Object");
 }
-function ObjectType(value) {
-  const result = {};
-  for (const key of Object.getOwnPropertyNames(value)) {
-    result[key] = Visit(value[key]);
-  }
-  for (const key of Object.getOwnPropertySymbols(value)) {
-    result[key] = Visit(value[key]);
-  }
-  return result;
+function IsPromise(value) {
+  return IsKindOf(value, "Promise");
 }
-function Visit(value) {
-  return IsArray(value) ? ArrayType(value) : IsDate(value) ? DateType(value) : IsUint8Array(value) ? Uint8ArrayType(value) : IsRegExp(value) ? RegExpType(value) : IsObject(value) ? ObjectType(value) : value;
+function IsRecord(value) {
+  return IsKindOf(value, "Record");
 }
-function Clone(value) {
-  return Visit(value);
+function IsRef(value) {
+  return IsKindOf(value, "Ref");
 }
-
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/clone/type.mjs
-function CloneType(schema, options) {
-  return options === void 0 ? Clone(schema) : Clone({ ...options, ...schema });
+function IsRegExp2(value) {
+  return IsKindOf(value, "RegExp");
 }
-
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/value/guard/guard.mjs
-function IsObject2(value) {
-  return value !== null && typeof value === "object";
+function IsString2(value) {
+  return IsKindOf(value, "String");
 }
-function IsArray2(value) {
-  return globalThis.Array.isArray(value) && !globalThis.ArrayBuffer.isView(value);
+function IsSymbol2(value) {
+  return IsKindOf(value, "Symbol");
 }
-function IsUndefined2(value) {
-  return value === void 0;
+function IsTemplateLiteral(value) {
+  return IsKindOf(value, "TemplateLiteral");
 }
-function IsNumber2(value) {
-  return typeof value === "number";
-}
-
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/system/policy.mjs
-var TypeSystemPolicy;
-(function(TypeSystemPolicy2) {
-  TypeSystemPolicy2.InstanceMode = "default";
-  TypeSystemPolicy2.ExactOptionalPropertyTypes = false;
-  TypeSystemPolicy2.AllowArrayObject = false;
-  TypeSystemPolicy2.AllowNaN = false;
-  TypeSystemPolicy2.AllowNullVoid = false;
-  function IsExactOptionalProperty(value, key) {
-    return TypeSystemPolicy2.ExactOptionalPropertyTypes ? key in value : value[key] !== void 0;
-  }
-  TypeSystemPolicy2.IsExactOptionalProperty = IsExactOptionalProperty;
-  function IsObjectLike(value) {
-    const isObject = IsObject2(value);
-    return TypeSystemPolicy2.AllowArrayObject ? isObject : isObject && !IsArray2(value);
-  }
-  TypeSystemPolicy2.IsObjectLike = IsObjectLike;
-  function IsRecordLike(value) {
-    return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
-  }
-  TypeSystemPolicy2.IsRecordLike = IsRecordLike;
-  function IsNumberLike(value) {
-    return TypeSystemPolicy2.AllowNaN ? IsNumber2(value) : Number.isFinite(value);
-  }
-  TypeSystemPolicy2.IsNumberLike = IsNumberLike;
-  function IsVoidLike(value) {
-    const isUndefined = IsUndefined2(value);
-    return TypeSystemPolicy2.AllowNullVoid ? isUndefined || value === null : isUndefined;
-  }
-  TypeSystemPolicy2.IsVoidLike = IsVoidLike;
-})(TypeSystemPolicy || (TypeSystemPolicy = {}));
-
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/create/immutable.mjs
-function ImmutableArray(value) {
-  return globalThis.Object.freeze(value).map((value2) => Immutable(value2));
-}
-function ImmutableDate(value) {
-  return value;
-}
-function ImmutableUint8Array(value) {
-  return value;
-}
-function ImmutableRegExp(value) {
-  return value;
-}
-function ImmutableObject(value) {
-  const result = {};
-  for (const key of Object.getOwnPropertyNames(value)) {
-    result[key] = Immutable(value[key]);
-  }
-  for (const key of Object.getOwnPropertySymbols(value)) {
-    result[key] = Immutable(value[key]);
-  }
-  return globalThis.Object.freeze(result);
-}
-function Immutable(value) {
-  return IsArray(value) ? ImmutableArray(value) : IsDate(value) ? ImmutableDate(value) : IsUint8Array(value) ? ImmutableUint8Array(value) : IsRegExp(value) ? ImmutableRegExp(value) : IsObject(value) ? ImmutableObject(value) : value;
-}
-
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/create/type.mjs
-function CreateType(schema, options) {
-  const result = options !== void 0 ? { ...options, ...schema } : schema;
-  switch (TypeSystemPolicy.InstanceMode) {
-    case "freeze":
-      return Immutable(result);
-    case "clone":
-      return Clone(result);
-    default:
-      return result;
-  }
-}
-
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/error/error.mjs
-var TypeBoxError = class extends Error {
-  constructor(message) {
-    super(message);
-  }
-};
-
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs
-var TransformKind = Symbol.for("TypeBox.Transform");
-var ReadonlyKind = Symbol.for("TypeBox.Readonly");
-var OptionalKind = Symbol.for("TypeBox.Optional");
-var Hint = Symbol.for("TypeBox.Hint");
-var Kind = Symbol.for("TypeBox.Kind");
-
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/guard/kind.mjs
-function IsReadonly(value) {
-  return IsObject(value) && value[ReadonlyKind] === "Readonly";
-}
-function IsOptional(value) {
-  return IsObject(value) && value[OptionalKind] === "Optional";
-}
-function IsAny(value) {
-  return IsKindOf(value, "Any");
-}
-function IsArgument(value) {
-  return IsKindOf(value, "Argument");
-}
-function IsArray3(value) {
-  return IsKindOf(value, "Array");
-}
-function IsAsyncIterator2(value) {
-  return IsKindOf(value, "AsyncIterator");
-}
-function IsBigInt2(value) {
-  return IsKindOf(value, "BigInt");
-}
-function IsBoolean2(value) {
-  return IsKindOf(value, "Boolean");
-}
-function IsComputed(value) {
-  return IsKindOf(value, "Computed");
-}
-function IsConstructor(value) {
-  return IsKindOf(value, "Constructor");
-}
-function IsDate2(value) {
-  return IsKindOf(value, "Date");
-}
-function IsFunction2(value) {
-  return IsKindOf(value, "Function");
-}
-function IsInteger(value) {
-  return IsKindOf(value, "Integer");
-}
-function IsIntersect(value) {
-  return IsKindOf(value, "Intersect");
-}
-function IsIterator2(value) {
-  return IsKindOf(value, "Iterator");
-}
-function IsKindOf(value, kind) {
-  return IsObject(value) && Kind in value && value[Kind] === kind;
-}
-function IsLiteralValue(value) {
-  return IsBoolean(value) || IsNumber(value) || IsString(value);
-}
-function IsLiteral(value) {
-  return IsKindOf(value, "Literal");
-}
-function IsMappedKey(value) {
-  return IsKindOf(value, "MappedKey");
-}
-function IsMappedResult(value) {
-  return IsKindOf(value, "MappedResult");
-}
-function IsNever(value) {
-  return IsKindOf(value, "Never");
-}
-function IsNot(value) {
-  return IsKindOf(value, "Not");
-}
-function IsNull2(value) {
-  return IsKindOf(value, "Null");
-}
-function IsNumber3(value) {
-  return IsKindOf(value, "Number");
-}
-function IsObject3(value) {
-  return IsKindOf(value, "Object");
-}
-function IsPromise(value) {
-  return IsKindOf(value, "Promise");
-}
-function IsRecord(value) {
-  return IsKindOf(value, "Record");
-}
-function IsRef(value) {
-  return IsKindOf(value, "Ref");
-}
-function IsRegExp2(value) {
-  return IsKindOf(value, "RegExp");
-}
-function IsString2(value) {
-  return IsKindOf(value, "String");
-}
-function IsSymbol2(value) {
-  return IsKindOf(value, "Symbol");
-}
-function IsTemplateLiteral(value) {
-  return IsKindOf(value, "TemplateLiteral");
-}
-function IsThis(value) {
-  return IsKindOf(value, "This");
+function IsThis(value) {
+  return IsKindOf(value, "This");
 }
 function IsTransform(value) {
   return IsObject(value) && TransformKind in value;
@@ -3737,138 +3326,1023 @@ function Recursive(callback, options = {}) {
   return CreateType({ [Hint]: "Recursive", ...thisType }, options);
 }
 
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/regexp/regexp.mjs
-function RegExp2(unresolved, options) {
-  const expr = IsString(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
-  return CreateType({ [Kind]: "RegExp", type: "RegExp", source: expr.source, flags: expr.flags }, options);
-}
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/regexp/regexp.mjs
+function RegExp2(unresolved, options) {
+  const expr = IsString(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
+  return CreateType({ [Kind]: "RegExp", type: "RegExp", source: expr.source, flags: expr.flags }, options);
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/rest/rest.mjs
+function RestResolve(T) {
+  return IsIntersect(T) ? T.allOf : IsUnion(T) ? T.anyOf : IsTuple(T) ? T.items ?? [] : [];
+}
+function Rest(T) {
+  return RestResolve(T);
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/return-type/return-type.mjs
+function ReturnType(schema, options) {
+  return IsFunction2(schema) ? CreateType(schema.returns, options) : Never(options);
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/transform/transform.mjs
+var TransformDecodeBuilder = class {
+  constructor(schema) {
+    this.schema = schema;
+  }
+  Decode(decode) {
+    return new TransformEncodeBuilder(this.schema, decode);
+  }
+};
+var TransformEncodeBuilder = class {
+  constructor(schema, decode) {
+    this.schema = schema;
+    this.decode = decode;
+  }
+  EncodeTransform(encode, schema) {
+    const Encode = (value) => schema[TransformKind].Encode(encode(value));
+    const Decode = (value) => this.decode(schema[TransformKind].Decode(value));
+    const Codec = { Encode, Decode };
+    return { ...schema, [TransformKind]: Codec };
+  }
+  EncodeSchema(encode, schema) {
+    const Codec = { Decode: this.decode, Encode: encode };
+    return { ...schema, [TransformKind]: Codec };
+  }
+  Encode(encode) {
+    return IsTransform(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema);
+  }
+};
+function Transform(schema) {
+  return new TransformDecodeBuilder(schema);
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/unsafe/unsafe.mjs
+function Unsafe(options = {}) {
+  return CreateType({ [Kind]: options[Kind] ?? "Unsafe" }, options);
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/void/void.mjs
+function Void(options) {
+  return CreateType({ [Kind]: "Void", type: "void" }, options);
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/type/type.mjs
+var type_exports2 = {};
+__export(type_exports2, {
+  Any: () => Any,
+  Argument: () => Argument,
+  Array: () => Array2,
+  AsyncIterator: () => AsyncIterator,
+  Awaited: () => Awaited,
+  BigInt: () => BigInt,
+  Boolean: () => Boolean,
+  Capitalize: () => Capitalize,
+  Composite: () => Composite,
+  Const: () => Const,
+  Constructor: () => Constructor,
+  ConstructorParameters: () => ConstructorParameters,
+  Date: () => Date2,
+  Enum: () => Enum,
+  Exclude: () => Exclude,
+  Extends: () => Extends,
+  Extract: () => Extract,
+  Function: () => Function,
+  Index: () => Index,
+  InstanceType: () => InstanceType,
+  Instantiate: () => Instantiate,
+  Integer: () => Integer,
+  Intersect: () => Intersect,
+  Iterator: () => Iterator,
+  KeyOf: () => KeyOf,
+  Literal: () => Literal,
+  Lowercase: () => Lowercase,
+  Mapped: () => Mapped,
+  Module: () => Module,
+  Never: () => Never,
+  Not: () => Not,
+  Null: () => Null,
+  Number: () => Number2,
+  Object: () => Object2,
+  Omit: () => Omit,
+  Optional: () => Optional,
+  Parameters: () => Parameters,
+  Partial: () => Partial,
+  Pick: () => Pick,
+  Promise: () => Promise2,
+  Readonly: () => Readonly,
+  ReadonlyOptional: () => ReadonlyOptional,
+  Record: () => Record,
+  Recursive: () => Recursive,
+  Ref: () => Ref,
+  RegExp: () => RegExp2,
+  Required: () => Required,
+  Rest: () => Rest,
+  ReturnType: () => ReturnType,
+  String: () => String2,
+  Symbol: () => Symbol2,
+  TemplateLiteral: () => TemplateLiteral,
+  Transform: () => Transform,
+  Tuple: () => Tuple,
+  Uint8Array: () => Uint8Array2,
+  Uncapitalize: () => Uncapitalize,
+  Undefined: () => Undefined,
+  Union: () => Union,
+  Unknown: () => Unknown,
+  Unsafe: () => Unsafe,
+  Uppercase: () => Uppercase,
+  Void: () => Void
+});
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/type/index.mjs
+var Type = type_exports2;
+
+// src/jobs/send-bulk-email-item.ts
+var SendBulkEmailItemInput = Type.Object({
+  notificationId: Type.Number(),
+  to: Type.Array(Type.String()),
+  from: Type.String(),
+  replyTo: Type.Optional(Type.String()),
+  subject: Type.String(),
+  text: Type.Optional(Type.String()),
+  html: Type.Optional(Type.String())
+});
+var sendBulkEmailItemJob = job("notification.send-bulk-email-item").input(SendBulkEmailItemInput).options({
+  retryLimit: 3,
+  retryDelay: 5e3,
+  batchSize: 50
+}).handler(async (input) => {
+  const { notificationId, ...emailParams } = input;
+  const result = await awsSesProvider.send(emailParams);
+  if (result.success) {
+    await markNotificationSent(notificationId, result.messageId);
+  } else {
+    await markNotificationFailed(notificationId, result.error || "Unknown error");
+    throw new Error(result.error || "Failed to send email");
+  }
+});
+
+// src/channels/email/index.ts
+import { logger as logger2 } from "@spfn/core/logger";
+var log2 = logger2.child("@spfn/notification:email");
+var providers = {
+  "aws-ses": awsSesProvider
+};
+function registerEmailProvider(provider) {
+  providers[provider.name] = provider;
+}
+function getProvider() {
+  const providerName = env.SPFN_NOTIFICATION_EMAIL_PROVIDER || "aws-ses";
+  const provider = providers[providerName];
+  if (!provider) {
+    throw new Error(`Email provider not found: ${providerName}`);
+  }
+  return provider;
+}
+async function sendEmail(params) {
+  const recipients = Array.isArray(params.to) ? params.to : [params.to];
+  let subject = params.subject;
+  let text3 = params.text;
+  let html = params.html;
+  if (params.template) {
+    if (!hasTemplate(params.template)) {
+      log2.warn(`Template not found: ${params.template}`);
+      return {
+        success: false,
+        error: `Template not found: ${params.template}`
+      };
+    }
+    const rendered = renderTemplate(params.template, params.data || {}, "email");
+    if (rendered.email) {
+      subject = rendered.email.subject;
+      text3 = rendered.email.text;
+      html = rendered.email.html;
+    }
+  }
+  if (!subject) {
+    log2.warn("Email subject is required", { to: recipients });
+    return {
+      success: false,
+      error: "Email subject is required"
+    };
+  }
+  if (!text3 && !html) {
+    log2.warn("Email content (text or html) is required", { to: recipients, subject });
+    return {
+      success: false,
+      error: "Email content (text or html) is required"
+    };
+  }
+  const internalParams = {
+    to: recipients,
+    from: params.from || getEmailFrom(),
+    replyTo: params.replyTo || getEmailReplyTo(),
+    subject,
+    text: text3,
+    html
+  };
+  const provider = getProvider();
+  let historyId;
+  if (isHistoryEnabled()) {
+    try {
+      const record = await createNotificationRecord({
+        channel: "email",
+        recipient: recipients.join(","),
+        templateName: params.template,
+        templateData: params.data,
+        subject,
+        content: text3,
+        providerName: provider.name
+      });
+      historyId = record.id;
+    } catch (error) {
+      log2.warn("Failed to create notification history record", error);
+    }
+  }
+  const shouldTrack = params.tracking ?? isTrackingEnabled();
+  const trackingBaseUrl = getTrackingBaseUrl();
+  if (shouldTrack && historyId && internalParams.html && trackingBaseUrl) {
+    try {
+      const { html: trackedHtml } = processTrackingHtml(internalParams.html, {
+        notificationId: historyId,
+        baseUrl: trackingBaseUrl
+      });
+      internalParams.html = trackedHtml;
+    } catch (error) {
+      log2.warn("Failed to apply tracking to email HTML", error);
+    }
+  }
+  const result = await provider.send(internalParams);
+  if (result.success) {
+    log2.info("Email sent", { to: recipients, subject, messageId: result.messageId });
+  } else {
+    log2.error("Email send failed", { to: recipients, subject, error: result.error });
+  }
+  if (historyId && isHistoryEnabled()) {
+    try {
+      if (result.success) {
+        await markNotificationSent(historyId, result.messageId);
+      } else {
+        await markNotificationFailed(historyId, result.error || "Unknown error");
+      }
+    } catch (error) {
+      log2.warn("Failed to update notification history record", error);
+    }
+  }
+  return result;
+}
+function prepareEmailItems(items) {
+  const prepared = [];
+  const earlyFailures = [];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const recipients = Array.isArray(item.to) ? item.to : [item.to];
+    let subject = item.subject;
+    let text3 = item.text;
+    let html = item.html;
+    if (item.template) {
+      if (!hasTemplate(item.template)) {
+        earlyFailures.push({ index: i, result: { success: false, error: `Template not found: ${item.template}` } });
+        continue;
+      }
+      const rendered = renderTemplate(item.template, item.data || {}, "email");
+      if (rendered.email) {
+        subject = rendered.email.subject;
+        text3 = rendered.email.text;
+        html = rendered.email.html;
+      }
+    }
+    if (!subject) {
+      earlyFailures.push({ index: i, result: { success: false, error: "Email subject is required" } });
+      continue;
+    }
+    if (!text3 && !html) {
+      earlyFailures.push({ index: i, result: { success: false, error: "Email content (text or html) is required" } });
+      continue;
+    }
+    prepared.push({
+      index: i,
+      params: {
+        to: recipients,
+        from: item.from || getEmailFrom(),
+        replyTo: item.replyTo || getEmailReplyTo(),
+        subject,
+        text: text3,
+        html
+      },
+      recipients,
+      template: item.template,
+      data: item.data,
+      subject,
+      text: text3,
+      tracking: item.tracking
+    });
+  }
+  return { prepared, earlyFailures };
+}
+async function sendEmailBulk(items, options) {
+  if (items.length === 0) {
+    return { results: [], successCount: 0, failureCount: 0, batchId: "" };
+  }
+  const batchId = crypto.randomUUID();
+  const provider = getProvider();
+  const { prepared, earlyFailures } = prepareEmailItems(items);
+  let historyRecords = [];
+  if (isHistoryEnabled() && prepared.length > 0) {
+    try {
+      historyRecords = await createNotificationRecords(
+        prepared.map((p) => ({
+          channel: "email",
+          recipient: p.recipients.join(","),
+          templateName: p.template,
+          templateData: p.data,
+          subject: p.subject,
+          content: p.text,
+          providerName: provider.name,
+          batchId
+        }))
+      );
+    } catch (error) {
+      log2.warn("Failed to batch create notification history records", error);
+    }
+  }
+  const shouldTrackGlobal = isTrackingEnabled();
+  const trackingBaseUrl = getTrackingBaseUrl();
+  for (let i = 0; i < prepared.length; i++) {
+    const p = prepared[i];
+    const historyId = historyRecords[i]?.id;
+    const shouldTrack = p.tracking ?? shouldTrackGlobal;
+    if (shouldTrack && historyId && p.params.html && trackingBaseUrl) {
+      try {
+        const { html } = processTrackingHtml(p.params.html, {
+          notificationId: historyId,
+          baseUrl: trackingBaseUrl
+        });
+        p.params.html = html;
+      } catch (error) {
+        log2.warn("Failed to apply tracking to email HTML", error);
+      }
+    }
+  }
+  if (options?.distributed) {
+    const jobInputs = prepared.map((p, i) => ({
+      notificationId: historyRecords[i]?.id ?? 0,
+      to: p.params.to,
+      from: p.params.from,
+      replyTo: p.params.replyTo,
+      subject: p.params.subject,
+      text: p.params.text,
+      html: p.params.html
+    }));
+    await sendBulkEmailItemJob.sendBatch(jobInputs);
+    log2.info("Bulk email enqueued for distributed processing", {
+      batchId,
+      total: items.length,
+      enqueued: prepared.length,
+      earlyFailures: earlyFailures.length
+    });
+    const results2 = new Array(items.length);
+    for (const { index: index3, result } of earlyFailures) {
+      results2[index3] = result;
+    }
+    for (const p of prepared) {
+      results2[p.index] = { success: true, messageId: `pending:${batchId}` };
+    }
+    return {
+      results: results2,
+      successCount: prepared.length,
+      failureCount: earlyFailures.length,
+      batchId
+    };
+  }
+  const concurrency = options?.concurrency ?? 10;
+  const sendResults = await runWithConcurrency(
+    prepared,
+    (p) => provider.send(p.params),
+    concurrency
+  );
+  const results = new Array(items.length);
+  let successCount = 0;
+  let failureCount = earlyFailures.length;
+  for (const { index: index3, result } of earlyFailures) {
+    results[index3] = result;
+  }
+  const historyUpdates = [];
+  for (let i = 0; i < prepared.length; i++) {
+    const { index: index3, recipients, subject } = prepared[i];
+    const result = sendResults[i];
+    results[index3] = result;
+    if (result.success) {
+      successCount++;
+      log2.info("Email sent", { to: recipients, subject, messageId: result.messageId });
+    } else {
+      failureCount++;
+      log2.error("Email send failed", { to: recipients, subject, error: result.error });
+    }
+    const historyId = historyRecords[i]?.id;
+    if (historyId && isHistoryEnabled()) {
+      const promise = result.success ? markNotificationSent(historyId, result.messageId) : markNotificationFailed(historyId, result.error || "Unknown error");
+      historyUpdates.push(
+        promise.catch((err) => log2.warn("Failed to update notification history", err))
+      );
+    }
+  }
+  await Promise.all(historyUpdates);
+  return { results, successCount, failureCount, batchId };
+}
+
+// src/channels/sms/providers/aws-sns.ts
+import { logger as logger3 } from "@spfn/core/logger";
+var log3 = logger3.child("@spfn/notification:sns");
+var snsClient = null;
+async function getSNSClient() {
+  if (snsClient) {
+    return snsClient;
+  }
+  try {
+    const { SNSClient } = await import("@aws-sdk/client-sns");
+    snsClient = new SNSClient({
+      region: env.AWS_REGION,
+      credentials: env.AWS_ACCESS_KEY_ID && env.AWS_SECRET_ACCESS_KEY ? {
+        accessKeyId: env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: env.AWS_SECRET_ACCESS_KEY
+      } : void 0
+    });
+    log3.debug("SNS client created", { region: env.AWS_REGION });
+    return snsClient;
+  } catch {
+    throw new Error(
+      "@aws-sdk/client-sns is not installed. Please install it: pnpm add @aws-sdk/client-sns"
+    );
+  }
+}
+var awsSnsProvider = {
+  name: "aws-sns",
+  async send(params) {
+    try {
+      const client = await getSNSClient();
+      const { PublishCommand } = await import("@aws-sdk/client-sns");
+      const command = new PublishCommand({
+        PhoneNumber: params.to,
+        Message: params.message,
+        MessageAttributes: {
+          "AWS.SNS.SMS.SMSType": {
+            DataType: "String",
+            StringValue: "Transactional"
+          }
+        }
+      });
+      const response = await client.send(command);
+      return {
+        success: true,
+        messageId: response.MessageId
+      };
+    } catch (error) {
+      const err = error;
+      log3.error("SNS send failed", err, { to: params.to });
+      return {
+        success: false,
+        error: err.message
+      };
+    }
+  }
+};
+
+// src/jobs/send-bulk-sms-item.ts
+import { job as job2 } from "@spfn/core/job";
+var SendBulkSmsItemInput = Type.Object({
+  notificationId: Type.Number(),
+  to: Type.String(),
+  message: Type.String()
+});
+var sendBulkSmsItemJob = job2("notification.send-bulk-sms-item").input(SendBulkSmsItemInput).options({
+  retryLimit: 3,
+  retryDelay: 5e3,
+  batchSize: 50
+}).handler(async (input) => {
+  const { notificationId, ...smsParams } = input;
+  const result = await awsSnsProvider.send(smsParams);
+  if (result.success) {
+    await markNotificationSent(notificationId, result.messageId);
+  } else {
+    await markNotificationFailed(notificationId, result.error || "Unknown error");
+    throw new Error(result.error || "Failed to send SMS");
+  }
+});
+
+// src/channels/sms/utils.ts
+function normalizePhoneNumber(phone, defaultCountryCode) {
+  let normalized = phone.replace(/[^\d+]/g, "");
+  if (!normalized.startsWith("+")) {
+    const countryCode = defaultCountryCode ?? getSmsDefaultCountryCode();
+    if (normalized.startsWith("0")) {
+      normalized = normalized.slice(1);
+    }
+    normalized = countryCode + normalized;
+  }
+  return normalized;
+}
+
+// src/channels/sms/index.ts
+import { logger as logger4 } from "@spfn/core/logger";
+var log4 = logger4.child("@spfn/notification:sms");
+var providers2 = {
+  "aws-sns": awsSnsProvider
+};
+function registerSMSProvider(provider) {
+  providers2[provider.name] = provider;
+}
+function getProvider2() {
+  const providerName = env.SPFN_NOTIFICATION_SMS_PROVIDER || "aws-sns";
+  const provider = providers2[providerName];
+  if (!provider) {
+    throw new Error(`SMS provider not found: ${providerName}`);
+  }
+  return provider;
+}
+async function sendSMS(params) {
+  const recipients = Array.isArray(params.to) ? params.to : [params.to];
+  let message = params.message;
+  if (params.template) {
+    if (!hasTemplate(params.template)) {
+      log4.warn(`Template not found: ${params.template}`);
+      return {
+        success: false,
+        error: `Template not found: ${params.template}`
+      };
+    }
+    const rendered = renderTemplate(params.template, params.data || {}, "sms");
+    if (rendered.sms) {
+      message = rendered.sms.message;
+    }
+  }
+  if (!message) {
+    log4.warn("SMS message is required", { to: recipients });
+    return {
+      success: false,
+      error: "SMS message is required"
+    };
+  }
+  const provider = getProvider2();
+  const results = [];
+  for (const recipient of recipients) {
+    const normalizedPhone = normalizePhoneNumber(recipient);
+    const internalParams = {
+      to: normalizedPhone,
+      message
+    };
+    let historyId;
+    if (isHistoryEnabled()) {
+      try {
+        const record = await createNotificationRecord({
+          channel: "sms",
+          recipient: normalizedPhone,
+          templateName: params.template,
+          templateData: params.data,
+          content: message,
+          providerName: provider.name
+        });
+        historyId = record.id;
+      } catch (error) {
+        log4.warn("Failed to create notification history record", error);
+      }
+    }
+    const result = await provider.send(internalParams);
+    if (result.success) {
+      log4.info("SMS sent", { to: normalizedPhone, messageId: result.messageId });
+    } else {
+      log4.error("SMS send failed", { to: normalizedPhone, error: result.error });
+    }
+    if (historyId && isHistoryEnabled()) {
+      try {
+        if (result.success) {
+          await markNotificationSent(historyId, result.messageId);
+        } else {
+          await markNotificationFailed(historyId, result.error || "Unknown error");
+        }
+      } catch (error) {
+        log4.warn("Failed to update notification history record", error);
+      }
+    }
+    results.push(result);
+  }
+  const allSuccess = results.every((r) => r.success);
+  const messageIds = results.filter((r) => r.messageId).map((r) => r.messageId).join(",");
+  const errors = results.filter((r) => r.error).map((r) => r.error).join("; ");
+  return {
+    success: allSuccess,
+    messageId: messageIds || void 0,
+    error: errors || void 0
+  };
+}
+async function sendSMSBulk(items, options) {
+  if (items.length === 0) {
+    return { results: [], successCount: 0, failureCount: 0, batchId: "" };
+  }
+  const batchId = crypto.randomUUID();
+  const provider = getProvider2();
+  const prepared = [];
+  const earlyFailures = [];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const recipients = Array.isArray(item.to) ? item.to : [item.to];
+    let message = item.message;
+    if (item.template) {
+      if (!hasTemplate(item.template)) {
+        earlyFailures.push({ index: i, result: { success: false, error: `Template not found: ${item.template}` } });
+        continue;
+      }
+      const rendered = renderTemplate(item.template, item.data || {}, "sms");
+      if (rendered.sms) {
+        message = rendered.sms.message;
+      }
+    }
+    if (!message) {
+      earlyFailures.push({ index: i, result: { success: false, error: "SMS message is required" } });
+      continue;
+    }
+    for (const recipient of recipients) {
+      prepared.push({
+        index: i,
+        phone: normalizePhoneNumber(recipient),
+        message,
+        template: item.template,
+        data: item.data
+      });
+    }
+  }
+  let historyRecords = [];
+  if (isHistoryEnabled() && prepared.length > 0) {
+    try {
+      historyRecords = await createNotificationRecords(
+        prepared.map((p) => ({
+          channel: "sms",
+          recipient: p.phone,
+          templateName: p.template,
+          templateData: p.data,
+          content: p.message,
+          providerName: provider.name,
+          batchId
+        }))
+      );
+    } catch (error) {
+      log4.warn("Failed to batch create notification history records", error);
+    }
+  }
+  if (options?.distributed) {
+    const jobInputs = prepared.map((p, i) => ({
+      notificationId: historyRecords[i]?.id ?? 0,
+      to: p.phone,
+      message: p.message
+    }));
+    await sendBulkSmsItemJob.sendBatch(jobInputs);
+    log4.info("Bulk SMS enqueued for distributed processing", {
+      batchId,
+      total: items.length,
+      enqueued: prepared.length,
+      earlyFailures: earlyFailures.length
+    });
+    const results2 = new Array(items.length);
+    for (const { index: index3, result } of earlyFailures) {
+      results2[index3] = result;
+    }
+    const pendingMap = /* @__PURE__ */ new Map();
+    for (const p of prepared) {
+      pendingMap.set(p.index, (pendingMap.get(p.index) ?? 0) + 1);
+    }
+    for (const [index3] of pendingMap) {
+      if (!results2[index3]) {
+        results2[index3] = { success: true, messageId: `pending:${batchId}` };
+      }
+    }
+    return {
+      results: results2,
+      successCount: pendingMap.size,
+      failureCount: earlyFailures.length,
+      batchId
+    };
+  }
+  const concurrency = options?.concurrency ?? 10;
+  const sendResults = await runWithConcurrency(
+    prepared,
+    (p) => provider.send({ to: p.phone, message: p.message }),
+    concurrency
+  );
+  const resultsMap = /* @__PURE__ */ new Map();
+  const historyUpdates = [];
+  for (let i = 0; i < prepared.length; i++) {
+    const { index: index3, phone } = prepared[i];
+    const result = sendResults[i];
+    if (!resultsMap.has(index3)) {
+      resultsMap.set(index3, []);
+    }
+    resultsMap.get(index3).push(result);
+    if (result.success) {
+      log4.info("SMS sent", { to: phone, messageId: result.messageId });
+    } else {
+      log4.error("SMS send failed", { to: phone, error: result.error });
+    }
+    const historyId = historyRecords[i]?.id;
+    if (historyId && isHistoryEnabled()) {
+      const promise = result.success ? markNotificationSent(historyId, result.messageId) : markNotificationFailed(historyId, result.error || "Unknown error");
+      historyUpdates.push(
+        promise.catch((err) => log4.warn("Failed to update notification history", err))
+      );
+    }
+  }
+  await Promise.all(historyUpdates);
+  const results = new Array(items.length);
+  let successCount = 0;
+  let failureCount = earlyFailures.length;
+  for (const { index: index3, result } of earlyFailures) {
+    results[index3] = result;
+  }
+  for (const [index3, itemResults] of resultsMap) {
+    const allSuccess = itemResults.every((r) => r.success);
+    const messageIds = itemResults.filter((r) => r.messageId).map((r) => r.messageId).join(",");
+    const errors = itemResults.filter((r) => r.error).map((r) => r.error).join("; ");
+    results[index3] = {
+      success: allSuccess,
+      messageId: messageIds || void 0,
+      error: errors || void 0
+    };
+    if (allSuccess) {
+      successCount++;
+    } else {
+      failureCount++;
+    }
+  }
+  return { results, successCount, failureCount, batchId };
+}
+
+// src/channels/slack/providers/webhook.ts
+import { logger as logger5 } from "@spfn/core/logger";
+var log5 = logger5.child("@spfn/notification:slack-webhook");
+var webhookProvider = {
+  name: "webhook",
+  async send(params) {
+    try {
+      const res = await fetch(params.webhookUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          text: params.text,
+          blocks: params.blocks
+        })
+      });
+      return {
+        success: res.ok,
+        error: res.ok ? void 0 : await res.text()
+      };
+    } catch (error) {
+      const err = error;
+      log5.error("Webhook request failed", err);
+      return {
+        success: false,
+        error: err.message
+      };
+    }
+  }
+};
+
+// src/jobs/send-bulk-slack-item.ts
+import { job as job3 } from "@spfn/core/job";
+var SendBulkSlackItemInput = Type.Object({
+  notificationId: Type.Number(),
+  webhookUrl: Type.String(),
+  text: Type.Optional(Type.String()),
+  blocks: Type.Optional(Type.Array(Type.Unknown()))
+});
+var sendBulkSlackItemJob = job3("notification.send-bulk-slack-item").input(SendBulkSlackItemInput).options({
+  retryLimit: 3,
+  retryDelay: 5e3,
+  batchSize: 50
+}).handler(async (input) => {
+  const { notificationId, ...slackParams } = input;
+  const result = await webhookProvider.send(slackParams);
+  if (result.success) {
+    await markNotificationSent(notificationId, result.messageId);
+  } else {
+    await markNotificationFailed(notificationId, result.error || "Unknown error");
+    throw new Error(result.error || "Failed to send Slack message");
+  }
+});
 
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/rest/rest.mjs
-function RestResolve(T) {
-  return IsIntersect(T) ? T.allOf : IsUnion(T) ? T.anyOf : IsTuple(T) ? T.items ?? [] : [];
+// src/channels/slack/index.ts
+import { logger as logger6 } from "@spfn/core/logger";
+var log6 = logger6.child("@spfn/notification:slack");
+var providers3 = {
+  "webhook": webhookProvider
+};
+function registerSlackProvider(provider) {
+  providers3[provider.name] = provider;
 }
-function Rest(T) {
-  return RestResolve(T);
+function getProvider3() {
+  return providers3["webhook"];
 }
-
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/return-type/return-type.mjs
-function ReturnType(schema, options) {
-  return IsFunction2(schema) ? CreateType(schema.returns, options) : Never(options);
+function resolveWebhookUrl(params) {
+  return params.webhookUrl || env.SPFN_NOTIFICATION_SLACK_WEBHOOK_URL;
 }
-
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/transform/transform.mjs
-var TransformDecodeBuilder = class {
-  constructor(schema) {
-    this.schema = schema;
+async function sendSlack(params) {
+  const webhookUrl = resolveWebhookUrl(params);
+  if (!webhookUrl) {
+    log6.warn("Slack webhook URL is required");
+    return {
+      success: false,
+      error: "Slack webhook URL is required. Set SPFN_NOTIFICATION_SLACK_WEBHOOK_URL or pass webhookUrl."
+    };
   }
-  Decode(decode) {
-    return new TransformEncodeBuilder(this.schema, decode);
+  let text3 = params.text;
+  let blocks = params.blocks;
+  if (params.template) {
+    if (!hasTemplate(params.template)) {
+      log6.warn(`Template not found: ${params.template}`);
+      return {
+        success: false,
+        error: `Template not found: ${params.template}`
+      };
+    }
+    const rendered = renderTemplate(params.template, params.data || {}, "slack");
+    if (rendered.slack) {
+      text3 = rendered.slack.text;
+      blocks = rendered.slack.blocks;
+    }
   }
-};
-var TransformEncodeBuilder = class {
-  constructor(schema, decode) {
-    this.schema = schema;
-    this.decode = decode;
+  if (!text3 && !blocks) {
+    log6.warn("Slack message requires text or blocks");
+    return {
+      success: false,
+      error: "Slack message requires text or blocks"
+    };
   }
-  EncodeTransform(encode, schema) {
-    const Encode = (value) => schema[TransformKind].Encode(encode(value));
-    const Decode = (value) => this.decode(schema[TransformKind].Decode(value));
-    const Codec = { Encode, Decode };
-    return { ...schema, [TransformKind]: Codec };
+  const internalParams = {
+    webhookUrl,
+    text: text3,
+    blocks
+  };
+  const provider = getProvider3();
+  let historyId;
+  if (isHistoryEnabled()) {
+    try {
+      const record = await createNotificationRecord({
+        channel: "slack",
+        recipient: webhookUrl,
+        templateName: params.template,
+        templateData: params.data,
+        content: text3,
+        providerName: provider.name
+      });
+      historyId = record.id;
+    } catch (error) {
+      log6.warn("Failed to create notification history record", error);
+    }
   }
-  EncodeSchema(encode, schema) {
-    const Codec = { Decode: this.decode, Encode: encode };
-    return { ...schema, [TransformKind]: Codec };
+  const result = await provider.send(internalParams);
+  if (result.success) {
+    log6.info("Slack message sent");
+  } else {
+    log6.error("Slack send failed", { error: result.error });
   }
-  Encode(encode) {
-    return IsTransform(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema);
+  if (historyId && isHistoryEnabled()) {
+    try {
+      if (result.success) {
+        await markNotificationSent(historyId, result.messageId);
+      } else {
+        await markNotificationFailed(historyId, result.error || "Unknown error");
+      }
+    } catch (error) {
+      log6.warn("Failed to update notification history record", error);
+    }
   }
-};
-function Transform(schema) {
-  return new TransformDecodeBuilder(schema);
-}
-
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/unsafe/unsafe.mjs
-function Unsafe(options = {}) {
-  return CreateType({ [Kind]: options[Kind] ?? "Unsafe" }, options);
+  return result;
 }
-
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/void/void.mjs
-function Void(options) {
-  return CreateType({ [Kind]: "Void", type: "void" }, options);
+async function sendSlackBulk(items, options) {
+  if (items.length === 0) {
+    return { results: [], successCount: 0, failureCount: 0, batchId: "" };
+  }
+  const batchId = crypto.randomUUID();
+  const provider = getProvider3();
+  const prepared = [];
+  const earlyFailures = [];
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const webhookUrl = resolveWebhookUrl(item);
+    if (!webhookUrl) {
+      earlyFailures.push({ index: i, result: { success: false, error: "Slack webhook URL is required. Set SPFN_NOTIFICATION_SLACK_WEBHOOK_URL or pass webhookUrl." } });
+      continue;
+    }
+    let text3 = item.text;
+    let blocks = item.blocks;
+    if (item.template) {
+      if (!hasTemplate(item.template)) {
+        earlyFailures.push({ index: i, result: { success: false, error: `Template not found: ${item.template}` } });
+        continue;
+      }
+      const rendered = renderTemplate(item.template, item.data || {}, "slack");
+      if (rendered.slack) {
+        text3 = rendered.slack.text;
+        blocks = rendered.slack.blocks;
+      }
+    }
+    if (!text3 && !blocks) {
+      earlyFailures.push({ index: i, result: { success: false, error: "Slack message requires text or blocks" } });
+      continue;
+    }
+    prepared.push({
+      index: i,
+      params: { webhookUrl, text: text3, blocks },
+      webhookUrl,
+      template: item.template,
+      data: item.data,
+      text: text3
+    });
+  }
+  let historyRecords = [];
+  if (isHistoryEnabled() && prepared.length > 0) {
+    try {
+      historyRecords = await createNotificationRecords(
+        prepared.map((p) => ({
+          channel: "slack",
+          recipient: p.webhookUrl,
+          templateName: p.template,
+          templateData: p.data,
+          content: p.text,
+          providerName: provider.name,
+          batchId
+        }))
+      );
+    } catch (error) {
+      log6.warn("Failed to batch create notification history records", error);
+    }
+  }
+  if (options?.distributed) {
+    const jobInputs = prepared.map((p, i) => ({
+      notificationId: historyRecords[i]?.id ?? 0,
+      webhookUrl: p.webhookUrl,
+      text: p.text,
+      blocks: p.params.blocks
+    }));
+    await sendBulkSlackItemJob.sendBatch(jobInputs);
+    log6.info("Bulk Slack enqueued for distributed processing", {
+      batchId,
+      total: items.length,
+      enqueued: prepared.length,
+      earlyFailures: earlyFailures.length
+    });
+    const results2 = new Array(items.length);
+    for (const { index: index3, result } of earlyFailures) {
+      results2[index3] = result;
+    }
+    for (const p of prepared) {
+      if (!results2[p.index]) {
+        results2[p.index] = { success: true, messageId: `pending:${batchId}` };
+      }
+    }
+    return {
+      results: results2,
+      successCount: prepared.length,
+      failureCount: earlyFailures.length,
+      batchId
+    };
+  }
+  const concurrency = options?.concurrency ?? 10;
+  const sendResults = await runWithConcurrency(
+    prepared,
+    (p) => provider.send(p.params),
+    concurrency
+  );
+  const results = new Array(items.length);
+  let successCount = 0;
+  let failureCount = earlyFailures.length;
+  for (const { index: index3, result } of earlyFailures) {
+    results[index3] = result;
+  }
+  const historyUpdates = [];
+  for (let i = 0; i < prepared.length; i++) {
+    const { index: index3 } = prepared[i];
+    const result = sendResults[i];
+    results[index3] = result;
+    if (result.success) {
+      successCount++;
+      log6.info("Slack message sent");
+    } else {
+      failureCount++;
+      log6.error("Slack send failed", { error: result.error });
+    }
+    const historyId = historyRecords[i]?.id;
+    if (historyId && isHistoryEnabled()) {
+      const promise = result.success ? markNotificationSent(historyId, result.messageId) : markNotificationFailed(historyId, result.error || "Unknown error");
+      historyUpdates.push(
+        promise.catch((err) => log6.warn("Failed to update notification history", err))
+      );
+    }
+  }
+  await Promise.all(historyUpdates);
+  return { results, successCount, failureCount, batchId };
 }
 
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/type/type.mjs
-var type_exports2 = {};
-__export(type_exports2, {
-  Any: () => Any,
-  Argument: () => Argument,
-  Array: () => Array2,
-  AsyncIterator: () => AsyncIterator,
-  Awaited: () => Awaited,
-  BigInt: () => BigInt,
-  Boolean: () => Boolean,
-  Capitalize: () => Capitalize,
-  Composite: () => Composite,
-  Const: () => Const,
-  Constructor: () => Constructor,
-  ConstructorParameters: () => ConstructorParameters,
-  Date: () => Date2,
-  Enum: () => Enum,
-  Exclude: () => Exclude,
-  Extends: () => Extends,
-  Extract: () => Extract,
-  Function: () => Function,
-  Index: () => Index,
-  InstanceType: () => InstanceType,
-  Instantiate: () => Instantiate,
-  Integer: () => Integer,
-  Intersect: () => Intersect,
-  Iterator: () => Iterator,
-  KeyOf: () => KeyOf,
-  Literal: () => Literal,
-  Lowercase: () => Lowercase,
-  Mapped: () => Mapped,
-  Module: () => Module,
-  Never: () => Never,
-  Not: () => Not,
-  Null: () => Null,
-  Number: () => Number2,
-  Object: () => Object2,
-  Omit: () => Omit,
-  Optional: () => Optional,
-  Parameters: () => Parameters,
-  Partial: () => Partial,
-  Pick: () => Pick,
-  Promise: () => Promise2,
-  Readonly: () => Readonly,
-  ReadonlyOptional: () => ReadonlyOptional,
-  Record: () => Record,
-  Recursive: () => Recursive,
-  Ref: () => Ref,
-  RegExp: () => RegExp2,
-  Required: () => Required,
-  Rest: () => Rest,
-  ReturnType: () => ReturnType,
-  String: () => String2,
-  Symbol: () => Symbol2,
-  TemplateLiteral: () => TemplateLiteral,
-  Transform: () => Transform,
-  Tuple: () => Tuple,
-  Uint8Array: () => Uint8Array2,
-  Uncapitalize: () => Uncapitalize,
-  Undefined: () => Undefined,
-  Union: () => Union,
-  Unknown: () => Unknown,
-  Unsafe: () => Unsafe,
-  Uppercase: () => Uppercase,
-  Void: () => Void
-});
-
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/type/index.mjs
-var Type = type_exports2;
-
 // src/jobs/send-scheduled-email.ts
+import { job as job4 } from "@spfn/core/job";
 var SendScheduledEmailInput = Type.Object({
   notificationId: Type.Number(),
   to: Type.Union([Type.String(), Type.Array(Type.String())]),
@@ -3880,7 +4354,7 @@ var SendScheduledEmailInput = Type.Object({
   from: Type.Optional(Type.String()),
   replyTo: Type.Optional(Type.String())
 });
-var sendScheduledEmailJob = job("notification.send-scheduled-email").input(SendScheduledEmailInput).options({
+var sendScheduledEmailJob = job4("notification.send-scheduled-email").input(SendScheduledEmailInput).options({
   retryLimit: 3,
   retryDelay: 5e3
 }).handler(async (input) => {
@@ -3896,7 +4370,7 @@ var sendScheduledEmailJob = job("notification.send-scheduled-email").input(SendS
 });
 
 // src/jobs/send-scheduled-sms.ts
-import { job as job2 } from "@spfn/core/job";
+import { job as job5 } from "@spfn/core/job";
 var SendScheduledSmsInput = Type.Object({
   notificationId: Type.Number(),
   to: Type.Union([Type.String(), Type.Array(Type.String())]),
@@ -3904,7 +4378,7 @@ var SendScheduledSmsInput = Type.Object({
   template: Type.Optional(Type.String()),
   data: Type.Optional(Type.Record(Type.String(), Type.Unknown()))
 });
-var sendScheduledSmsJob = job2("notification.send-scheduled-sms").input(SendScheduledSmsInput).options({
+var sendScheduledSmsJob = job5("notification.send-scheduled-sms").input(SendScheduledSmsInput).options({
   retryLimit: 3,
   retryDelay: 5e3
 }).handler(async (input) => {
@@ -4118,7 +4592,10 @@ async function cancelNotificationsByReference(referenceType, referenceId) {
 import { defineJobRouter } from "@spfn/core/job";
 var notificationJobRouter = defineJobRouter({
   sendScheduledEmail: sendScheduledEmailJob,
-  sendScheduledSms: sendScheduledSmsJob
+  sendScheduledSms: sendScheduledSmsJob,
+  sendBulkEmailItem: sendBulkEmailItemJob,
+  sendBulkSmsItem: sendBulkSmsItemJob,
+  sendBulkSlackItem: sendBulkSlackItemJob
 });
 
 // src/integrations/error-slack.ts
@@ -4466,6 +4943,9 @@ export {
   renderTemplate,
   scheduleEmail,
   scheduleSMS,
+  sendBulkEmailItemJob,
+  sendBulkSlackItemJob,
+  sendBulkSmsItemJob,
   sendEmail,
   sendEmailBulk,
   sendSMS,