@symbiote-native/brightness 0.0.1

package/LICENSE

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

package/README.md

@@ -0,0 +1,290 @@
+# @symbiote-native/brightness
+
+A wrapper package for [SymbioteNative](../../README.md) that makes
+[`expo-brightness`](https://github.com/expo/expo/tree/main/packages/expo-brightness) — screen
+brightness get/set, Android-only system-brightness-mode control, an iOS-only brightness-change
+listener, and permission get/request — usable from **every** adapter, React, Vue, and Angular, not
+just React. Unlike [`@symbiote-native/sensors`](../sensors) — a `DeviceSensor` class per instance,
+subscribed through a hook/composable/service — this package's surface is mostly stateless free
+async functions plus one listener; only the permission surface gets its own lifecycle hook/
+composable/service, mirroring upstream's own `usePermissions`. Built the same way as
+[`@symbiote-native/local-auth`](../local-auth), [`@symbiote-native/battery`](../battery), and
+[`@symbiote-native/haptics`](../haptics) — an `expo-modules-core`-based wrapper (see the
+`symbiote-expo-native-module` project skill for the full mechanism: why `expo-modules-core` is
+depended on directly and never the `expo` meta-package, why the upstream JS is hand-ported into
+`core/` rather than imported, and how autolinking picks up the native module).
+
+## Install
+
+```bash
+npm install @symbiote-native/brightness
+```
+
+`expo-brightness` and `expo-modules-core` come along as regular, pinned dependencies — never
+install either yourself, and never add the `expo` meta-package to this project (it bundles its own
+Metro/Babel pipeline that conflicts with this project's own).
+
+### Required one-time step: native autolinking wiring
+
+Unlike a plain RN native module, `expo-brightness`'s native code is discovered by
+`expo-modules-autolinking`, not the `react-native.config.cjs`/podspec mechanism other wrappers in
+this repo use — this needs wiring into the native host app **once**, covering this package and
+every other `expo-modules-core` package with zero further changes:
+
+| Platform | Touches |
+|---|---|
+| iOS | `ios/Podfile` — add `use_expo_modules!` |
+| iOS | `AppDelegate.swift` — Expo's runtime-bootstrap hook |
+| Android | `settings.gradle` / `app/build.gradle` — resolve and include the Expo Gradle projects |
+| Android | `MainApplication.kt` — Expo's bootstrap hook, plus a hand-written native-module name map (there's no `expo` meta-package here to auto-generate one) |
+| Android | `AndroidManifest.xml` — `android.permission.WRITE_SETTINGS`, required to set the system-wide brightness (`setSystemBrightnessAsync`/`setSystemBrightnessModeAsync`) |
+
+Full mechanics — the Podfile pieces that normally ship inside the `expo` package, the `expo`
+peer-dependency exclusion list — live in the `symbiote-expo-native-module` skill. Reference
+implementation: `examples/expo-react/android/app/src/main/AndroidManifest.xml` (the
+`WRITE_SETTINGS` permission) and
+`examples/expo-react/android/app/src/main/java/com/canaryexpo/MainApplication.kt` (the
+`BrightnessModule` registration) — the Vue and Angular Expo canaries wire the same three layers.
+
+## Shape
+
+```
+src/core/                 isAvailableAsync, get/setBrightnessAsync, the Android-only
+                          system-brightness-mode surface, permission get/request, and
+                          addBrightnessListener (iOS only); native-module.ts resolves
+                          ExpoBrightness through expo-modules-core's requireNativeModule.
+src/react/hooks/           @symbiote-native/brightness/react   — usePermissions
+src/vue/composables/       @symbiote-native/brightness/vue     — usePermissions (same name)
+src/angular/services/      @symbiote-native/brightness/angular — PermissionsService
+```
+
+Each adapter's hook/composable/service wraps the same one-shot `getPermissionsAsync`/
+`requestPermissionsAsync` pair in its own lifecycle idiom (auto-fetch on mount, exposed as a
+tuple/object/signal). Every other export — brightness get/set, the system-brightness-mode surface,
+the listener — is a stateless free-function re-export, written once in `core/` and shared verbatim
+by all three adapters.
+
+## Use it
+
+```tsx
+// React — trimmed from examples/expo-react/screens/BrightnessScreen.tsx
+import { useEffect, useState } from 'react';
+import { Pressable, Text, View } from '@symbiote-native/react';
+import {
+  addBrightnessListener,
+  getBrightnessAsync,
+  setBrightnessAsync,
+} from '@symbiote-native/brightness';
+import { usePermissions } from '@symbiote-native/brightness/react';
+
+function BrightnessScreen() {
+  const [brightness, setBrightness] = useState<number | null>(null);
+  const [permissionStatus, requestPermission] = usePermissions();
+
+  useEffect(() => {
+    getBrightnessAsync().then(setBrightness);
+    // iOS only — never fires on Android, so there the value only changes via setBrightnessAsync.
+    const subscription = addBrightnessListener(event => setBrightness(event.brightness));
+    return () => subscription.remove();
+  }, []);
+
+  return (
+    <View>
+      <Text>{brightness === null ? 'checking…' : `${Math.round(brightness * 100)}%`}</Text>
+      <Pressable onPress={() => setBrightnessAsync(0.5)}>
+        <Text>Set to 50%</Text>
+      </Pressable>
+      <Text>{permissionStatus?.status ?? 'checking…'}</Text>
+      <Pressable onPress={() => requestPermission()}>
+        <Text>Request permission</Text>
+      </Pressable>
+    </View>
+  );
+}
+```
+
+```vue
+<!-- Vue — trimmed from examples/expo-vue-sfc/screens/BrightnessScreen.vue -->
+<script setup lang="ts">
+import { onMounted, onUnmounted, ref } from 'vue';
+import { Pressable, Text, View } from '@symbiote-native/vue';
+import {
+  addBrightnessListener,
+  getBrightnessAsync,
+  setBrightnessAsync,
+  type EventSubscription,
+} from '@symbiote-native/brightness';
+import { usePermissions } from '@symbiote-native/brightness/vue';
+
+const brightness = ref<number | null>(null);
+const { status: permissionStatus, request: requestPermission } = usePermissions();
+
+let subscription: EventSubscription | undefined;
+
+onMounted(() => {
+  void getBrightnessAsync().then(value => (brightness.value = value));
+  subscription = addBrightnessListener(event => (brightness.value = event.brightness));
+});
+onUnmounted(() => subscription?.remove());
+</script>
+
+<template>
+  <View>
+    <Text>{{ brightness === null ? 'checking…' : `${Math.round(brightness * 100)}%` }}</Text>
+    <Pressable @press="setBrightnessAsync(0.5)">
+      <Text>Set to 50%</Text>
+    </Pressable>
+    <Text>{{ permissionStatus?.status ?? 'checking…' }}</Text>
+    <Pressable @press="requestPermission()">
+      <Text>Request permission</Text>
+    </Pressable>
+  </View>
+</template>
+```
+
+```ts
+// Angular — trimmed from examples/expo-angular/src/screens/BrightnessScreen.ts
+import { Component, inject, signal } from '@angular/core';
+import { Pressable, Text, View } from '@symbiote-native/angular';
+import {
+  PermissionsService,
+  addBrightnessListener,
+  getBrightnessAsync,
+  setBrightnessAsync,
+} from '@symbiote-native/brightness/angular';
+
+@Component({
+  selector: 'BrightnessScreen',
+  standalone: true,
+  imports: [Pressable, Text, View],
+  template: `
+    <View>
+      <Text>{{ brightnessLabel() }}</Text>
+      <Pressable (press)="setBrightnessAsync(0.5)"><Text>Set to 50%</Text></Pressable>
+      <Text>{{ permissionStatus()?.status ?? 'checking…' }}</Text>
+      <Pressable (press)="permissionsService.request()"><Text>Request permission</Text></Pressable>
+    </View>
+  `,
+})
+export class BrightnessScreen {
+  private readonly permissionsService = inject(PermissionsService);
+  readonly permissionStatus = this.permissionsService.connect();
+  readonly brightness = signal<number | null>(null);
+
+  constructor() {
+    getBrightnessAsync().then(value => this.brightness.set(value));
+    addBrightnessListener(event => this.brightness.set(event.brightness));
+  }
+
+  brightnessLabel(): string {
+    const value = this.brightness();
+    return value === null ? 'checking…' : `${Math.round(value * 100)}%`;
+  }
+
+  setBrightnessAsync(value: number): void {
+    setBrightnessAsync(value).then(() => getBrightnessAsync().then(result => this.brightness.set(result)));
+  }
+}
+```
+
+The real demo screens (`examples/expo-react/screens/BrightnessScreen.tsx` and its Vue/Angular
+twins in `examples/expo-vue-sfc`, `examples/expo-vue-tsx`, `examples/expo-angular`) additionally
+gate an Android-only system-brightness-mode card behind `Platform.OS === 'android'` — see
+[API](#api) below for that surface's full signatures.
+
+## API
+
+Mostly stateless async functions, plus one iOS-only listener and a permission surface that gets
+its own lifecycle hook/composable/service (matching upstream's own `usePermissions`).
+
+```ts
+isAvailableAsync(): Promise<boolean>
+// Whether the brightness API is available — !!native.getBrightnessAsync.
+
+getBrightnessAsync(): Promise<number>
+setBrightnessAsync(brightnessValue: number): Promise<void>
+// The app-local screen brightness, 0..1 (clamped; NaN throws a TypeError).
+
+getSystemBrightnessAsync(): Promise<number>
+setSystemBrightnessAsync(brightnessValue: number): Promise<void>
+// System-wide brightness. On iOS these delegate straight to get/setBrightnessAsync — there is
+// no separate system-level value on that platform.
+
+restoreSystemBrightnessAsync(): Promise<void>
+isUsingSystemBrightnessAsync(): Promise<boolean>
+getSystemBrightnessModeAsync(): Promise<BrightnessMode>       // UNKNOWN / AUTOMATIC / MANUAL
+setSystemBrightnessModeAsync(mode: BrightnessMode): Promise<void>
+// Android only — every one of these is a no-op (or resolves a fixed fallback) on iOS/other
+// platforms. setSystemBrightnessModeAsync(UNKNOWN) is also always a no-op, even on Android.
+
+getPermissionsAsync(): Promise<PermissionResponse>
+requestPermissionsAsync(): Promise<PermissionResponse>
+// Plain passthroughs to the native module — no platform gating.
+
+addBrightnessListener(listener: (event: BrightnessEvent) => void): EventSubscription
+// @platform ios — fires only on iOS; never fires on Android or web.
+```
+
+Plus `BrightnessMode` (enum: `UNKNOWN`/`AUTOMATIC`/`MANUAL`), `BrightnessEvent`, and
+`PermissionStatus`/`PermissionResponse`/`PermissionExpiration` — the latter three re-exported
+verbatim from `expo-modules-core`, never the `expo` meta-package.
+
+```ts
+import { getBrightnessAsync, setBrightnessAsync } from '@symbiote-native/brightness';
+
+// framework-scoped entry points re-export the same free functions, plus a usePermissions
+// hook/composable/service:
+import { usePermissions } from '@symbiote-native/brightness/react';
+import { usePermissions } from '@symbiote-native/brightness/vue';
+import { PermissionsService } from '@symbiote-native/brightness/angular';
+```
+
+`usePermissions` (React/Vue) auto-fetches the current permission status on mount and returns a
+`[status, request, get]` tuple (React) / `{ status, request, get }` object (Vue); Angular's
+`PermissionsService.connect()` does the same, returning a readonly `Signal`:
+
+```ts
+// React
+const [status, request] = usePermissions();
+
+// Vue
+const { status, request } = usePermissions();
+
+// Angular
+readonly status = inject(PermissionsService).connect();
+```
+
+## Platform notes
+
+- **System-brightness surface is Android only.** `getSystemBrightnessAsync`/
+  `setSystemBrightnessAsync` fall back to the app-local `get`/`setBrightnessAsync` on iOS (there
+  is no separate system-level brightness there); `restoreSystemBrightnessAsync`/
+  `setSystemBrightnessModeAsync` no-op, `isUsingSystemBrightnessAsync` resolves `false`, and
+  `getSystemBrightnessModeAsync` resolves `BrightnessMode.UNKNOWN` on every other platform.
+- **`addBrightnessListener` is iOS only.** It never fires on Android or web — an app relying on
+  it for cross-platform behavior needs its own fallback (e.g. polling `getBrightnessAsync`).
+- **The iOS Simulator never round-trips brightness at all.** `UIScreen.main.brightness` — what
+  `getBrightnessAsync`/`setBrightnessAsync` read and write on iOS — isn't implemented by the
+  Simulator: `set` is a silent no-op and `get` always resolves a constant (observed `1.0`),
+  regardless of what was written. This is a long-standing Apple Simulator limitation reproducible
+  in any app, including stock Expo Go — not a bug in this wrapper. It only reproduces on a real
+  iOS device; Android's emulator has no equivalent gap (see the `symbiote-expo-native-module`
+  skill for the verified symptom and the underlying `BrightnessModule.swift` call).
+
+## Test it
+
+No Fabric/Descriptor angle at all — brightness is a pure async-function + listener + permission
+surface, never a view. Tests inject a fake native-module object in place of the real
+`requireNativeModule` resolution (`src/core/*.test.ts`, `src/{react,vue,angular}/**/*.test.{ts,tsx}`,
+`vitest`), the same pattern `expo-brightness` itself uses upstream — no `installFabric()`, no
+ViewConfig. Native rendering itself is verified on-device (see the parent
+[README](../../README.md) for the project's testing model).
+
+## Known gaps
+
+- Not yet wired into the public, non-Expo `examples/react` canary — only in `examples/expo-react`
+  (and its Vue/Angular Expo twins, `examples/expo-vue-sfc`/`examples/expo-vue-tsx`/
+  `examples/expo-angular`, all of which already have full three-layer native wiring: Android
+  `MainApplication.kt` registration + `WRITE_SETTINGS`, plus the iOS Podfile/pod install).
+- Tests exercise the JS layer only (fake native module, `vitest`) — no on-device/simulator
+  automated smoke test yet, only manual verification.

package/build/angular/index.d.ts

@@ -0,0 +1,2 @@
+export { PermissionsService } from './services/permissions.service';
+export { isAvailableAsync, getBrightnessAsync, setBrightnessAsync, getSystemBrightnessAsync, setSystemBrightnessAsync, restoreSystemBrightnessAsync, isUsingSystemBrightnessAsync, getSystemBrightnessModeAsync, setSystemBrightnessModeAsync, getPermissionsAsync, requestPermissionsAsync, addBrightnessListener, BrightnessMode, PermissionStatus, type BrightnessEvent, type PermissionExpiration, type PermissionResponse, type EventSubscription, } from '../core';

package/build/angular/index.js

@@ -0,0 +1,4 @@
+// PermissionsService is the Angular-only lifecycle half; the free functions and event
+// subscription plumbing all live in core, shared with React/Vue.
+export { PermissionsService } from './services/permissions.service/index.js';
+export { isAvailableAsync, getBrightnessAsync, setBrightnessAsync, getSystemBrightnessAsync, setSystemBrightnessAsync, restoreSystemBrightnessAsync, isUsingSystemBrightnessAsync, getSystemBrightnessModeAsync, setSystemBrightnessModeAsync, getPermissionsAsync, requestPermissionsAsync, addBrightnessListener, BrightnessMode, PermissionStatus, } from '../core/index.js';

package/build/angular/services/permissions.service/index.d.ts

@@ -0,0 +1,8 @@
+import { type Signal } from '@angular/core';
+import { type PermissionResponse } from '../../../core';
+export declare class PermissionsService {
+    private readonly status;
+    connect(): Signal<PermissionResponse | null>;
+    get(): Promise<PermissionResponse>;
+    request(): Promise<PermissionResponse>;
+}

package/build/angular/services/permissions.service/index.js

@@ -0,0 +1,78 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+// Angular twin of React's usePermissions hook and Vue's usePermissions composable.
+// `connect()` auto-fetches once (no ongoing subscription to clean up, so no Injector/effect
+// needed, unlike BatteryStateService) and returns a readonly signal; get()/request() are
+// imperative one-shot methods.
+//
+//   readonly status = inject(PermissionsService).connect();
+//   // template: {{ status()?.granted }}
+import { Injectable, signal } from '@angular/core';
+import { getPermissionsAsync, requestPermissionsAsync, } from '../../../core';
+let PermissionsService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var PermissionsService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            PermissionsService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        status = signal(null);
+        connect() {
+            if (this.status() === null) {
+                void this.get();
+            }
+            return this.status.asReadonly();
+        }
+        async get() {
+            const response = await getPermissionsAsync();
+            this.status.set(response);
+            return response;
+        }
+        async request() {
+            const response = await requestPermissionsAsync();
+            this.status.set(response);
+            return response;
+        }
+    };
+    return PermissionsService = _classThis;
+})();
+export { PermissionsService };

package/build/core/brightness.d.ts

@@ -0,0 +1,56 @@
+import type { EventSubscription } from 'expo-modules-core';
+import { BrightnessMode, type BrightnessEvent, type PermissionResponse } from './types';
+/** Whether the brightness API is available on the current device. */
+export declare function isAvailableAsync(): Promise<boolean>;
+/** Gets the current brightness level of the device's main screen, between `0` and `1`. */
+export declare function getBrightnessAsync(): Promise<number>;
+/**
+ * Sets the current screen brightness. On iOS this only affects the screen while the app is
+ * foregrounded; on Android it persists until changed again.
+ */
+export declare function setBrightnessAsync(brightnessValue: number): Promise<void>;
+/**
+ * Gets the system-wide brightness. On iOS the app-local and system brightness are the same
+ * value, so this delegates to `getBrightnessAsync`.
+ * @platform android
+ */
+export declare function getSystemBrightnessAsync(): Promise<number>;
+/**
+ * Sets the system-wide brightness. On iOS this delegates to `setBrightnessAsync`, since there is
+ * no separate system-level brightness to set.
+ * @platform android
+ */
+export declare function setSystemBrightnessAsync(brightnessValue: number): Promise<void>;
+/**
+ * Resets the system brightness to the value it had before this app started controlling it. A
+ * no-op on every platform except Android.
+ * @platform android
+ */
+export declare function restoreSystemBrightnessAsync(): Promise<void>;
+/**
+ * Whether the app is currently controlling the system brightness (as opposed to only its own
+ * window's brightness). Always `false` on every platform except Android.
+ * @platform android
+ */
+export declare function isUsingSystemBrightnessAsync(): Promise<boolean>;
+/**
+ * Gets the system brightness mode (`AUTOMATIC` / `MANUAL`). Always resolves `UNKNOWN` on every
+ * platform except Android.
+ * @platform android
+ */
+export declare function getSystemBrightnessModeAsync(): Promise<BrightnessMode>;
+/**
+ * Sets the system brightness mode. A no-op on every platform except Android, and also a no-op
+ * when passed `BrightnessMode.UNKNOWN` (there is nothing meaningful to set it to).
+ * @platform android
+ */
+export declare function setSystemBrightnessModeAsync(brightnessMode: BrightnessMode): Promise<void>;
+/** Checks user's permissions for accessing the system brightness. */
+export declare function getPermissionsAsync(): Promise<PermissionResponse>;
+/** Asks the user for permission to access the system brightness. */
+export declare function requestPermissionsAsync(): Promise<PermissionResponse>;
+/**
+ * Subscribes to brightness changes. Only fires on iOS — never on Android or web.
+ * @platform ios
+ */
+export declare function addBrightnessListener(listener: (event: BrightnessEvent) => void): EventSubscription;

package/build/core/brightness.js

@@ -0,0 +1,137 @@
+// Hand-ported from .vendors/expo/packages/expo-brightness/src/Brightness.ts (sdk-57). The
+// system-brightness surface (mode, "using system brightness", restore) is Android-only —
+// upstream branches every one of those on `Platform.OS !== 'android'` before ever reaching the
+// native module, so those branches are preserved verbatim rather than guessed.
+import { Platform, UnavailabilityError } from 'expo-modules-core';
+import { expoBrightness } from './native-module.js';
+import { BrightnessMode } from './types.js';
+const NATIVE_MODULE_NAME = 'expo-brightness';
+function clampBrightness(brightnessValue, callerName) {
+    const clamped = Math.max(0, Math.min(brightnessValue, 1));
+    if (Number.isNaN(clamped)) {
+        throw new TypeError(`${callerName} cannot be called with ${brightnessValue}`);
+    }
+    return clamped;
+}
+/** Whether the brightness API is available on the current device. */
+export async function isAvailableAsync() {
+    return !!expoBrightness.getBrightnessAsync;
+}
+/** Gets the current brightness level of the device's main screen, between `0` and `1`. */
+export async function getBrightnessAsync() {
+    if (!expoBrightness.getBrightnessAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getBrightnessAsync');
+    }
+    return expoBrightness.getBrightnessAsync();
+}
+/**
+ * Sets the current screen brightness. On iOS this only affects the screen while the app is
+ * foregrounded; on Android it persists until changed again.
+ */
+export async function setBrightnessAsync(brightnessValue) {
+    const clamped = clampBrightness(brightnessValue, 'setBrightnessAsync');
+    if (!expoBrightness.setBrightnessAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'setBrightnessAsync');
+    }
+    await expoBrightness.setBrightnessAsync(clamped);
+}
+/**
+ * Gets the system-wide brightness. On iOS the app-local and system brightness are the same
+ * value, so this delegates to `getBrightnessAsync`.
+ * @platform android
+ */
+export async function getSystemBrightnessAsync() {
+    if (Platform.OS !== 'android') {
+        return getBrightnessAsync();
+    }
+    if (!expoBrightness.getSystemBrightnessAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getSystemBrightnessAsync');
+    }
+    return expoBrightness.getSystemBrightnessAsync();
+}
+/**
+ * Sets the system-wide brightness. On iOS this delegates to `setBrightnessAsync`, since there is
+ * no separate system-level brightness to set.
+ * @platform android
+ */
+export async function setSystemBrightnessAsync(brightnessValue) {
+    const clamped = clampBrightness(brightnessValue, 'setSystemBrightnessAsync');
+    if (Platform.OS !== 'android') {
+        return setBrightnessAsync(clamped);
+    }
+    if (!expoBrightness.setSystemBrightnessAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'setSystemBrightnessAsync');
+    }
+    await expoBrightness.setSystemBrightnessAsync(clamped);
+}
+/**
+ * Resets the system brightness to the value it had before this app started controlling it. A
+ * no-op on every platform except Android.
+ * @platform android
+ */
+export async function restoreSystemBrightnessAsync() {
+    if (Platform.OS !== 'android') {
+        return;
+    }
+    if (!expoBrightness.restoreSystemBrightnessAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'restoreSystemBrightnessAsync');
+    }
+    await expoBrightness.restoreSystemBrightnessAsync();
+}
+/**
+ * Whether the app is currently controlling the system brightness (as opposed to only its own
+ * window's brightness). Always `false` on every platform except Android.
+ * @platform android
+ */
+export async function isUsingSystemBrightnessAsync() {
+    if (Platform.OS !== 'android') {
+        return false;
+    }
+    if (!expoBrightness.isUsingSystemBrightnessAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'isUsingSystemBrightnessAsync');
+    }
+    return expoBrightness.isUsingSystemBrightnessAsync();
+}
+/**
+ * Gets the system brightness mode (`AUTOMATIC` / `MANUAL`). Always resolves `UNKNOWN` on every
+ * platform except Android.
+ * @platform android
+ */
+export async function getSystemBrightnessModeAsync() {
+    if (Platform.OS !== 'android') {
+        return BrightnessMode.UNKNOWN;
+    }
+    if (!expoBrightness.getSystemBrightnessModeAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getSystemBrightnessModeAsync');
+    }
+    return expoBrightness.getSystemBrightnessModeAsync();
+}
+/**
+ * Sets the system brightness mode. A no-op on every platform except Android, and also a no-op
+ * when passed `BrightnessMode.UNKNOWN` (there is nothing meaningful to set it to).
+ * @platform android
+ */
+export async function setSystemBrightnessModeAsync(brightnessMode) {
+    if (Platform.OS !== 'android' || brightnessMode === BrightnessMode.UNKNOWN) {
+        return;
+    }
+    if (!expoBrightness.setSystemBrightnessModeAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'setSystemBrightnessModeAsync');
+    }
+    await expoBrightness.setSystemBrightnessModeAsync(brightnessMode);
+}
+/** Checks user's permissions for accessing the system brightness. */
+export async function getPermissionsAsync() {
+    return expoBrightness.getPermissionsAsync();
+}
+/** Asks the user for permission to access the system brightness. */
+export async function requestPermissionsAsync() {
+    return expoBrightness.requestPermissionsAsync();
+}
+/**
+ * Subscribes to brightness changes. Only fires on iOS — never on Android or web.
+ * @platform ios
+ */
+export function addBrightnessListener(listener) {
+    return expoBrightness.addListener('Expo.brightnessDidChange', listener);
+}

package/build/core/index.d.ts

@@ -0,0 +1,3 @@
+export { isAvailableAsync, getBrightnessAsync, setBrightnessAsync, getSystemBrightnessAsync, setSystemBrightnessAsync, restoreSystemBrightnessAsync, isUsingSystemBrightnessAsync, getSystemBrightnessModeAsync, setSystemBrightnessModeAsync, getPermissionsAsync, requestPermissionsAsync, addBrightnessListener, } from './brightness';
+export { BrightnessMode, PermissionStatus, type BrightnessEvent, type PermissionExpiration, type PermissionResponse, } from './types';
+export type { EventSubscription } from 'expo-modules-core';

package/build/core/index.js

@@ -0,0 +1,2 @@
+export { isAvailableAsync, getBrightnessAsync, setBrightnessAsync, getSystemBrightnessAsync, setSystemBrightnessAsync, restoreSystemBrightnessAsync, isUsingSystemBrightnessAsync, getSystemBrightnessModeAsync, setSystemBrightnessModeAsync, getPermissionsAsync, requestPermissionsAsync, addBrightnessListener, } from './brightness.js';
+export { BrightnessMode, PermissionStatus, } from './types.js';

package/build/core/native-module.d.ts

@@ -0,0 +1,16 @@
+import type { EventSubscription } from 'expo-modules-core';
+import type { BrightnessEvent, BrightnessMode, PermissionResponse } from './types';
+export type INativeBrightnessModule = {
+    getBrightnessAsync?(): Promise<number>;
+    setBrightnessAsync?(value: number): Promise<void>;
+    getSystemBrightnessAsync?(): Promise<number>;
+    setSystemBrightnessAsync?(value: number): Promise<void>;
+    restoreSystemBrightnessAsync?(): Promise<void>;
+    isUsingSystemBrightnessAsync?(): Promise<boolean>;
+    getSystemBrightnessModeAsync?(): Promise<BrightnessMode>;
+    setSystemBrightnessModeAsync?(mode: BrightnessMode): Promise<void>;
+    getPermissionsAsync(): Promise<PermissionResponse>;
+    requestPermissionsAsync(): Promise<PermissionResponse>;
+    addListener(eventName: 'Expo.brightnessDidChange', listener: (event: BrightnessEvent) => void): EventSubscription;
+};
+export declare const expoBrightness: INativeBrightnessModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_BRIGHTNESS_MODULE_NAME = 'ExpoBrightness';
+export const expoBrightness = requireNativeModule(EXPO_BRIGHTNESS_MODULE_NAME);

package/build/core/types.d.ts

@@ -0,0 +1,16 @@
+import { PermissionStatus, type PermissionExpiration, type PermissionResponse } from 'expo-modules-core';
+export { PermissionStatus, type PermissionExpiration, type PermissionResponse };
+/** Enum representing the brightness mode of the device. */
+export declare enum BrightnessMode {
+    /** Returned when brightness mode cannot be determined. */
+    UNKNOWN = 0,
+    /** Automatic brightness mode, tracking the ambient light sensor. */
+    AUTOMATIC = 1,
+    /** Manual brightness mode, set by the user or by `setSystemBrightnessAsync`. */
+    MANUAL = 2
+}
+/** Fired when the screen brightness changes, on iOS only. */
+export type BrightnessEvent = {
+    /** The current brightness value between `0` and `1`, inclusive. */
+    brightness: number;
+};