@facteurjs/core 1.0.0-beta.3 → 2.0.0-beta.0

package/dist/notifications/notification_sender.mjs

@@ -0,0 +1,356 @@
+import { errors } from "../errors/index.mjs";
+import { chunk } from "../utils/chunk.mjs";
+import "./channel_resolver.mjs";
+import { capitalizeFirstLetter } from "../helpers.mjs";
+import { facteurEvents } from "../events/events.mjs";
+import debug_default from "../debug.mjs";
+import { Tenace, backoff } from "@julr/tenace";
+
+//#region src/notifications/notification_sender.ts
+/**
+* Responsible for sending notifications and messages
+*/
+var NotificationSender = class {
+	constructor(channels, channelResolver, emitter, retryConfig = {}) {
+		this.channels = channels;
+		this.channelResolver = channelResolver;
+		this.emitter = emitter;
+		this.retryConfig = retryConfig;
+	}
+	/**
+	* Build the message content by calling the notification's `as<ChannelName>Message` method
+	*/
+	#buildMessageContent(options) {
+		const { notification, channelName, sendOptions } = options;
+		const capitalizedChannelName = capitalizeFirstLetter(channelName);
+		const messageBuilder = notification[`as${capitalizedChannelName}Message`];
+		if (typeof messageBuilder !== "function") throw new errors.E_MISSING_MESSAGE_METHOD([capitalizedChannelName]);
+		const content = messageBuilder.call(notification, {
+			to: sendOptions.to,
+			params: sendOptions.params,
+			tenantId: sendOptions.tenantId
+		});
+		if (!content) return null;
+		return {
+			content,
+			capitalizedChannelName
+		};
+	}
+	/**
+	* Execute a function with retry/timeout if configured
+	*/
+	async #executeWithRetry(fn, options) {
+		if (!(options.retries !== void 0 || options.timeout !== void 0)) return fn();
+		let builder = Tenace.call(fn);
+		if (options.timeout !== void 0) builder = builder.withTimeout(options.timeout, "aggressive");
+		if (options.retries !== void 0 && options.retries > 0) builder = builder.withRetry({
+			times: options.retries,
+			delay: backoff.exponentialWithJitter({
+				initial: 100,
+				max: 5e3
+			})
+		});
+		await builder.execute();
+	}
+	/**
+	* Emit notification sending event
+	*/
+	#emitNotificationSending(notification, resolvedChannels) {
+		const event = facteurEvents.notificationSending({
+			notification,
+			resolvedChannels
+		});
+		this.emitter.emit(event.name, event.data);
+	}
+	/**
+	* Emit notification sent event
+	*/
+	#emitNotificationSent(notification, results) {
+		const event = facteurEvents.notificationSent({
+			notification,
+			results
+		});
+		this.emitter.emit(event.name, event.data);
+	}
+	/**
+	* Emit notification failed event
+	*/
+	#emitNotificationFailed(notification, errors$1) {
+		const event = facteurEvents.notificationFailed({
+			notification,
+			errors: errors$1
+		});
+		this.emitter.emit(event.name, event.data);
+	}
+	/**
+	* Emit message sending event
+	*/
+	#emitMessageSending(notification, channelName, message) {
+		const event = facteurEvents.messageSending({
+			notification,
+			channelName,
+			message
+		});
+		this.emitter.emit(event.name, event.data);
+	}
+	/**
+	* Emit message sent event
+	*/
+	#emitMessageSent(notification, channelName, message) {
+		const event = facteurEvents.messageSent({
+			notification,
+			channelName,
+			message
+		});
+		this.emitter.emit(event.name, event.data);
+	}
+	/**
+	* Emit message failed event
+	*/
+	#emitMessageFailed(notification, channelName, message, error) {
+		const event = facteurEvents.messageFailed({
+			notification,
+			channelName,
+			message,
+			error
+		});
+		this.emitter.emit(event.name, event.data);
+	}
+	/**
+	* Get a channel by its name, throws if not registered
+	*/
+	#getChannel(channelName) {
+		const channel = this.channels[channelName];
+		if (!channel) throw new Error(`Channel '${channelName}' is not registered`);
+		return channel;
+	}
+	/**
+	* Resolve retry options for a specific channel.
+	* Priority: send options > channel config > global config
+	*/
+	#resolveRetryOptions(channelName, sendOptions) {
+		const globalConfig = this.retryConfig;
+		const channelConfig = globalConfig.channels?.[channelName];
+		const retries = sendOptions.retries ?? channelConfig?.retries ?? globalConfig.retries;
+		const timeout = sendOptions.timeout ?? channelConfig?.timeout ?? globalConfig.timeout;
+		return {
+			...retries !== void 0 && { retries },
+			...timeout !== void 0 && { timeout }
+		};
+	}
+	/**
+	* Send a single message through a specific channel
+	*/
+	async #sendMessage(options) {
+		const { notification, channelName, options: sendOptions, channelConfig } = options;
+		const channel = this.#getChannel(channelName);
+		const messageResult = this.#buildMessageContent({
+			notification,
+			channelName,
+			sendOptions
+		});
+		if (!messageResult) return null;
+		const { content: messageContent } = messageResult;
+		debug_default(`Sending message via ${channelName}: %O`, messageContent);
+		this.#emitMessageSending(notification, channelName, messageContent);
+		const retryOptions = this.#resolveRetryOptions(channelName, sendOptions);
+		const doSend = async () => {
+			await channel.send({
+				tenantId: sendOptions.tenantId,
+				message: messageContent,
+				targets: channelConfig.target,
+				to: sendOptions.to
+			});
+		};
+		try {
+			await this.#executeWithRetry(doSend, retryOptions);
+			debug_default(`Message sent via ${channelName}`);
+			this.#emitMessageSent(notification, channelName, messageContent);
+			return {
+				channel: channelName,
+				status: "success"
+			};
+		} catch (error) {
+			this.#emitMessageFailed(notification, channelName, messageContent, error);
+			throw error;
+		}
+	}
+	/**
+	* Process results from sending messages and emit appropriate events
+	*/
+	async #processResults(options) {
+		const { results, throwOnError, notification } = options;
+		const channelResults = results.filter((result) => result !== null);
+		const successes = channelResults.filter((r) => r.status === "success");
+		const failures = channelResults.filter((r) => r.status === "failed");
+		if (!failures.length) {
+			this.#emitNotificationSent(notification, channelResults);
+			await notification.afterSend();
+			return {
+				failed: failures.length,
+				success: successes.length,
+				results: channelResults
+			};
+		}
+		const failureReasons = failures.map((r) => r.error);
+		this.#emitNotificationFailed(notification, failureReasons);
+		await notification.afterSend();
+		if (throwOnError !== false) throw new errors.E_SEND_NOTIFICATION_FAILED(failureReasons);
+		return {
+			failed: failures.length,
+			success: successes.length,
+			results: channelResults
+		};
+	}
+	/**
+	* Send messages using the channel's batch API
+	*/
+	async #sendWithBatchApi(channelName, channel, messages) {
+		const batches = chunk(messages, channel.batchConfig?.maxSize ?? 100);
+		const allResults = [];
+		for (const batch of batches) {
+			debug_default(`Sending batch of ${batch.length} messages via ${channelName}`);
+			for (const msg of batch) this.#emitMessageSending(msg.notification, channelName, msg.messageContent);
+			try {
+				const batchResult = await channel.sendBatch(batch.map((m) => m.sendParams));
+				for (const result of batchResult.results) {
+					const msg = batch[result.index];
+					if (result.status === "success") this.#emitMessageSent(msg.notification, channelName, msg.messageContent);
+					else this.#emitMessageFailed(msg.notification, channelName, msg.messageContent, result.error || /* @__PURE__ */ new Error("Unknown batch error"));
+					allResults.push({
+						channel: channelName,
+						status: result.status,
+						error: result.error
+					});
+				}
+			} catch (error) {
+				for (const msg of batch) {
+					this.#emitMessageFailed(msg.notification, channelName, msg.messageContent, error);
+					allResults.push({
+						channel: channelName,
+						status: "failed",
+						error
+					});
+				}
+			}
+		}
+		return allResults;
+	}
+	/**
+	* Send messages individually when batch API is not available
+	*/
+	async #sendIndividually(channelName, channel, messages, sendOptions) {
+		const retryOptions = this.#resolveRetryOptions(channelName, sendOptions);
+		const results = [];
+		for (const msg of messages) {
+			debug_default(`Sending message via ${channelName}: %O`, msg.messageContent);
+			this.#emitMessageSending(msg.notification, channelName, msg.messageContent);
+			try {
+				await this.#executeWithRetry(() => channel.send(msg.sendParams), retryOptions);
+				debug_default(`Message sent via ${channelName}`);
+				this.#emitMessageSent(msg.notification, channelName, msg.messageContent);
+				results.push({
+					channel: channelName,
+					status: "success"
+				});
+			} catch (error) {
+				this.#emitMessageFailed(msg.notification, channelName, msg.messageContent, error);
+				results.push({
+					channel: channelName,
+					status: "failed",
+					error
+				});
+			}
+		}
+		return results;
+	}
+	/**
+	* Send a notification through all resolved channels
+	*/
+	async send(options, notification) {
+		const { via, params, tenantId, to } = options;
+		const resolvedChannels = await this.channelResolver.resolveChannels({
+			to,
+			params,
+			tenantId,
+			notification: options.notification,
+			...via ? { via } : {}
+		});
+		debug_default(`Resolved channels: %O`, resolvedChannels);
+		this.#emitNotificationSending(notification, resolvedChannels);
+		const promises = Object.entries(resolvedChannels).map(async ([name, config]) => {
+			if (!config.shouldSend || !config.target) return null;
+			return await this.#sendMessage({
+				notification,
+				channelConfig: config,
+				channelName: name,
+				options
+			}).catch((error) => {
+				debug_default(`Failed to send notification via ${name}: %O`, error);
+				return {
+					channel: name,
+					status: "failed",
+					error
+				};
+			});
+		});
+		return await this.#processResults({
+			notification,
+			results: await Promise.all(promises),
+			throwOnError: options.throwOnError !== false
+		});
+	}
+	/**
+	* Prepare a message for a specific channel without sending it.
+	* Returns null if the message should not be sent.
+	*/
+	prepareMessage(options) {
+		const { notification, channelName, sendOptions, channelConfig } = options;
+		this.#getChannel(channelName);
+		const messageResult = this.#buildMessageContent({
+			notification,
+			channelName,
+			sendOptions
+		});
+		if (!messageResult) return null;
+		const { content: messageContent } = messageResult;
+		return {
+			channelName,
+			notification,
+			messageContent,
+			sendParams: {
+				tenantId: sendOptions.tenantId,
+				message: messageContent,
+				targets: channelConfig.target,
+				to: sendOptions.to
+			}
+		};
+	}
+	/**
+	* Send multiple messages through a channel using batch API if available.
+	* Falls back to individual sends if batch is not supported.
+	*/
+	async sendChannelBatch(options) {
+		const { channelName, messages, sendOptions } = options;
+		const channel = this.#getChannel(channelName);
+		const disableDriverBatch = sendOptions.disableDriverBatch === true;
+		if (channel.sendBatch && channel.batchConfig?.enabled !== false && !disableDriverBatch) return this.#sendWithBatchApi(channelName, channel, messages);
+		return this.#sendIndividually(channelName, channel, messages, sendOptions);
+	}
+	/**
+	* Check if a channel supports batch sending
+	*/
+	channelSupportsBatch(channelName) {
+		const ch = this.channels[channelName];
+		return !!(ch?.sendBatch && ch.batchConfig?.enabled !== false);
+	}
+	/**
+	* Get the batch config for a channel
+	*/
+	getChannelBatchConfig(channelName) {
+		return this.channels[channelName]?.batchConfig;
+	}
+};
+
+//#endregion
+export { NotificationSender };

package/dist/notifications/orchestration_sender.mjs

@@ -0,0 +1,92 @@
+import { chunk } from "../utils/chunk.mjs";
+import { Tenace, backoff } from "@julr/tenace";
+
+//#region src/notifications/orchestration_sender.ts
+/**
+* Handles bulk notification sending using orchestration mode.
+*
+* In orchestration mode, each recipient is processed individually with configurable
+* concurrency, chunking, retries, and timeout. This provides fine-grained control
+* over the sending process and per-recipient error handling.
+*/
+var OrchestrationSender = class {
+	#sender;
+	constructor(sender) {
+		this.#sender = sender;
+	}
+	/**
+	* Sends notifications to multiple recipients with concurrency control
+	*/
+	async send(options) {
+		const { chunkSize = Infinity, concurrency = 10, continueOnError = false, retries = 0, timeout, onProgress } = options.builderOptions;
+		const chunks = chunk(options.recipients, chunkSize);
+		const allResults = [];
+		let completedCount = 0;
+		const totalCount = options.recipients.length;
+		const { retries: _retries, timeout: _timeout, ...perRecipientOptions } = options.builderOptions;
+		for (const recipientChunk of chunks) {
+			const chunkResults = await this.#processChunk({
+				recipientChunk,
+				perRecipientOptions,
+				prepareNotification: options.prepareNotification,
+				concurrency,
+				retries,
+				continueOnError,
+				onProgress: () => {
+					completedCount++;
+					onProgress?.(completedCount, totalCount);
+				},
+				...timeout && { timeout }
+			});
+			allResults.push(...chunkResults);
+		}
+		return this.#aggregateResults(allResults);
+	}
+	/**
+	* Processes a single chunk of recipients with Tenace for concurrency and retry
+	*/
+	async #processChunk(options) {
+		const builder = Tenace.map(options.recipientChunk, async (recipient) => {
+			const recipientOptions = {
+				...options.perRecipientOptions,
+				to: recipient
+			};
+			const { notification, shouldSkip } = await options.prepareNotification(recipient, recipientOptions);
+			if (shouldSkip) {
+				options.onProgress();
+				return {
+					success: 0,
+					failed: 0,
+					results: []
+				};
+			}
+			const result = await this.#sender.send(recipientOptions, notification);
+			options.onProgress();
+			return result;
+		}).withConcurrency(options.concurrency);
+		if (options.retries > 0) builder.withRetryPerTask(options.retries, { delay: backoff.exponentialWithJitter({
+			initial: 100,
+			max: 5e3
+		}) });
+		if (options.timeout) builder.withTimeoutPerTask(options.timeout);
+		if (!options.continueOnError) return builder.execute();
+		return (await builder.settle()).map((result) => result.status === "fulfilled" ? result.value : {
+			success: 0,
+			failed: 1,
+			results: []
+		});
+	}
+	/**
+	* Combines multiple send results into a single aggregated result
+	*/
+	#aggregateResults(results) {
+		return {
+			success: results.reduce((sum, r) => sum + r.success, 0),
+			failed: results.reduce((sum, r) => sum + r.failed, 0),
+			results: results.flatMap((r) => r.results)
+		};
+	}
+};
+
+//#endregion
+export { OrchestrationSender };

package/dist/{options.d.ts → options.d.mts}

@@ -1,9 +1,9 @@
-import { DatabaseAdapter } from "./database/types.js";
-import { Channel } from "./types/channel.js";
-import { Emitter } from "./types/events.js";
-import { QueueAdapter } from "./types/queue.js";
-import { ResolvedDefaultPreferences } from "./types/preferences.js";
-import { FacteurConfiguration, NotificationResolver } from "./types/options.js";
+import { Channel } from "./types/channel.mjs";
+import { QueueAdapter } from "./types/queue.mjs";
+import { ResolvedDefaultPreferences } from "./types/preferences.mjs";
+import { Emitter } from "./types/events.mjs";
+import { FacteurConfiguration, NotificationResolver, RetryConfig } from "./types/options.mjs";
+import { DatabaseAdapter } from "./database/types.mjs";
 import { Logger } from "@julr/utils/logger";
 
 //#region src/options.d.ts
@@ -15,6 +15,7 @@ declare class FacteurOptions<KnownChannels extends Record<string, Channel>, DBAd
   queueAdapter: QueueAdapter;
   databaseAdapter: DBAdapter | null;
   notificationResolver: NotificationResolver;
+  retry: RetryConfig<KnownChannels>;
   readonly defaultPreferences: ResolvedDefaultPreferences<KnownChannels>;
   constructor(config: FacteurConfiguration<KnownChannels, DBAdapter>);
 }

package/dist/{options.js → options.mjs}

@@ -1,4 +1,4 @@
-import { errors } from "./errors/index.js";
+import { errors } from "./errors/index.mjs";
 import EventEmitter from "node:events";
 import { noopLogger } from "@julr/utils/logger";
 import { invoke } from "@julr/utils/functions";
@@ -11,6 +11,7 @@ var FacteurOptions = class {
 	queueAdapter;
 	databaseAdapter = null;
 	notificationResolver;
+	retry = {};
 	defaultPreferences;
 	#resolveDefaultPreferences(preferences) {
 		preferences = preferences || {};
@@ -23,11 +24,10 @@ var FacteurOptions = class {
 		* Build categories preferences
 		*/
 		const categories = Object.entries(preferences.categories || {}).map(([category, config]) => {
-			const value = invoke(() => {
+			return [category, { channels: invoke(() => {
 				if (typeof config === "boolean") return Object.fromEntries(allChannels.map((channel) => [channel, config]));
 				return Object.assign({}, globalChannelPreferences, config.channels || {});
-			});
-			return [category, { channels: value }];
+			}) }];
 		});
 		return {
 			enabled: preferences.enabled ?? true,
@@ -42,6 +42,7 @@ var FacteurOptions = class {
 		this.databaseAdapter = config.databaseAdapter ?? null;
 		this.defaultPreferences = this.#resolveDefaultPreferences(config.preferences);
 		this.notificationResolver = config.notificationResolver || ((notification, ctx) => new notification(ctx));
+		this.retry = config.retry || {};
 		const throwIfQueueNotSet = () => {
 			throw new errors.E_QUEUE_NOT_SET();
 		};

package/dist/types/builder.d.mts

@@ -0,0 +1,122 @@
+import { ChannelName } from "./extend.mjs";
+import { BulkSendOptions, ChannelSpecificConfig, ExtractNotifiable, ExtractParams, RetryOptions } from "./options.mjs";
+import { NotificationClass, NotificationSendResult } from "./notifications.mjs";
+import { Identifier } from "../database/types.mjs";
+import { Duration } from "@julr/tenace/types";
+
+//#region src/types/builder.d.ts
+
+/**
+ * Helper type to check if params are required for a notification
+ */
+type HasRequiredParams<T extends NotificationClass<any, any>> = ExtractParams<T> extends Record<string, never> ? false : unknown extends ExtractParams<T> ? false : true;
+/**
+ * Helper type to check if a notification is anonymous (no notifiable)
+ */
+type IsAnonymous<T extends NotificationClass<any, any>> = ExtractNotifiable<T> extends undefined ? true : false;
+/**
+ * State tracking for the builder
+ */
+interface BuilderState {
+  hasParams: boolean;
+  hasTo: boolean;
+  hasVia: boolean;
+}
+/**
+ * Internal options accumulated by the builder. Extends BulkSendOptions for bulk operations.
+ */
+interface BuilderOptions<TNotification extends NotificationClass<any, any>> extends BulkSendOptions {
+  notification: TNotification;
+  params?: ExtractParams<TNotification>;
+  to?: ExtractNotifiable<TNotification> | ExtractNotifiable<TNotification>[] | unknown;
+  via?: ChannelSpecificConfig<any>;
+  tenantId?: Identifier;
+  throwOnError?: boolean;
+}
+/**
+ * Minimal options needed by NotificationSender
+ */
+interface InternalSendOptions extends RetryOptions {
+  notification: NotificationClass<any, any>;
+  params?: Record<string, any>;
+  to?: unknown;
+  via?: ChannelSpecificConfig<any>;
+  tenantId?: Identifier;
+  throwOnError?: boolean;
+  disableDriverBatch?: boolean;
+}
+/**
+ * Merges builder state updates. Used to track which methods have been called.
+ */
+type MergeState<TState extends BuilderState, TUpdate extends Partial<BuilderState>> = {
+  hasParams: TUpdate extends {
+    hasParams: infer P;
+  } ? P : TState['hasParams'];
+  hasTo: TUpdate extends {
+    hasTo: infer T;
+  } ? T : TState['hasTo'];
+  hasVia: TUpdate extends {
+    hasVia: infer V;
+  } ? V : TState['hasVia'];
+};
+/**
+ * Methods available on all builders: bulk options, retry, and tenant selection.
+ */
+interface CommonBuilderMethods<TNotification extends NotificationClass<any, any>, TState extends BuilderState> {
+  tenant(id: Identifier): NotificationBuilder<TNotification, TState>;
+  chunkSize(size: number): NotificationBuilder<TNotification, TState>;
+  concurrency(limit: number): NotificationBuilder<TNotification, TState>;
+  continueOnError(value?: boolean): NotificationBuilder<TNotification, TState>;
+  retries(count: number): NotificationBuilder<TNotification, TState>;
+  timeout(duration: Duration): NotificationBuilder<TNotification, TState>;
+  throwOnError(value?: boolean): NotificationBuilder<TNotification, TState>;
+  useDriverBatching(value?: boolean): NotificationBuilder<TNotification, TState>;
+  disableDriverBatch(value?: boolean): NotificationBuilder<TNotification, TState>;
+  onProgress(callback: (completed: number, total: number) => void): NotificationBuilder<TNotification, TState>;
+}
+/**
+ * Override channel targets directly (e.g., send to a specific email address).
+ */
+interface ViaMethod<TNotification extends NotificationClass<any, any>, TState extends BuilderState> {
+  via(config: { [K in ChannelName]?: boolean | any }): NotificationBuilder<TNotification, MergeState<TState, {
+    hasVia: true;
+  }>>;
+}
+/**
+ * params() method type - always available but changes state
+ */
+interface ParamsMethod<TNotification extends NotificationClass<any, any>, TState extends BuilderState> {
+  params(params: ExtractParams<TNotification>): NotificationBuilder<TNotification, MergeState<TState, {
+    hasParams: true;
+  }>>;
+}
+/**
+ * Set recipients. Accepts single, array, or async iterable. Not available for anonymous notifications.
+ */
+interface ToMethod<TNotification extends NotificationClass<any, any>, TState extends BuilderState> {
+  to(recipients: NonNullable<ExtractNotifiable<TNotification>> | NonNullable<ExtractNotifiable<TNotification>>[] | AsyncIterable<NonNullable<ExtractNotifiable<TNotification>>>): NotificationBuilder<TNotification, MergeState<TState, {
+    hasTo: true;
+  }>>;
+}
+/**
+ * send() method type
+ */
+interface SendMethod {
+  send(): Promise<NotificationSendResult>;
+}
+/**
+ * Returns true if send() should be available. Requires:
+ * - params() called if notification has required params
+ * - to() called for non-anonymous, or via() called for anonymous
+ */
+type CanSend<TNotification extends NotificationClass<any, any>, TState extends BuilderState> = HasRequiredParams<TNotification> extends true ? TState['hasParams'] extends true ? CheckToOrVia<TNotification, TState> : false : CheckToOrVia<TNotification, TState>;
+/**
+ * Anonymous notifications require via(), non-anonymous require to().
+ */
+type CheckToOrVia<TNotification extends NotificationClass<any, any>, TState extends BuilderState> = IsAnonymous<TNotification> extends true ? TState['hasVia'] extends true ? true : false : TState['hasTo'] extends true ? true : false;
+/**
+ * Fluent builder for sending notifications. Methods appear/disappear based on state.
+ */
+type NotificationBuilder<TNotification extends NotificationClass<any, any>, TState extends BuilderState> = CommonBuilderMethods<TNotification, TState> & ViaMethod<TNotification, TState> & (TState['hasParams'] extends true ? {} : ParamsMethod<TNotification, TState>) & (IsAnonymous<TNotification> extends true ? {} : TState['hasTo'] extends true ? {} : ToMethod<TNotification, TState>) & (CanSend<TNotification, TState> extends true ? SendMethod : {});
+//#endregion
+export { BuilderOptions, BuilderState, HasRequiredParams, InternalSendOptions, IsAnonymous, NotificationBuilder };

package/dist/types/channel.d.mts

@@ -0,0 +1,56 @@
+import { Identifier } from "../database/types.mjs";
+import { Awaitable } from "@julr/utils/types";
+
+//#region src/types/channel.d.ts
+type ChannelSendParams<Message, Targets> = {
+  to?: any;
+  message: Message;
+  targets?: Targets;
+  tenantId?: Identifier | undefined;
+};
+/**
+ * Result of a batch send operation
+ */
+interface BatchSendResult {
+  success: number;
+  failed: number;
+  results: Array<{
+    index: number;
+    status: 'success' | 'failed';
+    error?: Error;
+    response?: any;
+  }>;
+}
+/**
+ * Configuration for batch sending capabilities
+ */
+interface BatchConfig {
+  /**
+   * Maximum number of messages per batch API call.
+   * E.g. 500 for FCM, 100 for Expo
+   */
+  maxSize: number;
+  /**
+   * Whether batching is enabled for this channel.
+   * @default true
+   */
+  enabled?: boolean;
+}
+declare const kTargetSymbol: unique symbol;
+interface Channel<_Options = any, Message = any, Response = any, Targets = any> {
+  [kTargetSymbol]: Targets;
+  name: string;
+  send: (options: ChannelSendParams<Message, Targets>) => Awaitable<Response>;
+  /**
+   * Optional batch send method for providers that support sending multiple messages in one API call.
+   * When implemented, the orchestration layer will group messages and use this method.
+   */
+  sendBatch?: (messages: ChannelSendParams<Message, Targets>[]) => Awaitable<BatchSendResult>;
+  /**
+   * Configuration for batch sending.
+   * Required when sendBatch is implemented.
+   */
+  batchConfig?: BatchConfig;
+}
+//#endregion
+export { BatchConfig, BatchSendResult, Channel, ChannelSendParams, kTargetSymbol };

package/dist/types/{events.d.ts → events.d.mts}

@@ -1,4 +1,4 @@
-import { facteurEvents } from "../events/events.js";
+import { facteurEvents } from "../events/events.mjs";
 
 //#region src/types/events.d.ts