@symbiote-native/keep-awake 0.0.1

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

@@ -0,0 +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"}

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

@@ -0,0 +1,8 @@
+export type KeepAwakeEvent = {
+    state: unknown;
+};
+export type KeepAwakeListener = (event: KeepAwakeEvent) => void;
+export type KeepAwakeOptions = {
+    listener?: KeepAwakeListener;
+    suppressDeactivateWarnings?: boolean;
+};

package/build-ngc/core/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/build-ngc/core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":""}

package/native-link.json

@@ -0,0 +1,12 @@
+{
+  "android": {
+    "gradleProjectName": "expo-keep-awake",
+    "modules": [
+      {
+        "importPath": "expo.modules.keepawake.KeepAwakeModule",
+        "className": "KeepAwakeModule",
+        "nativeName": "ExpoKeepAwake"
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@symbiote-native/keep-awake",
+  "version": "0.0.1",
+  "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.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneEyed1366/symbiote-native.git",
+    "directory": "packages/keep-awake"
+  },
+  "homepage": "https://github.com/OneEyed1366/symbiote-native/tree/master/packages/keep-awake#readme",
+  "bugs": {
+    "url": "https://github.com/OneEyed1366/symbiote-native/issues"
+  },
+  "author": "Andrey Prokopenko <psevdoproger@gmail.com>",
+  "type": "module",
+  "main": "./build/core/index.js",
+  "module": "./build/core/index.js",
+  "types": "./build/core/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/core/index.d.ts",
+      "default": "./build/core/index.js"
+    },
+    "./vue": {
+      "types": "./build/vue/index.d.ts",
+      "default": "./build/vue/index.js"
+    },
+    "./react": {
+      "types": "./build/react/index.d.ts",
+      "default": "./build/react/index.js"
+    },
+    "./angular": {
+      "types": "./build-ngc/angular/index.d.ts",
+      "react-native": "./build-ngc/angular/index.js",
+      "default": "./src/angular/index.ts"
+    }
+  },
+  "files": [
+    "src",
+    "build",
+    "build-ngc",
+    "native-link.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "expo-keep-awake": "57.0.1",
+    "expo-modules-core": "57.0.5"
+  },
+  "peerDependencies": {
+    "@symbiote-native/engine": ">=0.1.7",
+    "@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.1",
+    "@symbiote-native/react": "0.2.8",
+    "@symbiote-native/vue": "0.3.8"
+  },
+  "peerDependenciesMeta": {
+    "@symbiote-native/angular": {
+      "optional": true
+    },
+    "@symbiote-native/react": {
+      "optional": true
+    },
+    "@symbiote-native/vue": {
+      "optional": true
+    },
+    "@angular/core": {
+      "optional": true
+    },
+    "@vue/runtime-core": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@angular/compiler": "^22",
+    "@angular/compiler-cli": "^22",
+    "@angular/core": "^22",
+    "@types/node": "^26.0.0",
+    "@types/react": "^19.2.0",
+    "@vue/runtime-core": "^3.5.13",
+    "react": "19.2.3",
+    "typescript": "~6.0.0",
+    "@symbiote-native/test-utils": "0.1.6",
+    "@symbiote-native/engine": "0.1.7",
+    "@symbiote-native/react": "0.2.8",
+    "@symbiote-native/angular": "0.6.1",
+    "@symbiote-native/vue": "0.3.8"
+  },
+  "scripts": {
+    "typecheck": "tsc --build",
+    "clean": "rm -rf build-ngc",
+    "ng:build": "pnpm run clean && ngc -p tsconfig.angular.json",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\""
+  }
+}

package/src/angular/index.ts

@@ -0,0 +1,14 @@
+// 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';

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

@@ -0,0 +1,46 @@
+import { effect, inject, Injectable, Injector } from '@angular/core';
+import {
+  activateKeepAwakeAsync,
+  addListener,
+  deactivateKeepAwake,
+  type KeepAwakeOptions,
+} from '../../../core';
+
+// 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
+// the component's lifetime. Angular has no useId equivalent either, so the default tag comes
+// from the same monotonically-incrementing module-local counter the Vue composable uses.
+//
+//   constructor() { inject(KeepAwakeService).connect(); }
+let tagCounter = 0;
+
+@Injectable({ providedIn: 'root' })
+export class KeepAwakeService {
+  private readonly injector = inject(Injector);
+
+  connect(tag?: string, options?: KeepAwakeOptions): void {
+    const tagOrDefault = tag ?? `keep-awake-tag-${++tagCounter}`;
+
+    effect(
+      onCleanup => {
+        activateKeepAwakeAsync(tagOrDefault)
+          .then(() => {
+            if (options?.listener) {
+              addListener(tagOrDefault, options.listener);
+            }
+          })
+          .catch(() => {});
+
+        onCleanup(() => {
+          if (options?.suppressDeactivateWarnings) {
+            deactivateKeepAwake(tagOrDefault).catch(() => {});
+          } else {
+            deactivateKeepAwake(tagOrDefault);
+          }
+        });
+      },
+      { injector: this.injector },
+    );
+  }
+}

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

@@ -0,0 +1,98 @@
+// Co-located Angular-driven test (ADR 0025) for KeepAwakeService. See battery's
+// low-power-mode.service.test.ts for the shared rationale.
+//
+// Two host classes rather than one @Input-driven host: Angular sets @Input-bound properties
+// AFTER construction, so a constructor-time `connect(this.tag)` read off an @Input would always
+// see `undefined` — the same field-initializer/constructor timing every other service host in
+// this repo relies on (see battery's own PermissionsHost/BatteryLevelHost).
+
+import '@angular/compiler';
+import { Component, inject } from '@angular/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount } from '@symbiote-native/angular';
+import { installFabric } from '@symbiote-native/test-utils';
+import { KeepAwakeService } from './index';
+
+const activateKeepAwakeAsyncMock = vi.fn(async (_tag: string) => undefined);
+const addListenerMock = vi.fn();
+const deactivateKeepAwakeMock = vi.fn(async (_tag: string) => undefined);
+
+vi.mock('../../../core', () => ({
+  activateKeepAwakeAsync: (tag: string) => activateKeepAwakeAsyncMock(tag),
+  addListener: (...args: unknown[]) => addListenerMock(...args),
+  deactivateKeepAwake: (tag: string) => deactivateKeepAwakeMock(tag),
+}));
+
+const ROOT_TAG = 974;
+const fabric = installFabric();
+const tick = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0));
+
+@Component({
+  selector: 'symbiote-keep-awake-default-host',
+  standalone: true,
+  template: '',
+})
+class KeepAwakeDefaultHost {
+  constructor() {
+    inject(KeepAwakeService).connect();
+  }
+}
+
+@Component({
+  selector: 'symbiote-keep-awake-custom-host',
+  standalone: true,
+  template: '',
+})
+class KeepAwakeCustomHost {
+  constructor() {
+    inject(KeepAwakeService).connect('custom-tag');
+  }
+}
+
+beforeEach(() => {
+  activateKeepAwakeAsyncMock.mockClear();
+  addListenerMock.mockClear();
+  deactivateKeepAwakeMock.mockClear();
+  activateKeepAwakeAsyncMock.mockResolvedValue(undefined);
+  deactivateKeepAwakeMock.mockResolvedValue(undefined);
+});
+
+afterEach(() => {
+  unmount(ROOT_TAG);
+  fabric.reset();
+  vi.clearAllMocks();
+});
+
+describe('KeepAwakeService.connect', () => {
+  it('activates a default tag on mount', async () => {
+    mount(ROOT_TAG, KeepAwakeDefaultHost);
+    await tick();
+
+    expect(activateKeepAwakeAsyncMock).toHaveBeenCalledTimes(1);
+    expect(typeof activateKeepAwakeAsyncMock.mock.calls[0][0]).toBe('string');
+  });
+
+  it('activates the explicit tag when one is given', async () => {
+    mount(ROOT_TAG, KeepAwakeCustomHost);
+    await tick();
+
+    expect(activateKeepAwakeAsyncMock).toHaveBeenCalledWith('custom-tag');
+  });
+
+  it('deactivates the same tag when the host component is unmounted', async () => {
+    mount(ROOT_TAG, KeepAwakeCustomHost);
+    await tick();
+
+    unmount(ROOT_TAG);
+    await tick();
+
+    expect(deactivateKeepAwakeMock).toHaveBeenCalledWith('custom-tag');
+  });
+
+  it('never touches addListener when no options are given', async () => {
+    mount(ROOT_TAG, KeepAwakeCustomHost);
+    await tick();
+
+    expect(addListenerMock).not.toHaveBeenCalled();
+  });
+});

package/src/core/index.ts

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

package/src/core/keep-awake.test.ts

@@ -0,0 +1,119 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const FAKE_NATIVE_KEEP_AWAKE = {
+  isAvailableAsync: vi.fn(async () => true),
+  activate: vi.fn(async () => undefined),
+  deactivate: vi.fn(async () => undefined),
+  addListenerForTag: vi.fn(() => ({ remove: vi.fn() })),
+};
+
+// The real ExpoKeepAwake native module only exists on device — resolving it via
+// requireNativeModule() at import time would throw in this headless test run, so the
+// module-lookup file is faked in place of expo-modules-core's runtime resolution, same pattern
+// packages/battery/src/core/battery.test.ts uses.
+vi.mock('./native-module', () => ({
+  expoKeepAwake: FAKE_NATIVE_KEEP_AWAKE,
+}));
+
+// expo-modules-core's real entry transitively imports 'react-native' for Platform/
+// TurboModuleRegistry, whose Flow-typed source Vitest's Oxc transform can't parse — same fake
+// packages/haptics/src/core/haptics.test.ts uses. keep-awake.ts imports UnavailabilityError as a
+// real value (not just a type), so it needs mocking here too.
+vi.mock('expo-modules-core', () => ({
+  UnavailabilityError: class UnavailabilityError extends Error {
+    constructor(moduleName: string, propertyName: string) {
+      super(`${propertyName} is not available on ${moduleName}`);
+    }
+  },
+}));
+
+const {
+  ExpoKeepAwakeTag,
+  isAvailableAsync,
+  activateKeepAwakeAsync,
+  deactivateKeepAwake,
+  addListener,
+} = await import('./keep-awake');
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('isAvailableAsync', () => {
+  it('delegates to the native module when isAvailableAsync exists', async () => {
+    await expect(isAvailableAsync()).resolves.toBe(true);
+  });
+
+  it('defaults to true when the native method is absent', async () => {
+    const { isAvailableAsync: native } = FAKE_NATIVE_KEEP_AWAKE;
+    // @ts-expect-error -- simulating a platform where the native module has no such method
+    FAKE_NATIVE_KEEP_AWAKE.isAvailableAsync = undefined;
+
+    await expect(isAvailableAsync()).resolves.toBe(true);
+
+    FAKE_NATIVE_KEEP_AWAKE.isAvailableAsync = native;
+  });
+});
+
+describe('activateKeepAwakeAsync', () => {
+  it('activates the default tag when none is given', async () => {
+    await activateKeepAwakeAsync();
+
+    expect(FAKE_NATIVE_KEEP_AWAKE.activate).toHaveBeenCalledWith(ExpoKeepAwakeTag);
+  });
+
+  it('activates an explicit tag', async () => {
+    await activateKeepAwakeAsync('custom-tag');
+
+    expect(FAKE_NATIVE_KEEP_AWAKE.activate).toHaveBeenCalledWith('custom-tag');
+  });
+});
+
+describe('deactivateKeepAwake', () => {
+  it('deactivates the default tag when none is given', async () => {
+    await deactivateKeepAwake();
+
+    expect(FAKE_NATIVE_KEEP_AWAKE.deactivate).toHaveBeenCalledWith(ExpoKeepAwakeTag);
+  });
+
+  it('deactivates an explicit tag', async () => {
+    await deactivateKeepAwake('custom-tag');
+
+    expect(FAKE_NATIVE_KEEP_AWAKE.deactivate).toHaveBeenCalledWith('custom-tag');
+  });
+});
+
+describe('addListener', () => {
+  it('subscribes the default tag when called with a bare listener', () => {
+    const listener = vi.fn();
+    addListener(listener);
+
+    expect(FAKE_NATIVE_KEEP_AWAKE.addListenerForTag).toHaveBeenCalledWith(
+      ExpoKeepAwakeTag,
+      listener,
+    );
+  });
+
+  it('subscribes an explicit tag when given tag + listener', () => {
+    const listener = vi.fn();
+    addListener('custom-tag', listener);
+
+    expect(FAKE_NATIVE_KEEP_AWAKE.addListenerForTag).toHaveBeenCalledWith('custom-tag', listener);
+  });
+
+  it('throws an UnavailabilityError-shaped error when addListenerForTag is absent', () => {
+    const { addListenerForTag: native } = FAKE_NATIVE_KEEP_AWAKE;
+    // @ts-expect-error -- simulating a platform where the native module has no such method
+    FAKE_NATIVE_KEEP_AWAKE.addListenerForTag = undefined;
+
+    expect(() => addListener(vi.fn())).toThrow(
+      'addListenerForTag is not available on ExpoKeepAwake',
+    );
+
+    FAKE_NATIVE_KEEP_AWAKE.addListenerForTag = native;
+  });
+
+  it('throws when no listener can be resolved', () => {
+    expect(() => addListener('custom-tag')).toThrow('addListener requires a listener function');
+  });
+});

package/src/core/keep-awake.ts

@@ -0,0 +1,50 @@
+// Hand-ported from .vendors/expo/packages/expo-keep-awake/src/index.ts (sdk-57, confirmed
+// against origin/sdk-57 — the .vendors/expo working tree sits on `main` and differs
+// cosmetically). Unlike battery (which falls back to a sentinel when a method is missing),
+// upstream keep-awake throws from `addListener` when the native module lacks
+// `addListenerForTag`, matching local-auth/haptics's UnavailabilityError convention.
+import { UnavailabilityError, type EventSubscription } from 'expo-modules-core';
+import { expoKeepAwake } from './native-module';
+import type { KeepAwakeListener } from './types';
+
+export const ExpoKeepAwakeTag = 'ExpoKeepAwakeDefaultTag';
+
+/** Resolves with whether the keep-awake API is available on this device. */
+export async function isAvailableAsync(): Promise<boolean> {
+  if (expoKeepAwake.isAvailableAsync) {
+    return await expoKeepAwake.isAvailableAsync();
+  }
+  return true;
+}
+
+/**
+ * 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> {
+  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> {
+  await expoKeepAwake.deactivate?.(tag);
+}
+
+/**
+ * Subscribes to keep-awake state changes for a tag. Overloaded to accept a bare listener for the
+ * default tag, matching upstream's own `addListener` signature.
+ */
+export function addListener(
+  tagOrListener: string | KeepAwakeListener,
+  listener?: KeepAwakeListener,
+): EventSubscription {
+  if (!expoKeepAwake.addListenerForTag) {
+    throw new UnavailabilityError('ExpoKeepAwake', 'addListenerForTag');
+  }
+  const tag = typeof tagOrListener === 'string' ? tagOrListener : ExpoKeepAwakeTag;
+  const resolvedListener = typeof tagOrListener === 'function' ? tagOrListener : listener;
+  if (!resolvedListener) {
+    throw new TypeError('addListener requires a listener function');
+  }
+  return expoKeepAwake.addListenerForTag(tag, resolvedListener);
+}

package/src/core/native-module.ts

@@ -0,0 +1,20 @@
+import { requireNativeModule } from 'expo-modules-core';
+import type { EventSubscription } from 'expo-modules-core';
+import type { KeepAwakeListener } from './types';
+
+const EXPO_KEEP_AWAKE_MODULE_NAME = 'ExpoKeepAwake';
+
+// Every method is optional — each call site checks for its presence before calling through and
+// throws (or falls back, for isAvailableAsync) itself, matching upstream's own per-platform
+// capability checks rather than assuming the native module implements the whole surface (same
+// convention as packages/battery, packages/haptics, packages/local-auth native-module.ts).
+export type INativeKeepAwakeModule = {
+  isAvailableAsync?(): Promise<boolean>;
+  activate?(tag: string): Promise<void>;
+  deactivate?(tag: string): Promise<void>;
+  addListenerForTag?(tag: string, listener: KeepAwakeListener): EventSubscription;
+};
+
+export const expoKeepAwake = requireNativeModule<INativeKeepAwakeModule>(
+  EXPO_KEEP_AWAKE_MODULE_NAME,
+);

package/src/core/types.ts

@@ -0,0 +1,14 @@
+// Hand-ported from .vendors/expo/packages/expo-keep-awake/src/KeepAwake.types.ts (sdk-57).
+// Upstream's KeepAwakeEvent#state is a web-only WakeLockSentinel-shaped value with no native
+// analogue — native listeners rarely fire and never depend on `state`'s shape, so it's kept as
+// a minimal placeholder rather than guessed at.
+export type KeepAwakeEvent = {
+  state: unknown;
+};
+
+export type KeepAwakeListener = (event: KeepAwakeEvent) => void;
+
+export type KeepAwakeOptions = {
+  listener?: KeepAwakeListener;
+  suppressDeactivateWarnings?: boolean;
+};

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

@@ -0,0 +1,43 @@
+// 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.
+//
+// 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.
+import { useEffect, useId } from 'react';
+import {
+  activateKeepAwakeAsync,
+  addListener,
+  deactivateKeepAwake,
+  type KeepAwakeOptions,
+} from '../../../core';
+
+export function useKeepAwake(tag?: string, options?: KeepAwakeOptions): void {
+  const defaultTag = useId();
+  const tagOrDefault = tag ?? defaultTag;
+
+  useEffect(() => {
+    let isMounted = true;
+
+    activateKeepAwakeAsync(tagOrDefault)
+      .then(() => {
+        if (isMounted && options?.listener) {
+          addListener(tagOrDefault, options.listener);
+        }
+      })
+      .catch(() => {});
+
+    return () => {
+      isMounted = false;
+      if (options?.suppressDeactivateWarnings) {
+        deactivateKeepAwake(tagOrDefault).catch(() => {});
+      } else {
+        deactivateKeepAwake(tagOrDefault);
+      }
+    };
+  }, [tagOrDefault]);
+}

package/src/react/hooks/use-keep-awake/use-keep-awake.test.tsx

@@ -0,0 +1,70 @@
+// Co-located React-driven test (ADR 0025) for useKeepAwake. See battery's
+// use-low-power-mode.test.tsx for the shared rationale (mocks `core`, not expo-modules-core
+// internals).
+
+import { createElement, type ReactElement } from 'react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount, View } from '@symbiote-native/react';
+import { installFabric } from '@symbiote-native/test-utils';
+import { useKeepAwake } from './index';
+
+const { activateKeepAwakeAsync, addListener, deactivateKeepAwake } = vi.hoisted(() => ({
+  activateKeepAwakeAsync: vi.fn(async (_tag: string) => undefined),
+  addListener: vi.fn(),
+  deactivateKeepAwake: vi.fn(async (_tag: string) => undefined),
+}));
+
+vi.mock('../../../core', () => ({
+  activateKeepAwakeAsync,
+  addListener,
+  deactivateKeepAwake,
+}));
+
+const ROOT_TAG = 954;
+
+function Probe({ tag }: { tag?: string }): ReactElement {
+  useKeepAwake(tag);
+  return createElement(View);
+}
+
+const fabric = installFabric();
+
+beforeEach(() => {
+  fabric.reset();
+  vi.clearAllMocks();
+  activateKeepAwakeAsync.mockResolvedValue(undefined);
+  deactivateKeepAwake.mockResolvedValue(undefined);
+});
+
+afterEach(() => unmount(ROOT_TAG));
+
+describe('useKeepAwake', () => {
+  it('activates a default tag on mount', async () => {
+    mount(ROOT_TAG, createElement(Probe));
+
+    await vi.waitFor(() => expect(activateKeepAwakeAsync).toHaveBeenCalledTimes(1));
+    expect(typeof activateKeepAwakeAsync.mock.calls[0][0]).toBe('string');
+  });
+
+  it('activates the explicit tag when one is given', async () => {
+    mount(ROOT_TAG, createElement(Probe, { tag: 'custom-tag' }));
+
+    await vi.waitFor(() => expect(activateKeepAwakeAsync).toHaveBeenCalledWith('custom-tag'));
+  });
+
+  it('deactivates the same tag on unmount', async () => {
+    mount(ROOT_TAG, createElement(Probe, { tag: 'custom-tag' }));
+    await vi.waitFor(() => expect(activateKeepAwakeAsync).toHaveBeenCalledTimes(1));
+
+    unmount(ROOT_TAG);
+
+    expect(deactivateKeepAwake).toHaveBeenCalledWith('custom-tag');
+  });
+
+  it('never touches addListener when no options are given', async () => {
+    mount(ROOT_TAG, createElement(Probe, { tag: 'custom-tag' }));
+
+    await vi.waitFor(() => expect(activateKeepAwakeAsync).toHaveBeenCalledTimes(1));
+    expect(addListener).not.toHaveBeenCalled();
+  });
+});

package/src/react/index.ts

@@ -0,0 +1,16 @@
+// @symbiote-native/keep-awake/react: the React entry over the framework-agnostic core. The
+// 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';
+export {
+  ExpoKeepAwakeTag,
+  isAvailableAsync,
+  activateKeepAwakeAsync,
+  deactivateKeepAwake,
+  addListener,
+  type KeepAwakeEvent,
+  type KeepAwakeListener,
+  type KeepAwakeOptions,
+  type EventSubscription,
+} from '../core';