@wcstack/broadcast 1.12.0

package/README.ja.md

@@ -0,0 +1,178 @@
+# @wcstack/broadcast
+
+`@wcstack/broadcast` は wcstack エコシステム向けのヘッドレスなタブ間メッセージングコンポーネントです。
+
+これは視覚的な UI ウィジェットではありません。
+`@wcstack/fetch` がネットワークリクエストをリアクティブな状態に変え、`@wcstack/websocket` がソケットをリアクティブな状態に変えるのと同じように、**同一オリジンのコンテキスト間メッセージングをリアクティブな状態に変える非同期プリミティブノード**です。
+
+`<wcs-broadcast>` は wc-bindable トークンプロトコルが**コンテキスト境界**をまたぐショーケースです。BroadcastChannel は、同じチャンネル名上の他のすべての同一オリジンコンテキスト（タブ・iframe・worker）にすべての post を配信しますが、送信者自身には決して配信しません。そのため、トークンプロトコルの両方向はタブを*またいで*はじめてループを閉じます。
+
+- **post**（`state → element`）— command-token プロトコル経由（`command.post: $command.send`）
+- **message**（`element → state`）— event-token プロトコル経由（`eventToken.message: onMessage`）
+
+`@wcstack/state` と組み合わせると、`<wcs-broadcast>` はパス契約を通じて直接バインドできます。
+
+- **入力面**: `name`, `manual`
+- **コマンド面**: `open`, `post`, `close`
+- **出力状態面**: `message`, `error`
+
+つまり、タブ間の同期を HTML 上で宣言的に表現でき、UI 層に `new BroadcastChannel()` / `postMessage()` / `onmessage` リスナ、後始末のグルーコードを書く必要がありません。
+
+`@wcstack/broadcast` は [CSBC](https://github.com/csbc-dev/arch/blob/main/README.md)（Core / Shell / Binding Contract）アーキテクチャに従います。
+
+- **Core**（`BroadcastCore`）がチャンネルのライフサイクル、post、structured clone による受信、エラー処理を担当
+- **Shell**（`<wcs-broadcast>`）がその状態を DOM 属性・ライフサイクル・宣言的コマンドに接続
+- **Binding Contract**（`static wcBindable`）が観測可能な `properties`・書き込み可能な `inputs`・呼び出し可能な `commands` を宣言
+
+## なぜ存在するのか
+
+BroadcastChannel API は `fetch` や `WebSocket` と同様、値を非同期に生み出すソースですが、**自己除外的**です。すなわち、あるコンテキストは自分自身の post を決して受信しません。命令的に書くと、チャンネルの構築・`message` / `messageerror` リスナの配線・解体時のクローズが必要になります。
+
+`@wcstack/broadcast` はそのロジックを再利用可能なコンポーネントに押し込み、結果をバインド可能な状態として公開します。タブ間の通知が命令的なコールバック配線ではなく、**状態遷移**になります。
+
+> **自己除外 — ページを 2 つのタブで開くこと。** あるコンテキストは自分自身の post を受信しないため、1 つのタブにある単一の `<wcs-broadcast>` は、自分の `post` が `message` に反映されるのを見ることはありません。往復は、**別の**コンテキスト（別のタブ、または同じチャンネル名の別の `<wcs-broadcast>`）が listen しているときにのみ閉じます。この README のデモは、ページが 2 つのタブで開かれていることを前提とします。
+
+> **同一オリジンのみ、structured clone。** BroadcastChannel は 1 つのオリジン内で動作します。ペイロードはブラウザの structured clone に乗るため、オブジェクトはそのまま渡されます — **JSON の往復は無く**、文字列化も不要です。クローン不可能なペイロード（関数、DOM ノード）は throw せず `error` プロパティを通じて `DataCloneError` を表面化します。
+
+## インストール
+
+```bash
+npm install @wcstack/broadcast
+```
+
+## クイックスタート
+
+### 1. メッセージを送信（post）
+
+post は DOM クリック（autoTrigger）または command-token から起動します。
+
+```html
+<script type="module" src="https://esm.run/@wcstack/state/auto"></script>
+<script type="module" src="https://esm.run/@wcstack/broadcast/auto"></script>
+
+<wcs-broadcast id="bc" name="room"></wcs-broadcast>
+
+<!-- 任意の DOM トリガ: クリックでリテラルテキストを post -->
+<input id="msg" value="hello" />
+<button data-broadcast-target="bc" data-broadcast-from="#msg">Send</button>
+<button data-broadcast-target="bc" data-broadcast-text="ping">Ping</button>
+```
+
+`data-broadcast-text` はリテラル文字列を post します。`data-broadcast-from` はセレクタにマッチした要素の `value`（なければ `textContent`）を post します。
+
+### 2. タブ間カウンタ（command-token + event-token）
+
+1 つの要素に双対性が同居します。`post` は command-token から配線され、受信する `message` は event-token 経由で受け取ります。これを 2 つのタブで開いて "Bump" をクリックすると、各タブのカウントが同期します。
+
+```html
+<wcs-state>
+  <script type="module">
+    export default {
+      count: 0,
+      $commandTokens: ["send"],
+      $eventTokens: ["onMessage"],
+      bump() {
+        this.count = this.count + 1;
+        this.$command.send.emit(this.count);   // state → element → 他のタブ
+      },
+      $on: {
+        onMessage: (state, event) => {          // 他のタブ → element → state
+          state.count = event.detail;
+        }
+      }
+    };
+  </script>
+</wcs-state>
+
+<wcs-broadcast name="counter" data-wcs="
+  command.post:       $command.send;
+  eventToken.message: onMessage
+"></wcs-broadcast>
+
+<button data-wcs="onclick: bump">Bump</button>
+<p data-wcs="textContent: count"></p>
+```
+
+### 3. 受信した値を state にミラーする
+
+最新のメッセージを*読む*だけなら event-token は不要です — `message` を直接バインドしてください。
+
+```html
+<wcs-state>
+  <script type="module">
+    export default { incoming: null };
+  </script>
+</wcs-state>
+
+<wcs-broadcast name="room" data-wcs="message: incoming"></wcs-broadcast>
+<p data-wcs="textContent: incoming"></p>
+```
+
+## 属性 / 入力（Attributes / Inputs）
+
+| 属性      | 型      | 既定値  | 説明                                                                         |
+| --------- | ------- | ------- | ---------------------------------------------------------------------------- |
+| `name`    | string  | `""`    | 参加するチャンネル名。変更すると新しいチャンネルで開き直す。                  |
+| `manual`  | boolean | `false` | 接続時や `name` 変更時にチャンネルを自動で開かない。代わりに `open()` を呼ぶ。接続時と各 `name` 変更時に評価される。`observedAttributes` に**含まれない**ため、既に接続済みの要素で `manual` をトグルしても即座の効果はない（*次回*の接続や `name` 変更時の挙動を変えるだけ）。 |
+
+### DOM トリガ属性（autoTrigger、クリックで post）
+
+| 属性                    | 付与先         | 説明                                                                    |
+| ----------------------- | -------------- | ----------------------------------------------------------------------- |
+| `data-broadcast-target` | トリガボタン   | 駆動する `<wcs-broadcast>` の id。                                      |
+| `data-broadcast-text`   | トリガボタン   | post するリテラルテキスト（優先される。空文字列も有効）。               |
+| `data-broadcast-from`   | トリガボタン   | CSS セレクタ。マッチした要素の `value`（なければ `textContent`）を post。 |
+
+> DOM トリガによる `post` は fire-and-forget で、決して reject しません。post 失敗（例: クローン不可能なペイロード — 文字列しか post しない DOM トリガからは発生しない）は `error` プロパティを通じて現れます。
+
+## 観測可能なプロパティ（出力）
+
+| プロパティ | イベント                 | 説明                                                                                 |
+| --------- | ------------------------ | ------------------------------------------------------------------------------------ |
+| `message` | `wcs-broadcast:message`  | チャンネル上の他のコンテキストから受信した直近の値（structured clone のコピー）。このコンテキスト自身の post では決して設定されない。 |
+| `error`   | `wcs-broadcast:error`    | 正規化された `{ name, message }` — `DataCloneError`（クローン不可能な post）、`DataError`（ピアのメッセージをデシリアライズできなかった）、`InvalidStateError`（開いているチャンネルが無い状態での post）、または `NotSupportedError`（BroadcastChannel が利用不可）。 |
+
+## コマンド
+
+| コマンド | 説明                                                                                    |
+| ------- | --------------------------------------------------------------------------------------- |
+| `open`  | `name` 属性で指定されたチャンネルに参加する（既に開いているチャンネルは閉じる）。       |
+| `post`  | structured clone 可能な値を他のすべてのコンテキストに post する（reject しない — 失敗は `error` へ）。 |
+| `close` | チャンネルから離脱する（冪等）。                                                        |
+
+状態からの起動には command-token プロトコルを使います。
+
+```html
+<wcs-broadcast name="room" data-wcs="command.post: $command.send"></wcs-broadcast>
+```
+
+## 注意点と制約
+
+- **自己除外は意図的。** あるコンテキストは自分自身の post を決して受信しません — これは BroadcastChannel の契約であり、バグではありません。往復を見るには、第 2 のコンテキスト（タブ/iframe/worker、または同じチャンネル名の第 2 の `<wcs-broadcast>`）を listen させてください。*同じ*タブ内の 2 つの `<wcs-broadcast name="x">` 要素は互いに受信します（別々のチャンネルオブジェクトだから）。単一の要素が自分自身に話しかける場合だけは受信しません。
+- **`name` は監視される。** `<wcs-clipboard>` と異なり、`<wcs-broadcast>` は `name` に対して `observedAttributes` を実装します。接続中（かつ非 `manual`）に `name` 属性を変更すると、古いチャンネルを閉じて新しいチャンネルを開きます。`name` をクリアする（空文字列にする、または属性を削除する）のは close *ではありません*。別の `name` に切り替えるか、明示的に `close()` を呼ぶまで、以前開いたチャンネルは維持されます。空でない新しい値だけが切り替えをトリガします。
+- **ワイヤエンコーディングは無い。** ペイロードは structured clone を使うため、JSON の stringify/parse ステップはありません（テキストワイヤで送る `<wcs-ws>` と異なります）。オブジェクトを直接 post すると、受信側はディープコピーを得ます。クローン不可能な値は `error` 経由で `DataCloneError` として失敗します。
+- **接続状態は無い。** BroadcastChannel は構築された瞬間に「開いて」います — connecting/ハンドシェイク段階も、`readyState` も、再接続もありません（必要ないため）。Shell は接続時に同期的に開くので、`connectedCallbackPromise` / SSR スナップショットはありません。
+- **再接続で開き直す。** 要素を削除して再挿入すると `connectedCallback` が再度実行され、`name` 属性（真実の源）からチャンネルを開き直します。`disconnectedCallback` がそれを閉じます。
+- **無言のエラー処理（ゼロログ）。** wcstack 全体のゼロ依存主義に従い、`<wcs-broadcast>` は実行時の失敗に対して一切ログ出力も throw もしません。BroadcastChannel コンストラクタの欠如、クローン不可能な post、デシリアライズ失敗は `error` プロパティ / `wcs-broadcast:error` イベントを通じてのみ表面化します — `post()` は resolve し、決して reject しません。観測・対処するには `error` をバインドしてください。
+
+## ヘッドレス利用（`BroadcastCore`）
+
+Core はグローバルな `BroadcastChannel` 以外に DOM 依存を持たず、`@wc-bindable/core` の `bind()` と直接組み合わせて使えます。
+
+```typescript
+import { BroadcastCore } from "@wcstack/broadcast";
+
+const bus = new BroadcastCore();
+bus.addEventListener("wcs-broadcast:message", (e) => {
+  console.log((e as CustomEvent).detail); // 受信した値
+});
+
+bus.open("room");
+bus.post({ type: "hello", at: Date.now() });
+// ...後で
+bus.close();
+```
+
+## ライセンス
+
+MIT

package/README.md

@@ -0,0 +1,178 @@
+# @wcstack/broadcast
+
+`@wcstack/broadcast` is a headless cross-tab messaging component for the wcstack ecosystem.
+
+It is not a visual UI widget.
+It is an **async primitive node** that turns same-origin cross-context messaging into reactive state — the same way `@wcstack/fetch` turns a network request into reactive state and `@wcstack/websocket` turns a socket into reactive state.
+
+`<wcs-broadcast>` is the showcase for the wc-bindable token protocol crossing a **context boundary**. A BroadcastChannel delivers every post to every other same-origin context (tab, iframe, worker) on the same channel name — but never to the sender itself. So the two directions of the token protocol only close the loop *across* tabs:
+
+- **post** (`state → element`) via the command-token protocol — `command.post: $command.send`
+- **message** (`element → state`) via the event-token protocol — `eventToken.message: onMessage`
+
+With `@wcstack/state`, `<wcs-broadcast>` can be bound directly through path contracts:
+
+- **input surface**: `name`, `manual`
+- **command surface**: `open`, `post`, `close`
+- **output state surface**: `message`, `error`
+
+This means cross-tab synchronization can be expressed declaratively in HTML, without writing `new BroadcastChannel()`, `postMessage()`, `onmessage` listeners, or teardown glue in your UI layer.
+
+`@wcstack/broadcast` follows the [CSBC](https://github.com/csbc-dev/arch/blob/main/README.md) (Core / Shell / Binding Contract) architecture:
+
+- **Core** (`BroadcastCore`) handles channel lifecycle, posting, structured-clone receipt, and error handling
+- **Shell** (`<wcs-broadcast>`) connects that state to DOM attributes, lifecycle, and declarative commands
+- **Binding Contract** (`static wcBindable`) declares observable `properties`, writable `inputs`, and callable `commands`
+
+## Why this exists
+
+The BroadcastChannel API is, like `fetch` or `WebSocket`, an asynchronous source of values — but it is **self-excluding**: a context never receives its own posts. Imperatively it requires constructing the channel, wiring `message` / `messageerror` listeners, and closing on teardown.
+
+`@wcstack/broadcast` moves that logic into a reusable component and exposes the result as bindable state. A cross-tab notification becomes a **state transition**, not imperative callback wiring.
+
+> **Self-exclusion — open the page in two tabs.** Because a context never hears its own posts, a single `<wcs-broadcast>` in one tab will not see its own `post` reflected back into `message`. The round trip only closes when **another** context (another tab, or another `<wcs-broadcast>` on the same channel name) is listening. Demos in this README assume the page is open in two tabs.
+
+> **Same-origin only, structured clone.** BroadcastChannel works within one origin. Payloads ride the browser's structured clone, so objects pass through as-is — there is **no JSON round-trip** and no need to stringify. A non-cloneable payload (a function, a DOM node) surfaces a `DataCloneError` through the `error` property rather than throwing.
+
+## Install
+
+```bash
+npm install @wcstack/broadcast
+```
+
+## Quick Start
+
+### 1. Send a message (post)
+
+Drive a post from a DOM click (autoTrigger) or a command-token.
+
+```html
+<script type="module" src="https://esm.run/@wcstack/state/auto"></script>
+<script type="module" src="https://esm.run/@wcstack/broadcast/auto"></script>
+
+<wcs-broadcast id="bc" name="room"></wcs-broadcast>
+
+<!-- Optional DOM triggering: click posts the literal text -->
+<input id="msg" value="hello" />
+<button data-broadcast-target="bc" data-broadcast-from="#msg">Send</button>
+<button data-broadcast-target="bc" data-broadcast-text="ping">Ping</button>
+```
+
+`data-broadcast-text` posts a literal string; `data-broadcast-from` posts the `value` (or `textContent`) of the element matched by the selector.
+
+### 2. Cross-tab counter (command-token + event-token)
+
+The duality in one element: `post` is wired from a command-token, and an incoming `message` is received via an event-token. Open this in two tabs and click "Bump" — each tab's count stays in sync.
+
+```html
+<wcs-state>
+  <script type="module">
+    export default {
+      count: 0,
+      $commandTokens: ["send"],
+      $eventTokens: ["onMessage"],
+      bump() {
+        this.count = this.count + 1;
+        this.$command.send.emit(this.count);   // state → element → other tabs
+      },
+      $on: {
+        onMessage: (state, event) => {          // other tabs → element → state
+          state.count = event.detail;
+        }
+      }
+    };
+  </script>
+</wcs-state>
+
+<wcs-broadcast name="counter" data-wcs="
+  command.post:       $command.send;
+  eventToken.message: onMessage
+"></wcs-broadcast>
+
+<button data-wcs="onclick: bump">Bump</button>
+<p data-wcs="textContent: count"></p>
+```
+
+### 3. Mirror a received value into state
+
+You do not need the event-token to *read* the latest message — bind `message` directly.
+
+```html
+<wcs-state>
+  <script type="module">
+    export default { incoming: null };
+  </script>
+</wcs-state>
+
+<wcs-broadcast name="room" data-wcs="message: incoming"></wcs-broadcast>
+<p data-wcs="textContent: incoming"></p>
+```
+
+## Attributes / Inputs
+
+| Attribute | Type    | Default | Description                                                                  |
+| --------- | ------- | ------- | ---------------------------------------------------------------------------- |
+| `name`    | string  | `""`    | The channel name to join. Changing it re-opens on the new channel.           |
+| `manual`  | boolean | `false` | Do not open the channel automatically on connect or on `name` change. Call `open()` instead. Evaluated at connect time and on each `name` change; it is **not** in `observedAttributes`, so toggling `manual` on an already-connected element has no immediate effect (it only changes how the *next* connect or `name` change behaves). |
+
+### DOM trigger attributes (autoTrigger, post-on-click)
+
+| Attribute               | On             | Description                                                              |
+| ----------------------- | -------------- | ----------------------------------------------------------------------- |
+| `data-broadcast-target` | trigger button | Id of the `<wcs-broadcast>` to drive.                                   |
+| `data-broadcast-text`   | trigger button | Literal text to post (takes precedence; empty string is valid).         |
+| `data-broadcast-from`   | trigger button | CSS selector; posts the matched element's `value` (or `textContent`).   |
+
+> A DOM-triggered `post` is fire-and-forget; it never rejects. A failed post (e.g. a non-cloneable payload — not possible from a DOM trigger, which only posts strings) surfaces through the `error` property.
+
+## Observable Properties (outputs)
+
+| Property  | Event                    | Description                                                                          |
+| --------- | ------------------------ | ------------------------------------------------------------------------------------ |
+| `message` | `wcs-broadcast:message`  | The last value received from another context on the channel (structured-clone copy). Never set by this context's own posts. |
+| `error`   | `wcs-broadcast:error`    | Normalized `{ name, message }` — `DataCloneError` (non-cloneable post), `DataError` (a peer's message could not be deserialized), `InvalidStateError` (post with no open channel), or `NotSupportedError` (BroadcastChannel unavailable). |
+
+## Commands
+
+| Command | Description                                                                              |
+| ------- | --------------------------------------------------------------------------------------- |
+| `open`  | Join the channel named by the `name` attribute (closes any previously-open channel).    |
+| `post`  | Post a structured-cloneable value to every other context (never rejects — failures go to `error`). |
+| `close` | Leave the channel (idempotent).                                                         |
+
+State-driven invocation uses the command-token protocol:
+
+```html
+<wcs-broadcast name="room" data-wcs="command.post: $command.send"></wcs-broadcast>
+```
+
+## Notes & limitations
+
+- **Self-exclusion is intentional.** A context never receives its own posts — this is the BroadcastChannel contract, not a bug. To see a round trip, have a second context (tab/iframe/worker, or a second `<wcs-broadcast>` on the same channel name) listening. Two `<wcs-broadcast name="x">` elements in the *same* tab do hear each other (they are distinct channel objects); only a single element talking to itself does not.
+- **`name` is observed.** Unlike `<wcs-clipboard>`, `<wcs-broadcast>` implements `observedAttributes` for `name`: changing the `name` attribute while connected (and not `manual`) closes the old channel and opens the new one. Clearing the `name` (setting it to an empty string or removing the attribute) is *not* a close: the previously-open channel is kept until you switch to another `name` or call `close()` explicitly. Only a non-empty new value triggers the switch.
+- **No wire encoding.** Payloads use structured clone, so there is no JSON stringify/parse step (unlike `<wcs-ws>`, which sends over a text wire). Post objects directly; receivers get a deep copy. Non-cloneable values fail with `DataCloneError` via `error`.
+- **No connection state.** A BroadcastChannel is "open" the moment it is constructed — there is no connecting/handshake phase, no `readyState`, and no reconnect (none is needed). The Shell opens synchronously on connect, so there is no `connectedCallbackPromise` / SSR snapshot.
+- **Reconnect re-opens.** Removing and re-inserting the element runs `connectedCallback` again, re-opening the channel from the `name` attribute (the source of truth), and `disconnectedCallback` closes it.
+- **Silent failure handling (zero-log).** Consistent with the rest of wcstack's zero-dependency philosophy, `<wcs-broadcast>` never logs or throws for runtime failures. A missing BroadcastChannel constructor, a non-cloneable post, or a deserialization failure are surfaced only through the `error` property / `wcs-broadcast:error` event — `post()` resolves and never rejects. Bind `error` to observe and react.
+
+## Headless usage (`BroadcastCore`)
+
+The Core has no DOM dependency beyond the global `BroadcastChannel` and can be used directly with `bind()` from `@wc-bindable/core`:
+
+```typescript
+import { BroadcastCore } from "@wcstack/broadcast";
+
+const bus = new BroadcastCore();
+bus.addEventListener("wcs-broadcast:message", (e) => {
+  console.log((e as CustomEvent).detail); // the received value
+});
+
+bus.open("room");
+bus.post({ type: "hello", at: Date.now() });
+// ...later
+bus.close();
+```
+
+## License
+
+MIT

package/dist/auto.js

@@ -0,0 +1,3 @@
+import { bootstrapBroadcast } from "./index.esm.js";
+
+bootstrapBroadcast();

package/dist/auto.min.js

@@ -0,0 +1,3 @@
+import { bootstrapBroadcast } from "./index.esm.min.js";
+
+bootstrapBroadcast();

package/dist/index.d.ts

@@ -0,0 +1,193 @@
+interface ITagNames {
+    readonly broadcast: string;
+}
+interface IWritableTagNames {
+    broadcast?: string;
+}
+interface IConfig {
+    readonly autoTrigger: boolean;
+    readonly triggerAttribute: string;
+    readonly tagNames: ITagNames;
+}
+interface IWritableConfig {
+    autoTrigger?: boolean;
+    triggerAttribute?: string;
+    tagNames?: IWritableTagNames;
+}
+interface IWcBindableProperty {
+    readonly name: string;
+    readonly event: string;
+    readonly getter?: (event: Event) => any;
+}
+interface IWcBindableInput {
+    readonly name: string;
+    readonly attribute?: string;
+}
+interface IWcBindableCommand {
+    readonly name: string;
+    readonly async?: boolean;
+}
+interface IWcBindable {
+    readonly protocol: "wc-bindable";
+    readonly version: number;
+    readonly properties: IWcBindableProperty[];
+    readonly inputs?: IWcBindableInput[];
+    readonly commands?: IWcBindableCommand[];
+}
+/**
+ * Normalized BroadcastChannel failure. `name` mirrors the `DOMException.name`
+ * (e.g. `DataCloneError` when a posted value is not structured-cloneable,
+ * `DataError` for a `messageerror` deserialization failure); `unsupported` is
+ * surfaced as `NotSupportedError` when the `BroadcastChannel` constructor is
+ * absent (older browsers, or a non-window environment).
+ */
+interface WcsBroadcastErrorDetail {
+    name: string;
+    message: string;
+}
+/**
+ * Value types for BroadcastCore (headless) — the observable state properties.
+ * Use with `bind()` from `@wc-bindable/core` for compile-time type checking.
+ *
+ * @example
+ * ```typescript
+ * const core = new BroadcastCore();
+ * bind(core, (name: keyof WcsBroadcastCoreValues, value) => { ... });
+ * ```
+ */
+interface WcsBroadcastCoreValues {
+    /**
+     * The most recent message received from *another* same-origin context on the
+     * channel. A context never receives its own posts (BroadcastChannel
+     * self-exclusion), so within a single tab `message` only updates from another
+     * `<wcs-broadcast>` on the same channel name. The value is whatever was
+     * posted, reconstructed via structured clone (no JSON round-trip).
+     */
+    message: any;
+    /** The last error (post failure / deserialization failure / unsupported), or `null`. */
+    error: WcsBroadcastErrorDetail | null;
+}
+/**
+ * Value types for the Shell (`<wcs-broadcast>`) — identical observable surface
+ * to the Core.
+ */
+type WcsBroadcastValues = WcsBroadcastCoreValues;
+interface WcsBroadcastInputs {
+    /** The channel name to join. Changing it re-opens on the new channel. */
+    name: string;
+    /**
+     * When present, do NOT open the channel automatically on connect (or when the
+     * `name` attribute changes). Open imperatively via `open()` instead.
+     */
+    manual: boolean;
+}
+interface WcsBroadcastCoreCommands {
+    open(name: string): void;
+    post(data: any): void;
+    close(): void;
+}
+/** Commands exposed on the Shell — `open()` reads the `name` attribute. */
+interface WcsBroadcastCommands {
+    open(): void;
+    post(data: any): void;
+    close(): void;
+}
+
+declare function bootstrapBroadcast(userConfig?: IWritableConfig): void;
+
+declare function getConfig(): IConfig;
+
+/**
+ * Headless cross-tab messaging primitive. A thin, framework-agnostic wrapper
+ * around the BroadcastChannel API exposed through the wc-bindable protocol.
+ *
+ * BroadcastChannel is a same-origin pub/sub bus: every context (tab, iframe,
+ * worker) that opens a channel with the same `name` receives every other
+ * context's posts — but NOT its own. This self-exclusion is the whole point:
+ * `post` is a `state → element` action (command-token) and an incoming
+ * `message` is an `element → state` notification (event-token), but the two
+ * only close the loop *across* a context boundary. Within a single tab a lone
+ * `<wcs-broadcast>` never hears itself; open the page in two tabs to see the
+ * round-trip.
+ *
+ * Unlike WebSocketCore there is no connection state, no reconnect, and no wire
+ * encoding: a channel is "open" the moment it is constructed, and payloads ride
+ * the browser's structured clone (objects pass through as-is, no JSON
+ * round-trip). The only failure surfaces are a non-cloneable `post`
+ * (`DataCloneError`), a `messageerror` (a peer posted something this context
+ * cannot deserialize), and an absent `BroadcastChannel` constructor
+ * (`unsupported`). All three flow through the `error` property — the Core never
+ * throws — symmetrical with FetchCore / ClipboardCore.
+ */
+declare class BroadcastCore extends EventTarget {
+    static wcBindable: IWcBindable;
+    private _target;
+    private _channel;
+    private _name;
+    private _message;
+    private _error;
+    constructor(target?: EventTarget);
+    get message(): any;
+    get error(): WcsBroadcastErrorDetail | null;
+    private _setMessage;
+    private _setError;
+    /**
+     * Join the named channel. Any previously-open channel is closed first, so
+     * calling `open()` again switches channels. When the BroadcastChannel
+     * constructor is unavailable this surfaces an `unsupported` error and leaves
+     * the Core channel-less (a later `post()` then errors loudly rather than
+     * silently dropping).
+     */
+    open(name: string): void;
+    /**
+     * Post a structured-cloneable value to every other context on the channel.
+     * The local context never receives it (self-exclusion). Never throws:
+     * a non-cloneable value surfaces as a `DataCloneError` through `error`, and
+     * posting with no open channel surfaces an `InvalidStateError`.
+     */
+    post(data: any): void;
+    /** Leave the channel. Idempotent — a no-op when no channel is open. */
+    close(): void;
+    /**
+     * Tear the Core down for a disconnected Shell: close the channel and reset the
+     * error shadow silently (no dispatch on a torn-down element). A later
+     * reconnect re-opens via the Shell's connectedCallback.
+     *
+     * Asymmetry by design: `_message` is deliberately NOT reset. `error` is
+     * transient connection state — a stale error from a previous channel would be
+     * misleading after a reconnect, so it is cleared. `message` is the last value
+     * received (an event payload), not connection state; it is retained as the
+     * Core's last-known datum so a binding still reads it across a disconnect/
+     * reconnect, and it is naturally overwritten by the next incoming message.
+     */
+    dispose(): void;
+    private _onMessage;
+    private _onMessageError;
+    private _closeChannel;
+    private _hasBroadcastChannel;
+    private _normalizeError;
+    private _unsupportedError;
+}
+
+declare class WcsBroadcast extends HTMLElement {
+    static hasConnectedCallbackPromise: boolean;
+    static wcBindable: IWcBindable;
+    static get observedAttributes(): string[];
+    private _core;
+    constructor();
+    get name(): string;
+    set name(value: string);
+    get manual(): boolean;
+    set manual(value: boolean);
+    get message(): any;
+    get error(): WcsBroadcastErrorDetail | null;
+    open(): void;
+    post(data: any): void;
+    close(): void;
+    attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}
+
+export { BroadcastCore, WcsBroadcast, bootstrapBroadcast, getConfig };
+export type { IWritableConfig, IWritableTagNames, WcsBroadcastCommands, WcsBroadcastCoreCommands, WcsBroadcastCoreValues, WcsBroadcastErrorDetail, WcsBroadcastInputs, WcsBroadcastValues };

package/dist/index.esm.js

@@ -0,0 +1,437 @@
+const _config = {
+    autoTrigger: true,
+    triggerAttribute: "data-broadcast-target",
+    tagNames: {
+        broadcast: "wcs-broadcast",
+    },
+};
+function deepFreeze(obj) {
+    if (obj === null || typeof obj !== "object")
+        return obj;
+    Object.freeze(obj);
+    for (const key of Object.keys(obj)) {
+        deepFreeze(obj[key]);
+    }
+    return obj;
+}
+function deepClone(obj) {
+    if (obj === null || typeof obj !== "object")
+        return obj;
+    const clone = {};
+    for (const key of Object.keys(obj)) {
+        clone[key] = deepClone(obj[key]);
+    }
+    return clone;
+}
+let frozenConfig = null;
+// Live reference to the mutable internal config: reads always reflect the latest
+// setConfig() call. The readonly IConfig type only blocks callers from writing
+// through it — the underlying object still changes. If you need a stable,
+// frozen snapshot that won't move under you, use getConfig() instead.
+const config = _config;
+function getConfig() {
+    if (!frozenConfig) {
+        frozenConfig = deepFreeze(deepClone(_config));
+    }
+    return frozenConfig;
+}
+function setConfig(partialConfig) {
+    if (typeof partialConfig.autoTrigger === "boolean") {
+        _config.autoTrigger = partialConfig.autoTrigger;
+    }
+    if (typeof partialConfig.triggerAttribute === "string") {
+        _config.triggerAttribute = partialConfig.triggerAttribute;
+    }
+    if (partialConfig.tagNames) {
+        Object.assign(_config.tagNames, partialConfig.tagNames);
+    }
+    frozenConfig = null;
+}
+
+/**
+ * Headless cross-tab messaging primitive. A thin, framework-agnostic wrapper
+ * around the BroadcastChannel API exposed through the wc-bindable protocol.
+ *
+ * BroadcastChannel is a same-origin pub/sub bus: every context (tab, iframe,
+ * worker) that opens a channel with the same `name` receives every other
+ * context's posts — but NOT its own. This self-exclusion is the whole point:
+ * `post` is a `state → element` action (command-token) and an incoming
+ * `message` is an `element → state` notification (event-token), but the two
+ * only close the loop *across* a context boundary. Within a single tab a lone
+ * `<wcs-broadcast>` never hears itself; open the page in two tabs to see the
+ * round-trip.
+ *
+ * Unlike WebSocketCore there is no connection state, no reconnect, and no wire
+ * encoding: a channel is "open" the moment it is constructed, and payloads ride
+ * the browser's structured clone (objects pass through as-is, no JSON
+ * round-trip). The only failure surfaces are a non-cloneable `post`
+ * (`DataCloneError`), a `messageerror` (a peer posted something this context
+ * cannot deserialize), and an absent `BroadcastChannel` constructor
+ * (`unsupported`). All three flow through the `error` property — the Core never
+ * throws — symmetrical with FetchCore / ClipboardCore.
+ */
+class BroadcastCore extends EventTarget {
+    static wcBindable = {
+        protocol: "wc-bindable",
+        version: 1,
+        properties: [
+            { name: "message", event: "wcs-broadcast:message" },
+            { name: "error", event: "wcs-broadcast:error" },
+        ],
+        commands: [
+            { name: "open" },
+            { name: "post" },
+            { name: "close" },
+        ],
+    };
+    _target;
+    _channel = null;
+    _name = null;
+    _message = null;
+    _error = null;
+    constructor(target) {
+        super();
+        this._target = target ?? this;
+    }
+    get message() {
+        return this._message;
+    }
+    get error() {
+        return this._error;
+    }
+    // --- State setters with event dispatch ---
+    // Deliberately NO same-value guard (unlike `error` below). A received message
+    // is an event, not idempotent state: a peer posting the same value twice is
+    // two distinct occurrences and must re-fire wcs-broadcast:message each time so
+    // a `message:` binding and any `eventToken.message:` subscriber see both.
+    _setMessage(message) {
+        this._message = message;
+        this._target.dispatchEvent(new CustomEvent("wcs-broadcast:message", {
+            detail: message,
+            bubbles: true,
+        }));
+    }
+    _setError(error) {
+        // Same-value guard. `error` has no derived state, so suppressing redundant
+        // null→null dispatches (e.g. a successful open clearing an already-null
+        // error) avoids spurious events. Reference identity is sufficient: each
+        // failure builds a fresh object, and the clear path always passes null.
+        if (this._error === error)
+            return;
+        this._error = error;
+        this._target.dispatchEvent(new CustomEvent("wcs-broadcast:error", {
+            detail: error,
+            bubbles: true,
+        }));
+    }
+    // --- Public API ---
+    /**
+     * Join the named channel. Any previously-open channel is closed first, so
+     * calling `open()` again switches channels. When the BroadcastChannel
+     * constructor is unavailable this surfaces an `unsupported` error and leaves
+     * the Core channel-less (a later `post()` then errors loudly rather than
+     * silently dropping).
+     */
+    open(name) {
+        if (!this._hasBroadcastChannel()) {
+            this._setError(this._unsupportedError());
+            return;
+        }
+        // Idempotent on the same channel: re-opening the channel we are already on
+        // is pure churn (BroadcastChannel has no reconnect semantics). This also
+        // absorbs the custom-element *upgrade* path — when a connected element with
+        // a `name` attribute is upgraded (autoloader defines the tag after the
+        // markup exists), the spec fires attributeChangedCallback (isConnected ===
+        // true) *and* connectedCallback, so the Shell calls open() twice. Without
+        // this guard that would create a channel and immediately tear it down.
+        if (this._channel && this._name === name)
+            return;
+        this._closeChannel();
+        this._setError(null);
+        const channel = new BroadcastChannel(name);
+        channel.addEventListener("message", this._onMessage);
+        channel.addEventListener("messageerror", this._onMessageError);
+        this._channel = channel;
+        this._name = name;
+    }
+    /**
+     * Post a structured-cloneable value to every other context on the channel.
+     * The local context never receives it (self-exclusion). Never throws:
+     * a non-cloneable value surfaces as a `DataCloneError` through `error`, and
+     * posting with no open channel surfaces an `InvalidStateError`.
+     */
+    post(data) {
+        if (!this._hasBroadcastChannel()) {
+            this._setError(this._unsupportedError());
+            return;
+        }
+        if (!this._channel) {
+            this._setError({
+                name: "InvalidStateError",
+                message: "Channel is not open. Call open(name) before post().",
+            });
+            return;
+        }
+        try {
+            this._channel.postMessage(data);
+        }
+        catch (err) {
+            this._setError(this._normalizeError(err));
+        }
+    }
+    /** Leave the channel. Idempotent — a no-op when no channel is open. */
+    close() {
+        this._closeChannel();
+    }
+    /**
+     * Tear the Core down for a disconnected Shell: close the channel and reset the
+     * error shadow silently (no dispatch on a torn-down element). A later
+     * reconnect re-opens via the Shell's connectedCallback.
+     *
+     * Asymmetry by design: `_message` is deliberately NOT reset. `error` is
+     * transient connection state — a stale error from a previous channel would be
+     * misleading after a reconnect, so it is cleared. `message` is the last value
+     * received (an event payload), not connection state; it is retained as the
+     * Core's last-known datum so a binding still reads it across a disconnect/
+     * reconnect, and it is naturally overwritten by the next incoming message.
+     */
+    dispose() {
+        this._closeChannel();
+        this._error = null;
+    }
+    // --- Internal ---
+    _onMessage = (event) => {
+        this._setMessage(event.data);
+    };
+    // Fired when a peer posted a value this context cannot deserialize. The event
+    // carries no usable payload, so report a synthetic DataError.
+    _onMessageError = () => {
+        this._setError({
+            name: "DataError",
+            message: "Failed to deserialize a message received on the channel.",
+        });
+    };
+    _closeChannel() {
+        if (!this._channel)
+            return;
+        this._channel.removeEventListener("message", this._onMessage);
+        this._channel.removeEventListener("messageerror", this._onMessageError);
+        this._channel.close();
+        this._channel = null;
+        this._name = null;
+    }
+    _hasBroadcastChannel() {
+        return typeof BroadcastChannel !== "undefined";
+    }
+    _normalizeError(err) {
+        if (err instanceof Error) {
+            // DOMException is an Error subclass; its `name` (DataCloneError, etc.) is
+            // the meaningful discriminator for consumers switching on failure kind.
+            return { name: err.name, message: err.message };
+        }
+        return { name: "Error", message: String(err) };
+    }
+    _unsupportedError() {
+        return {
+            name: "NotSupportedError",
+            message: "BroadcastChannel is not available in this environment.",
+        };
+    }
+}
+
+let registered = false;
+// Attribute names for the optional post-on-click DOM trigger (clipboard.js-style
+// DX). The element carrying `data-broadcast-target` points at a <wcs-broadcast>
+// by id; the text to post comes from either a literal `data-broadcast-text` or
+// a `data-broadcast-from` CSS selector resolving to a source element.
+const TEXT_ATTRIBUTE = "data-broadcast-text";
+const FROM_ATTRIBUTE = "data-broadcast-from";
+function resolveText(triggerElement) {
+    // Literal text wins when present (including an empty string — posting "" is a
+    // legitimate request). The `?? ""` right-hand side is defensive and
+    // unreachable: hasAttribute() just returned true, so getAttribute() cannot be
+    // null here. It exists only to satisfy the `string | null` return type — do
+    // not chase coverage on it (the DOM contract makes the null branch impossible).
+    if (triggerElement.hasAttribute(TEXT_ATTRIBUTE)) {
+        return triggerElement.getAttribute(TEXT_ATTRIBUTE) ?? "";
+    }
+    const selector = triggerElement.getAttribute(FROM_ATTRIBUTE);
+    if (!selector)
+        return null;
+    // A user-authored selector can be syntactically invalid (e.g. `[data-*` or a
+    // bare `:not()`), which makes querySelector throw a SyntaxError. Swallow it
+    // and treat the source as unresolvable — the same "nothing to post" path as a
+    // selector that matches no element — so one bad attribute never crashes the
+    // document-level click handler and kills autoTrigger for the whole tab.
+    let source;
+    try {
+        source = document.querySelector(selector);
+    }
+    catch {
+        return null;
+    }
+    if (!source)
+        return null;
+    // Read a form control's `value`; fall back to text content. A bare
+    // `"value" in source` check is too broad — it also matches <button>,
+    // <li value>, <progress>, etc. (which carry an unrelated `value`), posting the
+    // wrong thing. Narrow to the text-bearing controls a user actually points
+    // `data-broadcast-from` at; everything else falls through to textContent.
+    if (source instanceof HTMLInputElement ||
+        source instanceof HTMLTextAreaElement ||
+        source instanceof HTMLSelectElement) {
+        return source.value;
+    }
+    // `?? ""` is defensive: per the DOM spec only Document / DocumentType /
+    // Notation nodes have a null `textContent`, and querySelector only ever
+    // returns an Element (whose textContent is always a string). The branch is
+    // therefore unreachable in practice and kept solely for the `string | null`
+    // type — not worth a contrived test.
+    return source.textContent ?? "";
+}
+function handleClick(event) {
+    const target = event.target;
+    if (!(target instanceof Element))
+        return;
+    const triggerElement = target.closest(`[${config.triggerAttribute}]`);
+    if (!triggerElement)
+        return;
+    const broadcastId = triggerElement.getAttribute(config.triggerAttribute);
+    if (!broadcastId)
+        return;
+    // Resolve the registered constructor at call time instead of importing
+    // WcsBroadcast as a value (avoids a components ⇄ autoTrigger import cycle:
+    // Broadcast.connectedCallback() calls registerAutoTrigger()). instanceof
+    // against the customElements registry keeps the same identity guarantee.
+    const BroadcastCtor = customElements.get(config.tagNames.broadcast);
+    const broadcastElement = document.getElementById(broadcastId);
+    if (!BroadcastCtor || !(broadcastElement instanceof BroadcastCtor))
+        return;
+    const text = resolveText(triggerElement);
+    // No resolvable source: leave the click alone (do not preventDefault) so the
+    // element's default action is unaffected.
+    if (text === null)
+        return;
+    // Suppress the default action so a post can run without navigating. Intentional:
+    // do not attach data-broadcast-target to an element whose default action you
+    // also want (a real <a href> link). See README "Optional DOM Triggering".
+    event.preventDefault();
+    broadcastElement.post(text);
+}
+function registerAutoTrigger() {
+    if (registered)
+        return;
+    registered = true;
+    document.addEventListener("click", handleClick);
+}
+
+// Named WcsBroadcast (not `Broadcast`) to match the <wcs-clipboard> WcsClipboard
+// / <wcs-ws> WcsWebSocket convention and avoid shadowing any global.
+class WcsBroadcast extends HTMLElement {
+    // The channel opens synchronously in connectedCallback (no async init), so no
+    // connectedCallbackPromise is needed — mirrors <wcs-ws>.
+    static hasConnectedCallbackPromise = false;
+    static wcBindable = {
+        ...BroadcastCore.wcBindable,
+        // Shell-level settable surface. `name` selects the channel; `manual`
+        // suppresses auto-open on connect. There is no momentary `post` property:
+        // posting needs an argument (the payload), so element actions run via
+        // command-token (`command.post: $command.ping`) or the DOM autoTrigger, not
+        // a value-derived setter — keeping `post` a plain command keeps the
+        // command-token wiring (`command.post:`) readable.
+        inputs: [
+            { name: "name", attribute: "name" },
+            { name: "manual", attribute: "manual" },
+        ],
+        // Commands are identical to the Core's — no rename needed since the `name` /
+        // `manual` attribute accessors do not collide with open/post/close.
+        commands: BroadcastCore.wcBindable.commands,
+    };
+    static get observedAttributes() { return ["name"]; }
+    _core;
+    constructor() {
+        super();
+        this._core = new BroadcastCore(this);
+    }
+    // --- Attribute accessors ---
+    get name() {
+        return this.getAttribute("name") || "";
+    }
+    set name(value) {
+        this.setAttribute("name", value);
+    }
+    get manual() {
+        return this.hasAttribute("manual");
+    }
+    set manual(value) {
+        if (value) {
+            this.setAttribute("manual", "");
+        }
+        else {
+            this.removeAttribute("manual");
+        }
+    }
+    // --- Core delegated getters ---
+    get message() {
+        return this._core.message;
+    }
+    get error() {
+        return this._core.error;
+    }
+    // --- Commands ---
+    open() {
+        if (this.name) {
+            this._core.open(this.name);
+        }
+    }
+    post(data) {
+        this._core.post(data);
+    }
+    close() {
+        this._core.close();
+    }
+    // --- Lifecycle ---
+    attributeChangedCallback(name, _oldValue, newValue) {
+        if (name === "name" && this.isConnected && !this.manual && newValue) {
+            this._core.open(newValue);
+        }
+    }
+    connectedCallback() {
+        this.style.display = "none";
+        if (config.autoTrigger) {
+            registerAutoTrigger();
+        }
+        if (!this.manual && this.name) {
+            this._core.open(this.name);
+        }
+    }
+    disconnectedCallback() {
+        // Deliberately does NOT call unregisterAutoTrigger(). The autoTrigger click
+        // listener is a single process-wide document listener (registerAutoTrigger
+        // is idempotent), shared by every <wcs-broadcast> on the page — not owned by
+        // this element. Tearing it down when the last element disconnects would
+        // break a later-inserted trigger, so it is intentionally left installed for
+        // the document's lifetime (one passive listener, negligible cost). This
+        // mirrors <wcs-clipboard>, which registers but never unregisters either.
+        // unregisterAutoTrigger stays exported purely as a symmetric teardown hook
+        // for tests / advanced manual control; the production lifecycle never calls
+        // it.
+        this._core.dispose();
+    }
+}
+
+function registerComponents() {
+    if (!customElements.get(config.tagNames.broadcast)) {
+        customElements.define(config.tagNames.broadcast, WcsBroadcast);
+    }
+}
+
+function bootstrapBroadcast(userConfig) {
+    if (userConfig) {
+        setConfig(userConfig);
+    }
+    registerComponents();
+}
+
+export { BroadcastCore, WcsBroadcast, bootstrapBroadcast, getConfig };
+//# sourceMappingURL=index.esm.js.map

package/dist/index.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.esm.js","sources":["../src/config.ts","../src/core/BroadcastCore.ts","../src/autoTrigger.ts","../src/components/Broadcast.ts","../src/registerComponents.ts","../src/bootstrapBroadcast.ts"],"sourcesContent":["import { IConfig, IWritableConfig } from \"./types.js\";\n\ninterface IInternalConfig extends IConfig {\n  autoTrigger: boolean;\n  triggerAttribute: string;\n  tagNames: {\n    broadcast: string;\n  };\n}\n\nconst _config: IInternalConfig = {\n  autoTrigger: true,\n  triggerAttribute: \"data-broadcast-target\",\n  tagNames: {\n    broadcast: \"wcs-broadcast\",\n  },\n};\n\nfunction deepFreeze<T>(obj: T): T {\n  if (obj === null || typeof obj !== \"object\") return obj;\n  Object.freeze(obj);\n  for (const key of Object.keys(obj)) {\n    deepFreeze((obj as Record<string, unknown>)[key]);\n  }\n  return obj;\n}\n\nfunction deepClone<T>(obj: T): T {\n  if (obj === null || typeof obj !== \"object\") return obj;\n  const clone: Record<string, unknown> = {};\n  for (const key of Object.keys(obj)) {\n    clone[key] = deepClone((obj as Record<string, unknown>)[key]);\n  }\n  return clone as T;\n}\n\nlet frozenConfig: IConfig | null = null;\n\n// Live reference to the mutable internal config: reads always reflect the latest\n// setConfig() call. The readonly IConfig type only blocks callers from writing\n// through it — the underlying object still changes. If you need a stable,\n// frozen snapshot that won't move under you, use getConfig() instead.\nexport const config: IConfig = _config as IConfig;\n\nexport function getConfig(): IConfig {\n  if (!frozenConfig) {\n    frozenConfig = deepFreeze(deepClone(_config));\n  }\n  return frozenConfig;\n}\n\nexport function setConfig(partialConfig: IWritableConfig): void {\n  if (typeof partialConfig.autoTrigger === \"boolean\") {\n    _config.autoTrigger = partialConfig.autoTrigger;\n  }\n  if (typeof partialConfig.triggerAttribute === \"string\") {\n    _config.triggerAttribute = partialConfig.triggerAttribute;\n  }\n  if (partialConfig.tagNames) {\n    Object.assign(_config.tagNames, partialConfig.tagNames);\n  }\n  frozenConfig = null;\n}\n","import { IWcBindable, WcsBroadcastErrorDetail } from \"../types.js\";\n\n/**\n * Headless cross-tab messaging primitive. A thin, framework-agnostic wrapper\n * around the BroadcastChannel API exposed through the wc-bindable protocol.\n *\n * BroadcastChannel is a same-origin pub/sub bus: every context (tab, iframe,\n * worker) that opens a channel with the same `name` receives every other\n * context's posts — but NOT its own. This self-exclusion is the whole point:\n * `post` is a `state → element` action (command-token) and an incoming\n * `message` is an `element → state` notification (event-token), but the two\n * only close the loop *across* a context boundary. Within a single tab a lone\n * `<wcs-broadcast>` never hears itself; open the page in two tabs to see the\n * round-trip.\n *\n * Unlike WebSocketCore there is no connection state, no reconnect, and no wire\n * encoding: a channel is \"open\" the moment it is constructed, and payloads ride\n * the browser's structured clone (objects pass through as-is, no JSON\n * round-trip). The only failure surfaces are a non-cloneable `post`\n * (`DataCloneError`), a `messageerror` (a peer posted something this context\n * cannot deserialize), and an absent `BroadcastChannel` constructor\n * (`unsupported`). All three flow through the `error` property — the Core never\n * throws — symmetrical with FetchCore / ClipboardCore.\n */\nexport class BroadcastCore extends EventTarget {\n  static wcBindable: IWcBindable = {\n    protocol: \"wc-bindable\",\n    version: 1,\n    properties: [\n      { name: \"message\", event: \"wcs-broadcast:message\" },\n      { name: \"error\", event: \"wcs-broadcast:error\" },\n    ],\n    commands: [\n      { name: \"open\" },\n      { name: \"post\" },\n      { name: \"close\" },\n    ],\n  };\n\n  private _target: EventTarget;\n  private _channel: BroadcastChannel | null = null;\n  private _name: string | null = null;\n  private _message: any = null;\n  private _error: WcsBroadcastErrorDetail | null = null;\n\n  constructor(target?: EventTarget) {\n    super();\n    this._target = target ?? this;\n  }\n\n  get message(): any {\n    return this._message;\n  }\n\n  get error(): WcsBroadcastErrorDetail | null {\n    return this._error;\n  }\n\n  // --- State setters with event dispatch ---\n\n  // Deliberately NO same-value guard (unlike `error` below). A received message\n  // is an event, not idempotent state: a peer posting the same value twice is\n  // two distinct occurrences and must re-fire wcs-broadcast:message each time so\n  // a `message:` binding and any `eventToken.message:` subscriber see both.\n  private _setMessage(message: any): void {\n    this._message = message;\n    this._target.dispatchEvent(new CustomEvent(\"wcs-broadcast:message\", {\n      detail: message,\n      bubbles: true,\n    }));\n  }\n\n  private _setError(error: WcsBroadcastErrorDetail | null): void {\n    // Same-value guard. `error` has no derived state, so suppressing redundant\n    // null→null dispatches (e.g. a successful open clearing an already-null\n    // error) avoids spurious events. Reference identity is sufficient: each\n    // failure builds a fresh object, and the clear path always passes null.\n    if (this._error === error) return;\n    this._error = error;\n    this._target.dispatchEvent(new CustomEvent(\"wcs-broadcast:error\", {\n      detail: error,\n      bubbles: true,\n    }));\n  }\n\n  // --- Public API ---\n\n  /**\n   * Join the named channel. Any previously-open channel is closed first, so\n   * calling `open()` again switches channels. When the BroadcastChannel\n   * constructor is unavailable this surfaces an `unsupported` error and leaves\n   * the Core channel-less (a later `post()` then errors loudly rather than\n   * silently dropping).\n   */\n  open(name: string): void {\n    if (!this._hasBroadcastChannel()) {\n      this._setError(this._unsupportedError());\n      return;\n    }\n    // Idempotent on the same channel: re-opening the channel we are already on\n    // is pure churn (BroadcastChannel has no reconnect semantics). This also\n    // absorbs the custom-element *upgrade* path — when a connected element with\n    // a `name` attribute is upgraded (autoloader defines the tag after the\n    // markup exists), the spec fires attributeChangedCallback (isConnected ===\n    // true) *and* connectedCallback, so the Shell calls open() twice. Without\n    // this guard that would create a channel and immediately tear it down.\n    if (this._channel && this._name === name) return;\n    this._closeChannel();\n    this._setError(null);\n    const channel = new BroadcastChannel(name);\n    channel.addEventListener(\"message\", this._onMessage);\n    channel.addEventListener(\"messageerror\", this._onMessageError);\n    this._channel = channel;\n    this._name = name;\n  }\n\n  /**\n   * Post a structured-cloneable value to every other context on the channel.\n   * The local context never receives it (self-exclusion). Never throws:\n   * a non-cloneable value surfaces as a `DataCloneError` through `error`, and\n   * posting with no open channel surfaces an `InvalidStateError`.\n   */\n  post(data: any): void {\n    if (!this._hasBroadcastChannel()) {\n      this._setError(this._unsupportedError());\n      return;\n    }\n    if (!this._channel) {\n      this._setError({\n        name: \"InvalidStateError\",\n        message: \"Channel is not open. Call open(name) before post().\",\n      });\n      return;\n    }\n    try {\n      this._channel.postMessage(data);\n    } catch (err) {\n      this._setError(this._normalizeError(err));\n    }\n  }\n\n  /** Leave the channel. Idempotent — a no-op when no channel is open. */\n  close(): void {\n    this._closeChannel();\n  }\n\n  /**\n   * Tear the Core down for a disconnected Shell: close the channel and reset the\n   * error shadow silently (no dispatch on a torn-down element). A later\n   * reconnect re-opens via the Shell's connectedCallback.\n   *\n   * Asymmetry by design: `_message` is deliberately NOT reset. `error` is\n   * transient connection state — a stale error from a previous channel would be\n   * misleading after a reconnect, so it is cleared. `message` is the last value\n   * received (an event payload), not connection state; it is retained as the\n   * Core's last-known datum so a binding still reads it across a disconnect/\n   * reconnect, and it is naturally overwritten by the next incoming message.\n   */\n  dispose(): void {\n    this._closeChannel();\n    this._error = null;\n  }\n\n  // --- Internal ---\n\n  private _onMessage = (event: MessageEvent): void => {\n    this._setMessage(event.data);\n  };\n\n  // Fired when a peer posted a value this context cannot deserialize. The event\n  // carries no usable payload, so report a synthetic DataError.\n  private _onMessageError = (): void => {\n    this._setError({\n      name: \"DataError\",\n      message: \"Failed to deserialize a message received on the channel.\",\n    });\n  };\n\n  private _closeChannel(): void {\n    if (!this._channel) return;\n    this._channel.removeEventListener(\"message\", this._onMessage);\n    this._channel.removeEventListener(\"messageerror\", this._onMessageError);\n    this._channel.close();\n    this._channel = null;\n    this._name = null;\n  }\n\n  private _hasBroadcastChannel(): boolean {\n    return typeof BroadcastChannel !== \"undefined\";\n  }\n\n  private _normalizeError(err: unknown): WcsBroadcastErrorDetail {\n    if (err instanceof Error) {\n      // DOMException is an Error subclass; its `name` (DataCloneError, etc.) is\n      // the meaningful discriminator for consumers switching on failure kind.\n      return { name: err.name, message: err.message };\n    }\n    return { name: \"Error\", message: String(err) };\n  }\n\n  private _unsupportedError(): WcsBroadcastErrorDetail {\n    return {\n      name: \"NotSupportedError\",\n      message: \"BroadcastChannel is not available in this environment.\",\n    };\n  }\n}\n","import { config } from \"./config.js\";\nimport type { WcsBroadcast } from \"./components/Broadcast.js\";\n\nlet registered = false;\n\n// Attribute names for the optional post-on-click DOM trigger (clipboard.js-style\n// DX). The element carrying `data-broadcast-target` points at a <wcs-broadcast>\n// by id; the text to post comes from either a literal `data-broadcast-text` or\n// a `data-broadcast-from` CSS selector resolving to a source element.\nconst TEXT_ATTRIBUTE = \"data-broadcast-text\";\nconst FROM_ATTRIBUTE = \"data-broadcast-from\";\n\nfunction resolveText(triggerElement: Element): string | null {\n  // Literal text wins when present (including an empty string — posting \"\" is a\n  // legitimate request). The `?? \"\"` right-hand side is defensive and\n  // unreachable: hasAttribute() just returned true, so getAttribute() cannot be\n  // null here. It exists only to satisfy the `string | null` return type — do\n  // not chase coverage on it (the DOM contract makes the null branch impossible).\n  if (triggerElement.hasAttribute(TEXT_ATTRIBUTE)) {\n    return triggerElement.getAttribute(TEXT_ATTRIBUTE) ?? \"\";\n  }\n  const selector = triggerElement.getAttribute(FROM_ATTRIBUTE);\n  if (!selector) return null;\n  // A user-authored selector can be syntactically invalid (e.g. `[data-*` or a\n  // bare `:not()`), which makes querySelector throw a SyntaxError. Swallow it\n  // and treat the source as unresolvable — the same \"nothing to post\" path as a\n  // selector that matches no element — so one bad attribute never crashes the\n  // document-level click handler and kills autoTrigger for the whole tab.\n  let source: Element | null;\n  try {\n    source = document.querySelector(selector);\n  } catch {\n    return null;\n  }\n  if (!source) return null;\n  // Read a form control's `value`; fall back to text content. A bare\n  // `\"value\" in source` check is too broad — it also matches <button>,\n  // <li value>, <progress>, etc. (which carry an unrelated `value`), posting the\n  // wrong thing. Narrow to the text-bearing controls a user actually points\n  // `data-broadcast-from` at; everything else falls through to textContent.\n  if (\n    source instanceof HTMLInputElement ||\n    source instanceof HTMLTextAreaElement ||\n    source instanceof HTMLSelectElement\n  ) {\n    return source.value;\n  }\n  // `?? \"\"` is defensive: per the DOM spec only Document / DocumentType /\n  // Notation nodes have a null `textContent`, and querySelector only ever\n  // returns an Element (whose textContent is always a string). The branch is\n  // therefore unreachable in practice and kept solely for the `string | null`\n  // type — not worth a contrived test.\n  return source.textContent ?? \"\";\n}\n\nfunction handleClick(event: Event): void {\n  const target = event.target;\n  if (!(target instanceof Element)) return;\n\n  const triggerElement = target.closest<Element>(`[${config.triggerAttribute}]`);\n  if (!triggerElement) return;\n\n  const broadcastId = triggerElement.getAttribute(config.triggerAttribute);\n  if (!broadcastId) return;\n\n  // Resolve the registered constructor at call time instead of importing\n  // WcsBroadcast as a value (avoids a components ⇄ autoTrigger import cycle:\n  // Broadcast.connectedCallback() calls registerAutoTrigger()). instanceof\n  // against the customElements registry keeps the same identity guarantee.\n  const BroadcastCtor = customElements.get(config.tagNames.broadcast);\n  const broadcastElement = document.getElementById(broadcastId);\n  if (!BroadcastCtor || !(broadcastElement instanceof BroadcastCtor)) return;\n\n  const text = resolveText(triggerElement);\n  // No resolvable source: leave the click alone (do not preventDefault) so the\n  // element's default action is unaffected.\n  if (text === null) return;\n\n  // Suppress the default action so a post can run without navigating. Intentional:\n  // do not attach data-broadcast-target to an element whose default action you\n  // also want (a real <a href> link). See README \"Optional DOM Triggering\".\n  event.preventDefault();\n  (broadcastElement as WcsBroadcast).post(text);\n}\n\nexport function registerAutoTrigger(): void {\n  if (registered) return;\n  registered = true;\n  document.addEventListener(\"click\", handleClick);\n}\n\nexport function unregisterAutoTrigger(): void {\n  if (!registered) return;\n  registered = false;\n  document.removeEventListener(\"click\", handleClick);\n}\n","import { config } from \"../config.js\";\nimport { IWcBindable, WcsBroadcastErrorDetail } from \"../types.js\";\nimport { BroadcastCore } from \"../core/BroadcastCore.js\";\nimport { registerAutoTrigger } from \"../autoTrigger.js\";\n\n// Named WcsBroadcast (not `Broadcast`) to match the <wcs-clipboard> WcsClipboard\n// / <wcs-ws> WcsWebSocket convention and avoid shadowing any global.\nexport class WcsBroadcast extends HTMLElement {\n  // The channel opens synchronously in connectedCallback (no async init), so no\n  // connectedCallbackPromise is needed — mirrors <wcs-ws>.\n  static hasConnectedCallbackPromise = false;\n  static wcBindable: IWcBindable = {\n    ...BroadcastCore.wcBindable,\n    // Shell-level settable surface. `name` selects the channel; `manual`\n    // suppresses auto-open on connect. There is no momentary `post` property:\n    // posting needs an argument (the payload), so element actions run via\n    // command-token (`command.post: $command.ping`) or the DOM autoTrigger, not\n    // a value-derived setter — keeping `post` a plain command keeps the\n    // command-token wiring (`command.post:`) readable.\n    inputs: [\n      { name: \"name\", attribute: \"name\" },\n      { name: \"manual\", attribute: \"manual\" },\n    ],\n    // Commands are identical to the Core's — no rename needed since the `name` /\n    // `manual` attribute accessors do not collide with open/post/close.\n    commands: BroadcastCore.wcBindable.commands,\n  };\n  static get observedAttributes(): string[] { return [\"name\"]; }\n\n  private _core: BroadcastCore;\n\n  constructor() {\n    super();\n    this._core = new BroadcastCore(this);\n  }\n\n  // --- Attribute accessors ---\n\n  get name(): string {\n    return this.getAttribute(\"name\") || \"\";\n  }\n\n  set name(value: string) {\n    this.setAttribute(\"name\", value);\n  }\n\n  get manual(): boolean {\n    return this.hasAttribute(\"manual\");\n  }\n\n  set manual(value: boolean) {\n    if (value) {\n      this.setAttribute(\"manual\", \"\");\n    } else {\n      this.removeAttribute(\"manual\");\n    }\n  }\n\n  // --- Core delegated getters ---\n\n  get message(): any {\n    return this._core.message;\n  }\n\n  get error(): WcsBroadcastErrorDetail | null {\n    return this._core.error;\n  }\n\n  // --- Commands ---\n\n  open(): void {\n    if (this.name) {\n      this._core.open(this.name);\n    }\n  }\n\n  post(data: any): void {\n    this._core.post(data);\n  }\n\n  close(): void {\n    this._core.close();\n  }\n\n  // --- Lifecycle ---\n\n  attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void {\n    if (name === \"name\" && this.isConnected && !this.manual && newValue) {\n      this._core.open(newValue);\n    }\n  }\n\n  connectedCallback(): void {\n    this.style.display = \"none\";\n    if (config.autoTrigger) {\n      registerAutoTrigger();\n    }\n    if (!this.manual && this.name) {\n      this._core.open(this.name);\n    }\n  }\n\n  disconnectedCallback(): void {\n    // Deliberately does NOT call unregisterAutoTrigger(). The autoTrigger click\n    // listener is a single process-wide document listener (registerAutoTrigger\n    // is idempotent), shared by every <wcs-broadcast> on the page — not owned by\n    // this element. Tearing it down when the last element disconnects would\n    // break a later-inserted trigger, so it is intentionally left installed for\n    // the document's lifetime (one passive listener, negligible cost). This\n    // mirrors <wcs-clipboard>, which registers but never unregisters either.\n    // unregisterAutoTrigger stays exported purely as a symmetric teardown hook\n    // for tests / advanced manual control; the production lifecycle never calls\n    // it.\n    this._core.dispose();\n  }\n}\n","import { WcsBroadcast } from \"./components/Broadcast.js\";\nimport { config } from \"./config.js\";\n\nexport function registerComponents(): void {\n  if (!customElements.get(config.tagNames.broadcast)) {\n    customElements.define(config.tagNames.broadcast, WcsBroadcast);\n  }\n}\n","import { setConfig } from \"./config.js\";\nimport { registerComponents } from \"./registerComponents.js\";\nimport { IWritableConfig } from \"./types.js\";\n\nexport function bootstrapBroadcast(userConfig?: IWritableConfig): void {\n  if (userConfig) {\n    setConfig(userConfig);\n  }\n  registerComponents();\n}\n"],"names":[],"mappings":"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"}

package/dist/index.esm.min.js

@@ -0,0 +1,2 @@
+const e={autoTrigger:!0,triggerAttribute:"data-broadcast-target",tagNames:{broadcast:"wcs-broadcast"}};function t(e){if(null===e||"object"!=typeof e)return e;Object.freeze(e);for(const s of Object.keys(e))t(e[s]);return e}function s(e){if(null===e||"object"!=typeof e)return e;const t={};for(const r of Object.keys(e))t[r]=s(e[r]);return t}let r=null;const n=e;function a(){return r||(r=t(s(e))),r}class o extends EventTarget{static wcBindable={protocol:"wc-bindable",version:1,properties:[{name:"message",event:"wcs-broadcast:message"},{name:"error",event:"wcs-broadcast:error"}],commands:[{name:"open"},{name:"post"},{name:"close"}]};_target;_channel=null;_name=null;_message=null;_error=null;constructor(e){super(),this._target=e??this}get message(){return this._message}get error(){return this._error}_setMessage(e){this._message=e,this._target.dispatchEvent(new CustomEvent("wcs-broadcast:message",{detail:e,bubbles:!0}))}_setError(e){this._error!==e&&(this._error=e,this._target.dispatchEvent(new CustomEvent("wcs-broadcast:error",{detail:e,bubbles:!0})))}open(e){if(!this._hasBroadcastChannel())return void this._setError(this._unsupportedError());if(this._channel&&this._name===e)return;this._closeChannel(),this._setError(null);const t=new BroadcastChannel(e);t.addEventListener("message",this._onMessage),t.addEventListener("messageerror",this._onMessageError),this._channel=t,this._name=e}post(e){if(this._hasBroadcastChannel())if(this._channel)try{this._channel.postMessage(e)}catch(e){this._setError(this._normalizeError(e))}else this._setError({name:"InvalidStateError",message:"Channel is not open. Call open(name) before post()."});else this._setError(this._unsupportedError())}close(){this._closeChannel()}dispose(){this._closeChannel(),this._error=null}_onMessage=e=>{this._setMessage(e.data)};_onMessageError=()=>{this._setError({name:"DataError",message:"Failed to deserialize a message received on the channel."})};_closeChannel(){this._channel&&(this._channel.removeEventListener("message",this._onMessage),this._channel.removeEventListener("messageerror",this._onMessageError),this._channel.close(),this._channel=null,this._name=null)}_hasBroadcastChannel(){return"undefined"!=typeof BroadcastChannel}_normalizeError(e){return e instanceof Error?{name:e.name,message:e.message}:{name:"Error",message:String(e)}}_unsupportedError(){return{name:"NotSupportedError",message:"BroadcastChannel is not available in this environment."}}}let i=!1;const c="data-broadcast-text";function l(e){const t=e.target;if(!(t instanceof Element))return;const s=t.closest(`[${n.triggerAttribute}]`);if(!s)return;const r=s.getAttribute(n.triggerAttribute);if(!r)return;const a=customElements.get(n.tagNames.broadcast),o=document.getElementById(r);if(!(a&&o instanceof a))return;const i=function(e){if(e.hasAttribute(c))return e.getAttribute(c)??"";const t=e.getAttribute("data-broadcast-from");if(!t)return null;let s;try{s=document.querySelector(t)}catch{return null}return s?s instanceof HTMLInputElement||s instanceof HTMLTextAreaElement||s instanceof HTMLSelectElement?s.value:s.textContent??"":null}(s);null!==i&&(e.preventDefault(),o.post(i))}class u extends HTMLElement{static hasConnectedCallbackPromise=!1;static wcBindable={...o.wcBindable,inputs:[{name:"name",attribute:"name"},{name:"manual",attribute:"manual"}],commands:o.wcBindable.commands};static get observedAttributes(){return["name"]}_core;constructor(){super(),this._core=new o(this)}get name(){return this.getAttribute("name")||""}set name(e){this.setAttribute("name",e)}get manual(){return this.hasAttribute("manual")}set manual(e){e?this.setAttribute("manual",""):this.removeAttribute("manual")}get message(){return this._core.message}get error(){return this._core.error}open(){this.name&&this._core.open(this.name)}post(e){this._core.post(e)}close(){this._core.close()}attributeChangedCallback(e,t,s){"name"===e&&this.isConnected&&!this.manual&&s&&this._core.open(s)}connectedCallback(){this.style.display="none",n.autoTrigger&&(i||(i=!0,document.addEventListener("click",l))),!this.manual&&this.name&&this._core.open(this.name)}disconnectedCallback(){this._core.dispose()}}function h(t){var s;t&&("boolean"==typeof(s=t).autoTrigger&&(e.autoTrigger=s.autoTrigger),"string"==typeof s.triggerAttribute&&(e.triggerAttribute=s.triggerAttribute),s.tagNames&&Object.assign(e.tagNames,s.tagNames),r=null),customElements.get(n.tagNames.broadcast)||customElements.define(n.tagNames.broadcast,u)}export{o as BroadcastCore,u as WcsBroadcast,h as bootstrapBroadcast,a as getConfig};
+//# sourceMappingURL=index.esm.min.js.map

package/dist/index.esm.min.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.esm.min.js","sources":["../src/config.ts","../src/core/BroadcastCore.ts","../src/autoTrigger.ts","../src/components/Broadcast.ts","../src/bootstrapBroadcast.ts","../src/registerComponents.ts"],"sourcesContent":["import { IConfig, IWritableConfig } from \"./types.js\";\n\ninterface IInternalConfig extends IConfig {\n  autoTrigger: boolean;\n  triggerAttribute: string;\n  tagNames: {\n    broadcast: string;\n  };\n}\n\nconst _config: IInternalConfig = {\n  autoTrigger: true,\n  triggerAttribute: \"data-broadcast-target\",\n  tagNames: {\n    broadcast: \"wcs-broadcast\",\n  },\n};\n\nfunction deepFreeze<T>(obj: T): T {\n  if (obj === null || typeof obj !== \"object\") return obj;\n  Object.freeze(obj);\n  for (const key of Object.keys(obj)) {\n    deepFreeze((obj as Record<string, unknown>)[key]);\n  }\n  return obj;\n}\n\nfunction deepClone<T>(obj: T): T {\n  if (obj === null || typeof obj !== \"object\") return obj;\n  const clone: Record<string, unknown> = {};\n  for (const key of Object.keys(obj)) {\n    clone[key] = deepClone((obj as Record<string, unknown>)[key]);\n  }\n  return clone as T;\n}\n\nlet frozenConfig: IConfig | null = null;\n\n// Live reference to the mutable internal config: reads always reflect the latest\n// setConfig() call. The readonly IConfig type only blocks callers from writing\n// through it — the underlying object still changes. If you need a stable,\n// frozen snapshot that won't move under you, use getConfig() instead.\nexport const config: IConfig = _config as IConfig;\n\nexport function getConfig(): IConfig {\n  if (!frozenConfig) {\n    frozenConfig = deepFreeze(deepClone(_config));\n  }\n  return frozenConfig;\n}\n\nexport function setConfig(partialConfig: IWritableConfig): void {\n  if (typeof partialConfig.autoTrigger === \"boolean\") {\n    _config.autoTrigger = partialConfig.autoTrigger;\n  }\n  if (typeof partialConfig.triggerAttribute === \"string\") {\n    _config.triggerAttribute = partialConfig.triggerAttribute;\n  }\n  if (partialConfig.tagNames) {\n    Object.assign(_config.tagNames, partialConfig.tagNames);\n  }\n  frozenConfig = null;\n}\n","import { IWcBindable, WcsBroadcastErrorDetail } from \"../types.js\";\n\n/**\n * Headless cross-tab messaging primitive. A thin, framework-agnostic wrapper\n * around the BroadcastChannel API exposed through the wc-bindable protocol.\n *\n * BroadcastChannel is a same-origin pub/sub bus: every context (tab, iframe,\n * worker) that opens a channel with the same `name` receives every other\n * context's posts — but NOT its own. This self-exclusion is the whole point:\n * `post` is a `state → element` action (command-token) and an incoming\n * `message` is an `element → state` notification (event-token), but the two\n * only close the loop *across* a context boundary. Within a single tab a lone\n * `<wcs-broadcast>` never hears itself; open the page in two tabs to see the\n * round-trip.\n *\n * Unlike WebSocketCore there is no connection state, no reconnect, and no wire\n * encoding: a channel is \"open\" the moment it is constructed, and payloads ride\n * the browser's structured clone (objects pass through as-is, no JSON\n * round-trip). The only failure surfaces are a non-cloneable `post`\n * (`DataCloneError`), a `messageerror` (a peer posted something this context\n * cannot deserialize), and an absent `BroadcastChannel` constructor\n * (`unsupported`). All three flow through the `error` property — the Core never\n * throws — symmetrical with FetchCore / ClipboardCore.\n */\nexport class BroadcastCore extends EventTarget {\n  static wcBindable: IWcBindable = {\n    protocol: \"wc-bindable\",\n    version: 1,\n    properties: [\n      { name: \"message\", event: \"wcs-broadcast:message\" },\n      { name: \"error\", event: \"wcs-broadcast:error\" },\n    ],\n    commands: [\n      { name: \"open\" },\n      { name: \"post\" },\n      { name: \"close\" },\n    ],\n  };\n\n  private _target: EventTarget;\n  private _channel: BroadcastChannel | null = null;\n  private _name: string | null = null;\n  private _message: any = null;\n  private _error: WcsBroadcastErrorDetail | null = null;\n\n  constructor(target?: EventTarget) {\n    super();\n    this._target = target ?? this;\n  }\n\n  get message(): any {\n    return this._message;\n  }\n\n  get error(): WcsBroadcastErrorDetail | null {\n    return this._error;\n  }\n\n  // --- State setters with event dispatch ---\n\n  // Deliberately NO same-value guard (unlike `error` below). A received message\n  // is an event, not idempotent state: a peer posting the same value twice is\n  // two distinct occurrences and must re-fire wcs-broadcast:message each time so\n  // a `message:` binding and any `eventToken.message:` subscriber see both.\n  private _setMessage(message: any): void {\n    this._message = message;\n    this._target.dispatchEvent(new CustomEvent(\"wcs-broadcast:message\", {\n      detail: message,\n      bubbles: true,\n    }));\n  }\n\n  private _setError(error: WcsBroadcastErrorDetail | null): void {\n    // Same-value guard. `error` has no derived state, so suppressing redundant\n    // null→null dispatches (e.g. a successful open clearing an already-null\n    // error) avoids spurious events. Reference identity is sufficient: each\n    // failure builds a fresh object, and the clear path always passes null.\n    if (this._error === error) return;\n    this._error = error;\n    this._target.dispatchEvent(new CustomEvent(\"wcs-broadcast:error\", {\n      detail: error,\n      bubbles: true,\n    }));\n  }\n\n  // --- Public API ---\n\n  /**\n   * Join the named channel. Any previously-open channel is closed first, so\n   * calling `open()` again switches channels. When the BroadcastChannel\n   * constructor is unavailable this surfaces an `unsupported` error and leaves\n   * the Core channel-less (a later `post()` then errors loudly rather than\n   * silently dropping).\n   */\n  open(name: string): void {\n    if (!this._hasBroadcastChannel()) {\n      this._setError(this._unsupportedError());\n      return;\n    }\n    // Idempotent on the same channel: re-opening the channel we are already on\n    // is pure churn (BroadcastChannel has no reconnect semantics). This also\n    // absorbs the custom-element *upgrade* path — when a connected element with\n    // a `name` attribute is upgraded (autoloader defines the tag after the\n    // markup exists), the spec fires attributeChangedCallback (isConnected ===\n    // true) *and* connectedCallback, so the Shell calls open() twice. Without\n    // this guard that would create a channel and immediately tear it down.\n    if (this._channel && this._name === name) return;\n    this._closeChannel();\n    this._setError(null);\n    const channel = new BroadcastChannel(name);\n    channel.addEventListener(\"message\", this._onMessage);\n    channel.addEventListener(\"messageerror\", this._onMessageError);\n    this._channel = channel;\n    this._name = name;\n  }\n\n  /**\n   * Post a structured-cloneable value to every other context on the channel.\n   * The local context never receives it (self-exclusion). Never throws:\n   * a non-cloneable value surfaces as a `DataCloneError` through `error`, and\n   * posting with no open channel surfaces an `InvalidStateError`.\n   */\n  post(data: any): void {\n    if (!this._hasBroadcastChannel()) {\n      this._setError(this._unsupportedError());\n      return;\n    }\n    if (!this._channel) {\n      this._setError({\n        name: \"InvalidStateError\",\n        message: \"Channel is not open. Call open(name) before post().\",\n      });\n      return;\n    }\n    try {\n      this._channel.postMessage(data);\n    } catch (err) {\n      this._setError(this._normalizeError(err));\n    }\n  }\n\n  /** Leave the channel. Idempotent — a no-op when no channel is open. */\n  close(): void {\n    this._closeChannel();\n  }\n\n  /**\n   * Tear the Core down for a disconnected Shell: close the channel and reset the\n   * error shadow silently (no dispatch on a torn-down element). A later\n   * reconnect re-opens via the Shell's connectedCallback.\n   *\n   * Asymmetry by design: `_message` is deliberately NOT reset. `error` is\n   * transient connection state — a stale error from a previous channel would be\n   * misleading after a reconnect, so it is cleared. `message` is the last value\n   * received (an event payload), not connection state; it is retained as the\n   * Core's last-known datum so a binding still reads it across a disconnect/\n   * reconnect, and it is naturally overwritten by the next incoming message.\n   */\n  dispose(): void {\n    this._closeChannel();\n    this._error = null;\n  }\n\n  // --- Internal ---\n\n  private _onMessage = (event: MessageEvent): void => {\n    this._setMessage(event.data);\n  };\n\n  // Fired when a peer posted a value this context cannot deserialize. The event\n  // carries no usable payload, so report a synthetic DataError.\n  private _onMessageError = (): void => {\n    this._setError({\n      name: \"DataError\",\n      message: \"Failed to deserialize a message received on the channel.\",\n    });\n  };\n\n  private _closeChannel(): void {\n    if (!this._channel) return;\n    this._channel.removeEventListener(\"message\", this._onMessage);\n    this._channel.removeEventListener(\"messageerror\", this._onMessageError);\n    this._channel.close();\n    this._channel = null;\n    this._name = null;\n  }\n\n  private _hasBroadcastChannel(): boolean {\n    return typeof BroadcastChannel !== \"undefined\";\n  }\n\n  private _normalizeError(err: unknown): WcsBroadcastErrorDetail {\n    if (err instanceof Error) {\n      // DOMException is an Error subclass; its `name` (DataCloneError, etc.) is\n      // the meaningful discriminator for consumers switching on failure kind.\n      return { name: err.name, message: err.message };\n    }\n    return { name: \"Error\", message: String(err) };\n  }\n\n  private _unsupportedError(): WcsBroadcastErrorDetail {\n    return {\n      name: \"NotSupportedError\",\n      message: \"BroadcastChannel is not available in this environment.\",\n    };\n  }\n}\n","import { config } from \"./config.js\";\nimport type { WcsBroadcast } from \"./components/Broadcast.js\";\n\nlet registered = false;\n\n// Attribute names for the optional post-on-click DOM trigger (clipboard.js-style\n// DX). The element carrying `data-broadcast-target` points at a <wcs-broadcast>\n// by id; the text to post comes from either a literal `data-broadcast-text` or\n// a `data-broadcast-from` CSS selector resolving to a source element.\nconst TEXT_ATTRIBUTE = \"data-broadcast-text\";\nconst FROM_ATTRIBUTE = \"data-broadcast-from\";\n\nfunction resolveText(triggerElement: Element): string | null {\n  // Literal text wins when present (including an empty string — posting \"\" is a\n  // legitimate request). The `?? \"\"` right-hand side is defensive and\n  // unreachable: hasAttribute() just returned true, so getAttribute() cannot be\n  // null here. It exists only to satisfy the `string | null` return type — do\n  // not chase coverage on it (the DOM contract makes the null branch impossible).\n  if (triggerElement.hasAttribute(TEXT_ATTRIBUTE)) {\n    return triggerElement.getAttribute(TEXT_ATTRIBUTE) ?? \"\";\n  }\n  const selector = triggerElement.getAttribute(FROM_ATTRIBUTE);\n  if (!selector) return null;\n  // A user-authored selector can be syntactically invalid (e.g. `[data-*` or a\n  // bare `:not()`), which makes querySelector throw a SyntaxError. Swallow it\n  // and treat the source as unresolvable — the same \"nothing to post\" path as a\n  // selector that matches no element — so one bad attribute never crashes the\n  // document-level click handler and kills autoTrigger for the whole tab.\n  let source: Element | null;\n  try {\n    source = document.querySelector(selector);\n  } catch {\n    return null;\n  }\n  if (!source) return null;\n  // Read a form control's `value`; fall back to text content. A bare\n  // `\"value\" in source` check is too broad — it also matches <button>,\n  // <li value>, <progress>, etc. (which carry an unrelated `value`), posting the\n  // wrong thing. Narrow to the text-bearing controls a user actually points\n  // `data-broadcast-from` at; everything else falls through to textContent.\n  if (\n    source instanceof HTMLInputElement ||\n    source instanceof HTMLTextAreaElement ||\n    source instanceof HTMLSelectElement\n  ) {\n    return source.value;\n  }\n  // `?? \"\"` is defensive: per the DOM spec only Document / DocumentType /\n  // Notation nodes have a null `textContent`, and querySelector only ever\n  // returns an Element (whose textContent is always a string). The branch is\n  // therefore unreachable in practice and kept solely for the `string | null`\n  // type — not worth a contrived test.\n  return source.textContent ?? \"\";\n}\n\nfunction handleClick(event: Event): void {\n  const target = event.target;\n  if (!(target instanceof Element)) return;\n\n  const triggerElement = target.closest<Element>(`[${config.triggerAttribute}]`);\n  if (!triggerElement) return;\n\n  const broadcastId = triggerElement.getAttribute(config.triggerAttribute);\n  if (!broadcastId) return;\n\n  // Resolve the registered constructor at call time instead of importing\n  // WcsBroadcast as a value (avoids a components ⇄ autoTrigger import cycle:\n  // Broadcast.connectedCallback() calls registerAutoTrigger()). instanceof\n  // against the customElements registry keeps the same identity guarantee.\n  const BroadcastCtor = customElements.get(config.tagNames.broadcast);\n  const broadcastElement = document.getElementById(broadcastId);\n  if (!BroadcastCtor || !(broadcastElement instanceof BroadcastCtor)) return;\n\n  const text = resolveText(triggerElement);\n  // No resolvable source: leave the click alone (do not preventDefault) so the\n  // element's default action is unaffected.\n  if (text === null) return;\n\n  // Suppress the default action so a post can run without navigating. Intentional:\n  // do not attach data-broadcast-target to an element whose default action you\n  // also want (a real <a href> link). See README \"Optional DOM Triggering\".\n  event.preventDefault();\n  (broadcastElement as WcsBroadcast).post(text);\n}\n\nexport function registerAutoTrigger(): void {\n  if (registered) return;\n  registered = true;\n  document.addEventListener(\"click\", handleClick);\n}\n\nexport function unregisterAutoTrigger(): void {\n  if (!registered) return;\n  registered = false;\n  document.removeEventListener(\"click\", handleClick);\n}\n","import { config } from \"../config.js\";\nimport { IWcBindable, WcsBroadcastErrorDetail } from \"../types.js\";\nimport { BroadcastCore } from \"../core/BroadcastCore.js\";\nimport { registerAutoTrigger } from \"../autoTrigger.js\";\n\n// Named WcsBroadcast (not `Broadcast`) to match the <wcs-clipboard> WcsClipboard\n// / <wcs-ws> WcsWebSocket convention and avoid shadowing any global.\nexport class WcsBroadcast extends HTMLElement {\n  // The channel opens synchronously in connectedCallback (no async init), so no\n  // connectedCallbackPromise is needed — mirrors <wcs-ws>.\n  static hasConnectedCallbackPromise = false;\n  static wcBindable: IWcBindable = {\n    ...BroadcastCore.wcBindable,\n    // Shell-level settable surface. `name` selects the channel; `manual`\n    // suppresses auto-open on connect. There is no momentary `post` property:\n    // posting needs an argument (the payload), so element actions run via\n    // command-token (`command.post: $command.ping`) or the DOM autoTrigger, not\n    // a value-derived setter — keeping `post` a plain command keeps the\n    // command-token wiring (`command.post:`) readable.\n    inputs: [\n      { name: \"name\", attribute: \"name\" },\n      { name: \"manual\", attribute: \"manual\" },\n    ],\n    // Commands are identical to the Core's — no rename needed since the `name` /\n    // `manual` attribute accessors do not collide with open/post/close.\n    commands: BroadcastCore.wcBindable.commands,\n  };\n  static get observedAttributes(): string[] { return [\"name\"]; }\n\n  private _core: BroadcastCore;\n\n  constructor() {\n    super();\n    this._core = new BroadcastCore(this);\n  }\n\n  // --- Attribute accessors ---\n\n  get name(): string {\n    return this.getAttribute(\"name\") || \"\";\n  }\n\n  set name(value: string) {\n    this.setAttribute(\"name\", value);\n  }\n\n  get manual(): boolean {\n    return this.hasAttribute(\"manual\");\n  }\n\n  set manual(value: boolean) {\n    if (value) {\n      this.setAttribute(\"manual\", \"\");\n    } else {\n      this.removeAttribute(\"manual\");\n    }\n  }\n\n  // --- Core delegated getters ---\n\n  get message(): any {\n    return this._core.message;\n  }\n\n  get error(): WcsBroadcastErrorDetail | null {\n    return this._core.error;\n  }\n\n  // --- Commands ---\n\n  open(): void {\n    if (this.name) {\n      this._core.open(this.name);\n    }\n  }\n\n  post(data: any): void {\n    this._core.post(data);\n  }\n\n  close(): void {\n    this._core.close();\n  }\n\n  // --- Lifecycle ---\n\n  attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void {\n    if (name === \"name\" && this.isConnected && !this.manual && newValue) {\n      this._core.open(newValue);\n    }\n  }\n\n  connectedCallback(): void {\n    this.style.display = \"none\";\n    if (config.autoTrigger) {\n      registerAutoTrigger();\n    }\n    if (!this.manual && this.name) {\n      this._core.open(this.name);\n    }\n  }\n\n  disconnectedCallback(): void {\n    // Deliberately does NOT call unregisterAutoTrigger(). The autoTrigger click\n    // listener is a single process-wide document listener (registerAutoTrigger\n    // is idempotent), shared by every <wcs-broadcast> on the page — not owned by\n    // this element. Tearing it down when the last element disconnects would\n    // break a later-inserted trigger, so it is intentionally left installed for\n    // the document's lifetime (one passive listener, negligible cost). This\n    // mirrors <wcs-clipboard>, which registers but never unregisters either.\n    // unregisterAutoTrigger stays exported purely as a symmetric teardown hook\n    // for tests / advanced manual control; the production lifecycle never calls\n    // it.\n    this._core.dispose();\n  }\n}\n","import { setConfig } from \"./config.js\";\nimport { registerComponents } from \"./registerComponents.js\";\nimport { IWritableConfig } from \"./types.js\";\n\nexport function bootstrapBroadcast(userConfig?: IWritableConfig): void {\n  if (userConfig) {\n    setConfig(userConfig);\n  }\n  registerComponents();\n}\n","import { WcsBroadcast } from \"./components/Broadcast.js\";\nimport { config } from \"./config.js\";\n\nexport function registerComponents(): void {\n  if (!customElements.get(config.tagNames.broadcast)) {\n    customElements.define(config.tagNames.broadcast, WcsBroadcast);\n  }\n}\n"],"names":["_config","autoTrigger","triggerAttribute","tagNames","broadcast","deepFreeze","obj","Object","freeze","key","keys","deepClone","clone","frozenConfig","config","getConfig","BroadcastCore","EventTarget","static","protocol","version","properties","name","event","commands","_target","_channel","_name","_message","_error","constructor","target","super","this","message","error","_setMessage","dispatchEvent","CustomEvent","detail","bubbles","_setError","open","_hasBroadcastChannel","_unsupportedError","_closeChannel","channel","BroadcastChannel","addEventListener","_onMessage","_onMessageError","post","data","postMessage","err","_normalizeError","close","dispose","removeEventListener","Error","String","registered","TEXT_ATTRIBUTE","handleClick","Element","triggerElement","closest","broadcastId","getAttribute","BroadcastCtor","customElements","get","broadcastElement","document","getElementById","text","hasAttribute","selector","source","querySelector","HTMLInputElement","HTMLTextAreaElement","HTMLSelectElement","value","textContent","resolveText","preventDefault","WcsBroadcast","HTMLElement","wcBindable","inputs","attribute","observedAttributes","_core","setAttribute","manual","removeAttribute","attributeChangedCallback","_oldValue","newValue","isConnected","connectedCallback","style","display","disconnectedCallback","bootstrapBroadcast","userConfig","partialConfig","assign","define"],"mappings":"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"}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@wcstack/broadcast",
+  "version": "1.12.0",
+  "description": "Declarative cross-tab messaging component for Web Components. Framework-agnostic BroadcastChannel primitive via wc-bindable-protocol.",
+  "type": "module",
+  "main": "./dist/index.esm.js",
+  "module": "./dist/index.esm.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.esm.js"
+    },
+    "./auto": "./dist/auto.min.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "rimraf dist .tsc-out",
+    "build": "rimraf dist .tsc-out && tsc && rollup -c",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint src",
+    "version:patch": "npm version patch",
+    "version:minor": "npm version minor",
+    "version:major": "npm version major",
+    "prepublishOnly": "npm run build && npm run test:coverage"
+  },
+  "keywords": [
+    "web-components",
+    "broadcast",
+    "broadcastchannel",
+    "cross-tab",
+    "pub-sub",
+    "custom-elements",
+    "wc-bindable",
+    "declarative",
+    "zero-dependencies",
+    "framework-agnostic"
+  ],
+  "author": "mogera551",
+  "homepage": "https://wcstack.github.io",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wcstack/wcstack.git",
+    "directory": "packages/broadcast"
+  },
+  "bugs": {
+    "url": "https://github.com/wcstack/wcstack/issues"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^11.1.6",
+    "@vitest/coverage-v8": "^4.0.15",
+    "@vitest/ui": "^4.0.15",
+    "eslint": "^9.39.1",
+    "globals": "^16.5.0",
+    "happy-dom": "^20.0.11",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.22.4",
+    "rollup-plugin-dts": "^6.1.1",
+    "rollup-plugin-copy": "^3.5.0",
+    "tslib": "^2.8.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.49.0",
+    "vitest": "^4.0.15"
+  }
+}