@fluojs/discord 1.0.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fluo contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.ko.md

@@ -0,0 +1,216 @@
+# @fluojs/discord
+
+<p><a href="./README.md"><kbd>English</kbd></a> <strong><kbd>한국어</kbd></strong></p>
+
+fluo를 위한 webhook-first, transport-agnostic Discord 전달 코어 패키지입니다. Nest-like 모듈 API, standalone 사용을 위한 주입 가능한 `DiscordService`, 그리고 Node 전용 Discord SDK를 가정하지 않는 `@fluojs/notifications` 연동용 1st-party `DiscordChannel`을 제공합니다.
+
+## 목차
+
+- [설치](#설치)
+- [사용 시점](#사용-시점)
+- [빠른 시작](#빠른-시작)
+- [일반적인 패턴](#일반적인-패턴)
+  - [`DiscordService`를 이용한 standalone 전달](#discordservice를-이용한-standalone-전달)
+  - [`@fluojs/notifications`와의 통합](#fluojs-notifications와의-통합)
+  - [명시적 fetch 주입을 사용하는 webhook-first 전달](#명시적-fetch-주입을-사용하는-webhook-first-전달)
+  - [의도적인 제한 사항](#의도적인-제한-사항)
+- [공개 API 개요](#공개-api-개요)
+- [관련 패키지](#관련-패키지)
+- [예제 소스](#예제-소스)
+
+## 설치
+
+```bash
+npm install @fluojs/discord @fluojs/notifications
+```
+
+이 패키지는 published package metadata에 반영된 저장소 전반의 Node.js 20+ 설치 baseline을 따르지만, 런타임 전달 계약 자체는 명시적인 fetch-compatible 경계를 통해 계속 transport-agnostic하게 유지됩니다.
+
+## 사용 시점
+
+- Discord 메시지를 직접 보내는 기능과 `@fluojs/notifications` 채널 연동을 한 패키지에서 처리하고 싶을 때.
+- transport 선택을 Node, Bun, Deno, Cloudflare 호환 애플리케이션 경계 전반에서 명시적이고 이식 가능하게 유지해야 할 때.
+- incoming webhook을 기본 경로로 선호하되, 더 풍부한 REST 또는 bot 기반 연동은 커스텀 transport 계약으로 열어 두고 싶을 때.
+- 설정을 패키지 내부 `process.env` 접근이 아니라 DI 또는 명시적인 옵션으로 주입하고 싶을 때.
+
+## 빠른 시작
+
+### 모듈 등록
+
+```typescript
+import { Module } from '@fluojs/core';
+import { DiscordModule, createDiscordWebhookTransport } from '@fluojs/discord';
+
+@Module({
+  imports: [
+    DiscordModule.forRoot({
+      defaultThreadId: 'release-thread-id',
+      transport: createDiscordWebhookTransport({
+        fetch: globalThis.fetch.bind(globalThis),
+        webhookUrl: 'https://discord.com/api/webhooks/123/abc',
+      }),
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### 직접 Discord 메시지 보내기
+
+```typescript
+import { Inject } from '@fluojs/core';
+import { DiscordService } from '@fluojs/discord';
+
+export class DeployNotifier {
+  constructor(@Inject(DiscordService) private readonly discord: DiscordService) {}
+
+  async announce(version: string) {
+    await this.discord.send({
+      content: `Deploy ${version} finished successfully.`,
+    });
+  }
+}
+```
+
+## 일반적인 패턴
+
+### `DiscordService`를 이용한 standalone 전달
+
+notifications foundation을 거치지 않고 직접 Discord 전달을 하고 싶다면 `DiscordService`를 사용합니다.
+
+```typescript
+DiscordModule.forRootAsync({
+  inject: [ConfigService],
+  useFactory: (config) => ({
+    defaultThreadId: config.discord.defaultThreadId,
+    transport: createDiscordWebhookTransport({
+      fetch: config.runtime.fetch,
+      webhookUrl: config.discord.webhookUrl,
+    }),
+  }),
+});
+```
+
+Behavioral contract 메모:
+
+- `DiscordService.send(...)`는 전달 전에 `defaultThreadId`를 해석합니다.
+- 서비스는 모듈 bootstrap 시 transport를 초기화하고, factory가 소유한 리소스만 애플리케이션 shutdown 시 닫습니다.
+- 이 패키지는 절대로 `process.env`를 직접 읽지 않습니다. 모든 설정은 명시적인 옵션 또는 DI를 통해 들어와야 합니다.
+
+### `@fluojs/notifications`와의 통합
+
+`DISCORD_CHANNEL`을 `NotificationsModule.forRootAsync(...)`에 주입하여, Discord 전용 payload 필드와 recipient-to-thread 해석 규칙이 모두 `@fluojs/discord` 안에만 남도록 구성합니다.
+
+```typescript
+import { Module } from '@fluojs/core';
+import { NotificationsModule } from '@fluojs/notifications';
+import {
+  DISCORD_CHANNEL,
+  DiscordModule,
+  createDiscordWebhookTransport,
+} from '@fluojs/discord';
+
+@Module({
+  imports: [
+    DiscordModule.forRoot({
+      transport: createDiscordWebhookTransport({
+        fetch: globalThis.fetch.bind(globalThis),
+        webhookUrl: 'https://discord.com/api/webhooks/123/abc',
+      }),
+    }),
+    NotificationsModule.forRootAsync({
+      inject: [DISCORD_CHANNEL],
+      useFactory: (channel) => ({
+        channels: [channel],
+      }),
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+지원하는 notification payload 필드:
+
+- `content`, `embeds`, `components`, `attachments`
+- `allowedMentions`, `username`, `avatarUrl`, `tts`
+- `threadId`, `threadName`, `flags`, `poll`, `metadata`
+
+Behavioral contract 메모:
+
+- 하나의 notification dispatch는 정확히 하나의 Discord thread 경로로 매핑됩니다. `payload.threadId` 또는 `recipients`의 단일 항목을 사용해야 합니다.
+- `payload.threadId`가 없으면 `DiscordService.sendNotification(...)`는 첫 번째 `recipients` 항목을 사용하고, 그것도 없으면 `defaultThreadId`로 폴백합니다.
+- 여러 Discord thread로 fan-out이 필요하다면 하나의 multi-recipient dispatch 대신 `sendMany(...)`를 사용해야 합니다.
+
+### 명시적 fetch 주입을 사용하는 webhook-first 전달
+
+런타임에 독립적인 1st-party transport가 필요하다면 fetch-compatible HTTP 경계만 의존하는 `createDiscordWebhookTransport(...)`를 사용합니다.
+
+```typescript
+const transport = createDiscordWebhookTransport({
+  fetch: runtime.fetch,
+  webhookUrl: discordWebhookUrl,
+});
+
+await discord.send({
+  content: 'Deploy finished',
+  embeds: [{ description: 'Build 124 succeeded.' }],
+});
+```
+
+bot 기반 REST 전달처럼 더 풍부한 API 연동이 필요하다면 export된 `DiscordTransport` 계약을 구현해 `DiscordModule.forRoot(...)` 또는 `forRootAsync(...)`에 주입하면 됩니다.
+
+Behavioral contract 메모:
+
+- 내장 webhook transport는 `408`, `429`, `5xx` 같은 일시적 실패를 호출자에게 에러를 노출하기 전에 bounded exponential backoff로 재시도합니다.
+- 잘못되었거나 절대 URL이 아닌 `webhookUrl` 값은 전달 실패로 재시도하지 않고 즉시 `DiscordConfigurationError`로 거부됩니다.
+- 호출자에게 보이는 `DiscordTransportError` 메시지는 기본적으로 raw upstream response body를 포함하지 않습니다.
+
+### 의도적인 제한 사항
+
+Discord 패키지는 의도적으로 다음을 **포함하지 않습니다**:
+
+- 자격 증명이나 webhook URL을 `process.env`에서 직접 읽는 동작
+- 공유 루트 패키지 경계에 Node 전용 Discord SDK를 내장하는 것
+- webhook helper와 export된 transport 계약 이상으로 하나의 provider 전략을 강제하는 것
+- 하나의 dispatch 호출 안에서 multi-thread fan-out을 자동 변환하는 것
+
+이 제한 사항은 런타임 선택, provider capability, rollout 전략이 애플리케이션 경계에서 명시적으로 결정되도록 하기 위한 package contract의 일부입니다.
+
+## 공개 API 개요
+
+### 핵심
+
+- `DiscordModule.forRoot(options)` / `DiscordModule.forRootAsync(options)`
+- `DiscordService`
+- `DiscordChannel`
+- `DISCORD`
+- `DISCORD_CHANNEL`
+
+애플리케이션 구성은 `DiscordModule`로, notifications 연동은 `DISCORD_CHANNEL`과 export된 transport 계약으로 조합합니다.
+
+### 계약과 헬퍼
+
+- `DiscordMessage`
+- `DiscordTransport`
+- `DiscordTransportFactory`
+- `DiscordTemplateRenderer`
+- `createDiscordWebhookTransport(options)`
+
+### 상태 및 에러
+
+- `createDiscordPlatformStatusSnapshot(...)`
+- `DiscordConfigurationError`
+- `DiscordMessageValidationError`
+- `DiscordTransportError`
+
+## 관련 패키지
+
+- `@fluojs/notifications`: `DISCORD_CHANNEL`을 소비하는 공통 오케스트레이션 계층입니다.
+- `@fluojs/config`: 환경 직접 접근 없이 webhook URL이나 thread id를 해석하려는 경우 권장됩니다.
+- `@fluojs/event-bus`: Discord 알림이 여러 이벤트 기반 부작용 중 하나일 때 유용합니다.
+
+## 예제 소스
+
+- `packages/discord/src/module.test.ts`: 모듈 등록, async wiring, webhook transport, notifications integration 예제.
+- `packages/discord/src/public-surface.test.ts`: 공개 export와 TypeScript 계약 검증 예제.
+- `packages/discord/src/status.test.ts`: health/readiness 계약 예제.

package/README.md

@@ -0,0 +1,216 @@
+# @fluojs/discord
+
+<p><strong><kbd>English</kbd></strong> <a href="./README.ko.md"><kbd>한국어</kbd></a></p>
+
+Webhook-first, transport-agnostic Discord delivery core for fluo. It provides a Nest-like module API, an injectable `DiscordService` for standalone usage, and a first-party `DiscordChannel` for `@fluojs/notifications` integration without assuming a Node-only Discord SDK.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [When to Use](#when-to-use)
+- [Quick Start](#quick-start)
+- [Common Patterns](#common-patterns)
+  - [Standalone delivery with `DiscordService`](#standalone-delivery-with-discordservice)
+  - [Integration with `@fluojs/notifications`](#integration-with-fluojs-notifications)
+  - [Webhook-first delivery with explicit fetch injection](#webhook-first-delivery-with-explicit-fetch-injection)
+  - [Intentional limitations](#intentional-limitations)
+- [Public API Overview](#public-api-overview)
+- [Related Packages](#related-packages)
+- [Example Sources](#example-sources)
+
+## Installation
+
+```bash
+npm install @fluojs/discord @fluojs/notifications
+```
+
+This package follows the repo-wide Node.js 20+ install baseline reflected in published package metadata, while keeping its delivery contract transport-agnostic at runtime through explicit fetch-compatible boundaries.
+
+## When to Use
+
+- When you want one package that can send Discord messages directly and also plug into `@fluojs/notifications`.
+- When transport choice must stay explicit and portable across Node, Bun, Deno, and Cloudflare-compatible application boundaries.
+- When Discord delivery should prefer incoming webhooks while still allowing richer REST or bot-backed integrations through a custom transport contract.
+- When configuration must enter through DI or explicit options instead of `process.env` reads inside the package.
+
+## Quick Start
+
+### Register the module
+
+```typescript
+import { Module } from '@fluojs/core';
+import { DiscordModule, createDiscordWebhookTransport } from '@fluojs/discord';
+
+@Module({
+  imports: [
+    DiscordModule.forRoot({
+      defaultThreadId: 'release-thread-id',
+      transport: createDiscordWebhookTransport({
+        fetch: globalThis.fetch.bind(globalThis),
+        webhookUrl: 'https://discord.com/api/webhooks/123/abc',
+      }),
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### Send Discord messages directly
+
+```typescript
+import { Inject } from '@fluojs/core';
+import { DiscordService } from '@fluojs/discord';
+
+export class DeployNotifier {
+  constructor(@Inject(DiscordService) private readonly discord: DiscordService) {}
+
+  async announce(version: string) {
+    await this.discord.send({
+      content: `Deploy ${version} finished successfully.`,
+    });
+  }
+}
+```
+
+## Common Patterns
+
+### Standalone delivery with `DiscordService`
+
+Use `DiscordService` when your application wants direct Discord delivery without routing through the notifications foundation.
+
+```typescript
+DiscordModule.forRootAsync({
+  inject: [ConfigService],
+  useFactory: (config) => ({
+    defaultThreadId: config.discord.defaultThreadId,
+    transport: createDiscordWebhookTransport({
+      fetch: config.runtime.fetch,
+      webhookUrl: config.discord.webhookUrl,
+    }),
+  }),
+});
+```
+
+Behavioral contract notes:
+
+- `DiscordService.send(...)` resolves `defaultThreadId` before delivery.
+- The service initializes the configured transport during module bootstrap and closes factory-owned resources during application shutdown.
+- The package never reads `process.env` directly. All configuration must enter through explicit options or DI.
+
+### Integration with `@fluojs/notifications`
+
+Inject `DISCORD_CHANNEL` into `NotificationsModule.forRootAsync(...)` so the Discord package remains the only place that understands Discord-specific payload fields and recipient-to-thread translation.
+
+```typescript
+import { Module } from '@fluojs/core';
+import { NotificationsModule } from '@fluojs/notifications';
+import {
+  DISCORD_CHANNEL,
+  DiscordModule,
+  createDiscordWebhookTransport,
+} from '@fluojs/discord';
+
+@Module({
+  imports: [
+    DiscordModule.forRoot({
+      transport: createDiscordWebhookTransport({
+        fetch: globalThis.fetch.bind(globalThis),
+        webhookUrl: 'https://discord.com/api/webhooks/123/abc',
+      }),
+    }),
+    NotificationsModule.forRootAsync({
+      inject: [DISCORD_CHANNEL],
+      useFactory: (channel) => ({
+        channels: [channel],
+      }),
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+Supported notification payload fields:
+
+- `content`, `embeds`, `components`, `attachments`
+- `allowedMentions`, `username`, `avatarUrl`, `tts`
+- `threadId`, `threadName`, `flags`, `poll`, `metadata`
+
+Behavioral contract notes:
+
+- One notification dispatch maps to exactly one Discord thread route. Use `payload.threadId` or a single entry in `recipients`.
+- If `payload.threadId` is omitted, `DiscordService.sendNotification(...)` uses the first `recipients` entry or falls back to `defaultThreadId`.
+- If a notification needs fan-out across multiple Discord threads, call `sendMany(...)` instead of one multi-recipient dispatch.
+
+### Webhook-first delivery with explicit fetch injection
+
+Use `createDiscordWebhookTransport(...)` when you want a portable first-party transport that only depends on a fetch-compatible HTTP boundary.
+
+```typescript
+const transport = createDiscordWebhookTransport({
+  fetch: runtime.fetch,
+  webhookUrl: discordWebhookUrl,
+});
+
+await discord.send({
+  content: 'Deploy finished',
+  embeds: [{ description: 'Build 124 succeeded.' }],
+});
+```
+
+For richer API integrations such as bot-backed REST delivery, implement the exported `DiscordTransport` contract and inject it through `DiscordModule.forRoot(...)` or `forRootAsync(...)`.
+
+Behavioral contract notes:
+
+- The built-in webhook transport retries transient `408`, `429`, and `5xx` failures with bounded exponential backoff before surfacing an error.
+- Malformed or non-absolute `webhookUrl` values are rejected immediately as `DiscordConfigurationError` instead of being retried as delivery failures.
+- Caller-visible `DiscordTransportError` messages omit raw upstream response bodies by default.
+
+### Intentional limitations
+
+The Discord package intentionally does **not**:
+
+- read credentials or webhook URLs from `process.env`
+- ship a Node-only Discord SDK inside the shared root package boundary
+- force one provider strategy beyond the webhook-first helper and exported transport contract
+- translate one notification into multi-thread fan-out inside a single dispatch call
+
+These limitations are part of the package contract so runtime choice, provider capability, and rollout strategy stay explicit at the application boundary.
+
+## Public API Overview
+
+### Core
+
+- `DiscordModule.forRoot(options)` / `DiscordModule.forRootAsync(options)`
+- `DiscordService`
+- `DiscordChannel`
+- `DISCORD`
+- `DISCORD_CHANNEL`
+
+Compose applications through `DiscordModule` and integrate notifications through `DISCORD_CHANNEL` plus the exported transport contracts.
+
+### Contracts and helpers
+
+- `DiscordMessage`
+- `DiscordTransport`
+- `DiscordTransportFactory`
+- `DiscordTemplateRenderer`
+- `createDiscordWebhookTransport(options)`
+
+### Status and errors
+
+- `createDiscordPlatformStatusSnapshot(...)`
+- `DiscordConfigurationError`
+- `DiscordMessageValidationError`
+- `DiscordTransportError`
+
+## Related Packages
+
+- `@fluojs/notifications`: Shared orchestration layer that consumes `DISCORD_CHANNEL`.
+- `@fluojs/config`: Recommended for resolving webhook URLs or thread ids without direct environment access.
+- `@fluojs/event-bus`: Useful when Discord notifications are one side effect among several event-driven workflows.
+
+## Example Sources
+
+- `packages/discord/src/module.test.ts`: Module registration, async wiring, webhook transport, and notifications integration examples.
+- `packages/discord/src/public-surface.test.ts`: Public export and TypeScript contract verification.
+- `packages/discord/src/status.test.ts`: Health/readiness contract examples.

package/dist/channel.d.ts

@@ -0,0 +1,24 @@
+import type { NotificationChannel, NotificationChannelContext, NotificationChannelDelivery } from '@fluojs/notifications';
+import { DiscordService } from './service.js';
+import type { DiscordNotificationDispatchRequest, DiscordSendResult, NormalizedDiscordModuleOptions } from './types.js';
+/**
+ * Notification channel implementation that bridges `@fluojs/notifications` to {@link DiscordService}.
+ *
+ * @remarks
+ * This class keeps the foundation package channel-agnostic while allowing `@fluojs/discord`
+ * to interpret Discord-specific payload fields, webhook delivery, and transport behavior.
+ */
+export declare class DiscordChannel implements NotificationChannel<DiscordNotificationDispatchRequest, DiscordSendResult> {
+    private readonly discord;
+    readonly channel: string;
+    constructor(discord: DiscordService, options: NormalizedDiscordModuleOptions);
+    /**
+     * Sends one notifications foundation request through the configured Discord transport.
+     *
+     * @param notification Shared notification envelope understood by the Discord package.
+     * @param context Optional abort context propagated from the notifications service.
+     * @returns A normalized channel delivery result with the provider message id exposed as `externalId` when available.
+     */
+    send(notification: DiscordNotificationDispatchRequest, context: NotificationChannelContext): Promise<NotificationChannelDelivery<DiscordSendResult>>;
+}
+//# sourceMappingURL=channel.d.ts.map

package/dist/channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../src/channel.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAC;AAG1H,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,KAAK,EAAE,kCAAkC,EAAE,iBAAiB,EAAE,8BAA8B,EAAE,MAAM,YAAY,CAAC;AAExH;;;;;;GAMG;AACH,qBACa,cAAe,YAAW,mBAAmB,CAAC,kCAAkC,EAAE,iBAAiB,CAAC;IAI7G,OAAO,CAAC,QAAQ,CAAC,OAAO;IAH1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAGN,OAAO,EAAE,cAAc,EACxC,OAAO,EAAE,8BAA8B;IAKzC;;;;;;OAMG;IACG,IAAI,CACR,YAAY,EAAE,kCAAkC,EAChD,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,2BAA2B,CAAC,iBAAiB,CAAC,CAAC;CAqB3D"}

package/dist/channel.js

@@ -0,0 +1,61 @@
+let _initClass;
+function _applyDecs(e, t, n, r, o, i) { var a, c, u, s, f, l, p, d = Symbol.metadata || Symbol.for("Symbol.metadata"), m = Object.defineProperty, h = Object.create, y = [h(null), h(null)], v = t.length; function g(t, n, r) { return function (o, i) { n && (i = o, o = e); for (var a = 0; a < t.length; a++) i = t[a].apply(o, r ? [i] : []); return r ? i : o; }; } function b(e, t, n, r) { if ("function" != typeof e && (r || void 0 !== e)) throw new TypeError(t + " must " + (n || "be") + " a function" + (r ? "" : " or undefined")); return e; } function applyDec(e, t, n, r, o, i, u, s, f, l, p) { function d(e) { if (!p(e)) throw new TypeError("Attempted to access private element on non-instance"); } var h = [].concat(t[0]), v = t[3], w = !u, D = 1 === o, S = 3 === o, j = 4 === o, E = 2 === o; function I(t, n, r) { return function (o, i) { return n && (i = o, o = e), r && r(o), P[t].call(o, i); }; } if (!w) { var P = {}, k = [], F = S ? "get" : j || D ? "set" : "value"; if (f ? (l || D ? P = { get: _setFunctionName(function () { return v(this); }, r, "get"), set: function (e) { t[4](this, e); } } : P[F] = v, l || _setFunctionName(P[F], r, E ? "" : F)) : l || (P = Object.getOwnPropertyDescriptor(e, r)), !l && !f) { if ((c = y[+s][r]) && 7 !== (c ^ o)) throw Error("Decorating two elements with the same name (" + P[F].name + ") is not supported yet"); y[+s][r] = o < 3 ? 1 : o; } } for (var N = e, O = h.length - 1; O >= 0; O -= n ? 2 : 1) { var T = b(h[O], "A decorator", "be", !0), z = n ? h[O - 1] : void 0, A = {}, H = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: r, metadata: a, addInitializer: function (e, t) { if (e.v) throw new TypeError("attempted to call addInitializer after decoration was finished"); b(t, "An initializer", "be", !0), i.push(t); }.bind(null, A) }; if (w) c = T.call(z, N, H), A.v = 1, b(c, "class decorators", "return") && (N = c);else if (H.static = s, H.private = f, c = H.access = { has: f ? p.bind() : function (e) { return r in e; } }, j || (c.get = f ? E ? function (e) { return d(e), P.value; } : I("get", 0, d) : function (e) { return e[r]; }), E || S || (c.set = f ? I("set", 0, d) : function (e, t) { e[r] = t; }), N = T.call(z, D ? { get: P.get, set: P.set } : P[F], H), A.v = 1, D) { if ("object" == typeof N && N) (c = b(N.get, "accessor.get")) && (P.get = c), (c = b(N.set, "accessor.set")) && (P.set = c), (c = b(N.init, "accessor.init")) && k.unshift(c);else if (void 0 !== N) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined"); } else b(N, (l ? "field" : "method") + " decorators", "return") && (l ? k.unshift(N) : P[F] = N); } return o < 2 && u.push(g(k, s, 1), g(i, s, 0)), l || w || (f ? D ? u.splice(-1, 0, I("get", s), I("set", s)) : u.push(E ? P[F] : b.call.bind(P[F])) : m(e, r, P)), N; } function w(e) { return m(e, d, { configurable: !0, enumerable: !0, value: a }); } return void 0 !== i && (a = i[d]), a = h(null == a ? null : a), f = [], l = function (e) { e && f.push(g(e)); }, p = function (t, r) { for (var i = 0; i < n.length; i++) { var a = n[i], c = a[1], l = 7 & c; if ((8 & c) == t && !l == r) { var p = a[2], d = !!a[3], m = 16 & c; applyDec(t ? e : e.prototype, a, m, d ? "#" + p : _toPropertyKey(p), l, l < 2 ? [] : t ? s = s || [] : u = u || [], f, !!t, d, r, t && d ? function (t) { return _checkInRHS(t) === e; } : o); } } }, p(8, 0), p(0, 0), p(8, 1), p(0, 1), l(u), l(s), c = f, v || w(e), { e: c, get c() { var n = []; return v && [w(e = applyDec(e, [t], r, e.name, 5, n)), g(n, 1)]; } }; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; }
+function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; }
+import { Inject } from '@fluojs/core';
+import { DiscordTransportError } from './errors.js';
+import { DiscordService } from './service.js';
+import { DISCORD_OPTIONS } from './tokens.js';
+let _DiscordChannel;
+/**
+ * Notification channel implementation that bridges `@fluojs/notifications` to {@link DiscordService}.
+ *
+ * @remarks
+ * This class keeps the foundation package channel-agnostic while allowing `@fluojs/discord`
+ * to interpret Discord-specific payload fields, webhook delivery, and transport behavior.
+ */
+class DiscordChannel {
+  static {
+    [_DiscordChannel, _initClass] = _applyDecs(this, [Inject(DiscordService, DISCORD_OPTIONS)], []).c;
+  }
+  channel;
+  constructor(discord, options) {
+    this.discord = discord;
+    this.channel = options.notifications.channel;
+  }
+
+  /**
+   * Sends one notifications foundation request through the configured Discord transport.
+   *
+   * @param notification Shared notification envelope understood by the Discord package.
+   * @param context Optional abort context propagated from the notifications service.
+   * @returns A normalized channel delivery result with the provider message id exposed as `externalId` when available.
+   */
+  async send(notification, context) {
+    const receipt = await this.discord.sendNotification(notification, {
+      signal: context.signal
+    });
+    if (receipt.ok === false) {
+      throw new DiscordTransportError('Discord transport reported an unsuccessful delivery.');
+    }
+    return {
+      externalId: receipt.messageId,
+      metadata: {
+        channelId: receipt.channelId,
+        guildId: receipt.guildId,
+        response: receipt.response,
+        statusCode: receipt.statusCode,
+        threadId: receipt.threadId,
+        warnings: receipt.warnings
+      },
+      receipt,
+      status: 'delivered'
+    };
+  }
+  static {
+    _initClass();
+  }
+}
+export { _DiscordChannel as DiscordChannel };

package/dist/errors.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Base error type for caller-visible Discord module configuration failures.
+ */
+export declare class DiscordConfigurationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when a Discord message or notification payload is missing one required contract field.
+ */
+export declare class DiscordMessageValidationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when one concrete Discord transport reports a caller-visible delivery failure.
+ */
+export declare class DiscordTransportError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,KAAK;gBACtC,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,6BAA8B,SAAQ,KAAK;gBAC1C,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;gBAClC,OAAO,EAAE,MAAM;CAI5B"}

package/dist/errors.js

@@ -0,0 +1,29 @@
+/**
+ * Base error type for caller-visible Discord module configuration failures.
+ */
+export class DiscordConfigurationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'DiscordConfigurationError';
+  }
+}
+
+/**
+ * Thrown when a Discord message or notification payload is missing one required contract field.
+ */
+export class DiscordMessageValidationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'DiscordMessageValidationError';
+  }
+}
+
+/**
+ * Thrown when one concrete Discord transport reports a caller-visible delivery failure.
+ */
+export class DiscordTransportError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'DiscordTransportError';
+  }
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { DiscordConfigurationError, DiscordMessageValidationError, DiscordTransportError, } from './errors.js';
+export { DiscordChannel } from './channel.js';
+export { DiscordModule } from './module.js';
+export { DiscordService } from './service.js';
+export { createDiscordPlatformStatusSnapshot } from './status.js';
+export type { DiscordLifecycleState, DiscordPlatformStatusSnapshot, DiscordStatusAdapterInput } from './status.js';
+export { DISCORD, DISCORD_CHANNEL } from './tokens.js';
+export type { Discord, DiscordAllowedMentions, DiscordAsyncModuleOptions, DiscordAttachment, DiscordComponent, DiscordEmbed, DiscordFetchLike, DiscordFetchResponse, DiscordMessage, DiscordModuleOptions, DiscordNotificationDispatchRequest, DiscordNotificationPayload, DiscordPoll, DiscordSendBatchResult, DiscordSendFailure, DiscordSendManyOptions, DiscordSendOptions, DiscordSendResult, DiscordTemplateRenderInput, DiscordTemplateRenderer, DiscordTemplateRenderResult, DiscordTransport, DiscordTransportContext, DiscordTransportFactory, DiscordTransportReceipt, DiscordWebhookTransportOptions, NormalizedDiscordMessage, } from './types.js';
+export { createDiscordWebhookTransport } from './webhook.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EACzB,6BAA6B,EAC7B,qBAAqB,GACtB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,mCAAmC,EAAE,MAAM,aAAa,CAAC;AAClE,YAAY,EAAE,qBAAqB,EAAE,6BAA6B,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AACnH,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACvD,YAAY,EACV,OAAO,EACP,sBAAsB,EACtB,yBAAyB,EACzB,iBAAiB,EACjB,gBAAgB,EAChB,YAAY,EACZ,gBAAgB,EAChB,oBAAoB,EACpB,cAAc,EACd,oBAAoB,EACpB,kCAAkC,EAClC,0BAA0B,EAC1B,WAAW,EACX,sBAAsB,EACtB,kBAAkB,EAClB,sBAAsB,EACtB,kBAAkB,EAClB,iBAAiB,EACjB,0BAA0B,EAC1B,uBAAuB,EACvB,2BAA2B,EAC3B,gBAAgB,EAChB,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,EACvB,8BAA8B,EAC9B,wBAAwB,GACzB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,6BAA6B,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export { DiscordConfigurationError, DiscordMessageValidationError, DiscordTransportError } from './errors.js';
+export { DiscordChannel } from './channel.js';
+export { DiscordModule } from './module.js';
+export { DiscordService } from './service.js';
+export { createDiscordPlatformStatusSnapshot } from './status.js';
+export { DISCORD, DISCORD_CHANNEL } from './tokens.js';
+export { createDiscordWebhookTransport } from './webhook.js';

package/dist/module.d.ts

@@ -0,0 +1,41 @@
+import { type ModuleType } from '@fluojs/runtime';
+import type { DiscordAsyncModuleOptions, DiscordModuleOptions } from './types.js';
+/** Runtime module entrypoint for Discord delivery and notifications integration. */
+export declare class DiscordModule {
+    /**
+     * Registers Discord providers using static options.
+     *
+     * @param options Static Discord module options including transport wiring and optional template rendering behavior.
+     * @returns A global module definition that exports {@link DiscordService}, {@link DiscordChannel}, and compatibility tokens.
+     *
+     * @example
+     * ```ts
+     * DiscordModule.forRoot({
+     *   transport: createDiscordWebhookTransport({ webhookUrl: 'https://discord.com/api/webhooks/...' }),
+     * });
+     * ```
+     */
+    static forRoot(options: DiscordModuleOptions): ModuleType;
+    /**
+     * Registers Discord providers from an async DI factory.
+     *
+     * @param options Async module options that resolve Discord transport and renderer configuration through DI.
+     * @returns A global module definition that memoizes async option resolution per module instance.
+     *
+     * @example
+     * ```ts
+     * DiscordModule.forRootAsync({
+     *   inject: [ConfigService],
+     *   useFactory: (config) => ({
+     *     defaultThreadId: config.discord.threadId,
+     *     transport: createDiscordWebhookTransport({
+     *       fetch: config.runtime.fetch,
+     *       webhookUrl: config.discord.webhookUrl,
+     *     }),
+     *   }),
+     * });
+     * ```
+     */
+    static forRootAsync(options: DiscordAsyncModuleOptions): ModuleType;
+}
+//# sourceMappingURL=module.d.ts.map