@symbiote-native/brightness 0.1.0 → 0.3.0

package/README.md

@@ -3,8 +3,8 @@
 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,
+listener, and permission get/request — usable from **every** adapter: React, Vue, Svelte, Solid,
+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
@@ -31,13 +31,13 @@ Unlike a plain RN native module, `expo-brightness`'s native code is discovered b
 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`) |
+| 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
@@ -55,14 +55,17 @@ src/core/                 isAvailableAsync, get/setBrightnessAsync, the Android-
                           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/svelte/runes/          @symbiote-native/brightness/svelte  — usePermissions (same name)
+src/solid/primitives/      @symbiote-native/brightness/solid   — createPermissions (Solid says
+                                                                 create*, not use*)
 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.
+tuple/object/accessor/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 every adapter.
 
 ## Use it
 
@@ -84,13 +87,17 @@ function BrightnessScreen() {
   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));
+    const subscription = addBrightnessListener(event =>
+      setBrightness(event.brightness),
+    );
     return () => subscription.remove();
   }, []);
 
   return (
     <View>
-      <Text>{brightness === null ? 'checking…' : `${Math.round(brightness * 100)}%`}</Text>
+      <Text>
+        {brightness === null ? 'checking…' : `${Math.round(brightness * 100)}%`}
+      </Text>
       <Pressable onPress={() => setBrightnessAsync(0.5)}>
         <Text>Set to 50%</Text>
       </Pressable>
@@ -117,20 +124,25 @@ import {
 import { usePermissions } from '@symbiote-native/brightness/vue';
 
 const brightness = ref<number | null>(null);
-const { status: permissionStatus, request: requestPermission } = usePermissions();
+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));
+  subscription = addBrightnessListener(
+    event => (brightness.value = event.brightness),
+  );
 });
 onUnmounted(() => subscription?.remove());
 </script>
 
 <template>
   <View>
-    <Text>{{ brightness === null ? 'checking…' : `${Math.round(brightness * 100)}%` }}</Text>
+    <Text>{{
+      brightness === null ? 'checking…' : `${Math.round(brightness * 100)}%`
+    }}</Text>
     <Pressable @press="setBrightnessAsync(0.5)">
       <Text>Set to 50%</Text>
     </Pressable>
@@ -160,9 +172,13 @@ import {
   template: `
     <View>
       <Text>{{ brightnessLabel() }}</Text>
-      <Pressable (press)="setBrightnessAsync(0.5)"><Text>Set to 50%</Text></Pressable>
+      <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>
+      <Pressable (press)="permissionsService.request()"
+        ><Text>Request permission</Text></Pressable
+      >
     </View>
   `,
 })
@@ -182,7 +198,9 @@ export class BrightnessScreen {
   }
 
   setBrightnessAsync(value: number): void {
-    setBrightnessAsync(value).then(() => getBrightnessAsync().then(result => this.brightness.set(result)));
+    setBrightnessAsync(value).then(() =>
+      getBrightnessAsync().then(result => this.brightness.set(result)),
+    );
   }
 }
 ```
@@ -230,18 +248,25 @@ Plus `BrightnessMode` (enum: `UNKNOWN`/`AUTOMATIC`/`MANUAL`), `BrightnessEvent`,
 verbatim from `expo-modules-core`, never the `expo` meta-package.
 
 ```ts
-import { getBrightnessAsync, setBrightnessAsync } from '@symbiote-native/brightness';
+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 { usePermissions } from '@symbiote-native/brightness/svelte';
+import { createPermissions } from '@symbiote-native/brightness/solid';
 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`:
+`usePermissions` (React/Vue/Svelte) auto-fetches the current permission status on mount and
+returns a `[status, request, get]` tuple (React) / a `{ status, request, get }` object (Vue refs,
+Svelte getters). Solid's `createPermissions` fetches synchronously from the primitive body and
+returns the same object with `status`/`error` as ACCESSORS; Angular's
+`PermissionsService.connect()` returns a readonly `Signal`:
 
 ```ts
 // React
@@ -250,6 +275,12 @@ const [status, request] = usePermissions();
 // Vue
 const { status, request } = usePermissions();
 
+// Svelte — a boxed getter, read as permissions.status
+const permissions = usePermissions();
+
+// Solid — accessors, so status() is what a tracked scope reads
+const { status, request } = createPermissions();
+
 // Angular
 readonly status = inject(PermissionsService).connect();
 ```
@@ -275,7 +306,8 @@ readonly status = inject(PermissionsService).connect();
 
 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}`,
+`requireNativeModule` resolution (`src/core/*.test.ts`,
+`src/{react,vue,svelte,solid,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).

package/build/angular/index.d.ts

@@ -1,2 +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';
+export * from '../core';

package/build/angular/index.js

@@ -1,4 +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';
+export * from '../core/index.js';

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

@@ -2,6 +2,10 @@ import { type Signal } from '@angular/core';
 import { type PermissionResponse } from '../../../core';
 export declare class PermissionsService {
     private readonly status;
+    private readonly fetchError;
+    private isAutoFetchStarted;
+    /** Why the auto-fetch left `status` at null. Cleared by the next successful get()/request(). */
+    readonly error: Signal<Error | null>;
     connect(): Signal<PermissionResponse | null>;
     get(): Promise<PermissionResponse>;
     request(): Promise<PermissionResponse>;

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

@@ -39,6 +39,11 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 //
 //   readonly status = inject(PermissionsService).connect();
 //   // template: {{ status()?.granted }}
+//
+// The auto-fetch has nobody to reject to, so its failure lands in the `error` signal instead of
+// escaping as an unhandled rejection: a null status with a non-null error is how a consumer tells
+// "the fetch failed" from "not fetched yet". get()/request() still reject to their direct caller —
+// only the automatic call is made safe.
 import { Injectable, signal } from '@angular/core';
 import { getPermissionsAsync, requestPermissionsAsync, } from '../../../core/index.js';
 let PermissionsService = (() => {
@@ -56,20 +61,32 @@ let PermissionsService = (() => {
             __runInitializers(_classThis, _classExtraInitializers);
         }
         status = signal(null);
+        fetchError = signal(null);
+        isAutoFetchStarted = false;
+        /** Why the auto-fetch left `status` at null. Cleared by the next successful get()/request(). */
+        error = this.fetchError.asReadonly();
         connect() {
-            if (this.status() === null) {
-                void this.get();
+            // Latched rather than guarded on `status() === null`: a failed fetch leaves status null
+            // forever, so the old guard turned every later connect() into another native call — unbounded
+            // once connect() is reached from a change-detected expression instead of a field initializer.
+            if (!this.isAutoFetchStarted) {
+                this.isAutoFetchStarted = true;
+                this.get().catch((cause) => {
+                    this.fetchError.set(cause instanceof Error ? cause : new Error(String(cause)));
+                });
             }
             return this.status.asReadonly();
         }
         async get() {
             const response = await getPermissionsAsync();
             this.status.set(response);
+            this.fetchError.set(null);
             return response;
         }
         async request() {
             const response = await requestPermissionsAsync();
             this.status.set(response);
+            this.fetchError.set(null);
             return response;
         }
     };

package/build/core/brightness.js

@@ -4,7 +4,7 @@
 // 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';
+import { BrightnessMode, } from './types.js';
 const NATIVE_MODULE_NAME = 'expo-brightness';
 function clampBrightness(brightnessValue, callerName) {
     const clamped = Math.max(0, Math.min(brightnessValue, 1));

package/build/react/hooks/use-permissions/index.d.ts

@@ -2,5 +2,6 @@ import { type PermissionResponse } from '../../../core';
 export declare function usePermissions(): [
     PermissionResponse | null,
     () => Promise<PermissionResponse>,
-    () => Promise<PermissionResponse>
+    () => Promise<PermissionResponse>,
+    Error | null
 ];

package/build/react/hooks/use-permissions/index.js

@@ -2,29 +2,42 @@
 // the current permission status on mount, then exposes get/request as imperative callbacks.
 // Mirrors the shape @symbiote-native/cellular's own usePermissions ships in parallel, so both
 // stay byte-for-byte consistent.
+//
+// The mount fetch has nobody to reject to, so its failure lands in the 4th tuple slot (`error`)
+// instead of escaping as an unhandled rejection: a null status with a non-null error is how a
+// consumer tells "the fetch failed" from "not fetched yet". get()/request() still reject to their
+// direct caller — only the automatic call is made safe.
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { getPermissionsAsync, requestPermissionsAsync, } from '../../../core/index.js';
 export function usePermissions() {
     const isMounted = useRef(true);
     const [status, setStatus] = useState(null);
+    const [error, setError] = useState(null);
     const getPermission = useCallback(async () => {
         const response = await getPermissionsAsync();
-        if (isMounted.current)
+        if (isMounted.current) {
             setStatus(response);
+            setError(null);
+        }
         return response;
     }, []);
     const requestPermission = useCallback(async () => {
         const response = await requestPermissionsAsync();
-        if (isMounted.current)
+        if (isMounted.current) {
             setStatus(response);
+            setError(null);
+        }
         return response;
     }, []);
     useEffect(() => {
         isMounted.current = true;
-        void getPermission();
+        getPermission().catch((cause) => {
+            if (isMounted.current)
+                setError(cause instanceof Error ? cause : new Error(String(cause)));
+        });
         return () => {
             isMounted.current = false;
         };
     }, [getPermission]);
-    return [status, requestPermission, getPermission];
+    return [status, requestPermission, getPermission, error];
 }

package/build/react/index.d.ts

@@ -1,2 +1,2 @@
 export { usePermissions } from './hooks/use-permissions';
-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';
+export * from '../core';

package/build/react/index.js

@@ -3,4 +3,4 @@
 // every other export is a stateless async function or one-shot listener, re-exported verbatim —
 // mirrors the lifecycle-bucket naming convention of adapters/react/src/hooks.
 export { usePermissions } from './hooks/use-permissions/index.js';
-export { isAvailableAsync, getBrightnessAsync, setBrightnessAsync, getSystemBrightnessAsync, setSystemBrightnessAsync, restoreSystemBrightnessAsync, isUsingSystemBrightnessAsync, getSystemBrightnessModeAsync, setSystemBrightnessModeAsync, getPermissionsAsync, requestPermissionsAsync, addBrightnessListener, BrightnessMode, PermissionStatus, } from '../core/index.js';
+export * from '../core/index.js';

package/build/solid/index.d.ts

@@ -0,0 +1,2 @@
+export { createPermissions } from './primitives/create-permissions';
+export * from '../core';

package/build/solid/index.js

@@ -0,0 +1,7 @@
+// @symbiote-native/brightness/solid: the Solid entry over the framework-agnostic core, plus
+// createPermissions — the only stateful surface this package needs a lifecycle wrapper for. The
+// lifecycle bucket is `primitives/` and the name is `create*` (never `hooks/`/`use*`, that is
+// React's term and Solid's word for consuming an existing thing) — see
+// adapters/solid/src/primitives for the same convention.
+export { createPermissions } from './primitives/create-permissions.js';
+export * from '../core/index.js';

package/build/solid/primitives/create-permissions.d.ts

@@ -0,0 +1,8 @@
+import { type Accessor } from 'solid-js';
+import { type PermissionResponse } from '../../core';
+export declare function createPermissions(): {
+    status: Accessor<PermissionResponse | null>;
+    error: Accessor<Error | null>;
+    request: () => Promise<PermissionResponse>;
+    get: () => Promise<PermissionResponse>;
+};

package/build/solid/primitives/create-permissions.js

@@ -0,0 +1,55 @@
+// Solid lifecycle wiring over the framework-agnostic core (core/brightness.ts) — the Solid twin of
+// React's usePermissions hook, Vue's composable, Svelte's rune and Angular's PermissionsService.
+//
+// `primitives/` and `create*`, not `hooks/`/`use*`: Solid's ecosystem calls a composable reactive
+// function a PRIMITIVE and reserves `use*` for consuming something that already exists. Full
+// rationale in adapters/solid/src/primitives/create-color-scheme.ts's header.
+//
+// Returns ACCESSORS, never a snapshot: a Solid component body runs ONCE, so a plain returned value
+// would freeze at "not fetched yet" and never move again.
+//
+// The initial fetch is fired SYNCHRONOUSLY from the primitive body rather than from a mount hook
+// (React's useEffect, Vue's onMounted, Svelte's $effect) — same reason create-color-scheme
+// subscribes synchronously: nothing can interleave between construction and the fetch starting, so
+// there is no window in which a consumer sees a primitive that has not asked for status yet.
+//
+// That fetch has nobody to reject to, so its failure lands in `error` instead of escaping as an
+// unhandled rejection: a null status with a non-null error is how a consumer tells "the fetch
+// failed" from "not fetched yet". get()/request() still reject to their direct caller — only the
+// automatic call is made safe.
+//
+// `onCleanup` drops the writes of a call still in flight when the owner is disposed — the Solid
+// equivalent of React's isMounted ref. Outside a component / createRoot there is no owner to hang
+// it on, so those late writes land instead (harmless: nothing reads a disposed signal).
+import { createSignal, onCleanup } from 'solid-js';
+import { getPermissionsAsync, requestPermissionsAsync, } from '../../core/index.js';
+export function createPermissions() {
+    const [status, setStatus] = createSignal(null);
+    const [error, setError] = createSignal(null);
+    let isDisposed = false;
+    const record = (response) => {
+        if (isDisposed)
+            return;
+        setStatus(response);
+        setError(null);
+    };
+    const get = async () => {
+        const response = await getPermissionsAsync();
+        record(response);
+        return response;
+    };
+    const request = async () => {
+        const response = await requestPermissionsAsync();
+        record(response);
+        return response;
+    };
+    get().catch((cause) => {
+        if (isDisposed)
+            return;
+        setError(cause instanceof Error ? cause : new Error(String(cause)));
+    });
+    onCleanup(() => {
+        isDisposed = true;
+    });
+    return { status, error, request, get };
+}

package/build/svelte/index.d.ts

@@ -0,0 +1,2 @@
+export { usePermissions } from './runes/use-permissions.svelte';
+export * from '../core';

package/build/svelte/index.js

@@ -0,0 +1,6 @@
+// @symbiote-native/brightness/svelte: the Svelte entry over the framework-agnostic core. Same
+// reasoning as the React and Vue entries — only the permission surface gets a lifecycle rune,
+// every other export is a plain re-export — mirrors the lifecycle-bucket naming convention of
+// adapters/svelte/src/runes (never `hooks/`/`composables/`, those are React's and Vue's terms).
+export { usePermissions } from './runes/use-permissions.svelte';
+export * from '../core/index.js';

package/build/svelte/runes/use-permissions.svelte.d.ts

@@ -0,0 +1,7 @@
+import { type PermissionResponse } from '../../core';
+export declare function usePermissions(): {
+    readonly status: PermissionResponse | null;
+    readonly error: Error | null;
+    request: () => Promise<PermissionResponse>;
+    get: () => Promise<PermissionResponse>;
+};

package/build/svelte/runes/use-permissions.svelte.js

@@ -0,0 +1,55 @@
+// Svelte lifecycle wiring over the framework-agnostic core (core/brightness.ts) — auto-fetches
+// the current permission status on mount, then exposes get/request as imperative callbacks. The
+// Svelte twin of vue/composables/use-permissions and react/hooks/use-permissions.
+//
+// `.svelte.ts` (not `.ts`): runes ($state/$effect) are only usable in a file with this extension
+// outside an actual `.svelte` component. `runes/` is Svelte's own term for the bucket React calls
+// `hooks/` and Vue calls `composables/` — see adapters/svelte/src/runes.
+//
+// Vue's onMounted collapses into a `$effect` with no teardown (there is no ongoing subscription
+// here, just a one-shot get). The effect only WRITES `status` (through `get()`), never reads it,
+// so its dependency set stays empty and it fires exactly once on mount.
+//
+// `status` comes back as a GETTER on the returned object rather than a raw `$state` variable:
+// Svelte 5 reactivity is lexically scoped to the declaring module, so a raw `let x = $state(...)`
+// handed out of a plain function arrives dead at the caller. Reading `.status` is the Svelte
+// equivalent of unwrapping Vue's `Ref` via `.value`.
+//
+// The mount fetch has nobody to reject to, so its failure lands in `error` (a second boxed getter,
+// same reason as `status`) instead of escaping as an unhandled rejection: a null status with a
+// non-null error is how a consumer tells "the fetch failed" from "not fetched yet".
+// get()/request() still reject to their direct caller — only the automatic call is made safe.
+import { getPermissionsAsync, requestPermissionsAsync, } from '../../core/index.js';
+export function usePermissions() {
+    let status = $state(null);
+    let error = $state(null);
+    const get = async () => {
+        const response = await getPermissionsAsync();
+        status = response;
+        error = null;
+        return response;
+    };
+    const request = async () => {
+        const response = await requestPermissionsAsync();
+        status = response;
+        error = null;
+        return response;
+    };
+    $effect(() => {
+        // The catch runs after the effect has settled, so writing `error` there adds no dependency and
+        // the effect still fires exactly once.
+        get().catch((cause) => {
+            error = cause instanceof Error ? cause : new Error(String(cause));
+        });
+    });
+    return {
+        get status() {
+            return status;
+        },
+        get error() {
+            return error;
+        },
+        request,
+        get,
+    };
+}

package/build/vue/composables/use-permissions/index.d.ts

@@ -2,6 +2,7 @@ import { type Ref } from '@vue/runtime-core';
 import { type PermissionResponse } from '../../../core';
 export declare function usePermissions(): {
     status: Ref<PermissionResponse | null>;
+    error: Ref<Error | null>;
     request: () => Promise<PermissionResponse>;
     get: () => Promise<PermissionResponse>;
 };

package/build/vue/composables/use-permissions/index.js

@@ -2,22 +2,32 @@
 // current permission status on mount (mirrors use-battery-level's onMounted/onUnmounted style,
 // but there is no ongoing subscription to tear down here, just a one-shot get), then exposes
 // get/request as imperative callbacks.
+//
+// The mount fetch has nobody to reject to, so its failure lands in the `error` ref instead of
+// escaping as an unhandled rejection: a null status with a non-null error is how a consumer tells
+// "the fetch failed" from "not fetched yet". get()/request() still reject to their direct caller —
+// only the automatic call is made safe.
 import { onMounted, ref } from '@vue/runtime-core';
 import { getPermissionsAsync, requestPermissionsAsync, } from '../../../core/index.js';
 export function usePermissions() {
     const status = ref(null);
+    const error = ref(null);
     const get = async () => {
         const response = await getPermissionsAsync();
         status.value = response;
+        error.value = null;
         return response;
     };
     const request = async () => {
         const response = await requestPermissionsAsync();
         status.value = response;
+        error.value = null;
         return response;
     };
     onMounted(() => {
-        void get();
+        get().catch((cause) => {
+            error.value = cause instanceof Error ? cause : new Error(String(cause));
+        });
     });
-    return { status, request, get };
+    return { status, error, request, get };
 }

package/build/vue/index.d.ts

@@ -1,2 +1,2 @@
 export { usePermissions } from './composables/use-permissions';
-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';
+export * from '../core';

package/build/vue/index.js

@@ -3,4 +3,4 @@
 // other export is a plain re-export — mirrors the lifecycle-bucket naming convention of
 // adapters/vue/src/composables (never `hooks/`, that's React's term).
 export { usePermissions } from './composables/use-permissions/index.js';
-export { isAvailableAsync, getBrightnessAsync, setBrightnessAsync, getSystemBrightnessAsync, setSystemBrightnessAsync, restoreSystemBrightnessAsync, isUsingSystemBrightnessAsync, getSystemBrightnessModeAsync, setSystemBrightnessModeAsync, getPermissionsAsync, requestPermissionsAsync, addBrightnessListener, BrightnessMode, PermissionStatus, } from '../core/index.js';
+export * from '../core/index.js';

package/build-ngc/angular/index.d.ts

@@ -1,2 +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';
+export * from '../core';

package/build-ngc/angular/index.js

@@ -1,5 +1,5 @@
 // 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';
-export { isAvailableAsync, getBrightnessAsync, setBrightnessAsync, getSystemBrightnessAsync, setSystemBrightnessAsync, restoreSystemBrightnessAsync, isUsingSystemBrightnessAsync, getSystemBrightnessModeAsync, setSystemBrightnessModeAsync, getPermissionsAsync, requestPermissionsAsync, addBrightnessListener, BrightnessMode, PermissionStatus, } from '../core';
+export * from '../core';
 //# sourceMappingURL=index.js.map

package/build-ngc/angular/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,iEAAiE;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EACL,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,wBAAwB,EACxB,wBAAwB,EACxB,4BAA4B,EAC5B,4BAA4B,EAC5B,4BAA4B,EAC5B,4BAA4B,EAC5B,mBAAmB,EACnB,uBAAuB,EACvB,qBAAqB,EACrB,cAAc,EACd,gBAAgB,GAKjB,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,iEAAiE;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,cAAc,SAAS,CAAC"}

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

@@ -3,6 +3,10 @@ import { type PermissionResponse } from '../../../core';
 import * as i0 from "@angular/core";
 export declare class PermissionsService {
     private readonly status;
+    private readonly fetchError;
+    private isAutoFetchStarted;
+    /** Why the auto-fetch left `status` at null. Cleared by the next successful get()/request(). */
+    readonly error: Signal<Error | null>;
     connect(): Signal<PermissionResponse | null>;
     get(): Promise<PermissionResponse>;
     request(): Promise<PermissionResponse>;