@symbiote-native/tracking-transparency 0.0.1 → 0.2.0

package/README.md

@@ -142,6 +142,12 @@ export class TrackingScreen {
 }
 ```
 
+All three examples mirror the real canary demo screens —
+`examples/expo-react/screens/TrackingTransparencyScreen.tsx`,
+`examples/expo-vue-sfc/screens/TrackingTransparencyScreen.vue`,
+`examples/expo-vue-tsx/screens/TrackingTransparencyScreen.tsx`,
+`examples/expo-angular/src/screens/TrackingTransparencyScreen.ts`.
+
 ## API
 
 ```ts
@@ -205,6 +211,5 @@ surface, never a view. Tests inject a fake native-module object in place of the
 
 ## Known gaps
 
-- Not yet wired into any `examples/expo-*` canary.
 - Tests exercise the JS layer only (fake native module, `vitest`) — no on-device/simulator
   automated smoke test yet, only manual verification.

package/build/angular/index.js

@@ -1,4 +1,4 @@
 // PermissionsService is the Angular-only lifecycle half; getAdvertisingId/isAvailable are
 // stateless free functions, shared with React/Vue.
-export { PermissionsService } from './services/permissions.service';
-export * from '../core';
+export { PermissionsService } from './services/permissions.service/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,8 +39,13 @@ 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 { getTrackingPermissionsAsync, requestTrackingPermissionsAsync, } from '../../../core';
+import { getTrackingPermissionsAsync, requestTrackingPermissionsAsync, } from '../../../core/index.js';
 let PermissionsService = (() => {
     let _classDecorators = [Injectable({ providedIn: 'root' })];
     let _classDescriptor;
@@ -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 getTrackingPermissionsAsync();
             this.status.set(response);
+            this.fetchError.set(null);
             return response;
         }
         async request() {
             const response = await requestTrackingPermissionsAsync();
             this.status.set(response);
+            this.fetchError.set(null);
             return response;
         }
     };

package/build/core/index.js

@@ -1,2 +1,2 @@
-export { getAdvertisingId, requestTrackingPermissionsAsync, getTrackingPermissionsAsync, isAvailable, } from './tracking-transparency';
+export { getAdvertisingId, requestTrackingPermissionsAsync, getTrackingPermissionsAsync, isAvailable, } from './tracking-transparency.js';
 export { PermissionStatus, } from 'expo-modules-core';

package/build/core/tracking-transparency.js

@@ -6,7 +6,7 @@
 // convention is for each adapter to hand-roll its own permission hook instead (react/hooks,
 // vue/composables, angular/services), same as brightness/cellular already do.
 import { Platform, PermissionStatus, UnavailabilityError } from 'expo-modules-core';
-import { expoTrackingTransparency } from './native-module';
+import { expoTrackingTransparency } from './native-module.js';
 const NATIVE_MODULE_NAME = 'TrackingTransparency';
 /**
  * Gets the advertising ID, a UUID string intended only for advertising. Returns `null` on the

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 @@
 // auto-fetches 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 { getTrackingPermissionsAsync, requestTrackingPermissionsAsync, } from '../../../core';
+import { getTrackingPermissionsAsync, requestTrackingPermissionsAsync, } 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 getTrackingPermissionsAsync();
-        if (isMounted.current)
+        if (isMounted.current) {
             setStatus(response);
+            setError(null);
+        }
         return response;
     }, []);
     const requestPermission = useCallback(async () => {
         const response = await requestTrackingPermissionsAsync();
-        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.js

@@ -2,5 +2,5 @@
 // core. Only the permission surface gets a lifecycle hook (there is per-instance state to seed
 // and refresh); getAdvertisingId/isAvailable are stateless, re-exported verbatim — mirrors the
 // lifecycle-bucket naming convention of adapters/react/src/hooks.
-export { usePermissions } from './hooks/use-permissions';
-export * from '../core';
+export { usePermissions } from './hooks/use-permissions/index.js';
+export * from '../core/index.js';

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/tracking-transparency/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,49 @@
+// Svelte lifecycle wiring over the framework-agnostic core (core/tracking-transparency.ts) —
+// auto-fetches the current permission status on mount, then exposes get/request as imperative
+// callbacks. Just a one-shot get with no ongoing subscription, so `$effect` needs no cleanup.
+//
+// `.svelte.ts` (not `.ts`): runes ($state/$effect) only work in files with this extension
+// outside an actual `.svelte` component. `status` is returned as a getter, NOT a bare
+// `$state`: Svelte 5 reactivity is lexically scoped to the declaring module and doesn't
+// survive being returned as a raw value from a plain function — mirrors how Vue's `Ref`
+// needs `.value` to unwrap.
+//
+// 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 { getTrackingPermissionsAsync, requestTrackingPermissionsAsync, } from '../../core/index.js';
+export function usePermissions() {
+    let status = $state(null);
+    let error = $state(null);
+    const get = async () => {
+        const response = await getTrackingPermissionsAsync();
+        status = response;
+        error = null;
+        return response;
+    };
+    const request = async () => {
+        const response = await requestTrackingPermissionsAsync();
+        status = response;
+        error = null;
+        return response;
+    };
+    $effect(() => {
+        // `get` is a plain closure, not reactive state, so the effect has an empty dependency set and
+        // runs exactly once on mount — the twin of Vue's onMounted. The catch runs after the effect
+        // has settled, so writing `error` there adds no dependency and does not re-arm it.
+        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 @@
 // auto-fetches the 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 { getTrackingPermissionsAsync, requestTrackingPermissionsAsync, } from '../../../core';
+import { getTrackingPermissionsAsync, requestTrackingPermissionsAsync, } from '../../../core/index.js';
 export function usePermissions() {
     const status = ref(null);
+    const error = ref(null);
     const get = async () => {
         const response = await getTrackingPermissionsAsync();
         status.value = response;
+        error.value = null;
         return response;
     };
     const request = async () => {
         const response = await requestTrackingPermissionsAsync();
         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.js

@@ -2,5 +2,5 @@
 // Same reasoning as the React entry — only the permission surface gets a lifecycle composable,
 // every 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';
-export * from '../core';
+export { usePermissions } from './composables/use-permissions/index.js';
+export * from '../core/index.js';

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>;

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

@@ -5,32 +5,50 @@
 //
 //   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 { getTrackingPermissionsAsync, requestTrackingPermissionsAsync, } from '../../../core';
 import * as i0 from "@angular/core";
 export class PermissionsService {
     status = signal(null, /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "status" }] : /* istanbul ignore next */ []));
+    fetchError = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "fetchError" }] : /* istanbul ignore next */ []));
+    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 getTrackingPermissionsAsync();
         this.status.set(response);
+        this.fetchError.set(null);
         return response;
     }
     async request() {
         const response = await requestTrackingPermissionsAsync();
         this.status.set(response);
+        this.fetchError.set(null);
         return response;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: PermissionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: PermissionsService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: PermissionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: PermissionsService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: PermissionsService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: PermissionsService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/permissions.service/index.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,4FAA4F;AAC5F,yFAAyF;AACzF,+BAA+B;AAC/B,EAAE;AACF,4DAA4D;AAC5D,yCAAyC;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,EAAe,MAAM,eAAe,CAAC;AAChE,OAAO,EACL,2BAA2B,EAC3B,+BAA+B,GAEhC,MAAM,eAAe,CAAC;;AAGvB,MAAM,OAAO,kBAAkB;IACZ,MAAM,GAAG,MAAM,CAA4B,IAAI;+EAAC,CAAC;IAElE,OAAO;QACL,IAAI,IAAI,CAAC,MAAM,EAAE,KAAK,IAAI,EAAE,CAAC;YAC3B,KAAK,IAAI,CAAC,GAAG,EAAE,CAAC;QAClB,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;IAClC,CAAC;IAED,KAAK,CAAC,GAAG;QACP,MAAM,QAAQ,GAAG,MAAM,2BAA2B,EAAE,CAAC;QACrD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC1B,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,KAAK,CAAC,OAAO;QACX,MAAM,QAAQ,GAAG,MAAM,+BAA+B,EAAE,CAAC;QACzD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC1B,OAAO,QAAQ,CAAC;IAClB,CAAC;uGApBU,kBAAkB;2GAAlB,kBAAkB,cADL,MAAM;;2FACnB,kBAAkB;kBAD9B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/permissions.service/index.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,4FAA4F;AAC5F,yFAAyF;AACzF,+BAA+B;AAC/B,EAAE;AACF,4DAA4D;AAC5D,yCAAyC;AACzC,EAAE;AACF,gGAAgG;AAChG,kGAAkG;AAClG,mGAAmG;AACnG,wCAAwC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,EAAe,MAAM,eAAe,CAAC;AAChE,OAAO,EACL,2BAA2B,EAC3B,+BAA+B,GAEhC,MAAM,eAAe,CAAC;;AAGvB,MAAM,OAAO,kBAAkB;IACZ,MAAM,GAAG,MAAM,CAA4B,IAAI;+EAAC,CAAC;IACjD,UAAU,GAAG,MAAM,CAAe,IAAI;mFAAC,CAAC;IACjD,kBAAkB,GAAG,KAAK,CAAC;IAEnC,gGAAgG;IACvF,KAAK,GAAyB,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC;IAEpE,OAAO;QACL,wFAAwF;QACxF,8FAA8F;QAC9F,8FAA8F;QAC9F,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC7B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;YAC/B,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;gBAClC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACjF,CAAC,CAAC,CAAC;QACL,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;IAClC,CAAC;IAED,KAAK,CAAC,GAAG;QACP,MAAM,QAAQ,GAAG,MAAM,2BAA2B,EAAE,CAAC;QACrD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC1B,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC1B,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,KAAK,CAAC,OAAO;QACX,MAAM,QAAQ,GAAG,MAAM,+BAA+B,EAAE,CAAC;QACzD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC1B,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC1B,OAAO,QAAQ,CAAC;IAClB,CAAC;uGAjCU,kBAAkB;2GAAlB,kBAAkB,cADL,MAAM;;2FACnB,kBAAkB;kBAD9B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/tracking-transparency",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "description": "expo-tracking-transparency wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, and Angular adapters. iOS App Tracking Transparency prompt (permission get/request, always-granted on Android/web) plus the advertising-ID getter.",
   "license": "MIT",
   "repository": {
@@ -30,6 +30,10 @@
       "types": "./build/react/index.d.ts",
       "default": "./build/react/index.js"
     },
+    "./svelte": {
+      "types": "./build/svelte/index.d.ts",
+      "default": "./build/svelte/index.js"
+    },
     "./angular": {
       "types": "./build-ngc/angular/index.d.ts",
       "react-native": "./build-ngc/angular/index.js",
@@ -40,7 +44,10 @@
     "src",
     "build",
     "build-ngc",
-    "native-link.json"
+    "native-link.json",
+    "!src/**/*.test.*",
+    "!src/**/*.spec.*",
+    "!src/**/*.detox.*"
   ],
   "publishConfig": {
     "access": "public"
@@ -50,15 +57,17 @@
     "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/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.1",
-    "@symbiote-native/react": "0.2.8",
-    "@symbiote-native/vue": "0.3.8"
+    "svelte": ">=5.56.0",
+    "vue": ">=3.5.0"
   },
   "peerDependenciesMeta": {
     "@symbiote-native/angular": {
@@ -67,6 +76,9 @@
     "@symbiote-native/react": {
       "optional": true
     },
+    "@symbiote-native/svelte": {
+      "optional": true
+    },
     "@symbiote-native/vue": {
       "optional": true
     },
@@ -79,24 +91,29 @@
     "react": {
       "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",
+    "svelte": "^5.56.0",
     "typescript": "~6.0.0",
-    "@symbiote-native/angular": "0.6.1",
-    "@symbiote-native/engine": "0.1.7",
-    "@symbiote-native/vue": "0.3.8",
+    "@symbiote-native/angular": "0.7.0",
+    "@symbiote-native/engine": "0.2.0",
+    "@symbiote-native/react": "0.3.0",
+    "@symbiote-native/svelte": "0.2.0",
     "@symbiote-native/test-utils": "0.1.6",
-    "@symbiote-native/react": "0.2.8"
+    "@symbiote-native/vue": "0.4.0"
   },
   "scripts": {
     "typecheck": "tsc --build",

package/src/angular/services/permissions.service/index.ts

@@ -5,6 +5,11 @@
 //
 //   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, type Signal } from '@angular/core';
 import {
   getTrackingPermissionsAsync,
@@ -15,10 +20,21 @@ import {
 @Injectable({ providedIn: 'root' })
 export class PermissionsService {
   private readonly status = signal<PermissionResponse | null>(null);
+  private readonly fetchError = signal<Error | null>(null);
+  private isAutoFetchStarted = false;
+
+  /** Why the auto-fetch left `status` at null. Cleared by the next successful get()/request(). */
+  readonly error: Signal<Error | null> = this.fetchError.asReadonly();
 
   connect(): Signal<PermissionResponse | null> {
-    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: unknown) => {
+        this.fetchError.set(cause instanceof Error ? cause : new Error(String(cause)));
+      });
     }
     return this.status.asReadonly();
   }
@@ -26,12 +42,14 @@ export class PermissionsService {
   async get(): Promise<PermissionResponse> {
     const response = await getTrackingPermissionsAsync();
     this.status.set(response);
+    this.fetchError.set(null);
     return response;
   }
 
   async request(): Promise<PermissionResponse> {
     const response = await requestTrackingPermissionsAsync();
     this.status.set(response);
+    this.fetchError.set(null);
     return response;
   }
 }

package/src/react/hooks/use-permissions/index.ts

@@ -2,6 +2,11 @@
 // auto-fetches 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 {
   getTrackingPermissionsAsync,
@@ -13,29 +18,39 @@ export function usePermissions(): [
   PermissionResponse | null,
   () => Promise<PermissionResponse>,
   () => Promise<PermissionResponse>,
+  Error | null,
 ] {
   const isMounted = useRef(true);
   const [status, setStatus] = useState<PermissionResponse | null>(null);
+  const [error, setError] = useState<Error | null>(null);
 
   const getPermission = useCallback(async () => {
     const response = await getTrackingPermissionsAsync();
-    if (isMounted.current) setStatus(response);
+    if (isMounted.current) {
+      setStatus(response);
+      setError(null);
+    }
     return response;
   }, []);
 
   const requestPermission = useCallback(async () => {
     const response = await requestTrackingPermissionsAsync();
-    if (isMounted.current) setStatus(response);
+    if (isMounted.current) {
+      setStatus(response);
+      setError(null);
+    }
     return response;
   }, []);
 
   useEffect(() => {
     isMounted.current = true;
-    void getPermission();
+    getPermission().catch((cause: unknown) => {
+      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/src/svelte/index.ts

@@ -0,0 +1,7 @@
+// @symbiote-native/tracking-transparency/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';

package/src/svelte/runes/use-permissions.svelte.ts

@@ -0,0 +1,63 @@
+// Svelte lifecycle wiring over the framework-agnostic core (core/tracking-transparency.ts) —
+// auto-fetches the current permission status on mount, then exposes get/request as imperative
+// callbacks. Just a one-shot get with no ongoing subscription, so `$effect` needs no cleanup.
+//
+// `.svelte.ts` (not `.ts`): runes ($state/$effect) only work in files with this extension
+// outside an actual `.svelte` component. `status` is returned as a getter, NOT a bare
+// `$state`: Svelte 5 reactivity is lexically scoped to the declaring module and doesn't
+// survive being returned as a raw value from a plain function — mirrors how Vue's `Ref`
+// needs `.value` to unwrap.
+//
+// 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 {
+  getTrackingPermissionsAsync,
+  requestTrackingPermissionsAsync,
+  type PermissionResponse,
+} from '../../core';
+
+export function usePermissions(): {
+  readonly status: PermissionResponse | null;
+  readonly error: Error | null;
+  request: () => Promise<PermissionResponse>;
+  get: () => Promise<PermissionResponse>;
+} {
+  let status = $state<PermissionResponse | null>(null);
+  let error = $state<Error | null>(null);
+
+  const get = async (): Promise<PermissionResponse> => {
+    const response = await getTrackingPermissionsAsync();
+    status = response;
+    error = null;
+    return response;
+  };
+
+  const request = async (): Promise<PermissionResponse> => {
+    const response = await requestTrackingPermissionsAsync();
+    status = response;
+    error = null;
+    return response;
+  };
+
+  $effect(() => {
+    // `get` is a plain closure, not reactive state, so the effect has an empty dependency set and
+    // runs exactly once on mount — the twin of Vue's onMounted. The catch runs after the effect
+    // has settled, so writing `error` there adds no dependency and does not re-arm it.
+    get().catch((cause: unknown) => {
+      error = cause instanceof Error ? cause : new Error(String(cause));
+    });
+  });
+
+  return {
+    get status(): PermissionResponse | null {
+      return status;
+    },
+    get error(): Error | null {
+      return error;
+    },
+    request,
+    get,
+  };
+}

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-permissions/index.ts

@@ -2,6 +2,11 @@
 // auto-fetches the 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, type Ref } from '@vue/runtime-core';
 import {
   getTrackingPermissionsAsync,
@@ -11,26 +16,32 @@ import {
 
 export function usePermissions(): {
   status: Ref<PermissionResponse | null>;
+  error: Ref<Error | null>;
   request: () => Promise<PermissionResponse>;
   get: () => Promise<PermissionResponse>;
 } {
   const status = ref<PermissionResponse | null>(null);
+  const error = ref<Error | null>(null);
 
   const get = async () => {
     const response = await getTrackingPermissionsAsync();
     status.value = response;
+    error.value = null;
     return response;
   };
 
   const request = async () => {
     const response = await requestTrackingPermissionsAsync();
     status.value = response;
+    error.value = null;
     return response;
   };
 
   onMounted(() => {
-    void get();
+    get().catch((cause: unknown) => {
+      error.value = cause instanceof Error ? cause : new Error(String(cause));
+    });
   });
 
-  return { status, request, get };
+  return { status, error, request, get };
 }

package/src/angular/services/permissions.service/permissions.service.test.ts

@@ -1,107 +0,0 @@
-// Co-located Angular-driven test (ADR 0025) for PermissionsService. See battery's
-// battery-state.service.test.ts for the shared rationale.
-
-import '@angular/compiler';
-import { Component, inject, type Signal } 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 { PermissionsService } from './index';
-import { PermissionStatus, type PermissionResponse } from '../../../core';
-
-const { getTrackingPermissionsAsync, requestTrackingPermissionsAsync } = vi.hoisted(() => ({
-  getTrackingPermissionsAsync: vi.fn(),
-  requestTrackingPermissionsAsync: vi.fn(),
-}));
-
-// Same enum-shaped-object mock trick packages/battery/src/angular/services/battery-state.service's
-// test uses for BatteryState.
-vi.mock('../../../core', () => ({
-  getTrackingPermissionsAsync,
-  requestTrackingPermissionsAsync,
-  PermissionStatus: { GRANTED: 'granted', DENIED: 'denied', UNDETERMINED: 'undetermined' },
-}));
-
-const GRANTED: PermissionResponse = {
-  status: PermissionStatus.GRANTED,
-  granted: true,
-  canAskAgain: true,
-  expires: 'never',
-};
-const DENIED: PermissionResponse = {
-  status: PermissionStatus.DENIED,
-  granted: false,
-  canAskAgain: true,
-  expires: 'never',
-};
-
-const ROOT_TAG = 974;
-const fabric = installFabric();
-const tick = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0));
-
-let capturedStatus: Signal<PermissionResponse | null> | undefined;
-let capturedService: PermissionsService | undefined;
-
-@Component({
-  selector: 'symbiote-permissions-host',
-  standalone: true,
-  template: '',
-})
-class PermissionsHost {
-  readonly service = inject(PermissionsService);
-  readonly status = this.service.connect();
-
-  constructor() {
-    capturedStatus = this.status;
-    capturedService = this.service;
-  }
-}
-
-beforeEach(() => {
-  capturedStatus = undefined;
-  capturedService = undefined;
-  vi.clearAllMocks();
-  getTrackingPermissionsAsync.mockResolvedValue(GRANTED);
-  requestTrackingPermissionsAsync.mockResolvedValue(GRANTED);
-});
-
-afterEach(() => {
-  unmount(ROOT_TAG);
-  fabric.reset();
-});
-
-describe('PermissionsService.connect', () => {
-  it('reports null before the initial fetch resolves', () => {
-    mount(ROOT_TAG, PermissionsHost);
-
-    expect(capturedStatus?.()).toBe(null);
-  });
-
-  it('reports the fetched status once getTrackingPermissionsAsync() resolves', async () => {
-    mount(ROOT_TAG, PermissionsHost);
-    await tick();
-
-    expect(capturedStatus?.()).toEqual(GRANTED);
-    expect(getTrackingPermissionsAsync).toHaveBeenCalledTimes(1);
-  });
-
-  it('request() delegates to requestTrackingPermissionsAsync and updates the signal', async () => {
-    mount(ROOT_TAG, PermissionsHost);
-    await tick();
-
-    requestTrackingPermissionsAsync.mockResolvedValueOnce(DENIED);
-    await capturedService?.request();
-
-    expect(capturedStatus?.()).toEqual(DENIED);
-  });
-
-  it('get() re-fetches and updates the signal', async () => {
-    mount(ROOT_TAG, PermissionsHost);
-    await tick();
-
-    getTrackingPermissionsAsync.mockResolvedValueOnce(DENIED);
-    await capturedService?.get();
-
-    expect(capturedStatus?.()).toEqual(DENIED);
-  });
-});

package/src/core/tracking-transparency.test.ts

@@ -1,137 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-const FAKE_NATIVE_TRACKING_TRANSPARENCY = {
-  getAdvertisingId: vi.fn(() => 'E9228286-4C4E-4789-9D95-15827DCB291B'),
-  requestPermissionsAsync: vi.fn(async () => ({ status: 'granted', granted: true })),
-  getPermissionsAsync: vi.fn(async () => ({ status: 'granted', granted: true })),
-};
-
-// The real ExpoTrackingTransparency 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/brightness/src/core/brightness.test.ts and packages/device/src/core/device.test.ts use.
-vi.mock('./native-module', () => ({
-  expoTrackingTransparency: FAKE_NATIVE_TRACKING_TRANSPARENCY,
-}));
-
-// 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/brightness/src/core/brightness.test.ts uses, since Platform.OS gates the
-// Android/web-vs-iOS branch here.
-const fakePlatform = { OS: 'ios' as 'ios' | 'android' };
-
-vi.mock('expo-modules-core', () => ({
-  Platform: fakePlatform,
-  PermissionStatus: { GRANTED: 'granted', DENIED: 'denied', UNDETERMINED: 'undetermined' },
-  UnavailabilityError: class UnavailabilityError extends Error {
-    constructor(moduleName: string, propertyName: string) {
-      super(`${propertyName} is not available on ${moduleName}`);
-    }
-  },
-}));
-
-const {
-  getAdvertisingId,
-  requestTrackingPermissionsAsync,
-  getTrackingPermissionsAsync,
-  isAvailable,
-} = await import('./tracking-transparency');
-
-afterEach(() => {
-  fakePlatform.OS = 'ios';
-  vi.clearAllMocks();
-});
-
-describe('getAdvertisingId', () => {
-  it('returns the advertising ID straight from the native module', () => {
-    expect(getAdvertisingId()).toBe('E9228286-4C4E-4789-9D95-15827DCB291B');
-  });
-
-  it('maps the all-zero UUID sentinel to null', () => {
-    FAKE_NATIVE_TRACKING_TRANSPARENCY.getAdvertisingId.mockReturnValueOnce(
-      '00000000-0000-0000-0000-000000000000',
-    );
-
-    expect(getAdvertisingId()).toBeNull();
-  });
-});
-
-describe('requestTrackingPermissionsAsync', () => {
-  it('always resolves granted on Android without calling the native module', async () => {
-    fakePlatform.OS = 'android';
-
-    await expect(requestTrackingPermissionsAsync()).resolves.toEqual({
-      granted: true,
-      expires: 'never',
-      canAskAgain: true,
-      status: 'granted',
-    });
-    expect(FAKE_NATIVE_TRACKING_TRANSPARENCY.requestPermissionsAsync).not.toHaveBeenCalled();
-  });
-
-  it('delegates to the native module on iOS', async () => {
-    fakePlatform.OS = 'ios';
-
-    await expect(requestTrackingPermissionsAsync()).resolves.toEqual({
-      status: 'granted',
-      granted: true,
-    });
-    expect(FAKE_NATIVE_TRACKING_TRANSPARENCY.requestPermissionsAsync).toHaveBeenCalledTimes(1);
-  });
-
-  it('throws an UnavailabilityError-shaped error on iOS when the native method is absent', async () => {
-    fakePlatform.OS = 'ios';
-    const { requestPermissionsAsync: native } = FAKE_NATIVE_TRACKING_TRANSPARENCY;
-    // @ts-expect-error -- simulating a native module build missing this method
-    FAKE_NATIVE_TRACKING_TRANSPARENCY.requestPermissionsAsync = undefined;
-
-    await expect(requestTrackingPermissionsAsync()).rejects.toThrow(
-      'requestPermissionsAsync is not available on TrackingTransparency',
-    );
-
-    FAKE_NATIVE_TRACKING_TRANSPARENCY.requestPermissionsAsync = native;
-  });
-});
-
-describe('getTrackingPermissionsAsync', () => {
-  it('always resolves granted on Android without calling the native module', async () => {
-    fakePlatform.OS = 'android';
-
-    await expect(getTrackingPermissionsAsync()).resolves.toEqual({
-      granted: true,
-      expires: 'never',
-      canAskAgain: true,
-      status: 'granted',
-    });
-    expect(FAKE_NATIVE_TRACKING_TRANSPARENCY.getPermissionsAsync).not.toHaveBeenCalled();
-  });
-
-  it('delegates to the native module on iOS', async () => {
-    fakePlatform.OS = 'ios';
-
-    await expect(getTrackingPermissionsAsync()).resolves.toEqual({
-      status: 'granted',
-      granted: true,
-    });
-    expect(FAKE_NATIVE_TRACKING_TRANSPARENCY.getPermissionsAsync).toHaveBeenCalledTimes(1);
-  });
-
-  it('throws an UnavailabilityError-shaped error on iOS when the native method is absent', async () => {
-    fakePlatform.OS = 'ios';
-    const { getPermissionsAsync: native } = FAKE_NATIVE_TRACKING_TRANSPARENCY;
-    // @ts-expect-error -- simulating a native module build missing this method
-    FAKE_NATIVE_TRACKING_TRANSPARENCY.getPermissionsAsync = undefined;
-
-    await expect(getTrackingPermissionsAsync()).rejects.toThrow(
-      'getPermissionsAsync is not available on TrackingTransparency',
-    );
-
-    FAKE_NATIVE_TRACKING_TRANSPARENCY.getPermissionsAsync = native;
-  });
-});
-
-describe('isAvailable', () => {
-  it('resolves true when the native module resolved', () => {
-    expect(isAvailable()).toBe(true);
-  });
-});

package/src/react/hooks/use-permissions/use-permissions.test.tsx

@@ -1,100 +0,0 @@
-// Co-located React-driven test (ADR 0025) for usePermissions. See battery's
-// use-battery-state.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 { usePermissions } from './index';
-import { PermissionStatus, type PermissionResponse } from '../../../core';
-
-const { getTrackingPermissionsAsync, requestTrackingPermissionsAsync } = vi.hoisted(() => ({
-  getTrackingPermissionsAsync: vi.fn(),
-  requestTrackingPermissionsAsync: vi.fn(),
-}));
-
-// Same enum-shaped-object mock trick packages/battery/src/react/hooks/use-battery-state's test
-// uses for BatteryState — the mock factory's runtime object stands in for the real enum
-// (imported here purely for its type), so `PermissionStatus.GRANTED` still type-checks.
-vi.mock('../../../core', () => ({
-  getTrackingPermissionsAsync,
-  requestTrackingPermissionsAsync,
-  PermissionStatus: { GRANTED: 'granted', DENIED: 'denied', UNDETERMINED: 'undetermined' },
-}));
-
-const ROOT_TAG = 954;
-
-const GRANTED: PermissionResponse = {
-  status: PermissionStatus.GRANTED,
-  granted: true,
-  canAskAgain: true,
-  expires: 'never',
-};
-const DENIED: PermissionResponse = {
-  status: PermissionStatus.DENIED,
-  granted: false,
-  canAskAgain: true,
-  expires: 'never',
-};
-
-const results: (PermissionResponse | null)[] = [];
-let latestRequest: (() => Promise<PermissionResponse>) | undefined;
-let latestGet: (() => Promise<PermissionResponse>) | undefined;
-
-function Probe(): ReactElement {
-  const [status, request, get] = usePermissions();
-  results.push(status);
-  latestRequest = request;
-  latestGet = get;
-  return createElement(View);
-}
-
-const fabric = installFabric();
-
-beforeEach(() => {
-  fabric.reset();
-  results.length = 0;
-  latestRequest = undefined;
-  latestGet = undefined;
-  vi.clearAllMocks();
-  getTrackingPermissionsAsync.mockResolvedValue(GRANTED);
-  requestTrackingPermissionsAsync.mockResolvedValue(GRANTED);
-});
-
-afterEach(() => unmount(ROOT_TAG));
-
-describe('usePermissions', () => {
-  it('starts at null before the initial fetch resolves', () => {
-    mount(ROOT_TAG, createElement(Probe));
-
-    expect(results[results.length - 1]).toBe(null);
-  });
-
-  it('fetches the permission status once on mount', async () => {
-    mount(ROOT_TAG, createElement(Probe));
-
-    await vi.waitFor(() => expect(results[results.length - 1]).toEqual(GRANTED));
-    expect(getTrackingPermissionsAsync).toHaveBeenCalledTimes(1);
-  });
-
-  it('request() delegates to requestTrackingPermissionsAsync and updates the status', async () => {
-    mount(ROOT_TAG, createElement(Probe));
-    await vi.waitFor(() => expect(results[results.length - 1]).toEqual(GRANTED));
-
-    requestTrackingPermissionsAsync.mockResolvedValueOnce(DENIED);
-    await latestRequest?.();
-
-    await vi.waitFor(() => expect(results[results.length - 1]).toEqual(DENIED));
-  });
-
-  it('get() re-fetches and updates the status', async () => {
-    mount(ROOT_TAG, createElement(Probe));
-    await vi.waitFor(() => expect(results[results.length - 1]).toEqual(GRANTED));
-
-    getTrackingPermissionsAsync.mockResolvedValueOnce(DENIED);
-    await latestGet?.();
-
-    await vi.waitFor(() => expect(results[results.length - 1]).toEqual(DENIED));
-  });
-});

package/src/vue/composables/use-permissions/use-permissions.test.ts

@@ -1,99 +0,0 @@
-// Co-located Vue-driven test (ADR 0025) for usePermissions. See battery's
-// use-battery-state.test.ts for the shared rationale.
-
-import { defineComponent, h } from '@vue/runtime-core';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { mount, unmount } from '@symbiote-native/vue';
-import { installFabric } from '@symbiote-native/test-utils';
-import { usePermissions } from './index';
-import { PermissionStatus, type PermissionResponse } from '../../../core';
-
-const { getTrackingPermissionsAsync, requestTrackingPermissionsAsync } = vi.hoisted(() => ({
-  getTrackingPermissionsAsync: vi.fn(),
-  requestTrackingPermissionsAsync: vi.fn(),
-}));
-
-// Same enum-shaped-object mock trick packages/battery/src/vue/composables/use-battery-state's
-// test uses for BatteryState.
-vi.mock('../../../core', () => ({
-  getTrackingPermissionsAsync,
-  requestTrackingPermissionsAsync,
-  PermissionStatus: { GRANTED: 'granted', DENIED: 'denied', UNDETERMINED: 'undetermined' },
-}));
-
-const GRANTED: PermissionResponse = {
-  status: PermissionStatus.GRANTED,
-  granted: true,
-  canAskAgain: true,
-  expires: 'never',
-};
-const DENIED: PermissionResponse = {
-  status: PermissionStatus.DENIED,
-  granted: false,
-  canAskAgain: true,
-  expires: 'never',
-};
-
-const ROOT_TAG = 9954;
-const fabric = installFabric();
-
-beforeEach(() => {
-  fabric.reset();
-  vi.clearAllMocks();
-  getTrackingPermissionsAsync.mockResolvedValue(GRANTED);
-  requestTrackingPermissionsAsync.mockResolvedValue(GRANTED);
-});
-
-afterEach(() => unmount(ROOT_TAG));
-
-function mountPermissions(): ReturnType<typeof usePermissions> {
-  let result: ReturnType<typeof usePermissions> | undefined;
-  mount(
-    ROOT_TAG,
-    defineComponent({
-      setup: () => {
-        result = usePermissions();
-        return () => h('symbiote-text', {}, 'tracking-transparency');
-      },
-    }),
-  );
-  if (result === undefined) {
-    throw new Error('setup() did not run');
-  }
-  return result;
-}
-
-describe('usePermissions (Vue)', () => {
-  it('starts at null before the initial fetch resolves', () => {
-    const { status } = mountPermissions();
-
-    expect(status.value).toBe(null);
-  });
-
-  it('fetches the permission status once on mount', async () => {
-    const { status } = mountPermissions();
-
-    await vi.waitFor(() => expect(status.value).toEqual(GRANTED));
-    expect(getTrackingPermissionsAsync).toHaveBeenCalledTimes(1);
-  });
-
-  it('request() delegates to requestTrackingPermissionsAsync and updates the status', async () => {
-    const { status, request } = mountPermissions();
-    await vi.waitFor(() => expect(status.value).toEqual(GRANTED));
-
-    requestTrackingPermissionsAsync.mockResolvedValueOnce(DENIED);
-    await request();
-
-    expect(status.value).toEqual(DENIED);
-  });
-
-  it('get() re-fetches and updates the status', async () => {
-    const { status, get } = mountPermissions();
-    await vi.waitFor(() => expect(status.value).toEqual(GRANTED));
-
-    getTrackingPermissionsAsync.mockResolvedValueOnce(DENIED);
-    await get();
-
-    expect(status.value).toEqual(DENIED);
-  });
-});