@fluojs/slack 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,246 @@
+# @fluojs/slack
+
+<p><a href="./README.md"><kbd>English</kbd></a> <strong><kbd>한국어</kbd></strong></p>
+
+fluo를 위한 webhook-first, transport-agnostic Slack 전달 코어 패키지입니다. Nest-like 모듈 API, standalone 사용을 위한 주입 가능한 `SlackService`, 그리고 Node 전용 SDK를 가정하지 않는 `@fluojs/notifications` 연동용 1st-party `SlackChannel`을 제공합니다.
+
+## 목차
+
+- [설치](#설치)
+- [사용 시점](#사용-시점)
+- [빠른 시작](#빠른-시작)
+- [일반적인 패턴](#일반적인-패턴)
+  - [`createSlackProviders`를 이용한 수동 provider 조합](#createslackproviders를-이용한-수동-provider-조합)
+  - [`SlackService`를 이용한 standalone 전달](#slackservice를-이용한-standalone-전달)
+  - [`@fluojs/notifications`와의 통합](#fluojs-notifications와의-통합)
+  - [명시적 fetch 주입을 사용하는 webhook-first 전달](#명시적-fetch-주입을-사용하는-webhook-first-전달)
+  - [의도적인 제한 사항](#의도적인-제한-사항)
+- [공개 API 개요](#공개-api-개요)
+- [관련 패키지](#관련-패키지)
+- [예제 소스](#예제-소스)
+
+## 설치
+
+```bash
+npm install @fluojs/slack @fluojs/notifications
+```
+
+이 패키지는 published package metadata에 반영된 저장소 전반의 Node.js 20+ 설치 baseline을 따르지만, 런타임 전달 계약 자체는 명시적인 fetch-compatible 경계를 통해 계속 transport-agnostic하게 유지됩니다.
+
+## 사용 시점
+
+- Slack 메시지를 직접 보내는 기능과 `@fluojs/notifications` 채널 연동을 한 패키지에서 처리하고 싶을 때.
+- transport 선택을 Node, Bun, Deno, Cloudflare 호환 애플리케이션 경계 전반에서 명시적이고 이식 가능하게 유지해야 할 때.
+- incoming webhook을 기본 경로로 선호하되, 더 풍부한 API 연동은 커스텀 transport 계약으로 열어 두고 싶을 때.
+- 설정을 패키지 내부 `process.env` 접근이 아니라 DI 또는 명시적인 옵션으로 주입하고 싶을 때.
+
+## 빠른 시작
+
+### 모듈 등록
+
+```typescript
+import { Module } from '@fluojs/core';
+import { SlackModule, createSlackWebhookTransport } from '@fluojs/slack';
+
+@Module({
+  imports: [
+    SlackModule.forRoot({
+      defaultChannel: '#ops',
+      transport: createSlackWebhookTransport({
+        fetch: globalThis.fetch.bind(globalThis),
+        webhookUrl: 'https://hooks.slack.com/services/T000/B000/XXXX',
+      }),
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### 직접 Slack 메시지 보내기
+
+```typescript
+import { Inject } from '@fluojs/core';
+import { SlackService } from '@fluojs/slack';
+
+export class DeployNotifier {
+  constructor(@Inject(SlackService) private readonly slack: SlackService) {}
+
+  async announce(version: string) {
+    await this.slack.send({
+      text: `Deploy ${version} finished successfully.`,
+    });
+  }
+}
+```
+
+## 일반적인 패턴
+
+### `createSlackProviders`를 이용한 수동 provider 조합
+
+`createSlackProviders(...)`는 애플리케이션이 `SlackModule.forRoot(...)` 밖에서 동일한 provider 정규화 구성을 재사용해야 할 때 지원되는 manual-composition helper입니다.
+
+```typescript
+import { Module } from '@fluojs/core';
+import { createSlackProviders, createSlackWebhookTransport } from '@fluojs/slack';
+
+@Module({
+  providers: [
+    ...createSlackProviders({
+      defaultChannel: '#ops',
+      notifications: { channel: 'alerts' },
+      transport: createSlackWebhookTransport({
+        fetch: globalThis.fetch.bind(globalThis),
+        webhookUrl: 'https://hooks.slack.com/services/T000/B000/XXXX',
+      }),
+    }),
+  ],
+  exports: [],
+})
+export class SlackProvidersModule {}
+```
+
+Behavioral contract 메모:
+
+- 이 helper는 `SlackModule.forRoot(...)`가 구성하는 `SLACK`, `SLACK_CHANNEL`, `SlackService` wiring을 동일하게 유지합니다.
+- `createSlackProviders(...)`는 trim된 기본 채널, notification 채널 fallback, transport 소유권 기본값을 포함해 `SlackModule.forRoot(...)`와 동일한 옵션 정규화를 적용합니다.
+- 이 helper도 여전히 명시적인 `transport`를 요구하며, 패키지의 runtime-portable·no-implicit-env 계약을 약화시키지 않습니다.
+
+### `SlackService`를 이용한 standalone 전달
+
+notifications foundation을 거치지 않고 직접 Slack 전달을 하고 싶다면 `SlackService`를 사용합니다.
+
+```typescript
+SlackModule.forRootAsync({
+  inject: [ConfigService],
+  useFactory: (config) => ({
+    defaultChannel: config.slack.defaultChannel,
+    transport: createSlackWebhookTransport({
+      fetch: config.runtime.fetch,
+      webhookUrl: config.slack.webhookUrl,
+    }),
+  }),
+});
+```
+
+Behavioral contract 메모:
+
+- `SlackService.send(...)`는 전달 전에 `defaultChannel`을 해석합니다.
+- 서비스는 모듈 bootstrap 시 transport를 초기화하고, factory가 소유한 리소스만 애플리케이션 shutdown 시 닫습니다.
+- 이 패키지는 절대로 `process.env`를 직접 읽지 않습니다. 모든 설정은 명시적인 옵션 또는 DI를 통해 들어와야 합니다.
+
+### `@fluojs/notifications`와의 통합
+
+`SLACK_CHANNEL`을 `NotificationsModule.forRootAsync(...)`에 주입하여, Slack 전용 payload 필드와 recipient-to-channel 해석 규칙이 모두 `@fluojs/slack` 안에만 남도록 구성합니다.
+
+```typescript
+import { Module } from '@fluojs/core';
+import { NotificationsModule } from '@fluojs/notifications';
+import {
+  SLACK_CHANNEL,
+  SlackModule,
+  createSlackWebhookTransport,
+} from '@fluojs/slack';
+
+@Module({
+  imports: [
+    SlackModule.forRoot({
+      transport: createSlackWebhookTransport({
+        fetch: globalThis.fetch.bind(globalThis),
+        webhookUrl: 'https://hooks.slack.com/services/T000/B000/XXXX',
+      }),
+    }),
+    NotificationsModule.forRootAsync({
+      inject: [SLACK_CHANNEL],
+      useFactory: (channel) => ({
+        channels: [channel],
+      }),
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+지원하는 notification payload 필드:
+
+- `text`, `blocks`, `attachments`
+- `channel`, `threadTs`, `replyBroadcast`
+- `username`, `iconEmoji`, `iconUrl`
+- `mrkdwn`, `unfurlLinks`, `unfurlMedia`, `metadata`
+
+Behavioral contract 메모:
+
+- 하나의 notification dispatch는 정확히 하나의 Slack 대상지로 매핑됩니다. `payload.channel` 또는 `recipients`의 단일 항목을 사용해야 합니다.
+- `payload.channel`이 없으면 `SlackService.sendNotification(...)`는 첫 번째 `recipients` 항목을 사용하고, 그것도 없으면 `defaultChannel`로 폴백합니다.
+- 여러 Slack 대상지로 fan-out이 필요하다면 하나의 multi-recipient dispatch 대신 `sendMany(...)`를 사용해야 합니다.
+
+### 명시적 fetch 주입을 사용하는 webhook-first 전달
+
+런타임에 독립적인 1st-party transport가 필요하다면 fetch-compatible HTTP 경계만 의존하는 `createSlackWebhookTransport(...)`를 사용합니다.
+
+```typescript
+const transport = createSlackWebhookTransport({
+  fetch: runtime.fetch,
+  webhookUrl: slackWebhookUrl,
+});
+
+await slack.send({
+  blocks: [{ type: 'section', text: { type: 'mrkdwn', text: '*Deploy finished*' } }],
+  text: 'Deploy finished',
+});
+```
+
+`chat.postMessage` 같은 더 풍부한 API 연동이 필요하다면 export된 `SlackTransport` 계약을 구현해 `SlackModule.forRoot(...)` 또는 `forRootAsync(...)`에 주입하면 됩니다.
+
+Behavioral contract 메모:
+
+- 내장 webhook transport는 `408`, `429`, `5xx` 같은 일시적 실패를 호출자에게 에러를 노출하기 전에 bounded exponential backoff로 재시도합니다.
+- 호출자에게 보이는 `SlackTransportError` 메시지는 기본적으로 raw upstream response body를 포함하지 않습니다.
+
+### 의도적인 제한 사항
+
+Slack 패키지는 의도적으로 다음을 **포함하지 않습니다**:
+
+- 자격 증명이나 webhook URL을 `process.env`에서 직접 읽는 동작
+- 공유 루트 패키지 경계에 Node 전용 Slack SDK를 내장하는 것
+- webhook helper와 export된 transport 계약 이상으로 하나의 provider 전략을 강제하는 것
+- 하나의 dispatch 호출 안에서 multi-channel fan-out을 자동 변환하는 것
+
+이 제한 사항은 런타임 선택, provider capability, rollout 전략이 애플리케이션 경계에서 명시적으로 결정되도록 하기 위한 package contract의 일부입니다.
+
+## 공개 API 개요
+
+### 핵심
+
+- `SlackModule.forRoot(options)` / `SlackModule.forRootAsync(options)`
+- `createSlackProviders(options)`
+- `SlackService`
+- `SlackChannel`
+- `SLACK`
+- `SLACK_CHANNEL`
+
+### 계약과 헬퍼
+
+- `SlackMessage`
+- `SlackTransport`
+- `SlackTransportFactory`
+- `SlackTemplateRenderer`
+- `createSlackWebhookTransport(options)`
+
+### 상태 및 에러
+
+- `createSlackPlatformStatusSnapshot(...)`
+- `SlackConfigurationError`
+- `SlackMessageValidationError`
+- `SlackTransportError`
+
+## 관련 패키지
+
+- `@fluojs/notifications`: `SLACK_CHANNEL`을 소비하는 공통 오케스트레이션 계층입니다.
+- `@fluojs/config`: 환경 직접 접근 없이 webhook URL이나 토큰을 해석하려는 경우 권장됩니다.
+- `@fluojs/event-bus`: Slack 알림이 여러 이벤트 기반 부작용 중 하나일 때 유용합니다.
+
+## 예제 소스
+
+- `packages/slack/src/module.test.ts`: 모듈 등록, `createSlackProviders(...)` helper coverage, async wiring, webhook transport, notifications integration 예제.
+- `packages/slack/src/public-surface.test.ts`: 공개 export와 TypeScript 계약 검증 예제.
+- `packages/slack/src/status.test.ts`: health/readiness 계약 예제.

package/README.md

@@ -0,0 +1,246 @@
+# @fluojs/slack
+
+<p><strong><kbd>English</kbd></strong> <a href="./README.ko.md"><kbd>한국어</kbd></a></p>
+
+Webhook-first, transport-agnostic Slack delivery core for fluo. It provides a Nest-like module API, an injectable `SlackService` for standalone usage, and a first-party `SlackChannel` for `@fluojs/notifications` integration without assuming a Node-only SDK.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [When to Use](#when-to-use)
+- [Quick Start](#quick-start)
+- [Common Patterns](#common-patterns)
+  - [Manual provider composition with `createSlackProviders`](#manual-provider-composition-with-createslackproviders)
+  - [Standalone delivery with `SlackService`](#standalone-delivery-with-slackservice)
+  - [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/slack @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 Slack 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 Slack delivery should prefer incoming webhooks while still allowing richer API 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 { SlackModule, createSlackWebhookTransport } from '@fluojs/slack';
+
+@Module({
+  imports: [
+    SlackModule.forRoot({
+      defaultChannel: '#ops',
+      transport: createSlackWebhookTransport({
+        fetch: globalThis.fetch.bind(globalThis),
+        webhookUrl: 'https://hooks.slack.com/services/T000/B000/XXXX',
+      }),
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### Send Slack messages directly
+
+```typescript
+import { Inject } from '@fluojs/core';
+import { SlackService } from '@fluojs/slack';
+
+export class DeployNotifier {
+  constructor(@Inject(SlackService) private readonly slack: SlackService) {}
+
+  async announce(version: string) {
+    await this.slack.send({
+      text: `Deploy ${version} finished successfully.`,
+    });
+  }
+}
+```
+
+## Common Patterns
+
+### Manual provider composition with `createSlackProviders`
+
+`createSlackProviders(...)` is the supported manual-composition helper when applications need the same provider normalization outside `SlackModule.forRoot(...)`.
+
+```typescript
+import { Module } from '@fluojs/core';
+import { createSlackProviders, createSlackWebhookTransport } from '@fluojs/slack';
+
+@Module({
+  providers: [
+    ...createSlackProviders({
+      defaultChannel: '#ops',
+      notifications: { channel: 'alerts' },
+      transport: createSlackWebhookTransport({
+        fetch: globalThis.fetch.bind(globalThis),
+        webhookUrl: 'https://hooks.slack.com/services/T000/B000/XXXX',
+      }),
+    }),
+  ],
+  exports: [],
+})
+export class SlackProvidersModule {}
+```
+
+Behavioral contract notes:
+
+- The helper preserves the same `SLACK`, `SLACK_CHANNEL`, and `SlackService` wiring that `SlackModule.forRoot(...)` installs.
+- `createSlackProviders(...)` applies the same option normalization as `SlackModule.forRoot(...)`, including trimmed default channels, notification channel fallback, and transport ownership defaults.
+- The helper still requires an explicit `transport`; it does not weaken the package's runtime-portable, no-implicit-env contract.
+
+### Standalone delivery with `SlackService`
+
+Use `SlackService` when your application wants direct Slack delivery without routing through the notifications foundation.
+
+```typescript
+SlackModule.forRootAsync({
+  inject: [ConfigService],
+  useFactory: (config) => ({
+    defaultChannel: config.slack.defaultChannel,
+    transport: createSlackWebhookTransport({
+      fetch: config.runtime.fetch,
+      webhookUrl: config.slack.webhookUrl,
+    }),
+  }),
+});
+```
+
+Behavioral contract notes:
+
+- `SlackService.send(...)` resolves `defaultChannel` 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 `SLACK_CHANNEL` into `NotificationsModule.forRootAsync(...)` so the Slack package remains the only place that understands Slack-specific payload fields and recipient-to-channel translation.
+
+```typescript
+import { Module } from '@fluojs/core';
+import { NotificationsModule } from '@fluojs/notifications';
+import {
+  SLACK_CHANNEL,
+  SlackModule,
+  createSlackWebhookTransport,
+} from '@fluojs/slack';
+
+@Module({
+  imports: [
+    SlackModule.forRoot({
+      transport: createSlackWebhookTransport({
+        fetch: globalThis.fetch.bind(globalThis),
+        webhookUrl: 'https://hooks.slack.com/services/T000/B000/XXXX',
+      }),
+    }),
+    NotificationsModule.forRootAsync({
+      inject: [SLACK_CHANNEL],
+      useFactory: (channel) => ({
+        channels: [channel],
+      }),
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+Supported notification payload fields:
+
+- `text`, `blocks`, `attachments`
+- `channel`, `threadTs`, `replyBroadcast`
+- `username`, `iconEmoji`, `iconUrl`
+- `mrkdwn`, `unfurlLinks`, `unfurlMedia`, `metadata`
+
+Behavioral contract notes:
+
+- One notification dispatch maps to exactly one Slack destination. Use `payload.channel` or a single entry in `recipients`.
+- If `payload.channel` is omitted, `SlackService.sendNotification(...)` uses the first `recipients` entry or falls back to `defaultChannel`.
+- If a notification needs fan-out across multiple Slack destinations, call `sendMany(...)` instead of one multi-recipient dispatch.
+
+### Webhook-first delivery with explicit fetch injection
+
+Use `createSlackWebhookTransport(...)` when you want a portable first-party transport that only depends on a fetch-compatible HTTP boundary.
+
+```typescript
+const transport = createSlackWebhookTransport({
+  fetch: runtime.fetch,
+  webhookUrl: slackWebhookUrl,
+});
+
+await slack.send({
+  blocks: [{ type: 'section', text: { type: 'mrkdwn', text: '*Deploy finished*' } }],
+  text: 'Deploy finished',
+});
+```
+
+For richer API integrations such as `chat.postMessage`, implement the exported `SlackTransport` contract and inject it through `SlackModule.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.
+- Caller-visible `SlackTransportError` messages omit raw upstream response bodies by default.
+
+### Intentional limitations
+
+The Slack package intentionally does **not**:
+
+- read credentials or webhook URLs from `process.env`
+- ship a Node-only Slack 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-channel 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
+
+- `SlackModule.forRoot(options)` / `SlackModule.forRootAsync(options)`
+- `createSlackProviders(options)`
+- `SlackService`
+- `SlackChannel`
+- `SLACK`
+- `SLACK_CHANNEL`
+
+### Contracts and helpers
+
+- `SlackMessage`
+- `SlackTransport`
+- `SlackTransportFactory`
+- `SlackTemplateRenderer`
+- `createSlackWebhookTransport(options)`
+
+### Status and errors
+
+- `createSlackPlatformStatusSnapshot(...)`
+- `SlackConfigurationError`
+- `SlackMessageValidationError`
+- `SlackTransportError`
+
+## Related Packages
+
+- `@fluojs/notifications`: Shared orchestration layer that consumes `SLACK_CHANNEL`.
+- `@fluojs/config`: Recommended for resolving webhook URLs or tokens without direct environment access.
+- `@fluojs/event-bus`: Useful when Slack notifications are one side effect among several event-driven workflows.
+
+## Example Sources
+
+- `packages/slack/src/module.test.ts`: Module registration, `createSlackProviders(...)` helper coverage, async wiring, webhook transport, and notifications integration examples.
+- `packages/slack/src/public-surface.test.ts`: Public export and TypeScript contract verification.
+- `packages/slack/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 { SlackService } from './service.js';
+import type { NormalizedSlackModuleOptions, SlackNotificationDispatchRequest, SlackSendResult } from './types.js';
+/**
+ * Notification channel implementation that bridges `@fluojs/notifications` to {@link SlackService}.
+ *
+ * @remarks
+ * This class keeps the foundation package channel-agnostic while allowing `@fluojs/slack`
+ * to interpret Slack-specific payload fields, webhook delivery, and transport behavior.
+ */
+export declare class SlackChannel implements NotificationChannel<SlackNotificationDispatchRequest, SlackSendResult> {
+    private readonly slack;
+    readonly channel: string;
+    constructor(slack: SlackService, options: NormalizedSlackModuleOptions);
+    /**
+     * Sends one notifications foundation request through the configured Slack transport.
+     *
+     * @param notification Shared notification envelope understood by the Slack package.
+     * @param context Optional abort context propagated from the notifications service.
+     * @returns A normalized channel delivery result with the provider message timestamp exposed as `externalId` when available.
+     */
+    send(notification: SlackNotificationDispatchRequest, context: NotificationChannelContext): Promise<NotificationChannelDelivery<SlackSendResult>>;
+}
+//# 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,YAAY,EAAE,MAAM,cAAc,CAAC;AAE5C,OAAO,KAAK,EAAE,4BAA4B,EAAE,gCAAgC,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElH;;;;;;GAMG;AACH,qBACa,YAAa,YAAW,mBAAmB,CAAC,gCAAgC,EAAE,eAAe,CAAC;IAIvG,OAAO,CAAC,QAAQ,CAAC,KAAK;IAHxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAGN,KAAK,EAAE,YAAY,EACpC,OAAO,EAAE,4BAA4B;IAKvC;;;;;;OAMG;IACG,IAAI,CACR,YAAY,EAAE,gCAAgC,EAC9C,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,2BAA2B,CAAC,eAAe,CAAC,CAAC;CAmBzD"}

package/dist/channel.js

@@ -0,0 +1,59 @@
+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 { SlackTransportError } from './errors.js';
+import { SlackService } from './service.js';
+import { SLACK_OPTIONS } from './tokens.js';
+let _SlackChannel;
+/**
+ * Notification channel implementation that bridges `@fluojs/notifications` to {@link SlackService}.
+ *
+ * @remarks
+ * This class keeps the foundation package channel-agnostic while allowing `@fluojs/slack`
+ * to interpret Slack-specific payload fields, webhook delivery, and transport behavior.
+ */
+class SlackChannel {
+  static {
+    [_SlackChannel, _initClass] = _applyDecs(this, [Inject(SlackService, SLACK_OPTIONS)], []).c;
+  }
+  channel;
+  constructor(slack, options) {
+    this.slack = slack;
+    this.channel = options.notifications.channel;
+  }
+
+  /**
+   * Sends one notifications foundation request through the configured Slack transport.
+   *
+   * @param notification Shared notification envelope understood by the Slack package.
+   * @param context Optional abort context propagated from the notifications service.
+   * @returns A normalized channel delivery result with the provider message timestamp exposed as `externalId` when available.
+   */
+  async send(notification, context) {
+    const receipt = await this.slack.sendNotification(notification, {
+      signal: context.signal
+    });
+    if (receipt.ok === false) {
+      throw new SlackTransportError('Slack transport reported an unsuccessful delivery.');
+    }
+    return {
+      externalId: receipt.messageTs,
+      metadata: {
+        channel: receipt.channel,
+        response: receipt.response,
+        statusCode: receipt.statusCode,
+        warnings: receipt.warnings
+      },
+      receipt,
+      status: 'delivered'
+    };
+  }
+  static {
+    _initClass();
+  }
+}
+export { _SlackChannel as SlackChannel };

package/dist/errors.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Base error type for caller-visible Slack module configuration failures.
+ */
+export declare class SlackConfigurationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when a Slack message or notification payload is missing one required contract field.
+ */
+export declare class SlackMessageValidationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when one concrete Slack transport reports a caller-visible delivery failure.
+ */
+export declare class SlackTransportError 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,uBAAwB,SAAQ,KAAK;gBACpC,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,2BAA4B,SAAQ,KAAK;gBACxC,OAAO,EAAE,MAAM;CAI5B;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAI5B"}

package/dist/errors.js

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

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { SlackConfigurationError, SlackMessageValidationError, SlackTransportError, } from './errors.js';
+export { SlackChannel } from './channel.js';
+export { SlackModule, createSlackProviders } from './module.js';
+export { SlackService } from './service.js';
+export { createSlackPlatformStatusSnapshot } from './status.js';
+export type { SlackLifecycleState, SlackPlatformStatusSnapshot, SlackStatusAdapterInput } from './status.js';
+export { SLACK, SLACK_CHANNEL } from './tokens.js';
+export type { NormalizedSlackMessage, Slack, SlackAsyncModuleOptions, SlackAttachment, SlackBlock, SlackFetchLike, SlackFetchResponse, SlackMessage, SlackModuleOptions, SlackNotificationDispatchRequest, SlackNotificationPayload, SlackSendBatchResult, SlackSendFailure, SlackSendManyOptions, SlackSendOptions, SlackSendResult, SlackTemplateRenderInput, SlackTemplateRenderer, SlackTemplateRenderResult, SlackTransport, SlackTransportContext, SlackTransportFactory, SlackTransportReceipt, SlackWebhookTransportOptions, } from './types.js';
+export { createSlackWebhookTransport } 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,uBAAuB,EACvB,2BAA2B,EAC3B,mBAAmB,GACpB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,iCAAiC,EAAE,MAAM,aAAa,CAAC;AAChE,YAAY,EAAE,mBAAmB,EAAE,2BAA2B,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAC7G,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACnD,YAAY,EACV,sBAAsB,EACtB,KAAK,EACL,uBAAuB,EACvB,eAAe,EACf,UAAU,EACV,cAAc,EACd,kBAAkB,EAClB,YAAY,EACZ,kBAAkB,EAClB,gCAAgC,EAChC,wBAAwB,EACxB,oBAAoB,EACpB,gBAAgB,EAChB,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,wBAAwB,EACxB,qBAAqB,EACrB,yBAAyB,EACzB,cAAc,EACd,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,4BAA4B,GAC7B,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,2BAA2B,EAAE,MAAM,cAAc,CAAC"}