@wcstack/ambient-light-sensor 1.16.0

package/README.ja.md

@@ -0,0 +1,138 @@
+# @wcstack/ambient-light-sensor
+
+`@wcstack/ambient-light-sensor` は wcstack エコシステム向けのヘッドレスな Generic Sensor API（AmbientLightSensor）コンポーネントです。
+
+視覚的な UI ウィジェットではありません。周囲の明るさ読み取りをリアクティブな state に変える**非同期プリミティブノード**です。
+
+`@wcstack/state` と組み合わせると、`<wcs-ambient-light-sensor>` はパス契約で直接バインドできます:
+
+- **入力サーフェス**: `frequency`（サンプリングレート、Hz）
+- **出力 state サーフェス**: `illuminance`、`error`
+
+明るさ駆動のUI（自動ダークモード、画面減光）を、`AmbientLightSensor`/`reading`/`error`リスナーの配線コードを書かずにHTML上で宣言的に表現できます。
+
+`@wcstack/ambient-light-sensor` は [CSBC](https://github.com/csbc-dev/arch/blob/main/README.md)（Core / Shell / Binding Contract）アーキテクチャに従います:
+
+- **Core**（`AmbientLightSensorCore`）がプラットフォームの`AmbientLightSensor`を構築し、live な`reading`/`error`イベントを追従
+- **Shell**（`<wcs-ambient-light-sensor>`）がその state を DOM ライフサイクルに接続
+- **Binding Contract**（`static wcBindable`）が観測可能な`properties`と`start`/`stop`の`commands`を宣言
+
+## なぜ存在するか — Generic Sensor族の中で最も対応が弱いメンバー
+
+Generic Sensor API の`Accelerometer`/`Gyroscope`/`Magnetometer`/`AmbientLightSensor`族は全て共通の形状を持ちます: `.start()`/`.stop()`、サンプルごとの`'reading'`イベント、そして——注目すべき点として——失敗は例外ではなく**`'error'`イベント**で通知されます。これは wcstack の never-throw 方針と最初から噛み合っています。唯一防御的な`try/catch`が要るのは、権限拒否やPermissions-Policyブロックで**同期的に例外を投げうる**`AmbientLightSensor`のコンストラクタ自体です。
+
+他の3兄弟と異なり、**`AmbientLightSensor`はx/y/z軸ではなく単一のスカラー値**（`illuminance`、lux単位）を報告します。
+
+> **対応状況は狭いだけでなく悪化しています。** 他のセンサー族と共通のChromium/Android中心という制約に加え、`AmbientLightSensor`は特にfingerprinting対策を理由に複数のブラウザで無効化・削除されてきた経緯があります。採用前に現在の対応状況（MDN/caniuse）を必ず確認してください——対象ブラウザによってはこのパッケージの採用自体を見送るべき場合もあります。
+
+> **`@wcstack/permission`との合成を推奨。** センサー自体が対応している環境では`navigator.permissions.query({name:"ambient-light-sensor"})`が存在するため、`<wcs-ambient-light-sensor>`は`<wcs-permission name="ambient-light-sensor">`と併置して`granted`/`denied`/`prompt`状態を得てください（権限状態はこのノード自身では重複実装しません、`docs/sensor-tag-design.md`参照）。
+
+## インストール
+
+```bash
+npm install @wcstack/ambient-light-sensor
+```
+
+## クイックスタート
+
+### 1. 明るさをライブ表示
+
+`<wcs-ambient-light-sensor>`は接続時に**自動開始しません** — バインドしただけでは
+`illuminance`は初期値`null`のままです。読み取りを流すには（例えばボタンから）
+`start`コマンドを発火する必要があります:
+
+```html
+<script type="module" src="https://esm.run/@wcstack/state/auto"></script>
+<script type="module" src="https://esm.run/@wcstack/ambient-light-sensor/auto"></script>
+
+<wcs-state>
+  <script type="module">
+    export default {
+      $commandTokens: ["startLight"],
+      illuminance: null,
+    };
+  </script>
+</wcs-state>
+
+<wcs-ambient-light-sensor
+  data-wcs="illuminance: illuminance; command.start: $command.startLight"
+></wcs-ambient-light-sensor>
+
+<button data-wcs="onclick: $command.startLight">開始</button>
+<p data-wcs="textContent: illuminance"></p>
+```
+
+ボタンは`<wcs-ambient-light-sensor>`に直接触れません: クリックは`startLight`コマンドトークンを発火し（`$commandTokens: ["startLight"]`で名前を宣言）、`<wcs-ambient-light-sensor>`は`command.start: $command.startLight`でそれを購読します（[command-token プロトコル](../state/) — コマンドメソッドを持つ要素が*subscriber*であり、emitter ではありません）。
+
+### 2. 権限を確認してから start する
+
+この例では`@wcstack/permission`の登録も必要です（例1の`@wcstack/state` /
+`@wcstack/ambient-light-sensor`の script に加えて）。`lightGranted`を宣言する
+独立した`<wcs-state>`を持ちます:
+
+```html
+<script type="module" src="https://esm.run/@wcstack/permission/auto"></script>
+
+<wcs-state>
+  <script type="module">
+    export default {
+      $commandTokens: ["startLight"],
+      lightGranted: false,
+    };
+  </script>
+</wcs-state>
+
+<wcs-permission name="ambient-light-sensor" data-wcs="granted: lightGranted"></wcs-permission>
+<wcs-ambient-light-sensor data-wcs="command.start: $command.startLight"></wcs-ambient-light-sensor>
+
+<button data-wcs="onclick: $command.startLight; disabled: lightGranted|not">開始</button>
+```
+
+バインドする state パスは事前にすべて宣言する必要があります — 未宣言のパスへのバインドは初期化時に例外を投げます。`data-wcs`パス内の否定は先頭`!`ではなく`|not`フィルタ(`lightGranted|not`)で行います。
+
+## 属性 / 入力
+
+| 属性        | 型     | 既定値 | 説明 |
+| ----------- | ------ | ------ | ---- |
+| `frequency` | number | —      | サンプリングレート（Hz）。`AmbientLightSensor`コンストラクタへそのまま渡る。 |
+
+## 観測可能プロパティ（出力）
+
+| プロパティ     | イベント                              | 説明 |
+| -------------- | --------------------------------------- | ---- |
+| `illuminance`  | `wcs-ambient-light-sensor:reading`       | 周囲の明るさ（lux）。初回読み取り前は`null`。 |
+| `error`        | `wcs-ambient-light-sensor:error`         | 正規化された`{ error, message }`、無ければ`null`。 |
+
+## コマンド
+
+| コマンド | 非同期 | 説明 |
+| -------- | ------ | ---- |
+| `start`  | いいえ | センサーを構築（never-throw: コンストラクタの同期例外はキャッチし`error`へ）し読み取りを開始する。 |
+| `stop`   | いいえ | センサーを停止しリスナーを解除する。未開始でも安全に呼べる。 |
+
+## 注意・制限
+
+- **`_gen`世代ガードは無し。** `start()`/`stop()`は同期的な購読/購読解除のトグルであり、`dispose()`とレースしうる非同期probeが存在しません（`docs/sensor-tag-design.md` §1.5）。
+- **`error`は sticky（据え置き）です。** 最後に観測した失敗（`unsupported`、`SecurityError`等）を保持し、その後の`start()`成功や`reading`受信では自動クリアされません。`stop()`＋`start()`でリトライが成功しても直前の`error`は残り続けます。必要なら利用側の state でクリア／再解釈してください。
+- **生の`new AmbientLightSensor(...)`は唯一のガード付き構築ヘルパー以外では呼ばない。** 権限拒否・Permissions-Policyブロックは同期的に例外を投げます。
+- 権限状態（`granted`/`denied`/`prompt`）は意図的にこのノードでは重複実装していません — `<wcs-permission name="ambient-light-sensor">`と合成してください。
+- **採用前に現在のブラウザ対応状況を必ず確認してください** — 上記「なぜ存在するか」参照。
+
+## ヘッドレス利用（`AmbientLightSensorCore`）
+
+```typescript
+import { AmbientLightSensorCore } from "@wcstack/ambient-light-sensor";
+
+const core = new AmbientLightSensorCore();
+core.addEventListener("wcs-ambient-light-sensor:reading", (e) => {
+  console.log((e as CustomEvent).detail); // { illuminance }
+});
+
+core.start();
+// 後始末:
+core.dispose();
+```
+
+## ライセンス
+
+MIT

package/README.md

@@ -0,0 +1,139 @@
+# @wcstack/ambient-light-sensor
+
+`@wcstack/ambient-light-sensor` is a headless Generic Sensor API (AmbientLightSensor) component for the wcstack ecosystem.
+
+It is not a visual UI widget.
+It is an **async primitive node** that turns ambient light readings into reactive state.
+
+With `@wcstack/state`, `<wcs-ambient-light-sensor>` can be bound directly through path contracts:
+
+- **input surface**: `frequency` (sampling rate in Hz)
+- **output state surface**: `illuminance`, `error`
+
+This means light-level-driven UI (auto dark mode, screen dimming) can be expressed declaratively in HTML, without writing `AmbientLightSensor`/`reading`/`error`-listener glue in your UI layer.
+
+`@wcstack/ambient-light-sensor` follows the [CSBC](https://github.com/csbc-dev/arch/blob/main/README.md) (Core / Shell / Binding Contract) architecture:
+
+- **Core** (`AmbientLightSensorCore`) constructs the platform `AmbientLightSensor`, tracks its live `reading`/`error` events
+- **Shell** (`<wcs-ambient-light-sensor>`) connects that state to DOM lifecycle
+- **Binding Contract** (`static wcBindable`) declares observable `properties` and `start`/`stop` `commands`
+
+## Why this exists — the weakest-supported member of the Generic Sensor family
+
+The Generic Sensor API's `Accelerometer`/`Gyroscope`/`Magnetometer`/`AmbientLightSensor` family all share one base shape: `.start()`/`.stop()`, a `'reading'` event per sample, and — notably — an `'error'` **event** for failures instead of a thrown exception. This already lines up with wcstack's never-throw convention; the one place this Core still needs a defensive `try/catch` is the synchronous `AmbientLightSensor` **constructor** itself, which can throw (`SecurityError`) on permission denial or a Permissions-Policy block.
+
+Unlike its three siblings, **`AmbientLightSensor` reports a single scalar** (`illuminance`, in lux) rather than x/y/z axes.
+
+> **Support is deteriorating, not just narrow.** Beyond the usual Chromium/Android-centric limits shared with the rest of the family, `AmbientLightSensor` specifically has been disabled or removed in several browsers over fingerprinting concerns. Verify current support (MDN/caniuse) before depending on this package — it may not be worth shipping at all depending on your target browsers.
+
+> **Compose with `@wcstack/permission`.** `navigator.permissions.query({name:"ambient-light-sensor"})` exists where the sensor itself is supported — pair `<wcs-ambient-light-sensor>` with `<wcs-permission name="ambient-light-sensor">` for `granted`/`denied`/`prompt` status rather than duplicating that state here (see `docs/sensor-tag-design.md`).
+
+## Install
+
+```bash
+npm install @wcstack/ambient-light-sensor
+```
+
+## Quick Start
+
+### 1. Read live illuminance
+
+`<wcs-ambient-light-sensor>` does **not** auto-start on connect — binding alone
+leaves `illuminance` at its initial `null`. You must fire the `start` command
+(e.g. from a button) before readings flow:
+
+```html
+<script type="module" src="https://esm.run/@wcstack/state/auto"></script>
+<script type="module" src="https://esm.run/@wcstack/ambient-light-sensor/auto"></script>
+
+<wcs-state>
+  <script type="module">
+    export default {
+      $commandTokens: ["startLight"],
+      illuminance: null,
+    };
+  </script>
+</wcs-state>
+
+<wcs-ambient-light-sensor
+  data-wcs="illuminance: illuminance; command.start: $command.startLight"
+></wcs-ambient-light-sensor>
+
+<button data-wcs="onclick: $command.startLight">Start</button>
+<p data-wcs="textContent: illuminance"></p>
+```
+
+The button never touches `<wcs-ambient-light-sensor>` directly: its click emits the `startLight` command token (`$commandTokens: ["startLight"]` declares the name), and `<wcs-ambient-light-sensor>` subscribes to it via `command.start: $command.startLight` (the [command-token protocol](../state/) — the element with the command method is the *subscriber*, not the emitter).
+
+### 2. Gate on permission, then start
+
+This example also needs `@wcstack/permission` registered (alongside the
+`@wcstack/state` / `@wcstack/ambient-light-sensor` scripts from example 1), with its
+own self-contained `<wcs-state>` declaring `lightGranted`:
+
+```html
+<script type="module" src="https://esm.run/@wcstack/permission/auto"></script>
+
+<wcs-state>
+  <script type="module">
+    export default {
+      $commandTokens: ["startLight"],
+      lightGranted: false,
+    };
+  </script>
+</wcs-state>
+
+<wcs-permission name="ambient-light-sensor" data-wcs="granted: lightGranted"></wcs-permission>
+<wcs-ambient-light-sensor data-wcs="command.start: $command.startLight"></wcs-ambient-light-sensor>
+
+<button data-wcs="onclick: $command.startLight; disabled: lightGranted|not">Start</button>
+```
+
+Every bound state path must be declared up front — binding an undeclared path throws at initialization. Negation in a `data-wcs` path is done with the `|not` filter (`lightGranted|not`), not a leading `!`.
+
+## Attributes / Inputs
+
+| Attribute   | Type   | Default | Description |
+| ----------- | ------ | ------- | ------------ |
+| `frequency` | number | —       | Sampling rate in Hz, forwarded to the `AmbientLightSensor` constructor. |
+
+## Observable Properties (outputs)
+
+| Property      | Event                                | Description |
+| ------------- | -------------------------------------- | ------------ |
+| `illuminance` | `wcs-ambient-light-sensor:reading`      | Ambient light level in lux, or `null` before the first reading. |
+| `error`       | `wcs-ambient-light-sensor:error`        | Normalized `{ error, message }`, or `null`. |
+
+## Commands
+
+| Command | Async | Description |
+| ------- | ----- | ------------ |
+| `start` | no    | Construct the sensor (never-throw: a synchronous constructor exception is caught and surfaced via `error`) and begin reading. |
+| `stop`  | no    | Stop the sensor and detach its listeners. Safe to call when not started. |
+
+## Notes & limitations
+
+- **No `_gen` generation guard.** `start()`/`stop()` are a synchronous subscribe/unsubscribe toggle with no asynchronous probe to race against a `dispose()` — see `docs/sensor-tag-design.md` §1.5.
+- **`error` is sticky.** It holds the last observed failure (e.g. `unsupported`, `SecurityError`) and is **not** auto-cleared by a later successful `start()` or by incoming `reading`s. A `stop()` + `start()` retry that succeeds still leaves the previous `error` in place — clear or reinterpret it in your own state if needed.
+- **Never call the raw `new AmbientLightSensor(...)` anywhere but the one guarded construction helper** — permission denial and Permissions-Policy blocks throw synchronously.
+- Permission status (`granted`/`denied`/`prompt`) is intentionally not duplicated here — compose with `<wcs-permission name="ambient-light-sensor">`.
+- **Confirm current browser support before adopting this package** — see "Why this exists" above.
+
+## Headless usage (`AmbientLightSensorCore`)
+
+```typescript
+import { AmbientLightSensorCore } from "@wcstack/ambient-light-sensor";
+
+const core = new AmbientLightSensorCore();
+core.addEventListener("wcs-ambient-light-sensor:reading", (e) => {
+  console.log((e as CustomEvent).detail); // { illuminance }
+});
+
+core.start();
+// later:
+core.dispose();
+```
+
+## License
+
+MIT

package/dist/auto.js

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

package/dist/auto.min.js

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

package/dist/index.d.ts

@@ -0,0 +1,211 @@
+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: 1;
+    readonly properties: readonly IWcBindableProperty[];
+    readonly inputs?: readonly IWcBindableInput[];
+    readonly commands?: readonly IWcBindableCommand[];
+}
+
+interface ITagNames {
+    readonly ambientLightSensor: string;
+}
+interface IWritableTagNames {
+    ambientLightSensor?: string;
+}
+interface IConfig {
+    readonly tagNames: ITagNames;
+}
+interface IWritableConfig {
+    tagNames?: IWritableTagNames;
+}
+
+/**
+ * A single `reading` sample from the AmbientLightSensor sensor: ambient light
+ * level in lux. Unlike Accelerometer/Gyroscope/Magnetometer (x/y/z axes),
+ * AmbientLightSensor reports a single scalar (docs/sensor-tag-design.md §2).
+ */
+interface WcsAmbientLightSensorReading {
+    illuminance: number | null;
+}
+/**
+ * Error detail published on the `wcs-ambient-light-sensor:error` event. Mirrors the
+ * Generic Sensor API's `SensorErrorEvent.error` (a `DOMException`-like value)
+ * flattened to a plain object, plus the synthetic `"unsupported"` name used
+ * when the global `AmbientLightSensor` constructor is absent.
+ */
+interface WcsAmbientLightSensorErrorDetail {
+    error: string;
+    message: string;
+}
+/**
+ * Value types for AmbientLightSensorCore (headless) — the observable state
+ * properties. Use with `bind()` from a wc-bindable binding core for
+ * compile-time type checking.
+ *
+ * @example
+ * ```typescript
+ * const core = new AmbientLightSensorCore();
+ * bind(core, (name: keyof WcsAmbientLightSensorCoreValues, value) => { ... });
+ * ```
+ */
+interface WcsAmbientLightSensorCoreValues extends WcsAmbientLightSensorReading {
+    error: WcsAmbientLightSensorErrorDetail | null;
+}
+/**
+ * Value types for the Shell (`<wcs-ambient-light-sensor>`) — identical observable
+ * surface to the Core, plus the `frequency` attribute-backed input.
+ */
+type WcsAmbientLightSensorValues = WcsAmbientLightSensorCoreValues;
+
+declare function bootstrapAmbientLightSensor(userConfig?: IWritableConfig): void;
+
+declare function getConfig(): IConfig;
+
+/**
+ * Headless AmbientLightSensor primitive. A thin, framework-agnostic wrapper around
+ * the Generic Sensor API's `AmbientLightSensor` class exposed through the
+ * wc-bindable protocol.
+ *
+ * The platform `Sensor` base class (shared by `Accelerometer` / `Gyroscope` /
+ * `Magnetometer` / `AmbientLightSensor`) reports failure through an `'error'`
+ * event rather than a rejected promise, so this Core can satisfy never-throw
+ * (docs/async-io-node-guidelines.md §3.6) by simply forwarding that event —
+ * see docs/sensor-tag-design.md §0. The one place a synchronous
+ * exception *can* still escape the platform API is the `AmbientLightSensor`
+ * constructor itself (e.g. `SecurityError` on permission denial or a
+ * feature-policy block); `_createSensor()` wraps that single call in
+ * try/catch, mirroring FetchCore's `_doFetch` try/catch around
+ * `globalThis.fetch` (packages/fetch/src/core/FetchCore.ts).
+ *
+ * `illuminance` is a single getter derived from the `wcs-ambient-light-sensor:reading`
+ * event (unlike Accelerometer/Gyroscope/Magnetometer's x/y/z, this sensor
+ * reports one scalar — docs/sensor-tag-design.md §2). `reading`
+ * is an event-like signal (a fresh sample every time, not a settled state) and
+ * is therefore deliberately NOT same-value guarded — every sample dispatches.
+ * `error` is state-like (denial / unsupported does not change from tick to
+ * tick) and IS same-value guarded, and is published on its own
+ * `wcs-ambient-light-sensor:error` event, independent of `reading`.
+ *
+ * No `_gen` generation guard: start()/stop() are a synchronous
+ * subscribe/unsubscribe toggle with no asynchronous probe whose stale
+ * resolution could race a dispose() — see docs/sensor-tag-design.md §1.5
+ * (the same reasoning as NetworkCore, docs/network-tag-design.md §5).
+ *
+ * Permissions: this Core does not query `navigator.permissions` itself.
+ * Compose with `<wcs-permission name="ambient-light-sensor">` instead — see
+ * docs/sensor-tag-design.md §"2番目の決定: Permissions APIとの合成".
+ */
+declare class AmbientLightSensorCore extends EventTarget {
+    static wcBindable: IWcBindable;
+    private _target;
+    private _reading;
+    private _error;
+    private _sensor;
+    constructor(target?: EventTarget);
+    get illuminance(): number | null;
+    get error(): WcsAmbientLightSensorErrorDetail | null;
+    /** No asynchronous probe to await: start()/stop() are synchronous
+     *  (docs/async-io-node-guidelines.md §3.8 is satisfied trivially, mirroring
+     *  NetworkCore). */
+    get ready(): Promise<void>;
+    private _setReading;
+    private _setError;
+    /**
+     * Start the sensor at the given `frequency` (Hz), or the platform default
+     * when omitted. Idempotent while already started: a redundant start() does
+     * not construct a second sensor instance (which would leak the first).
+     * Restart with a different frequency via stop() + start().
+     *
+     * Synchronous, mirroring the native `Sensor.start()` — never throws
+     * (docs/async-io-node-guidelines.md §3.6): both "unsupported" and a
+     * synchronous constructor exception (permission denial, feature-policy
+     * block) are converted to the `error` property instead of propagating.
+     */
+    start(frequency?: number): void;
+    /** Stop the sensor and detach its listeners. Safe to call when not started. */
+    stop(): void;
+    /** Lifecycle alias for start(), so the Shell's connectedCallback can drive
+     *  this Core the same way as other IO nodes' observe()/dispose() pair. No
+     *  asynchronous probe, so the returned promise always resolves immediately. */
+    observe(frequency?: number): Promise<void>;
+    /** Lifecycle alias for stop(), invoked from the Shell's disconnectedCallback. */
+    dispose(): void;
+    private _teardownSensor;
+    /**
+     * Construct the platform `AmbientLightSensor`, guarding both non-support and a
+     * synchronous constructor exception. Never calls the raw `new AmbientLightSensor(...)`
+     * anywhere else in this class — see docs/sensor-tag-design.md §1.5.
+     *
+     * API resolution is call-time (docs/async-io-node-guidelines.md §3.7):
+     * re-checked on every start(), never cached, so tests can install/remove the
+     * global freely and an unsupported environment is always reported correctly.
+     */
+    private _createSensor;
+    private _onReading;
+    private _onError;
+}
+
+/**
+ * `<wcs-ambient-light-sensor>` — declarative Generic Sensor API (`AmbientLightSensor`)
+ * monitor + start/stop control.
+ *
+ * Unlike `<wcs-network>` / `<wcs-permission>` (pure monitors), this Shell is a
+ * bidirectional node: `start`/`stop` commands (command-token: state → element)
+ * alongside the `illuminance`/`error` observable surface (event-token: element →
+ * state). The `frequency` attribute is the sole configuration input, forwarded
+ * to the platform `AmbientLightSensor` constructor's `{ frequency }` option
+ * (docs/sensor-tag-design.md §1.2). The getter normalizes it: a non-finite or
+ * non-positive value (NaN, 0, negative) reads back as `null` — meaning "no
+ * frequency specified" — so start() falls back to the platform default rather
+ * than forwarding a value the sensor would reject. Any positive finite value is
+ * passed through verbatim (no upper-bound clamping — an out-of-range-but-positive
+ * rate is still left to the browser/sensor to reject via `error`).
+ *
+ * Permission handling is intentionally NOT implemented here. Compose with
+ * `<wcs-permission name="ambient-light-sensor">` instead (see the README's permission
+ * example, "Gate on permission, then start", and docs/sensor-tag-design.md).
+ */
+declare class WcsAmbientLightSensor extends HTMLElement {
+    static hasConnectedCallbackPromise: boolean;
+    static wcBindable: IWcBindable;
+    private _core;
+    private _connectedCallbackPromise;
+    constructor();
+    /**
+     * Sampling frequency in Hz. Reads back `null` when unset, blank, or when the
+     * attribute does not parse to a positive finite number (NaN, `"0"`, negative)
+     * — in every such "no usable value" case the platform default applies.
+     *
+     * Note the deliberate set/get asymmetry: `set frequency(0)` (or any
+     * non-positive/non-finite value) still writes the attribute verbatim for
+     * transparency/inspectability, but the getter normalizes it back to `null`.
+     * A round-trip through a non-positive value therefore does NOT preserve it —
+     * that value carries no valid sampling meaning, so it is treated as "unset"
+     * on read. Only positive finite frequencies survive a set→get round-trip.
+     */
+    get frequency(): number | null;
+    set frequency(value: number | null | undefined);
+    get illuminance(): number | null;
+    get error(): WcsAmbientLightSensorErrorDetail | null;
+    get connectedCallbackPromise(): Promise<void>;
+    start(): void;
+    stop(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+}
+
+export { AmbientLightSensorCore, WcsAmbientLightSensor, bootstrapAmbientLightSensor, getConfig };
+export type { IWritableConfig, IWritableTagNames, WcsAmbientLightSensorCoreValues, WcsAmbientLightSensorErrorDetail, WcsAmbientLightSensorReading, WcsAmbientLightSensorValues };

package/dist/index.esm.js

@@ -0,0 +1,353 @@
+const _config = {
+    tagNames: {
+        ambientLightSensor: "wcs-ambient-light-sensor",
+    },
+};
+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;
+const config = _config;
+function getConfig() {
+    if (!frozenConfig) {
+        frozenConfig = deepFreeze(deepClone(_config));
+    }
+    return frozenConfig;
+}
+function setConfig(partialConfig) {
+    if (partialConfig.tagNames) {
+        Object.assign(_config.tagNames, partialConfig.tagNames);
+    }
+    frozenConfig = null;
+}
+
+const NULL_READING = Object.freeze({ illuminance: null });
+/**
+ * Headless AmbientLightSensor primitive. A thin, framework-agnostic wrapper around
+ * the Generic Sensor API's `AmbientLightSensor` class exposed through the
+ * wc-bindable protocol.
+ *
+ * The platform `Sensor` base class (shared by `Accelerometer` / `Gyroscope` /
+ * `Magnetometer` / `AmbientLightSensor`) reports failure through an `'error'`
+ * event rather than a rejected promise, so this Core can satisfy never-throw
+ * (docs/async-io-node-guidelines.md §3.6) by simply forwarding that event —
+ * see docs/sensor-tag-design.md §0. The one place a synchronous
+ * exception *can* still escape the platform API is the `AmbientLightSensor`
+ * constructor itself (e.g. `SecurityError` on permission denial or a
+ * feature-policy block); `_createSensor()` wraps that single call in
+ * try/catch, mirroring FetchCore's `_doFetch` try/catch around
+ * `globalThis.fetch` (packages/fetch/src/core/FetchCore.ts).
+ *
+ * `illuminance` is a single getter derived from the `wcs-ambient-light-sensor:reading`
+ * event (unlike Accelerometer/Gyroscope/Magnetometer's x/y/z, this sensor
+ * reports one scalar — docs/sensor-tag-design.md §2). `reading`
+ * is an event-like signal (a fresh sample every time, not a settled state) and
+ * is therefore deliberately NOT same-value guarded — every sample dispatches.
+ * `error` is state-like (denial / unsupported does not change from tick to
+ * tick) and IS same-value guarded, and is published on its own
+ * `wcs-ambient-light-sensor:error` event, independent of `reading`.
+ *
+ * No `_gen` generation guard: start()/stop() are a synchronous
+ * subscribe/unsubscribe toggle with no asynchronous probe whose stale
+ * resolution could race a dispose() — see docs/sensor-tag-design.md §1.5
+ * (the same reasoning as NetworkCore, docs/network-tag-design.md §5).
+ *
+ * Permissions: this Core does not query `navigator.permissions` itself.
+ * Compose with `<wcs-permission name="ambient-light-sensor">` instead — see
+ * docs/sensor-tag-design.md §"2番目の決定: Permissions APIとの合成".
+ */
+class AmbientLightSensorCore extends EventTarget {
+    static wcBindable = {
+        protocol: "wc-bindable",
+        version: 1,
+        properties: [
+            { name: "illuminance", event: "wcs-ambient-light-sensor:reading", getter: (e) => e.detail.illuminance },
+            { name: "error", event: "wcs-ambient-light-sensor:error" },
+        ],
+        commands: [{ name: "start" }, { name: "stop" }],
+    };
+    _target;
+    _reading = NULL_READING;
+    _error = null;
+    // The live sensor instance while started (null otherwise), kept so stop()
+    // can remove its listeners precisely and so start() can detect "already
+    // started" without a separate boolean (docs/async-io-node-guidelines.md §3.5
+    // idempotency).
+    _sensor = null;
+    constructor(target) {
+        super();
+        this._target = target ?? this;
+    }
+    get illuminance() {
+        return this._reading.illuminance;
+    }
+    get error() {
+        return this._error;
+    }
+    /** No asynchronous probe to await: start()/stop() are synchronous
+     *  (docs/async-io-node-guidelines.md §3.8 is satisfied trivially, mirroring
+     *  NetworkCore). */
+    get ready() {
+        return Promise.resolve();
+    }
+    // --- State setters ---
+    // Deliberately NOT same-value guarded: a `reading` is a fresh sample, not a
+    // settled state, so it must dispatch every time even when the values happen
+    // to repeat (docs/sensor-tag-design.md §1.1).
+    _setReading(reading) {
+        this._reading = reading;
+        this._target.dispatchEvent(new CustomEvent("wcs-ambient-light-sensor:reading", {
+            detail: reading,
+            bubbles: true,
+        }));
+    }
+    _setError(error) {
+        // Same-value guard (by error name + message): error is state-like, unlike
+        // reading — a repeated identical error (same name and message) must not
+        // redispatch. Note `error` is also STICKY: nothing calls _setError(null),
+        // so a successful (re)start does not clear a prior failure — the monitoring
+        // sensor family deliberately keeps the last observed error (docs/sensor-tag-design.md §1.5).
+        if (this._error?.error === error?.error && this._error?.message === error?.message)
+            return;
+        this._error = error;
+        this._target.dispatchEvent(new CustomEvent("wcs-ambient-light-sensor:error", {
+            detail: error,
+            bubbles: true,
+        }));
+    }
+    // --- Public API ---
+    /**
+     * Start the sensor at the given `frequency` (Hz), or the platform default
+     * when omitted. Idempotent while already started: a redundant start() does
+     * not construct a second sensor instance (which would leak the first).
+     * Restart with a different frequency via stop() + start().
+     *
+     * Synchronous, mirroring the native `Sensor.start()` — never throws
+     * (docs/async-io-node-guidelines.md §3.6): both "unsupported" and a
+     * synchronous constructor exception (permission denial, feature-policy
+     * block) are converted to the `error` property instead of propagating.
+     */
+    start(frequency) {
+        if (this._sensor)
+            return;
+        const sensor = this._createSensor(frequency);
+        if (!sensor)
+            return;
+        sensor.addEventListener("reading", this._onReading);
+        sensor.addEventListener("error", this._onError);
+        this._sensor = sensor;
+        try {
+            sensor.start();
+        }
+        catch (e) {
+            // Defensive: the platform contract says start()/stop() do not throw
+            // (failures surface via the 'error' event), but never-throw is a hard
+            // requirement here, so guard against a non-conformant implementation
+            // too.
+            this._teardownSensor();
+            this._setError({ error: e?.name ?? "error", message: e?.message ?? String(e) });
+        }
+    }
+    /** Stop the sensor and detach its listeners. Safe to call when not started. */
+    stop() {
+        if (!this._sensor)
+            return;
+        try {
+            this._sensor.stop();
+        }
+        catch {
+            // Never-throw defensive guard, symmetric with start(). Teardown below
+            // still runs so listeners are detached regardless.
+        }
+        this._teardownSensor();
+    }
+    /** Lifecycle alias for start(), so the Shell's connectedCallback can drive
+     *  this Core the same way as other IO nodes' observe()/dispose() pair. No
+     *  asynchronous probe, so the returned promise always resolves immediately. */
+    observe(frequency) {
+        this.start(frequency);
+        return this.ready;
+    }
+    /** Lifecycle alias for stop(), invoked from the Shell's disconnectedCallback. */
+    dispose() {
+        this.stop();
+    }
+    // --- Internal ---
+    // Both call sites (start()'s catch, stop()) only ever invoke this once
+    // `this._sensor` is already known non-null, so there is no null-guard here
+    // (nothing to defend against).
+    _teardownSensor() {
+        this._sensor.removeEventListener("reading", this._onReading);
+        this._sensor.removeEventListener("error", this._onError);
+        this._sensor = null;
+    }
+    /**
+     * Construct the platform `AmbientLightSensor`, guarding both non-support and a
+     * synchronous constructor exception. Never calls the raw `new AmbientLightSensor(...)`
+     * anywhere else in this class — see docs/sensor-tag-design.md §1.5.
+     *
+     * API resolution is call-time (docs/async-io-node-guidelines.md §3.7):
+     * re-checked on every start(), never cached, so tests can install/remove the
+     * global freely and an unsupported environment is always reported correctly.
+     */
+    _createSensor(frequency) {
+        const Ctor = globalThis.AmbientLightSensor;
+        if (typeof Ctor !== "function") {
+            this._setError({ error: "unsupported", message: "AmbientLightSensor is not supported" });
+            return null;
+        }
+        try {
+            return new Ctor(frequency !== undefined ? { frequency } : undefined);
+        }
+        catch (e) {
+            // SecurityError (permission denial, feature-policy block) or any other
+            // synchronous construction failure. Mirrors the FetchCore._doFetch
+            // try/catch structure (packages/fetch/src/core/FetchCore.ts) — a
+            // synchronous constructor call here instead of an awaited fetch().
+            this._setError({ error: e?.name ?? "error", message: e?.message ?? String(e) });
+            return null;
+        }
+    }
+    _onReading = (event) => {
+        const sensor = event.target;
+        this._setReading({ illuminance: sensor.illuminance });
+    };
+    _onError = (event) => {
+        const err = event.error;
+        // Fallback is a meaningful constant, NOT String(err): a SensorErrorEvent
+        // without an `error` field would otherwise stringify `undefined` into the
+        // literal message "undefined" (aligned across the sensor family).
+        this._setError({ error: err?.name ?? "error", message: err?.message ?? "Sensor error" });
+    };
+}
+
+/**
+ * `<wcs-ambient-light-sensor>` — declarative Generic Sensor API (`AmbientLightSensor`)
+ * monitor + start/stop control.
+ *
+ * Unlike `<wcs-network>` / `<wcs-permission>` (pure monitors), this Shell is a
+ * bidirectional node: `start`/`stop` commands (command-token: state → element)
+ * alongside the `illuminance`/`error` observable surface (event-token: element →
+ * state). The `frequency` attribute is the sole configuration input, forwarded
+ * to the platform `AmbientLightSensor` constructor's `{ frequency }` option
+ * (docs/sensor-tag-design.md §1.2). The getter normalizes it: a non-finite or
+ * non-positive value (NaN, 0, negative) reads back as `null` — meaning "no
+ * frequency specified" — so start() falls back to the platform default rather
+ * than forwarding a value the sensor would reject. Any positive finite value is
+ * passed through verbatim (no upper-bound clamping — an out-of-range-but-positive
+ * rate is still left to the browser/sensor to reject via `error`).
+ *
+ * Permission handling is intentionally NOT implemented here. Compose with
+ * `<wcs-permission name="ambient-light-sensor">` instead (see the README's permission
+ * example, "Gate on permission, then start", and docs/sensor-tag-design.md).
+ */
+class WcsAmbientLightSensor extends HTMLElement {
+    static hasConnectedCallbackPromise = true;
+    static wcBindable = {
+        ...AmbientLightSensorCore.wcBindable,
+        inputs: [{ name: "frequency" }],
+        // Core の commands をそのまま継承（単一情報源）。
+        commands: AmbientLightSensorCore.wcBindable.commands,
+    };
+    _core;
+    _connectedCallbackPromise = Promise.resolve();
+    constructor() {
+        super();
+        this._core = new AmbientLightSensorCore(this);
+    }
+    // --- Attribute accessors ---
+    /**
+     * Sampling frequency in Hz. Reads back `null` when unset, blank, or when the
+     * attribute does not parse to a positive finite number (NaN, `"0"`, negative)
+     * — in every such "no usable value" case the platform default applies.
+     *
+     * Note the deliberate set/get asymmetry: `set frequency(0)` (or any
+     * non-positive/non-finite value) still writes the attribute verbatim for
+     * transparency/inspectability, but the getter normalizes it back to `null`.
+     * A round-trip through a non-positive value therefore does NOT preserve it —
+     * that value carries no valid sampling meaning, so it is treated as "unset"
+     * on read. Only positive finite frequencies survive a set→get round-trip.
+     */
+    get frequency() {
+        const attr = this.getAttribute("frequency");
+        if (attr === null || attr.trim() === "")
+            return null;
+        const parsed = Number(attr);
+        return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+    }
+    set frequency(value) {
+        if (value === null || value === undefined) {
+            this.removeAttribute("frequency");
+        }
+        else {
+            this.setAttribute("frequency", String(value));
+        }
+    }
+    // --- Core delegated getters ---
+    get illuminance() {
+        return this._core.illuminance;
+    }
+    get error() {
+        return this._core.error;
+    }
+    get connectedCallbackPromise() {
+        return this._connectedCallbackPromise;
+    }
+    // --- Commands ---
+    start() {
+        this._core.start(this.frequency ?? undefined);
+    }
+    stop() {
+        this._core.stop();
+    }
+    // --- Lifecycle ---
+    // Deliberately does NOT auto-start the sensor on connect. Unlike
+    // Geolocation (whose default phase acquires a fix immediately unless
+    // `manual` is set), AmbientLightSensor has no such "connect implies observing"
+    // precedent in the design doc (docs/sensor-tag-design.md §1.3):
+    // start/stop are the only commands, so connecting the element merely makes
+    // it inert until a command-token `start` (or the `start()` method) is
+    // invoked. This also keeps behavior predictable when composed with
+    // `<wcs-permission name="ambient-light-sensor">`: the caller decides when to start,
+    // typically gated on `granted`.
+    connectedCallback() {
+        this.style.display = "none";
+        // No asynchronous probe to await (§3.8); kept for SSR uniformity with
+        // other IO nodes.
+        this._connectedCallbackPromise = this._core.ready;
+    }
+    disconnectedCallback() {
+        this._core.dispose();
+    }
+}
+
+function registerComponents() {
+    if (!customElements.get(config.tagNames.ambientLightSensor)) {
+        customElements.define(config.tagNames.ambientLightSensor, WcsAmbientLightSensor);
+    }
+}
+
+function bootstrapAmbientLightSensor(userConfig) {
+    if (userConfig) {
+        setConfig(userConfig);
+    }
+    registerComponents();
+}
+
+export { AmbientLightSensorCore, WcsAmbientLightSensor, bootstrapAmbientLightSensor, 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/AmbientLightSensorCore.ts","../src/components/AmbientLightSensor.ts","../src/registerComponents.ts","../src/bootstrapAmbientLightSensor.ts"],"sourcesContent":["import { IConfig, IWritableConfig } from \"./types.js\";\n\ninterface IInternalConfig extends IConfig {\n  tagNames: {\n    ambientLightSensor: string;\n  };\n}\n\nconst _config: IInternalConfig = {\n  tagNames: {\n    ambientLightSensor: \"wcs-ambient-light-sensor\",\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\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 (partialConfig.tagNames) {\n    Object.assign(_config.tagNames, partialConfig.tagNames);\n  }\n  frozenConfig = null;\n}\n","import { IWcBindable, WcsAmbientLightSensorReading, WcsAmbientLightSensorErrorDetail } from \"../types.js\";\n\nconst NULL_READING: WcsAmbientLightSensorReading = Object.freeze({ illuminance: null });\n\n/**\n * Headless AmbientLightSensor primitive. A thin, framework-agnostic wrapper around\n * the Generic Sensor API's `AmbientLightSensor` class exposed through the\n * wc-bindable protocol.\n *\n * The platform `Sensor` base class (shared by `Accelerometer` / `Gyroscope` /\n * `Magnetometer` / `AmbientLightSensor`) reports failure through an `'error'`\n * event rather than a rejected promise, so this Core can satisfy never-throw\n * (docs/async-io-node-guidelines.md §3.6) by simply forwarding that event —\n * see docs/sensor-tag-design.md §0. The one place a synchronous\n * exception *can* still escape the platform API is the `AmbientLightSensor`\n * constructor itself (e.g. `SecurityError` on permission denial or a\n * feature-policy block); `_createSensor()` wraps that single call in\n * try/catch, mirroring FetchCore's `_doFetch` try/catch around\n * `globalThis.fetch` (packages/fetch/src/core/FetchCore.ts).\n *\n * `illuminance` is a single getter derived from the `wcs-ambient-light-sensor:reading`\n * event (unlike Accelerometer/Gyroscope/Magnetometer's x/y/z, this sensor\n * reports one scalar — docs/sensor-tag-design.md §2). `reading`\n * is an event-like signal (a fresh sample every time, not a settled state) and\n * is therefore deliberately NOT same-value guarded — every sample dispatches.\n * `error` is state-like (denial / unsupported does not change from tick to\n * tick) and IS same-value guarded, and is published on its own\n * `wcs-ambient-light-sensor:error` event, independent of `reading`.\n *\n * No `_gen` generation guard: start()/stop() are a synchronous\n * subscribe/unsubscribe toggle with no asynchronous probe whose stale\n * resolution could race a dispose() — see docs/sensor-tag-design.md §1.5\n * (the same reasoning as NetworkCore, docs/network-tag-design.md §5).\n *\n * Permissions: this Core does not query `navigator.permissions` itself.\n * Compose with `<wcs-permission name=\"ambient-light-sensor\">` instead — see\n * docs/sensor-tag-design.md §\"2番目の決定: Permissions APIとの合成\".\n */\nexport class AmbientLightSensorCore extends EventTarget {\n  static wcBindable: IWcBindable = {\n    protocol: \"wc-bindable\",\n    version: 1,\n    properties: [\n      { name: \"illuminance\", event: \"wcs-ambient-light-sensor:reading\", getter: (e: Event) => (e as CustomEvent).detail.illuminance },\n      { name: \"error\", event: \"wcs-ambient-light-sensor:error\" },\n    ],\n    commands: [{ name: \"start\" }, { name: \"stop\" }],\n  };\n\n  private _target: EventTarget;\n  private _reading: WcsAmbientLightSensorReading = NULL_READING;\n  private _error: WcsAmbientLightSensorErrorDetail | null = null;\n\n  // The live sensor instance while started (null otherwise), kept so stop()\n  // can remove its listeners precisely and so start() can detect \"already\n  // started\" without a separate boolean (docs/async-io-node-guidelines.md §3.5\n  // idempotency).\n  private _sensor: (EventTarget & { start(): void; stop(): void }) | null = null;\n\n  constructor(target?: EventTarget) {\n    super();\n    this._target = target ?? this;\n  }\n\n  get illuminance(): number | null {\n    return this._reading.illuminance;\n  }\n\n  get error(): WcsAmbientLightSensorErrorDetail | null {\n    return this._error;\n  }\n\n  /** No asynchronous probe to await: start()/stop() are synchronous\n   *  (docs/async-io-node-guidelines.md §3.8 is satisfied trivially, mirroring\n   *  NetworkCore). */\n  get ready(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  // --- State setters ---\n\n  // Deliberately NOT same-value guarded: a `reading` is a fresh sample, not a\n  // settled state, so it must dispatch every time even when the values happen\n  // to repeat (docs/sensor-tag-design.md §1.1).\n  private _setReading(reading: WcsAmbientLightSensorReading): void {\n    this._reading = reading;\n    this._target.dispatchEvent(new CustomEvent(\"wcs-ambient-light-sensor:reading\", {\n      detail: reading,\n      bubbles: true,\n    }));\n  }\n\n  private _setError(error: WcsAmbientLightSensorErrorDetail | null): void {\n    // Same-value guard (by error name + message): error is state-like, unlike\n    // reading — a repeated identical error (same name and message) must not\n    // redispatch. Note `error` is also STICKY: nothing calls _setError(null),\n    // so a successful (re)start does not clear a prior failure — the monitoring\n    // sensor family deliberately keeps the last observed error (docs/sensor-tag-design.md §1.5).\n    if (this._error?.error === error?.error && this._error?.message === error?.message) return;\n    this._error = error;\n    this._target.dispatchEvent(new CustomEvent(\"wcs-ambient-light-sensor:error\", {\n      detail: error,\n      bubbles: true,\n    }));\n  }\n\n  // --- Public API ---\n\n  /**\n   * Start the sensor at the given `frequency` (Hz), or the platform default\n   * when omitted. Idempotent while already started: a redundant start() does\n   * not construct a second sensor instance (which would leak the first).\n   * Restart with a different frequency via stop() + start().\n   *\n   * Synchronous, mirroring the native `Sensor.start()` — never throws\n   * (docs/async-io-node-guidelines.md §3.6): both \"unsupported\" and a\n   * synchronous constructor exception (permission denial, feature-policy\n   * block) are converted to the `error` property instead of propagating.\n   */\n  start(frequency?: number): void {\n    if (this._sensor) return;\n    const sensor = this._createSensor(frequency);\n    if (!sensor) return;\n    sensor.addEventListener(\"reading\", this._onReading as EventListener);\n    sensor.addEventListener(\"error\", this._onError as EventListener);\n    this._sensor = sensor;\n    try {\n      sensor.start();\n    } catch (e: any) {\n      // Defensive: the platform contract says start()/stop() do not throw\n      // (failures surface via the 'error' event), but never-throw is a hard\n      // requirement here, so guard against a non-conformant implementation\n      // too.\n      this._teardownSensor();\n      this._setError({ error: e?.name ?? \"error\", message: e?.message ?? String(e) });\n    }\n  }\n\n  /** Stop the sensor and detach its listeners. Safe to call when not started. */\n  stop(): void {\n    if (!this._sensor) return;\n    try {\n      this._sensor.stop();\n    } catch {\n      // Never-throw defensive guard, symmetric with start(). Teardown below\n      // still runs so listeners are detached regardless.\n    }\n    this._teardownSensor();\n  }\n\n  /** Lifecycle alias for start(), so the Shell's connectedCallback can drive\n   *  this Core the same way as other IO nodes' observe()/dispose() pair. No\n   *  asynchronous probe, so the returned promise always resolves immediately. */\n  observe(frequency?: number): Promise<void> {\n    this.start(frequency);\n    return this.ready;\n  }\n\n  /** Lifecycle alias for stop(), invoked from the Shell's disconnectedCallback. */\n  dispose(): void {\n    this.stop();\n  }\n\n  // --- Internal ---\n\n  // Both call sites (start()'s catch, stop()) only ever invoke this once\n  // `this._sensor` is already known non-null, so there is no null-guard here\n  // (nothing to defend against).\n  private _teardownSensor(): void {\n    this._sensor!.removeEventListener(\"reading\", this._onReading as EventListener);\n    this._sensor!.removeEventListener(\"error\", this._onError as EventListener);\n    this._sensor = null;\n  }\n\n  /**\n   * Construct the platform `AmbientLightSensor`, guarding both non-support and a\n   * synchronous constructor exception. Never calls the raw `new AmbientLightSensor(...)`\n   * anywhere else in this class — see docs/sensor-tag-design.md §1.5.\n   *\n   * API resolution is call-time (docs/async-io-node-guidelines.md §3.7):\n   * re-checked on every start(), never cached, so tests can install/remove the\n   * global freely and an unsupported environment is always reported correctly.\n   */\n  private _createSensor(frequency?: number): (EventTarget & { start(): void; stop(): void }) | null {\n    const Ctor = (globalThis as any).AmbientLightSensor;\n    if (typeof Ctor !== \"function\") {\n      this._setError({ error: \"unsupported\", message: \"AmbientLightSensor is not supported\" });\n      return null;\n    }\n    try {\n      return new Ctor(frequency !== undefined ? { frequency } : undefined);\n    } catch (e: any) {\n      // SecurityError (permission denial, feature-policy block) or any other\n      // synchronous construction failure. Mirrors the FetchCore._doFetch\n      // try/catch structure (packages/fetch/src/core/FetchCore.ts) — a\n      // synchronous constructor call here instead of an awaited fetch().\n      this._setError({ error: e?.name ?? \"error\", message: e?.message ?? String(e) });\n      return null;\n    }\n  }\n\n  private _onReading = (event: Event): void => {\n    const sensor = event.target as unknown as { illuminance: number | null };\n    this._setReading({ illuminance: sensor.illuminance });\n  };\n\n  private _onError = (event: Event): void => {\n    const err = (event as any).error as { name?: string; message?: string } | undefined;\n    // Fallback is a meaningful constant, NOT String(err): a SensorErrorEvent\n    // without an `error` field would otherwise stringify `undefined` into the\n    // literal message \"undefined\" (aligned across the sensor family).\n    this._setError({ error: err?.name ?? \"error\", message: err?.message ?? \"Sensor error\" });\n  };\n}\n","import { IWcBindable, WcsAmbientLightSensorErrorDetail } from \"../types.js\";\nimport { AmbientLightSensorCore } from \"../core/AmbientLightSensorCore.js\";\n\n/**\n * `<wcs-ambient-light-sensor>` — declarative Generic Sensor API (`AmbientLightSensor`)\n * monitor + start/stop control.\n *\n * Unlike `<wcs-network>` / `<wcs-permission>` (pure monitors), this Shell is a\n * bidirectional node: `start`/`stop` commands (command-token: state → element)\n * alongside the `illuminance`/`error` observable surface (event-token: element →\n * state). The `frequency` attribute is the sole configuration input, forwarded\n * to the platform `AmbientLightSensor` constructor's `{ frequency }` option\n * (docs/sensor-tag-design.md §1.2). The getter normalizes it: a non-finite or\n * non-positive value (NaN, 0, negative) reads back as `null` — meaning \"no\n * frequency specified\" — so start() falls back to the platform default rather\n * than forwarding a value the sensor would reject. Any positive finite value is\n * passed through verbatim (no upper-bound clamping — an out-of-range-but-positive\n * rate is still left to the browser/sensor to reject via `error`).\n *\n * Permission handling is intentionally NOT implemented here. Compose with\n * `<wcs-permission name=\"ambient-light-sensor\">` instead (see the README's permission\n * example, \"Gate on permission, then start\", and docs/sensor-tag-design.md).\n */\nexport class WcsAmbientLightSensor extends HTMLElement {\n  static hasConnectedCallbackPromise = true;\n\n  static wcBindable: IWcBindable = {\n    ...AmbientLightSensorCore.wcBindable,\n    inputs: [{ name: \"frequency\" }],\n    // Core の commands をそのまま継承（単一情報源）。\n    commands: AmbientLightSensorCore.wcBindable.commands,\n  };\n\n  private _core: AmbientLightSensorCore;\n  private _connectedCallbackPromise: Promise<void> = Promise.resolve();\n\n  constructor() {\n    super();\n    this._core = new AmbientLightSensorCore(this);\n  }\n\n  // --- Attribute accessors ---\n\n  /**\n   * Sampling frequency in Hz. Reads back `null` when unset, blank, or when the\n   * attribute does not parse to a positive finite number (NaN, `\"0\"`, negative)\n   * — in every such \"no usable value\" case the platform default applies.\n   *\n   * Note the deliberate set/get asymmetry: `set frequency(0)` (or any\n   * non-positive/non-finite value) still writes the attribute verbatim for\n   * transparency/inspectability, but the getter normalizes it back to `null`.\n   * A round-trip through a non-positive value therefore does NOT preserve it —\n   * that value carries no valid sampling meaning, so it is treated as \"unset\"\n   * on read. Only positive finite frequencies survive a set→get round-trip.\n   */\n  get frequency(): number | null {\n    const attr = this.getAttribute(\"frequency\");\n    if (attr === null || attr.trim() === \"\") return null;\n    const parsed = Number(attr);\n    return Number.isFinite(parsed) && parsed > 0 ? parsed : null;\n  }\n\n  set frequency(value: number | null | undefined) {\n    if (value === null || value === undefined) {\n      this.removeAttribute(\"frequency\");\n    } else {\n      this.setAttribute(\"frequency\", String(value));\n    }\n  }\n\n  // --- Core delegated getters ---\n\n  get illuminance(): number | null {\n    return this._core.illuminance;\n  }\n\n  get error(): WcsAmbientLightSensorErrorDetail | null {\n    return this._core.error;\n  }\n\n  get connectedCallbackPromise(): Promise<void> {\n    return this._connectedCallbackPromise;\n  }\n\n  // --- Commands ---\n\n  start(): void {\n    this._core.start(this.frequency ?? undefined);\n  }\n\n  stop(): void {\n    this._core.stop();\n  }\n\n  // --- Lifecycle ---\n\n  // Deliberately does NOT auto-start the sensor on connect. Unlike\n  // Geolocation (whose default phase acquires a fix immediately unless\n  // `manual` is set), AmbientLightSensor has no such \"connect implies observing\"\n  // precedent in the design doc (docs/sensor-tag-design.md §1.3):\n  // start/stop are the only commands, so connecting the element merely makes\n  // it inert until a command-token `start` (or the `start()` method) is\n  // invoked. This also keeps behavior predictable when composed with\n  // `<wcs-permission name=\"ambient-light-sensor\">`: the caller decides when to start,\n  // typically gated on `granted`.\n  connectedCallback(): void {\n    this.style.display = \"none\";\n    // No asynchronous probe to await (§3.8); kept for SSR uniformity with\n    // other IO nodes.\n    this._connectedCallbackPromise = this._core.ready;\n  }\n\n  disconnectedCallback(): void {\n    this._core.dispose();\n  }\n}\n","import { WcsAmbientLightSensor } from \"./components/AmbientLightSensor.js\";\nimport { config } from \"./config.js\";\n\nexport function registerComponents(): void {\n  if (!customElements.get(config.tagNames.ambientLightSensor)) {\n    customElements.define(config.tagNames.ambientLightSensor, WcsAmbientLightSensor);\n  }\n}\n","import { setConfig } from \"./config.js\";\nimport { registerComponents } from \"./registerComponents.js\";\nimport { IWritableConfig } from \"./types.js\";\n\nexport function bootstrapAmbientLightSensor(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={tagNames:{ambientLightSensor:"wcs-ambient-light-sensor"}};function r(e){if(null===e||"object"!=typeof e)return e;Object.freeze(e);for(const t of Object.keys(e))r(e[t]);return e}function t(e){if(null===e||"object"!=typeof e)return e;const r={};for(const s of Object.keys(e))r[s]=t(e[s]);return r}let s=null;const n=e;function i(){return s||(s=r(t(e))),s}const o=Object.freeze({illuminance:null});class a extends EventTarget{static wcBindable={protocol:"wc-bindable",version:1,properties:[{name:"illuminance",event:"wcs-ambient-light-sensor:reading",getter:e=>e.detail.illuminance},{name:"error",event:"wcs-ambient-light-sensor:error"}],commands:[{name:"start"},{name:"stop"}]};_target;_reading=o;_error=null;_sensor=null;constructor(e){super(),this._target=e??this}get illuminance(){return this._reading.illuminance}get error(){return this._error}get ready(){return Promise.resolve()}_setReading(e){this._reading=e,this._target.dispatchEvent(new CustomEvent("wcs-ambient-light-sensor:reading",{detail:e,bubbles:!0}))}_setError(e){this._error?.error===e?.error&&this._error?.message===e?.message||(this._error=e,this._target.dispatchEvent(new CustomEvent("wcs-ambient-light-sensor:error",{detail:e,bubbles:!0})))}start(e){if(this._sensor)return;const r=this._createSensor(e);if(r){r.addEventListener("reading",this._onReading),r.addEventListener("error",this._onError),this._sensor=r;try{r.start()}catch(e){this._teardownSensor(),this._setError({error:e?.name??"error",message:e?.message??String(e)})}}}stop(){if(this._sensor){try{this._sensor.stop()}catch{}this._teardownSensor()}}observe(e){return this.start(e),this.ready}dispose(){this.stop()}_teardownSensor(){this._sensor.removeEventListener("reading",this._onReading),this._sensor.removeEventListener("error",this._onError),this._sensor=null}_createSensor(e){const r=globalThis.AmbientLightSensor;if("function"!=typeof r)return this._setError({error:"unsupported",message:"AmbientLightSensor is not supported"}),null;try{return new r(void 0!==e?{frequency:e}:void 0)}catch(e){return this._setError({error:e?.name??"error",message:e?.message??String(e)}),null}}_onReading=e=>{const r=e.target;this._setReading({illuminance:r.illuminance})};_onError=e=>{const r=e.error;this._setError({error:r?.name??"error",message:r?.message??"Sensor error"})}}class c extends HTMLElement{static hasConnectedCallbackPromise=!0;static wcBindable={...a.wcBindable,inputs:[{name:"frequency"}],commands:a.wcBindable.commands};_core;_connectedCallbackPromise=Promise.resolve();constructor(){super(),this._core=new a(this)}get frequency(){const e=this.getAttribute("frequency");if(null===e||""===e.trim())return null;const r=Number(e);return Number.isFinite(r)&&r>0?r:null}set frequency(e){null==e?this.removeAttribute("frequency"):this.setAttribute("frequency",String(e))}get illuminance(){return this._core.illuminance}get error(){return this._core.error}get connectedCallbackPromise(){return this._connectedCallbackPromise}start(){this._core.start(this.frequency??void 0)}stop(){this._core.stop()}connectedCallback(){this.style.display="none",this._connectedCallbackPromise=this._core.ready}disconnectedCallback(){this._core.dispose()}}function l(r){var t;r&&((t=r).tagNames&&Object.assign(e.tagNames,t.tagNames),s=null),customElements.get(n.tagNames.ambientLightSensor)||customElements.define(n.tagNames.ambientLightSensor,c)}export{a as AmbientLightSensorCore,c as WcsAmbientLightSensor,l as bootstrapAmbientLightSensor,i 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/AmbientLightSensorCore.ts","../src/components/AmbientLightSensor.ts","../src/bootstrapAmbientLightSensor.ts","../src/registerComponents.ts"],"sourcesContent":["import { IConfig, IWritableConfig } from \"./types.js\";\n\ninterface IInternalConfig extends IConfig {\n  tagNames: {\n    ambientLightSensor: string;\n  };\n}\n\nconst _config: IInternalConfig = {\n  tagNames: {\n    ambientLightSensor: \"wcs-ambient-light-sensor\",\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\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 (partialConfig.tagNames) {\n    Object.assign(_config.tagNames, partialConfig.tagNames);\n  }\n  frozenConfig = null;\n}\n","import { IWcBindable, WcsAmbientLightSensorReading, WcsAmbientLightSensorErrorDetail } from \"../types.js\";\n\nconst NULL_READING: WcsAmbientLightSensorReading = Object.freeze({ illuminance: null });\n\n/**\n * Headless AmbientLightSensor primitive. A thin, framework-agnostic wrapper around\n * the Generic Sensor API's `AmbientLightSensor` class exposed through the\n * wc-bindable protocol.\n *\n * The platform `Sensor` base class (shared by `Accelerometer` / `Gyroscope` /\n * `Magnetometer` / `AmbientLightSensor`) reports failure through an `'error'`\n * event rather than a rejected promise, so this Core can satisfy never-throw\n * (docs/async-io-node-guidelines.md §3.6) by simply forwarding that event —\n * see docs/sensor-tag-design.md §0. The one place a synchronous\n * exception *can* still escape the platform API is the `AmbientLightSensor`\n * constructor itself (e.g. `SecurityError` on permission denial or a\n * feature-policy block); `_createSensor()` wraps that single call in\n * try/catch, mirroring FetchCore's `_doFetch` try/catch around\n * `globalThis.fetch` (packages/fetch/src/core/FetchCore.ts).\n *\n * `illuminance` is a single getter derived from the `wcs-ambient-light-sensor:reading`\n * event (unlike Accelerometer/Gyroscope/Magnetometer's x/y/z, this sensor\n * reports one scalar — docs/sensor-tag-design.md §2). `reading`\n * is an event-like signal (a fresh sample every time, not a settled state) and\n * is therefore deliberately NOT same-value guarded — every sample dispatches.\n * `error` is state-like (denial / unsupported does not change from tick to\n * tick) and IS same-value guarded, and is published on its own\n * `wcs-ambient-light-sensor:error` event, independent of `reading`.\n *\n * No `_gen` generation guard: start()/stop() are a synchronous\n * subscribe/unsubscribe toggle with no asynchronous probe whose stale\n * resolution could race a dispose() — see docs/sensor-tag-design.md §1.5\n * (the same reasoning as NetworkCore, docs/network-tag-design.md §5).\n *\n * Permissions: this Core does not query `navigator.permissions` itself.\n * Compose with `<wcs-permission name=\"ambient-light-sensor\">` instead — see\n * docs/sensor-tag-design.md §\"2番目の決定: Permissions APIとの合成\".\n */\nexport class AmbientLightSensorCore extends EventTarget {\n  static wcBindable: IWcBindable = {\n    protocol: \"wc-bindable\",\n    version: 1,\n    properties: [\n      { name: \"illuminance\", event: \"wcs-ambient-light-sensor:reading\", getter: (e: Event) => (e as CustomEvent).detail.illuminance },\n      { name: \"error\", event: \"wcs-ambient-light-sensor:error\" },\n    ],\n    commands: [{ name: \"start\" }, { name: \"stop\" }],\n  };\n\n  private _target: EventTarget;\n  private _reading: WcsAmbientLightSensorReading = NULL_READING;\n  private _error: WcsAmbientLightSensorErrorDetail | null = null;\n\n  // The live sensor instance while started (null otherwise), kept so stop()\n  // can remove its listeners precisely and so start() can detect \"already\n  // started\" without a separate boolean (docs/async-io-node-guidelines.md §3.5\n  // idempotency).\n  private _sensor: (EventTarget & { start(): void; stop(): void }) | null = null;\n\n  constructor(target?: EventTarget) {\n    super();\n    this._target = target ?? this;\n  }\n\n  get illuminance(): number | null {\n    return this._reading.illuminance;\n  }\n\n  get error(): WcsAmbientLightSensorErrorDetail | null {\n    return this._error;\n  }\n\n  /** No asynchronous probe to await: start()/stop() are synchronous\n   *  (docs/async-io-node-guidelines.md §3.8 is satisfied trivially, mirroring\n   *  NetworkCore). */\n  get ready(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  // --- State setters ---\n\n  // Deliberately NOT same-value guarded: a `reading` is a fresh sample, not a\n  // settled state, so it must dispatch every time even when the values happen\n  // to repeat (docs/sensor-tag-design.md §1.1).\n  private _setReading(reading: WcsAmbientLightSensorReading): void {\n    this._reading = reading;\n    this._target.dispatchEvent(new CustomEvent(\"wcs-ambient-light-sensor:reading\", {\n      detail: reading,\n      bubbles: true,\n    }));\n  }\n\n  private _setError(error: WcsAmbientLightSensorErrorDetail | null): void {\n    // Same-value guard (by error name + message): error is state-like, unlike\n    // reading — a repeated identical error (same name and message) must not\n    // redispatch. Note `error` is also STICKY: nothing calls _setError(null),\n    // so a successful (re)start does not clear a prior failure — the monitoring\n    // sensor family deliberately keeps the last observed error (docs/sensor-tag-design.md §1.5).\n    if (this._error?.error === error?.error && this._error?.message === error?.message) return;\n    this._error = error;\n    this._target.dispatchEvent(new CustomEvent(\"wcs-ambient-light-sensor:error\", {\n      detail: error,\n      bubbles: true,\n    }));\n  }\n\n  // --- Public API ---\n\n  /**\n   * Start the sensor at the given `frequency` (Hz), or the platform default\n   * when omitted. Idempotent while already started: a redundant start() does\n   * not construct a second sensor instance (which would leak the first).\n   * Restart with a different frequency via stop() + start().\n   *\n   * Synchronous, mirroring the native `Sensor.start()` — never throws\n   * (docs/async-io-node-guidelines.md §3.6): both \"unsupported\" and a\n   * synchronous constructor exception (permission denial, feature-policy\n   * block) are converted to the `error` property instead of propagating.\n   */\n  start(frequency?: number): void {\n    if (this._sensor) return;\n    const sensor = this._createSensor(frequency);\n    if (!sensor) return;\n    sensor.addEventListener(\"reading\", this._onReading as EventListener);\n    sensor.addEventListener(\"error\", this._onError as EventListener);\n    this._sensor = sensor;\n    try {\n      sensor.start();\n    } catch (e: any) {\n      // Defensive: the platform contract says start()/stop() do not throw\n      // (failures surface via the 'error' event), but never-throw is a hard\n      // requirement here, so guard against a non-conformant implementation\n      // too.\n      this._teardownSensor();\n      this._setError({ error: e?.name ?? \"error\", message: e?.message ?? String(e) });\n    }\n  }\n\n  /** Stop the sensor and detach its listeners. Safe to call when not started. */\n  stop(): void {\n    if (!this._sensor) return;\n    try {\n      this._sensor.stop();\n    } catch {\n      // Never-throw defensive guard, symmetric with start(). Teardown below\n      // still runs so listeners are detached regardless.\n    }\n    this._teardownSensor();\n  }\n\n  /** Lifecycle alias for start(), so the Shell's connectedCallback can drive\n   *  this Core the same way as other IO nodes' observe()/dispose() pair. No\n   *  asynchronous probe, so the returned promise always resolves immediately. */\n  observe(frequency?: number): Promise<void> {\n    this.start(frequency);\n    return this.ready;\n  }\n\n  /** Lifecycle alias for stop(), invoked from the Shell's disconnectedCallback. */\n  dispose(): void {\n    this.stop();\n  }\n\n  // --- Internal ---\n\n  // Both call sites (start()'s catch, stop()) only ever invoke this once\n  // `this._sensor` is already known non-null, so there is no null-guard here\n  // (nothing to defend against).\n  private _teardownSensor(): void {\n    this._sensor!.removeEventListener(\"reading\", this._onReading as EventListener);\n    this._sensor!.removeEventListener(\"error\", this._onError as EventListener);\n    this._sensor = null;\n  }\n\n  /**\n   * Construct the platform `AmbientLightSensor`, guarding both non-support and a\n   * synchronous constructor exception. Never calls the raw `new AmbientLightSensor(...)`\n   * anywhere else in this class — see docs/sensor-tag-design.md §1.5.\n   *\n   * API resolution is call-time (docs/async-io-node-guidelines.md §3.7):\n   * re-checked on every start(), never cached, so tests can install/remove the\n   * global freely and an unsupported environment is always reported correctly.\n   */\n  private _createSensor(frequency?: number): (EventTarget & { start(): void; stop(): void }) | null {\n    const Ctor = (globalThis as any).AmbientLightSensor;\n    if (typeof Ctor !== \"function\") {\n      this._setError({ error: \"unsupported\", message: \"AmbientLightSensor is not supported\" });\n      return null;\n    }\n    try {\n      return new Ctor(frequency !== undefined ? { frequency } : undefined);\n    } catch (e: any) {\n      // SecurityError (permission denial, feature-policy block) or any other\n      // synchronous construction failure. Mirrors the FetchCore._doFetch\n      // try/catch structure (packages/fetch/src/core/FetchCore.ts) — a\n      // synchronous constructor call here instead of an awaited fetch().\n      this._setError({ error: e?.name ?? \"error\", message: e?.message ?? String(e) });\n      return null;\n    }\n  }\n\n  private _onReading = (event: Event): void => {\n    const sensor = event.target as unknown as { illuminance: number | null };\n    this._setReading({ illuminance: sensor.illuminance });\n  };\n\n  private _onError = (event: Event): void => {\n    const err = (event as any).error as { name?: string; message?: string } | undefined;\n    // Fallback is a meaningful constant, NOT String(err): a SensorErrorEvent\n    // without an `error` field would otherwise stringify `undefined` into the\n    // literal message \"undefined\" (aligned across the sensor family).\n    this._setError({ error: err?.name ?? \"error\", message: err?.message ?? \"Sensor error\" });\n  };\n}\n","import { IWcBindable, WcsAmbientLightSensorErrorDetail } from \"../types.js\";\nimport { AmbientLightSensorCore } from \"../core/AmbientLightSensorCore.js\";\n\n/**\n * `<wcs-ambient-light-sensor>` — declarative Generic Sensor API (`AmbientLightSensor`)\n * monitor + start/stop control.\n *\n * Unlike `<wcs-network>` / `<wcs-permission>` (pure monitors), this Shell is a\n * bidirectional node: `start`/`stop` commands (command-token: state → element)\n * alongside the `illuminance`/`error` observable surface (event-token: element →\n * state). The `frequency` attribute is the sole configuration input, forwarded\n * to the platform `AmbientLightSensor` constructor's `{ frequency }` option\n * (docs/sensor-tag-design.md §1.2). The getter normalizes it: a non-finite or\n * non-positive value (NaN, 0, negative) reads back as `null` — meaning \"no\n * frequency specified\" — so start() falls back to the platform default rather\n * than forwarding a value the sensor would reject. Any positive finite value is\n * passed through verbatim (no upper-bound clamping — an out-of-range-but-positive\n * rate is still left to the browser/sensor to reject via `error`).\n *\n * Permission handling is intentionally NOT implemented here. Compose with\n * `<wcs-permission name=\"ambient-light-sensor\">` instead (see the README's permission\n * example, \"Gate on permission, then start\", and docs/sensor-tag-design.md).\n */\nexport class WcsAmbientLightSensor extends HTMLElement {\n  static hasConnectedCallbackPromise = true;\n\n  static wcBindable: IWcBindable = {\n    ...AmbientLightSensorCore.wcBindable,\n    inputs: [{ name: \"frequency\" }],\n    // Core の commands をそのまま継承（単一情報源）。\n    commands: AmbientLightSensorCore.wcBindable.commands,\n  };\n\n  private _core: AmbientLightSensorCore;\n  private _connectedCallbackPromise: Promise<void> = Promise.resolve();\n\n  constructor() {\n    super();\n    this._core = new AmbientLightSensorCore(this);\n  }\n\n  // --- Attribute accessors ---\n\n  /**\n   * Sampling frequency in Hz. Reads back `null` when unset, blank, or when the\n   * attribute does not parse to a positive finite number (NaN, `\"0\"`, negative)\n   * — in every such \"no usable value\" case the platform default applies.\n   *\n   * Note the deliberate set/get asymmetry: `set frequency(0)` (or any\n   * non-positive/non-finite value) still writes the attribute verbatim for\n   * transparency/inspectability, but the getter normalizes it back to `null`.\n   * A round-trip through a non-positive value therefore does NOT preserve it —\n   * that value carries no valid sampling meaning, so it is treated as \"unset\"\n   * on read. Only positive finite frequencies survive a set→get round-trip.\n   */\n  get frequency(): number | null {\n    const attr = this.getAttribute(\"frequency\");\n    if (attr === null || attr.trim() === \"\") return null;\n    const parsed = Number(attr);\n    return Number.isFinite(parsed) && parsed > 0 ? parsed : null;\n  }\n\n  set frequency(value: number | null | undefined) {\n    if (value === null || value === undefined) {\n      this.removeAttribute(\"frequency\");\n    } else {\n      this.setAttribute(\"frequency\", String(value));\n    }\n  }\n\n  // --- Core delegated getters ---\n\n  get illuminance(): number | null {\n    return this._core.illuminance;\n  }\n\n  get error(): WcsAmbientLightSensorErrorDetail | null {\n    return this._core.error;\n  }\n\n  get connectedCallbackPromise(): Promise<void> {\n    return this._connectedCallbackPromise;\n  }\n\n  // --- Commands ---\n\n  start(): void {\n    this._core.start(this.frequency ?? undefined);\n  }\n\n  stop(): void {\n    this._core.stop();\n  }\n\n  // --- Lifecycle ---\n\n  // Deliberately does NOT auto-start the sensor on connect. Unlike\n  // Geolocation (whose default phase acquires a fix immediately unless\n  // `manual` is set), AmbientLightSensor has no such \"connect implies observing\"\n  // precedent in the design doc (docs/sensor-tag-design.md §1.3):\n  // start/stop are the only commands, so connecting the element merely makes\n  // it inert until a command-token `start` (or the `start()` method) is\n  // invoked. This also keeps behavior predictable when composed with\n  // `<wcs-permission name=\"ambient-light-sensor\">`: the caller decides when to start,\n  // typically gated on `granted`.\n  connectedCallback(): void {\n    this.style.display = \"none\";\n    // No asynchronous probe to await (§3.8); kept for SSR uniformity with\n    // other IO nodes.\n    this._connectedCallbackPromise = this._core.ready;\n  }\n\n  disconnectedCallback(): void {\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 bootstrapAmbientLightSensor(userConfig?: IWritableConfig): void {\n  if (userConfig) {\n    setConfig(userConfig);\n  }\n  registerComponents();\n}\n","import { WcsAmbientLightSensor } from \"./components/AmbientLightSensor.js\";\nimport { config } from \"./config.js\";\n\nexport function registerComponents(): void {\n  if (!customElements.get(config.tagNames.ambientLightSensor)) {\n    customElements.define(config.tagNames.ambientLightSensor, WcsAmbientLightSensor);\n  }\n}\n"],"names":["_config","tagNames","ambientLightSensor","deepFreeze","obj","Object","freeze","key","keys","deepClone","clone","frozenConfig","config","getConfig","NULL_READING","illuminance","AmbientLightSensorCore","EventTarget","static","protocol","version","properties","name","event","getter","e","detail","commands","_target","_reading","_error","_sensor","constructor","target","super","this","error","ready","Promise","resolve","_setReading","reading","dispatchEvent","CustomEvent","bubbles","_setError","message","start","frequency","sensor","_createSensor","addEventListener","_onReading","_onError","_teardownSensor","String","stop","observe","dispose","removeEventListener","Ctor","globalThis","AmbientLightSensor","undefined","err","WcsAmbientLightSensor","HTMLElement","wcBindable","inputs","_core","_connectedCallbackPromise","attr","getAttribute","trim","parsed","Number","isFinite","value","removeAttribute","setAttribute","connectedCallbackPromise","connectedCallback","style","display","disconnectedCallback","bootstrapAmbientLightSensor","userConfig","partialConfig","assign","customElements","get","define"],"mappings":"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"}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@wcstack/ambient-light-sensor",
+  "version": "1.16.0",
+  "description": "Declarative AmbientLightSensor component for Web Components. Framework-agnostic Generic Sensor API (AmbientLightSensor) monitor 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",
+    "ambient-light-sensor",
+    "generic-sensor",
+    "illuminance",
+    "light",
+    "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/ambient-light-sensor"
+  },
+  "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"
+  }
+}