@symbiote-native/keep-awake 0.1.0 → 0.3.0

package/README.md

@@ -2,8 +2,8 @@
 
 Port of [`expo-keep-awake`](https://docs.expo.dev/versions/latest/sdk/keep-awake/) for
 [SymbioteNative](../../README.md) — keeps the screen on for the lifetime of a mounted
-component/composable/service, reachable from every adapter (React, Vue, Angular), not just
-React.
+component/composable/service, reachable from every adapter (React, Vue, Svelte, Solid, Angular),
+not just React.
 
 Built the same way as [`@symbiote-native/battery`](../battery) and
 [`@symbiote-native/device`](../device), an `expo-modules-core`-based wrapper (see the
@@ -31,12 +31,12 @@ into the native host app **once**, covering this package and every other `expo-m
 package (`@symbiote-native/battery`, `@symbiote-native/device`, `@symbiote-native/sensors`, …)
 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) |
+| 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) |
 
 The recurring per-package half of the Android wiring (`app/build.gradle`'s
 `implementation project(':expo-keep-awake')` line and `MainApplication.kt`'s module-name map
@@ -59,15 +59,18 @@ src/core/               keep-awake.ts — isAvailableAsync/activateKeepAwakeAsyn
                         KeepAwakeOptions, hand-ported from KeepAwake.types.ts.
 src/react/hooks/        @symbiote-native/keep-awake/react   — useKeepAwake
 src/vue/composables/    @symbiote-native/keep-awake/vue     — useKeepAwake
+src/svelte/runes/       @symbiote-native/keep-awake/svelte  — useKeepAwake
+src/solid/primitives/   @symbiote-native/keep-awake/solid   — createKeepAwake (Solid says
+                                                              create*, not use*)
 src/angular/services/   @symbiote-native/keep-awake/angular — KeepAwakeService (`.connect()`,
                         no return value — a pure side effect for the component's lifetime)
 ```
 
-Each adapter's hook/composable/service activates a keep-awake lock on mount and deactivates it on
-unmount, over the same `core` functions — the tag-generation and activate/deactivate lifecycle is
-written once and shared by all three. React uses `useId()` for its default per-instance tag,
-matching upstream; Vue and Angular have no `useId` equivalent, so both fall back to a small
-monotonically-incrementing module-local counter (`keep-awake-tag-1`, `keep-awake-tag-2`, …) when
+Each adapter's hook/composable/rune/primitive/service activates a keep-awake lock on mount and
+deactivates it on unmount, over the same `core` functions — the tag-generation and
+activate/deactivate lifecycle is written once and shared by every adapter. React uses `useId()`
+for its default per-instance tag, matching upstream; Vue, Svelte, Solid and Angular have no
+`useId` equivalent, so they fall back to a small monotonically-incrementing module-local counter (`keep-awake-tag-1`, `keep-awake-tag-2`, …) when
 no explicit tag is given.
 
 ## Use it
@@ -100,7 +103,7 @@ useKeepAwake();
 import { Component, inject } from '@angular/core';
 import { KeepAwakeService } from '@symbiote-native/keep-awake/angular';
 
-@Component({ /* ... */ })
+@Component({/* ... */})
 export class KeepAwakeScreen {
   constructor() {
     inject(KeepAwakeService).connect();
@@ -123,25 +126,31 @@ as a minimal `unknown` placeholder: upstream's own shape there is web-specific a
 analogue, and native listeners for it rarely fire.
 
 ```ts
-import { activateKeepAwakeAsync, deactivateKeepAwake } from '@symbiote-native/keep-awake';
+import {
+  activateKeepAwakeAsync,
+  deactivateKeepAwake,
+} from '@symbiote-native/keep-awake';
 
 // framework-scoped entry points re-export the same free functions, plus a lifecycle
 // hook/composable/service:
 import { useKeepAwake } from '@symbiote-native/keep-awake/react';
 import { useKeepAwake } from '@symbiote-native/keep-awake/vue';
+import { useKeepAwake } from '@symbiote-native/keep-awake/svelte';
+import { createKeepAwake } from '@symbiote-native/keep-awake/solid';
 import { KeepAwakeService } from '@symbiote-native/keep-awake/angular';
 ```
 
-Each hook/composable/service activates a lock on mount (optionally registering `options.listener`
-once activation resolves) and deactivates it on unmount — mirroring upstream's own
-`useKeepAwake(tag?, options?)`.
+Each hook/composable/rune/primitive/service activates a lock on mount (optionally registering
+`options.listener` once activation resolves) and deactivates it on unmount — mirroring upstream's
+own `useKeepAwake(tag?, options?)`. Solid's `createKeepAwake(tag?, options?)` does it from the
+primitive body, releasing through `onCleanup`.
 
 ## Test it
 
 No Fabric/Descriptor angle at all — keep-awake is a pure async-function + `EventEmitter` listener
 surface, never a view. Tests inject a fake native-module object in place of the real
 `requireNativeModule` resolution (`src/core/keep-awake.test.ts`,
-`src/{react,vue,angular}/**/*.test.{ts,tsx}`, `vitest`), the same pattern
+`src/{react,vue,svelte,solid,angular}/**/*.test.{ts,tsx}`, `vitest`), the same pattern
 `@symbiote-native/battery` and `@symbiote-native/device` use — no `installFabric()`-driven Fabric
 assertions on the core level, only the adapter lifecycle tests mount through the fake Fabric slot
 to prove activate-on-mount/deactivate-on-unmount. Native rendering itself is verified on-device —

package/build/angular/index.d.ts

@@ -1,2 +1,2 @@
 export { KeepAwakeService } from './services/keep-awake.service';
-export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, type KeepAwakeEvent, type KeepAwakeListener, type KeepAwakeOptions, type EventSubscription, } from '../core';
+export * from '../core';

package/build/angular/index.js

@@ -1,4 +1,4 @@
 // KeepAwakeService is the Angular-only lifecycle half; the free functions and event
 // subscription plumbing all live in core, shared with React/Vue.
 export { KeepAwakeService } from './services/keep-awake.service/index.js';
-export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, } from '../core/index.js';
+export * from '../core/index.js';

package/build/angular/services/keep-awake.service/index.js

@@ -33,7 +33,8 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     return useValue ? value : void 0;
 };
 import { effect, inject, Injectable, Injector } from '@angular/core';
-import { activateKeepAwakeAsync, addListener, deactivateKeepAwake, } from '../../../core/index.js';
+import { activateKeepAwakeAsync, deactivateKeepAwake, } from '../../../core/index.js';
+import { createKeepAwakeListenerAttachment } from '../../../core/listener-attachment.js';
 // Angular twin of React's `useKeepAwake` hook and Vue's `useKeepAwake` composable. See
 // LowPowerModeService (packages/battery) for the `connect()`/`effect()` pattern rationale — same
 // wiring, but keep-awake has no value to surface as a Signal since it's a pure side effect for
@@ -60,14 +61,14 @@ let KeepAwakeService = (() => {
         connect(tag, options) {
             const tagOrDefault = tag ?? `keep-awake-tag-${++tagCounter}`;
             effect(onCleanup => {
+                // Per effect run: onCleanup releases this exact attachment, so a re-run always starts
+                // from a fresh one rather than reviving a released attach.
+                const attachment = createKeepAwakeListenerAttachment(tagOrDefault, options?.listener);
                 activateKeepAwakeAsync(tagOrDefault)
-                    .then(() => {
-                    if (options?.listener) {
-                        addListener(tagOrDefault, options.listener);
-                    }
-                })
+                    .then(() => attachment.attach())
                     .catch(() => { });
                 onCleanup(() => {
+                    attachment.release();
                     if (options?.suppressDeactivateWarnings) {
                         deactivateKeepAwake(tagOrDefault).catch(() => { });
                     }

package/build/core/index.d.ts

@@ -1,3 +1,3 @@
 export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, } from './keep-awake';
-export type { KeepAwakeEvent, KeepAwakeListener, KeepAwakeOptions } from './types';
+export type { KeepAwakeEvent, KeepAwakeListener, KeepAwakeOptions, } from './types';
 export type { EventSubscription } from 'expo-modules-core';

package/build/core/listener-attachment.d.ts

@@ -0,0 +1,8 @@
+import type { KeepAwakeListener } from './types';
+export type IKeepAwakeListenerAttachment = {
+    /** Registers the listener for `tag`. A no-op once `release` has run, or with no listener. */
+    attach: () => void;
+    /** Cancels a not-yet-run `attach` and removes the subscription if one was already registered. */
+    release: () => void;
+};
+export declare function createKeepAwakeListenerAttachment(tag: string, listener?: KeepAwakeListener): IKeepAwakeListenerAttachment;

package/build/core/listener-attachment.js

@@ -0,0 +1,18 @@
+import { addListener } from './keep-awake.js';
+export function createKeepAwakeListenerAttachment(tag, listener) {
+    let isReleased = false;
+    let subscription;
+    return {
+        attach: () => {
+            if (isReleased || !listener) {
+                return;
+            }
+            subscription = addListener(tag, listener);
+        },
+        release: () => {
+            isReleased = true;
+            subscription?.remove();
+            subscription = undefined;
+        },
+    };
+}

package/build/react/hooks/use-keep-awake/index.js

@@ -1,29 +1,26 @@
-// React lifecycle wiring over the framework-agnostic core (core/keep-awake.ts) — activates on
-// mount, deactivates on unmount, mirroring upstream's own useKeepAwake. Uses React's useId for
-// the default per-instance tag exactly like upstream, so two components calling useKeepAwake()
-// concurrently without an explicit tag don't clobber each other's activation/deactivation.
+// React lifecycle wiring over the framework-agnostic core (core/keep-awake.ts): activates on
+// mount, deactivates on unmount, mirroring upstream's useKeepAwake. Uses React's useId for the
+// default per-instance tag so concurrent callers without an explicit tag don't clobber each
+// other's activation/deactivation.
 //
-// Upstream also checks the native module's own `addListenerForTag` presence directly before
-// calling `addListener`; that private module isn't reachable from here (only core's public API
-// is), so registering the listener just goes through the same promise chain — an
-// UnavailabilityError from `addListener` is swallowed by the trailing `.catch(() => {})` exactly
-// like a rejected `activateKeepAwakeAsync`, same net effect as upstream's own guard.
+// Upstream guards `addListener` by checking the native module's `addListenerForTag` directly;
+// that's not reachable here (only core's public API is), so an UnavailabilityError from
+// `addListener` is just swallowed by the trailing `.catch(() => {})` instead - same net effect.
 import { useEffect, useId } from 'react';
-import { activateKeepAwakeAsync, addListener, deactivateKeepAwake, } from '../../../core/index.js';
+import { activateKeepAwakeAsync, deactivateKeepAwake, } from '../../../core/index.js';
+import { createKeepAwakeListenerAttachment } from '../../../core/listener-attachment.js';
 export function useKeepAwake(tag, options) {
     const defaultTag = useId();
     const tagOrDefault = tag ?? defaultTag;
     useEffect(() => {
-        let isMounted = true;
+        // Per effect run, not per hook call - a changed tag tears the old attachment down with the
+        // rest of the cleanup and starts a fresh one.
+        const attachment = createKeepAwakeListenerAttachment(tagOrDefault, options?.listener);
         activateKeepAwakeAsync(tagOrDefault)
-            .then(() => {
-            if (isMounted && options?.listener) {
-                addListener(tagOrDefault, options.listener);
-            }
-        })
+            .then(() => attachment.attach())
             .catch(() => { });
         return () => {
-            isMounted = false;
+            attachment.release();
             if (options?.suppressDeactivateWarnings) {
                 deactivateKeepAwake(tagOrDefault).catch(() => { });
             }

package/build/react/index.d.ts

@@ -1,2 +1,2 @@
 export { useKeepAwake } from './hooks/use-keep-awake';
-export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, type KeepAwakeEvent, type KeepAwakeListener, type KeepAwakeOptions, type EventSubscription, } from '../core';
+export * from '../core';

package/build/react/index.js

@@ -2,4 +2,4 @@
 // lifecycle bucket is `hooks/` (never `composables/`, that's Vue's term) — see
 // adapters/react/src/hooks for the same convention.
 export { useKeepAwake } from './hooks/use-keep-awake/index.js';
-export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, } from '../core/index.js';
+export * from '../core/index.js';

package/build/solid/index.d.ts

@@ -0,0 +1,2 @@
+export { createKeepAwake } from './primitives/create-keep-awake';
+export * from '../core';

package/build/solid/index.js

@@ -0,0 +1,6 @@
+// @symbiote-native/keep-awake/solid: the Solid entry over the framework-agnostic core. 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 { createKeepAwake } from './primitives/create-keep-awake.js';
+export * from '../core/index.js';

package/build/solid/primitives/create-keep-awake.d.ts

@@ -0,0 +1,2 @@
+import { type KeepAwakeOptions } from '../../core';
+export declare function createKeepAwake(tag?: string, options?: KeepAwakeOptions): void;

package/build/solid/primitives/create-keep-awake.js

@@ -0,0 +1,41 @@
+// Solid lifecycle wiring over the framework-agnostic core (core/keep-awake.ts): activates a
+// keep-awake lock in the primitive body, deactivates it when the owner is disposed — the Solid
+// twin of React's hook, Vue's composable, Svelte's rune and Angular's KeepAwakeService.connect().
+//
+// `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.
+//
+// Activation runs SYNCHRONOUSLY in the body with `onCleanup` for teardown, not from a mount hook
+// (React's useEffect, Vue's onMounted, Svelte's $effect) — the lock is requested one tick earlier,
+// and nothing can interleave between construction and the request.
+//
+// Nothing reactive is returned: keeping the screen awake is a pure side effect for the owner's
+// lifetime, so there is no accessor and the once-per-owner contract matches Vue/Svelte/Angular
+// rather than React's hook, which re-runs when the tag changes.
+//
+// No `useId` in Solid, so the default tag comes from a module-local counter, as in Vue and Svelte.
+//
+// Outside a component / createRoot there is no owner for `onCleanup`, so the lock is never
+// released — see create-color-scheme's header for the same documented caveat.
+import { onCleanup } from 'solid-js';
+import { activateKeepAwakeAsync, deactivateKeepAwake, } from '../../core/index.js';
+import { createKeepAwakeListenerAttachment } from '../../core/listener-attachment.js';
+let tagCounter = 0;
+export function createKeepAwake(tag, options) {
+    const tagOrDefault = tag ?? `keep-awake-tag-${++tagCounter}`;
+    // One attachment per owner: the body runs once, so it spans the single activate/onCleanup pair.
+    const attachment = createKeepAwakeListenerAttachment(tagOrDefault, options?.listener);
+    activateKeepAwakeAsync(tagOrDefault)
+        .then(() => attachment.attach())
+        .catch(() => { });
+    onCleanup(() => {
+        attachment.release();
+        if (options?.suppressDeactivateWarnings) {
+            deactivateKeepAwake(tagOrDefault).catch(() => { });
+        }
+        else {
+            deactivateKeepAwake(tagOrDefault);
+        }
+    });
+}

package/build/svelte/index.d.ts

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

package/build/svelte/index.js

@@ -0,0 +1,5 @@
+// @symbiote-native/keep-awake/svelte: the Svelte entry over the framework-agnostic core. The
+// lifecycle bucket is `runes/` (never `hooks/`/`composables/`, those are React's and Vue's terms)
+// — see adapters/svelte/src/runes for the same convention.
+export { useKeepAwake } from './runes/use-keep-awake.svelte';
+export * from '../core/index.js';

package/build/svelte/runes/use-keep-awake.svelte.d.ts

@@ -0,0 +1,2 @@
+import { type KeepAwakeOptions } from '../../core';
+export declare function useKeepAwake(tag?: string, options?: KeepAwakeOptions): void;

package/build/svelte/runes/use-keep-awake.svelte.js

@@ -0,0 +1,37 @@
+// Svelte lifecycle wiring over the framework-agnostic core (core/keep-awake.ts): activates on
+// mount, deactivates on unmount, mirroring React's hook and Vue's composable.
+//
+// `.svelte.ts` extension: `$effect` only works there outside a `.svelte` component. `runes/` is
+// Svelte's name for what React calls `hooks/` and Vue calls `composables/`.
+//
+// The effect reads no reactive state, so it fires once per mount (its return value is the
+// teardown) - same once-per-mount contract as Vue's composable, unlike React's hook, which
+// re-runs when `tagOrDefault` changes.
+//
+// `tag`/`options` are plain values, not getters, because the `<script>` body (like Vue's setup)
+// runs once - nothing here re-reads them.
+//
+// No `useId` in Svelte, so the default tag comes from a module-local counter, as in Vue's
+// composable.
+import { activateKeepAwakeAsync, deactivateKeepAwake, } from '../../core/index.js';
+import { createKeepAwakeListenerAttachment } from '../../core/listener-attachment.js';
+let tagCounter = 0;
+export function useKeepAwake(tag, options) {
+    const tagOrDefault = tag ?? `keep-awake-tag-${++tagCounter}`;
+    $effect(() => {
+        // Inside the effect, so the attachment shares the teardown returned below.
+        const attachment = createKeepAwakeListenerAttachment(tagOrDefault, options?.listener);
+        activateKeepAwakeAsync(tagOrDefault)
+            .then(() => attachment.attach())
+            .catch(() => { });
+        return () => {
+            attachment.release();
+            if (options?.suppressDeactivateWarnings) {
+                deactivateKeepAwake(tagOrDefault).catch(() => { });
+            }
+            else {
+                deactivateKeepAwake(tagOrDefault);
+            }
+        };
+    });
+}

package/build/vue/composables/use-keep-awake/index.js

@@ -4,20 +4,21 @@
 // counter instead — simplest robust way to give each composable instance its own tag when the
 // caller doesn't supply one.
 import { onMounted, onUnmounted } from '@vue/runtime-core';
-import { activateKeepAwakeAsync, addListener, deactivateKeepAwake, } from '../../../core/index.js';
+import { activateKeepAwakeAsync, deactivateKeepAwake, } from '../../../core/index.js';
+import { createKeepAwakeListenerAttachment } from '../../../core/listener-attachment.js';
 let tagCounter = 0;
 export function useKeepAwake(tag, options) {
     const tagOrDefault = tag ?? `keep-awake-tag-${++tagCounter}`;
+    // Setup body scope: it runs once per instance, so one attachment spans the single
+    // onMounted/onUnmounted pair - no need to re-create it on the mount hook.
+    const attachment = createKeepAwakeListenerAttachment(tagOrDefault, options?.listener);
     onMounted(() => {
         activateKeepAwakeAsync(tagOrDefault)
-            .then(() => {
-            if (options?.listener) {
-                addListener(tagOrDefault, options.listener);
-            }
-        })
+            .then(() => attachment.attach())
             .catch(() => { });
     });
     onUnmounted(() => {
+        attachment.release();
         if (options?.suppressDeactivateWarnings) {
             deactivateKeepAwake(tagOrDefault).catch(() => { });
         }

package/build/vue/index.d.ts

@@ -1,2 +1,2 @@
 export { useKeepAwake } from './composables/use-keep-awake';
-export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, type KeepAwakeEvent, type KeepAwakeListener, type KeepAwakeOptions, type EventSubscription, } from '../core';
+export * from '../core';

package/build/vue/index.js

@@ -2,4 +2,4 @@
 // lifecycle bucket is `composables/` (never `hooks/`, that's React's term) — see
 // adapters/vue/src/composables for the same convention.
 export { useKeepAwake } from './composables/use-keep-awake/index.js';
-export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, } from '../core/index.js';
+export * from '../core/index.js';

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

@@ -1,2 +1,2 @@
 export { KeepAwakeService } from './services/keep-awake.service';
-export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, type KeepAwakeEvent, type KeepAwakeListener, type KeepAwakeOptions, type EventSubscription, } from '../core';
+export * from '../core';

package/build-ngc/angular/index.js

@@ -1,5 +1,5 @@
 // KeepAwakeService is the Angular-only lifecycle half; the free functions and event
 // subscription plumbing all live in core, shared with React/Vue.
 export { KeepAwakeService } from './services/keep-awake.service';
-export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, } 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,oFAAoF;AACpF,iEAAiE;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,sBAAsB,EACtB,mBAAmB,EACnB,WAAW,GAKZ,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,iEAAiE;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,cAAc,SAAS,CAAC"}

package/build-ngc/angular/services/keep-awake.service/index.js

@@ -1,5 +1,6 @@
 import { effect, inject, Injectable, Injector } from '@angular/core';
-import { activateKeepAwakeAsync, addListener, deactivateKeepAwake, } from '../../../core';
+import { activateKeepAwakeAsync, deactivateKeepAwake, } from '../../../core';
+import { createKeepAwakeListenerAttachment } from '../../../core/listener-attachment';
 import * as i0 from "@angular/core";
 // Angular twin of React's `useKeepAwake` hook and Vue's `useKeepAwake` composable. See
 // LowPowerModeService (packages/battery) for the `connect()`/`effect()` pattern rationale — same
@@ -14,14 +15,14 @@ export class KeepAwakeService {
     connect(tag, options) {
         const tagOrDefault = tag ?? `keep-awake-tag-${++tagCounter}`;
         effect(onCleanup => {
+            // Per effect run: onCleanup releases this exact attachment, so a re-run always starts
+            // from a fresh one rather than reviving a released attach.
+            const attachment = createKeepAwakeListenerAttachment(tagOrDefault, options?.listener);
             activateKeepAwakeAsync(tagOrDefault)
-                .then(() => {
-                if (options?.listener) {
-                    addListener(tagOrDefault, options.listener);
-                }
-            })
+                .then(() => attachment.attach())
                 .catch(() => { });
             onCleanup(() => {
+                attachment.release();
                 if (options?.suppressDeactivateWarnings) {
                     deactivateKeepAwake(tagOrDefault).catch(() => { });
                 }
@@ -31,10 +32,10 @@ export class KeepAwakeService {
             });
         }, { injector: this.injector });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: KeepAwakeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: KeepAwakeService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: KeepAwakeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: KeepAwakeService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: KeepAwakeService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: KeepAwakeService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });

package/build-ngc/angular/services/keep-awake.service/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/keep-awake.service/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EACL,sBAAsB,EACtB,WAAW,EACX,mBAAmB,GAEpB,MAAM,eAAe,CAAC;;AAEvB,uFAAuF;AACvF,iGAAiG;AACjG,+FAA+F;AAC/F,6FAA6F;AAC7F,yFAAyF;AACzF,EAAE;AACF,0DAA0D;AAC1D,IAAI,UAAU,GAAG,CAAC,CAAC;AAGnB,MAAM,OAAO,gBAAgB;IACV,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAE7C,OAAO,CAAC,GAAY,EAAE,OAA0B;QAC9C,MAAM,YAAY,GAAG,GAAG,IAAI,kBAAkB,EAAE,UAAU,EAAE,CAAC;QAE7D,MAAM,CACJ,SAAS,CAAC,EAAE;YACV,sBAAsB,CAAC,YAAY,CAAC;iBACjC,IAAI,CAAC,GAAG,EAAE;gBACT,IAAI,OAAO,EAAE,QAAQ,EAAE,CAAC;oBACtB,WAAW,CAAC,YAAY,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;gBAC9C,CAAC;YACH,CAAC,CAAC;iBACD,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;YAEnB,SAAS,CAAC,GAAG,EAAE;gBACb,IAAI,OAAO,EAAE,0BAA0B,EAAE,CAAC;oBACxC,mBAAmB,CAAC,YAAY,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;gBACpD,CAAC;qBAAM,CAAC;oBACN,mBAAmB,CAAC,YAAY,CAAC,CAAC;gBACpC,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC,EACD,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAC5B,CAAC;IACJ,CAAC;uGA1BU,gBAAgB;2GAAhB,gBAAgB,cADH,MAAM;;2FACnB,gBAAgB;kBAD5B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/keep-awake.service/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EACL,sBAAsB,EACtB,mBAAmB,GAEpB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,iCAAiC,EAAE,MAAM,mCAAmC,CAAC;;AAEtF,uFAAuF;AACvF,iGAAiG;AACjG,+FAA+F;AAC/F,6FAA6F;AAC7F,yFAAyF;AACzF,EAAE;AACF,0DAA0D;AAC1D,IAAI,UAAU,GAAG,CAAC,CAAC;AAGnB,MAAM,OAAO,gBAAgB;IACV,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAE7C,OAAO,CAAC,GAAY,EAAE,OAA0B;QAC9C,MAAM,YAAY,GAAG,GAAG,IAAI,kBAAkB,EAAE,UAAU,EAAE,CAAC;QAE7D,MAAM,CACJ,SAAS,CAAC,EAAE;YACV,sFAAsF;YACtF,2DAA2D;YAC3D,MAAM,UAAU,GAAG,iCAAiC,CAClD,YAAY,EACZ,OAAO,EAAE,QAAQ,CAClB,CAAC;YAEF,sBAAsB,CAAC,YAAY,CAAC;iBACjC,IAAI,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;iBAC/B,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;YAEnB,SAAS,CAAC,GAAG,EAAE;gBACb,UAAU,CAAC,OAAO,EAAE,CAAC;gBACrB,IAAI,OAAO,EAAE,0BAA0B,EAAE,CAAC;oBACxC,mBAAmB,CAAC,YAAY,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;gBACpD,CAAC;qBAAM,CAAC;oBACN,mBAAmB,CAAC,YAAY,CAAC,CAAC;gBACpC,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC,EACD,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAC5B,CAAC;IACJ,CAAC;uGA9BU,gBAAgB;2GAAhB,gBAAgB,cADH,MAAM;;2FACnB,gBAAgB;kBAD5B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}

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

@@ -1,3 +1,3 @@
 export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, } from './keep-awake';
-export type { KeepAwakeEvent, KeepAwakeListener, KeepAwakeOptions } from './types';
+export type { KeepAwakeEvent, KeepAwakeListener, KeepAwakeOptions, } from './types';
 export type { EventSubscription } from 'expo-modules-core';

package/build-ngc/core/keep-awake.js.map

@@ -1 +1 @@
-{"version":3,"file":"keep-awake.js","sourceRoot":"","sources":["../../src/core/keep-awake.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAC1F,oFAAoF;AACpF,2FAA2F;AAC3F,6EAA6E;AAC7E,qFAAqF;AACrF,OAAO,EAAE,mBAAmB,EAA0B,MAAM,mBAAmB,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,MAAM,CAAC,MAAM,gBAAgB,GAAG,yBAAyB,CAAC;AAE1D,4EAA4E;AAC5E,MAAM,CAAC,KAAK,UAAU,gBAAgB;IACpC,IAAI,aAAa,CAAC,gBAAgB,EAAE,CAAC;QACnC,OAAO,MAAM,aAAa,CAAC,gBAAgB,EAAE,CAAC;IAChD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAAC,MAAc,gBAAgB;IACzE,MAAM,aAAa,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC;AACtC,CAAC;AAED,iGAAiG;AACjG,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,MAAc,gBAAgB;IACtE,MAAM,aAAa,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,CAAC;AACxC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW,CACzB,aAAyC,EACzC,QAA4B;IAE5B,IAAI,CAAC,aAAa,CAAC,iBAAiB,EAAE,CAAC;QACrC,MAAM,IAAI,mBAAmB,CAAC,eAAe,EAAE,mBAAmB,CAAC,CAAC;IACtE,CAAC;IACD,MAAM,GAAG,GAAG,OAAO,aAAa,KAAK,QAAQ,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,gBAAgB,CAAC;IACjF,MAAM,gBAAgB,GAAG,OAAO,aAAa,KAAK,UAAU,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC;IACxF,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACtB,MAAM,IAAI,SAAS,CAAC,0CAA0C,CAAC,CAAC;IAClE,CAAC;IACD,OAAO,aAAa,CAAC,iBAAiB,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC;AAChE,CAAC"}
+{"version":3,"file":"keep-awake.js","sourceRoot":"","sources":["../../src/core/keep-awake.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAC1F,oFAAoF;AACpF,2FAA2F;AAC3F,6EAA6E;AAC7E,qFAAqF;AACrF,OAAO,EAAE,mBAAmB,EAA0B,MAAM,mBAAmB,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,MAAM,CAAC,MAAM,gBAAgB,GAAG,yBAAyB,CAAC;AAE1D,4EAA4E;AAC5E,MAAM,CAAC,KAAK,UAAU,gBAAgB;IACpC,IAAI,aAAa,CAAC,gBAAgB,EAAE,CAAC;QACnC,OAAO,MAAM,aAAa,CAAC,gBAAgB,EAAE,CAAC;IAChD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAC1C,MAAc,gBAAgB;IAE9B,MAAM,aAAa,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC;AACtC,CAAC;AAED,iGAAiG;AACjG,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,MAAc,gBAAgB;IAE9B,MAAM,aAAa,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,CAAC;AACxC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW,CACzB,aAAyC,EACzC,QAA4B;IAE5B,IAAI,CAAC,aAAa,CAAC,iBAAiB,EAAE,CAAC;QACrC,MAAM,IAAI,mBAAmB,CAAC,eAAe,EAAE,mBAAmB,CAAC,CAAC;IACtE,CAAC;IACD,MAAM,GAAG,GACP,OAAO,aAAa,KAAK,QAAQ,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,gBAAgB,CAAC;IACvE,MAAM,gBAAgB,GACpB,OAAO,aAAa,KAAK,UAAU,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC;IACjE,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACtB,MAAM,IAAI,SAAS,CAAC,0CAA0C,CAAC,CAAC;IAClE,CAAC;IACD,OAAO,aAAa,CAAC,iBAAiB,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC;AAChE,CAAC"}

package/build-ngc/core/listener-attachment.d.ts

@@ -0,0 +1,8 @@
+import type { KeepAwakeListener } from './types';
+export type IKeepAwakeListenerAttachment = {
+    /** Registers the listener for `tag`. A no-op once `release` has run, or with no listener. */
+    attach: () => void;
+    /** Cancels a not-yet-run `attach` and removes the subscription if one was already registered. */
+    release: () => void;
+};
+export declare function createKeepAwakeListenerAttachment(tag: string, listener?: KeepAwakeListener): IKeepAwakeListenerAttachment;

package/build-ngc/core/listener-attachment.js

@@ -0,0 +1,19 @@
+import { addListener } from './keep-awake';
+export function createKeepAwakeListenerAttachment(tag, listener) {
+    let isReleased = false;
+    let subscription;
+    return {
+        attach: () => {
+            if (isReleased || !listener) {
+                return;
+            }
+            subscription = addListener(tag, listener);
+        },
+        release: () => {
+            isReleased = true;
+            subscription?.remove();
+            subscription = undefined;
+        },
+    };
+}
+//# sourceMappingURL=listener-attachment.js.map

package/build-ngc/core/listener-attachment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"listener-attachment.js","sourceRoot":"","sources":["../../src/core/listener-attachment.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAU3C,MAAM,UAAU,iCAAiC,CAC/C,GAAW,EACX,QAA4B;IAE5B,IAAI,UAAU,GAAG,KAAK,CAAC;IACvB,IAAI,YAA2C,CAAC;IAEhD,OAAO;QACL,MAAM,EAAE,GAAG,EAAE;YACX,IAAI,UAAU,IAAI,CAAC,QAAQ,EAAE,CAAC;gBAC5B,OAAO;YACT,CAAC;YACD,YAAY,GAAG,WAAW,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QAC5C,CAAC;QACD,OAAO,EAAE,GAAG,EAAE;YACZ,UAAU,GAAG,IAAI,CAAC;YAClB,YAAY,EAAE,MAAM,EAAE,CAAC;YACvB,YAAY,GAAG,SAAS,CAAC;QAC3B,CAAC;KACF,CAAC;AACJ,CAAC"}

package/build-ngc/core/native-module.js.map

@@ -1 +1 @@
-{"version":3,"file":"native-module.js","sourceRoot":"","sources":["../../src/core/native-module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAIxD,MAAM,2BAA2B,GAAG,eAAe,CAAC;AAapD,MAAM,CAAC,MAAM,aAAa,GAAG,mBAAmB,CAC9C,2BAA2B,CAC5B,CAAC"}
+{"version":3,"file":"native-module.js","sourceRoot":"","sources":["../../src/core/native-module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAIxD,MAAM,2BAA2B,GAAG,eAAe,CAAC;AAgBpD,MAAM,CAAC,MAAM,aAAa,GAAG,mBAAmB,CAC9C,2BAA2B,CAC5B,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@symbiote-native/keep-awake",
-  "version": "0.1.0",
-  "description": "expo-keep-awake wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, and Angular adapters. Keeps the screen awake for the lifetime of a mounted component/composable/service, with an optional listener for keep-awake state changes.",
+  "version": "0.3.0",
+  "description": "expo-keep-awake wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, Svelte, Solid, and Angular adapters. Keeps the screen awake for the lifetime of a mounted component/composable/service, with an optional listener for keep-awake state changes.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -30,6 +30,14 @@
       "types": "./build/react/index.d.ts",
       "default": "./build/react/index.js"
     },
+    "./svelte": {
+      "types": "./build/svelte/index.d.ts",
+      "default": "./build/svelte/index.js"
+    },
+    "./solid": {
+      "types": "./build/solid/index.d.ts",
+      "default": "./build/solid/index.js"
+    },
     "./angular": {
       "types": "./build-ngc/angular/index.d.ts",
       "react-native": "./build-ngc/angular/index.js",
@@ -53,15 +61,19 @@
     "expo-modules-core": "57.0.5"
   },
   "peerDependencies": {
+    "@symbiote-native/angular": ">=0.6.2",
     "@symbiote-native/engine": ">=0.1.7",
+    "@symbiote-native/react": ">=0.2.8",
+    "@symbiote-native/solid": ">=0.0.1",
+    "@symbiote-native/svelte": ">=0.1.0",
+    "@symbiote-native/vue": ">=0.3.8",
     "@angular/core": ">=20",
     "@vue/runtime-core": "^3.5.13",
     "react": ">=19.0.0",
     "react-native": ">=0.86",
-    "vue": ">=3.5.0",
-    "@symbiote-native/angular": "0.6.2",
-    "@symbiote-native/react": "0.2.8",
-    "@symbiote-native/vue": "0.3.8"
+    "solid-js": ">=1.9.0",
+    "svelte": ">=5.56.0",
+    "vue": ">=3.5.0"
   },
   "peerDependenciesMeta": {
     "@symbiote-native/angular": {
@@ -70,6 +82,12 @@
     "@symbiote-native/react": {
       "optional": true
     },
+    "@symbiote-native/solid": {
+      "optional": true
+    },
+    "@symbiote-native/svelte": {
+      "optional": true
+    },
     "@symbiote-native/vue": {
       "optional": true
     },
@@ -82,24 +100,34 @@
     "react": {
       "optional": true
     },
+    "solid-js": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
+    },
     "vue": {
       "optional": true
     }
   },
   "devDependencies": {
-    "@angular/compiler": "^22",
-    "@angular/compiler-cli": "^22",
-    "@angular/core": "^22",
+    "@angular/compiler": "~22.0.8",
+    "@angular/compiler-cli": "~22.0.8",
+    "@angular/core": "~22.0.8",
     "@types/node": "^26.0.0",
     "@types/react": "^19.2.0",
     "@vue/runtime-core": "^3.5.13",
     "react": "19.2.3",
+    "solid-js": "^1.9.14",
+    "svelte": "^5.56.0",
     "typescript": "~6.0.0",
-    "@symbiote-native/angular": "0.6.2",
-    "@symbiote-native/engine": "0.1.7",
-    "@symbiote-native/react": "0.2.8",
-    "@symbiote-native/test-utils": "0.1.6",
-    "@symbiote-native/vue": "0.3.8"
+    "@symbiote-native/angular": "0.8.0",
+    "@symbiote-native/engine": "0.3.0",
+    "@symbiote-native/react": "0.4.0",
+    "@symbiote-native/solid": "0.1.0",
+    "@symbiote-native/svelte": "0.3.0",
+    "@symbiote-native/test-utils": "0.2.0",
+    "@symbiote-native/vue": "0.5.0"
   },
   "scripts": {
     "typecheck": "tsc --build",

package/src/angular/index.ts

@@ -1,14 +1,4 @@
 // KeepAwakeService is the Angular-only lifecycle half; the free functions and event
 // subscription plumbing all live in core, shared with React/Vue.
 export { KeepAwakeService } from './services/keep-awake.service';
-export {
-  ExpoKeepAwakeTag,
-  isAvailableAsync,
-  activateKeepAwakeAsync,
-  deactivateKeepAwake,
-  addListener,
-  type KeepAwakeEvent,
-  type KeepAwakeListener,
-  type KeepAwakeOptions,
-  type EventSubscription,
-} from '../core';
+export * from '../core';

package/src/angular/services/keep-awake.service/index.ts

@@ -1,10 +1,10 @@
 import { effect, inject, Injectable, Injector } from '@angular/core';
 import {
   activateKeepAwakeAsync,
-  addListener,
   deactivateKeepAwake,
   type KeepAwakeOptions,
 } from '../../../core';
+import { createKeepAwakeListenerAttachment } from '../../../core/listener-attachment';
 
 // Angular twin of React's `useKeepAwake` hook and Vue's `useKeepAwake` composable. See
 // LowPowerModeService (packages/battery) for the `connect()`/`effect()` pattern rationale — same
@@ -24,15 +24,19 @@ export class KeepAwakeService {
 
     effect(
       onCleanup => {
+        // Per effect run: onCleanup releases this exact attachment, so a re-run always starts
+        // from a fresh one rather than reviving a released attach.
+        const attachment = createKeepAwakeListenerAttachment(
+          tagOrDefault,
+          options?.listener,
+        );
+
         activateKeepAwakeAsync(tagOrDefault)
-          .then(() => {
-            if (options?.listener) {
-              addListener(tagOrDefault, options.listener);
-            }
-          })
+          .then(() => attachment.attach())
           .catch(() => {});
 
         onCleanup(() => {
+          attachment.release();
           if (options?.suppressDeactivateWarnings) {
             deactivateKeepAwake(tagOrDefault).catch(() => {});
           } else {

package/src/core/index.ts

@@ -5,5 +5,9 @@ export {
   deactivateKeepAwake,
   addListener,
 } from './keep-awake';
-export type { KeepAwakeEvent, KeepAwakeListener, KeepAwakeOptions } from './types';
+export type {
+  KeepAwakeEvent,
+  KeepAwakeListener,
+  KeepAwakeOptions,
+} from './types';
 export type { EventSubscription } from 'expo-modules-core';

package/src/core/keep-awake.ts

@@ -21,12 +21,16 @@ export async function isAvailableAsync(): Promise<boolean> {
  * Activates a keep-awake lock under `tag` (the shared default tag when none is given) — the
  * screen stays on for as long as any tag holds an active lock.
  */
-export async function activateKeepAwakeAsync(tag: string = ExpoKeepAwakeTag): Promise<void> {
+export async function activateKeepAwakeAsync(
+  tag: string = ExpoKeepAwakeTag,
+): Promise<void> {
   await expoKeepAwake.activate?.(tag);
 }
 
 /** Releases the keep-awake lock held under `tag` (the shared default tag when none is given). */
-export async function deactivateKeepAwake(tag: string = ExpoKeepAwakeTag): Promise<void> {
+export async function deactivateKeepAwake(
+  tag: string = ExpoKeepAwakeTag,
+): Promise<void> {
   await expoKeepAwake.deactivate?.(tag);
 }
 
@@ -41,8 +45,10 @@ export function addListener(
   if (!expoKeepAwake.addListenerForTag) {
     throw new UnavailabilityError('ExpoKeepAwake', 'addListenerForTag');
   }
-  const tag = typeof tagOrListener === 'string' ? tagOrListener : ExpoKeepAwakeTag;
-  const resolvedListener = typeof tagOrListener === 'function' ? tagOrListener : listener;
+  const tag =
+    typeof tagOrListener === 'string' ? tagOrListener : ExpoKeepAwakeTag;
+  const resolvedListener =
+    typeof tagOrListener === 'function' ? tagOrListener : listener;
   if (!resolvedListener) {
     throw new TypeError('addListener requires a listener function');
   }

package/src/core/listener-attachment.ts

@@ -0,0 +1,43 @@
+// The listener half of a keep-awake session, plus the teardown race that comes with it:
+// activation is async, so the consumer can be gone by the time it resolves. Whoever tears down
+// first has to do two things - cancel an attach that hasn't run yet, AND remove a subscription
+// that already landed. Miss either and the listener outlives the consumer with nothing left
+// holding a reference to remove it.
+//
+// It lives here rather than in each adapter because the flag-plus-subscription bookkeeping is
+// identical in all four; only WHERE attach/release get called differs (useEffect cleanup,
+// onUnmounted, effect's onCleanup, $effect teardown). Deliberately NOT re-exported from
+// core/index.ts - every framework entry does `export * from '../core'`, and this is lifecycle
+// plumbing for the adapters, not public API.
+import type { EventSubscription } from 'expo-modules-core';
+import { addListener } from './keep-awake';
+import type { KeepAwakeListener } from './types';
+
+export type IKeepAwakeListenerAttachment = {
+  /** Registers the listener for `tag`. A no-op once `release` has run, or with no listener. */
+  attach: () => void;
+  /** Cancels a not-yet-run `attach` and removes the subscription if one was already registered. */
+  release: () => void;
+};
+
+export function createKeepAwakeListenerAttachment(
+  tag: string,
+  listener?: KeepAwakeListener,
+): IKeepAwakeListenerAttachment {
+  let isReleased = false;
+  let subscription: EventSubscription | undefined;
+
+  return {
+    attach: () => {
+      if (isReleased || !listener) {
+        return;
+      }
+      subscription = addListener(tag, listener);
+    },
+    release: () => {
+      isReleased = true;
+      subscription?.remove();
+      subscription = undefined;
+    },
+  };
+}

package/src/core/native-module.ts

@@ -12,7 +12,10 @@ export type INativeKeepAwakeModule = {
   isAvailableAsync?(): Promise<boolean>;
   activate?(tag: string): Promise<void>;
   deactivate?(tag: string): Promise<void>;
-  addListenerForTag?(tag: string, listener: KeepAwakeListener): EventSubscription;
+  addListenerForTag?(
+    tag: string,
+    listener: KeepAwakeListener,
+  ): EventSubscription;
 };
 
 export const expoKeepAwake = requireNativeModule<INativeKeepAwakeModule>(

package/src/react/hooks/use-keep-awake/index.ts

@@ -1,38 +1,37 @@
-// React lifecycle wiring over the framework-agnostic core (core/keep-awake.ts) — activates on
-// mount, deactivates on unmount, mirroring upstream's own useKeepAwake. Uses React's useId for
-// the default per-instance tag exactly like upstream, so two components calling useKeepAwake()
-// concurrently without an explicit tag don't clobber each other's activation/deactivation.
+// React lifecycle wiring over the framework-agnostic core (core/keep-awake.ts): activates on
+// mount, deactivates on unmount, mirroring upstream's useKeepAwake. Uses React's useId for the
+// default per-instance tag so concurrent callers without an explicit tag don't clobber each
+// other's activation/deactivation.
 //
-// Upstream also checks the native module's own `addListenerForTag` presence directly before
-// calling `addListener`; that private module isn't reachable from here (only core's public API
-// is), so registering the listener just goes through the same promise chain — an
-// UnavailabilityError from `addListener` is swallowed by the trailing `.catch(() => {})` exactly
-// like a rejected `activateKeepAwakeAsync`, same net effect as upstream's own guard.
+// Upstream guards `addListener` by checking the native module's `addListenerForTag` directly;
+// that's not reachable here (only core's public API is), so an UnavailabilityError from
+// `addListener` is just swallowed by the trailing `.catch(() => {})` instead - same net effect.
 import { useEffect, useId } from 'react';
 import {
   activateKeepAwakeAsync,
-  addListener,
   deactivateKeepAwake,
   type KeepAwakeOptions,
 } from '../../../core';
+import { createKeepAwakeListenerAttachment } from '../../../core/listener-attachment';
 
 export function useKeepAwake(tag?: string, options?: KeepAwakeOptions): void {
   const defaultTag = useId();
   const tagOrDefault = tag ?? defaultTag;
 
   useEffect(() => {
-    let isMounted = true;
+    // Per effect run, not per hook call - a changed tag tears the old attachment down with the
+    // rest of the cleanup and starts a fresh one.
+    const attachment = createKeepAwakeListenerAttachment(
+      tagOrDefault,
+      options?.listener,
+    );
 
     activateKeepAwakeAsync(tagOrDefault)
-      .then(() => {
-        if (isMounted && options?.listener) {
-          addListener(tagOrDefault, options.listener);
-        }
-      })
+      .then(() => attachment.attach())
       .catch(() => {});
 
     return () => {
-      isMounted = false;
+      attachment.release();
       if (options?.suppressDeactivateWarnings) {
         deactivateKeepAwake(tagOrDefault).catch(() => {});
       } else {

package/src/react/index.ts

@@ -3,14 +3,4 @@
 // adapters/react/src/hooks for the same convention.
 
 export { useKeepAwake } from './hooks/use-keep-awake';
-export {
-  ExpoKeepAwakeTag,
-  isAvailableAsync,
-  activateKeepAwakeAsync,
-  deactivateKeepAwake,
-  addListener,
-  type KeepAwakeEvent,
-  type KeepAwakeListener,
-  type KeepAwakeOptions,
-  type EventSubscription,
-} from '../core';
+export * from '../core';

package/src/solid/index.ts

@@ -0,0 +1,7 @@
+// @symbiote-native/keep-awake/solid: the Solid entry over the framework-agnostic core. 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 { createKeepAwake } from './primitives/create-keep-awake';
+export * from '../core';

package/src/solid/primitives/create-keep-awake.ts

@@ -0,0 +1,54 @@
+// Solid lifecycle wiring over the framework-agnostic core (core/keep-awake.ts): activates a
+// keep-awake lock in the primitive body, deactivates it when the owner is disposed — the Solid
+// twin of React's hook, Vue's composable, Svelte's rune and Angular's KeepAwakeService.connect().
+//
+// `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.
+//
+// Activation runs SYNCHRONOUSLY in the body with `onCleanup` for teardown, not from a mount hook
+// (React's useEffect, Vue's onMounted, Svelte's $effect) — the lock is requested one tick earlier,
+// and nothing can interleave between construction and the request.
+//
+// Nothing reactive is returned: keeping the screen awake is a pure side effect for the owner's
+// lifetime, so there is no accessor and the once-per-owner contract matches Vue/Svelte/Angular
+// rather than React's hook, which re-runs when the tag changes.
+//
+// No `useId` in Solid, so the default tag comes from a module-local counter, as in Vue and Svelte.
+//
+// Outside a component / createRoot there is no owner for `onCleanup`, so the lock is never
+// released — see create-color-scheme's header for the same documented caveat.
+import { onCleanup } from 'solid-js';
+import {
+  activateKeepAwakeAsync,
+  deactivateKeepAwake,
+  type KeepAwakeOptions,
+} from '../../core';
+import { createKeepAwakeListenerAttachment } from '../../core/listener-attachment';
+
+let tagCounter = 0;
+
+export function createKeepAwake(
+  tag?: string,
+  options?: KeepAwakeOptions,
+): void {
+  const tagOrDefault = tag ?? `keep-awake-tag-${++tagCounter}`;
+  // One attachment per owner: the body runs once, so it spans the single activate/onCleanup pair.
+  const attachment = createKeepAwakeListenerAttachment(
+    tagOrDefault,
+    options?.listener,
+  );
+
+  activateKeepAwakeAsync(tagOrDefault)
+    .then(() => attachment.attach())
+    .catch(() => {});
+
+  onCleanup(() => {
+    attachment.release();
+    if (options?.suppressDeactivateWarnings) {
+      deactivateKeepAwake(tagOrDefault).catch(() => {});
+    } else {
+      deactivateKeepAwake(tagOrDefault);
+    }
+  });
+}

package/src/svelte/index.ts

@@ -0,0 +1,6 @@
+// @symbiote-native/keep-awake/svelte: the Svelte entry over the framework-agnostic core. The
+// lifecycle bucket is `runes/` (never `hooks/`/`composables/`, those are React's and Vue's terms)
+// — see adapters/svelte/src/runes for the same convention.
+
+export { useKeepAwake } from './runes/use-keep-awake.svelte';
+export * from '../core';

package/src/svelte/runes/use-keep-awake.svelte.ts

@@ -0,0 +1,48 @@
+// Svelte lifecycle wiring over the framework-agnostic core (core/keep-awake.ts): activates on
+// mount, deactivates on unmount, mirroring React's hook and Vue's composable.
+//
+// `.svelte.ts` extension: `$effect` only works there outside a `.svelte` component. `runes/` is
+// Svelte's name for what React calls `hooks/` and Vue calls `composables/`.
+//
+// The effect reads no reactive state, so it fires once per mount (its return value is the
+// teardown) - same once-per-mount contract as Vue's composable, unlike React's hook, which
+// re-runs when `tagOrDefault` changes.
+//
+// `tag`/`options` are plain values, not getters, because the `<script>` body (like Vue's setup)
+// runs once - nothing here re-reads them.
+//
+// No `useId` in Svelte, so the default tag comes from a module-local counter, as in Vue's
+// composable.
+import {
+  activateKeepAwakeAsync,
+  deactivateKeepAwake,
+  type KeepAwakeOptions,
+} from '../../core';
+import { createKeepAwakeListenerAttachment } from '../../core/listener-attachment';
+
+let tagCounter = 0;
+
+export function useKeepAwake(tag?: string, options?: KeepAwakeOptions): void {
+  const tagOrDefault = tag ?? `keep-awake-tag-${++tagCounter}`;
+
+  $effect(() => {
+    // Inside the effect, so the attachment shares the teardown returned below.
+    const attachment = createKeepAwakeListenerAttachment(
+      tagOrDefault,
+      options?.listener,
+    );
+
+    activateKeepAwakeAsync(tagOrDefault)
+      .then(() => attachment.attach())
+      .catch(() => {});
+
+    return () => {
+      attachment.release();
+      if (options?.suppressDeactivateWarnings) {
+        deactivateKeepAwake(tagOrDefault).catch(() => {});
+      } else {
+        deactivateKeepAwake(tagOrDefault);
+      }
+    };
+  });
+}

package/src/svelte/svelte-ambient.d.ts

@@ -0,0 +1,6 @@
+// Pulls in svelte's ambient global declarations ($state/$effect/...) for this package's tsc
+// program. adapters/svelte gets these for free because render.ts does a real value import from
+// 'svelte' (any file in a program importing a module loads its ambient globals for the whole
+// program); this package has no such import, so a triple-slash reference does the same job
+// explicitly rather than relying on an incidental side-effect.
+/// <reference types="svelte" />

package/src/vue/composables/use-keep-awake/index.ts

@@ -6,27 +6,30 @@
 import { onMounted, onUnmounted } from '@vue/runtime-core';
 import {
   activateKeepAwakeAsync,
-  addListener,
   deactivateKeepAwake,
   type KeepAwakeOptions,
 } from '../../../core';
+import { createKeepAwakeListenerAttachment } from '../../../core/listener-attachment';
 
 let tagCounter = 0;
 
 export function useKeepAwake(tag?: string, options?: KeepAwakeOptions): void {
   const tagOrDefault = tag ?? `keep-awake-tag-${++tagCounter}`;
+  // Setup body scope: it runs once per instance, so one attachment spans the single
+  // onMounted/onUnmounted pair - no need to re-create it on the mount hook.
+  const attachment = createKeepAwakeListenerAttachment(
+    tagOrDefault,
+    options?.listener,
+  );
 
   onMounted(() => {
     activateKeepAwakeAsync(tagOrDefault)
-      .then(() => {
-        if (options?.listener) {
-          addListener(tagOrDefault, options.listener);
-        }
-      })
+      .then(() => attachment.attach())
       .catch(() => {});
   });
 
   onUnmounted(() => {
+    attachment.release();
     if (options?.suppressDeactivateWarnings) {
       deactivateKeepAwake(tagOrDefault).catch(() => {});
     } else {

package/src/vue/index.ts

@@ -3,14 +3,4 @@
 // adapters/vue/src/composables for the same convention.
 
 export { useKeepAwake } from './composables/use-keep-awake';
-export {
-  ExpoKeepAwakeTag,
-  isAvailableAsync,
-  activateKeepAwakeAsync,
-  deactivateKeepAwake,
-  addListener,
-  type KeepAwakeEvent,
-  type KeepAwakeListener,
-  type KeepAwakeOptions,
-  type EventSubscription,
-} from '../core';
+export * from '../core';