@symbiote-native/network 0.1.0 → 0.3.0

package/README.md

@@ -3,7 +3,7 @@
 Port of [`expo-network`](https://docs.expo.dev/versions/latest/sdk/network/) for
 [SymbioteNative](../../README.md) — network connection state (type/connected/internet-reachable)
 with a change listener, device IP address, and airplane-mode detection, reachable from every
-adapter (React, Vue, Angular), not just React.
+adapter (React, Vue, Svelte, Solid, Angular), not just React.
 
 Built the same way as [`@symbiote-native/battery`](../battery) and
 [`@symbiote-native/local-auth`](../local-auth), 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/sensors`, `@symbiote-native/local-auth`)
 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) |
 
 Full mechanics — the Podfile pieces that normally ship inside the `expo` package, the `expo`
 peer-dependency exclusion list — live in the `symbiote-expo-native-module` skill. Reference
@@ -56,37 +56,50 @@ src/core/               network.ts — get*Async functions + addNetworkStateList
                         NetworkStateEvent, hand-ported from Network.types.ts.
 src/react/hooks/        @symbiote-native/network/react   — useNetworkState
 src/vue/composables/    @symbiote-native/network/vue     — useNetworkState (same name)
+src/svelte/runes/       @symbiote-native/network/svelte  — useNetworkState (same name)
+src/solid/primitives/   @symbiote-native/network/solid   — createNetworkState (returns an
+                        Accessor; Solid reserves `use*` for consuming existing state)
 src/angular/services/   @symbiote-native/network/angular — NetworkStateService (`.connect()`
                         returns a Signal)
 ```
 
-Each adapter's hook/composable/service is a thin lifecycle wrapper (seed from the one-shot
-`getNetworkStateAsync()` call, subscribe to `addNetworkStateListener`, unsubscribe on unmount) over
-the same `core` functions — the subscription logic is written once and shared by all three.
+Each adapter's hook/composable/rune/primitive/service is a thin lifecycle wrapper (seed from the
+one-shot `getNetworkStateAsync()` call, subscribe to `addNetworkStateListener`, unsubscribe on
+unmount) over the same `core` functions — the subscription logic is written once and shared by all
+of them.
 
 ## Use it
 
 ```tsx
 // React — examples/expo-react/screens/NetworkScreen.tsx
 import { useEffect, useState } from 'react';
-import { getIpAddressAsync, isAirplaneModeEnabledAsync } from '@symbiote-native/network';
+import {
+  getIpAddressAsync,
+  isAirplaneModeEnabledAsync,
+} from '@symbiote-native/network';
 import { useNetworkState } from '@symbiote-native/network/react';
 
 function NetworkScreen() {
-  const networkState = useNetworkState();          // { type, isConnected, isInternetReachable }
+  const networkState = useNetworkState(); // { type, isConnected, isInternetReachable }
   const [ipAddress, setIpAddress] = useState<string | null>(null);
   const [isAirplaneMode, setIsAirplaneMode] = useState<boolean | null>(null);
 
   useEffect(() => {
-    Promise.all([getIpAddressAsync(), isAirplaneModeEnabledAsync()]).then(([ip, airplaneMode]) => {
-      setIpAddress(ip);
-      setIsAirplaneMode(airplaneMode);
-    });
+    Promise.all([getIpAddressAsync(), isAirplaneModeEnabledAsync()]).then(
+      ([ip, airplaneMode]) => {
+        setIpAddress(ip);
+        setIsAirplaneMode(airplaneMode);
+      },
+    );
   }, [networkState]);
 
   return (
     <>
-      <Text>{networkState.isConnected ? `Connected via ${networkState.type}` : 'Offline'}</Text>
+      <Text>
+        {networkState.isConnected
+          ? `Connected via ${networkState.type}`
+          : 'Offline'}
+      </Text>
       <Text>{ipAddress ?? 'checking…'}</Text>
       <Text>{isAirplaneMode ? 'Airplane mode: On' : 'Airplane mode: Off'}</Text>
     </>
@@ -99,26 +112,33 @@ function NetworkScreen() {
 <script setup lang="ts">
 import { ref, watch } from 'vue';
 import { Text } from '@symbiote-native/vue';
-import { getIpAddressAsync, isAirplaneModeEnabledAsync } from '@symbiote-native/network';
+import {
+  getIpAddressAsync,
+  isAirplaneModeEnabledAsync,
+} from '@symbiote-native/network';
 import { useNetworkState } from '@symbiote-native/network/vue';
 
-const networkState = useNetworkState();           // Ref<NetworkState>
+const networkState = useNetworkState(); // Ref<NetworkState>
 const ipAddress = ref<string | null>(null);
 const isAirplaneMode = ref<boolean | null>(null);
 
 watch(
   networkState,
   () => {
-    void Promise.all([getIpAddressAsync(), isAirplaneModeEnabledAsync()]).then(([ip, airplaneMode]) => {
-      ipAddress.value = ip;
-      isAirplaneMode.value = airplaneMode;
-    });
+    void Promise.all([getIpAddressAsync(), isAirplaneModeEnabledAsync()]).then(
+      ([ip, airplaneMode]) => {
+        ipAddress.value = ip;
+        isAirplaneMode.value = airplaneMode;
+      },
+    );
   },
   { immediate: true },
 );
 </script>
 <template>
-  <Text>{{ networkState.isConnected ? `Connected via ${networkState.type}` : 'Offline' }}</Text>
+  <Text>{{
+    networkState.isConnected ? `Connected via ${networkState.type}` : 'Offline'
+  }}</Text>
   <Text>{{ ipAddress ?? 'checking…' }}</Text>
 </template>
 ```
@@ -145,15 +165,59 @@ export class NetworkScreen {
   constructor() {
     effect(() => {
       this.networkState();
-      Promise.all([getIpAddressAsync(), isAirplaneModeEnabledAsync()]).then(([ip]) => {
-        this.ipAddress.set(ip);
-      });
+      Promise.all([getIpAddressAsync(), isAirplaneModeEnabledAsync()]).then(
+        ([ip]) => {
+          this.ipAddress.set(ip);
+        },
+      );
     });
   }
 }
 ```
 
-Each of the three demo screens above also re-fetches the IP address and airplane-mode card
+```tsx
+// Solid — the accessor is CALLED; a Solid component body runs once, so a snapshot would freeze.
+import { createSignal, onMount } from 'solid-js';
+import { Text } from '@symbiote-native/solid';
+import {
+  getIpAddressAsync,
+  isAirplaneModeEnabledAsync,
+} from '@symbiote-native/network';
+import { createNetworkState } from '@symbiote-native/network/solid';
+
+function NetworkScreen() {
+  const networkState = createNetworkState(); // Accessor<NetworkState>
+  const [ipAddress, setIpAddress] = createSignal<string | null>(null);
+  const [isAirplaneMode, setIsAirplaneMode] = createSignal<boolean | null>(
+    null,
+  );
+
+  onMount(() => {
+    void Promise.all([getIpAddressAsync(), isAirplaneModeEnabledAsync()]).then(
+      ([ip, airplaneMode]) => {
+        setIpAddress(ip);
+        setIsAirplaneMode(airplaneMode);
+      },
+    );
+  });
+
+  return (
+    <>
+      <Text>
+        {networkState().isConnected
+          ? `Connected via ${networkState().type}`
+          : 'Offline'}
+      </Text>
+      <Text>{ipAddress() ?? 'checking…'}</Text>
+      <Text>
+        {isAirplaneMode() ? 'Airplane mode: On' : 'Airplane mode: Off'}
+      </Text>
+    </>
+  );
+}
+```
+
+Each of the demo screens above also re-fetches the IP address and airplane-mode card
 whenever the live network state changes (toggling Wi-Fi/airplane mode on the device updates both
 cards together) — see the linked files for the full version, including the connection-type label
 switch and the layout around it.
@@ -174,18 +238,25 @@ Plus `NetworkStateType` (enum: `NONE`/`UNKNOWN`/`CELLULAR`/`WIFI`/`BLUETOOTH`/`E
 `VPN`/`OTHER`), `NetworkState`, `NetworkStateEvent` — ported from upstream's `Network.types.ts`.
 
 ```ts
-import { getNetworkStateAsync, addNetworkStateListener } from '@symbiote-native/network';
+import {
+  getNetworkStateAsync,
+  addNetworkStateListener,
+} from '@symbiote-native/network';
 
 // framework-scoped entry points re-export the same free functions, plus a lifecycle
 // hook/composable/service:
 import { useNetworkState } from '@symbiote-native/network/react';
 import { useNetworkState } from '@symbiote-native/network/vue';
+import { useNetworkState } from '@symbiote-native/network/svelte';
+import { createNetworkState } from '@symbiote-native/network/solid';
 import { NetworkStateService } from '@symbiote-native/network/angular';
 ```
 
-`useNetworkState` seeds its initial value from a one-shot `getNetworkStateAsync()` call, then
-subscribes to `addNetworkStateListener` for updates, and unsubscribes on unmount — mirroring
-upstream's own `useNetworkState`.
+`useNetworkState` (Solid: `createNetworkState`) seeds its initial value from a one-shot
+`getNetworkStateAsync()` call, then subscribes to `addNetworkStateListener` for updates, and
+unsubscribes on unmount — mirroring upstream's own `useNetworkState`. The Solid primitive returns
+an `Accessor<NetworkState>` and subscribes from its body rather than an effect, so nothing can slip
+between the seed and the subscription.
 
 ## Test it
 

package/build/angular/index.d.ts

@@ -1,2 +1,2 @@
 export { NetworkStateService } from './services/network-state.service';
-export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, NetworkStateType, type NetworkState, type NetworkStateEvent, type EventSubscription, } from '../core';
+export * from '../core';

package/build/angular/index.js

@@ -1,4 +1,4 @@
 // NetworkStateService is the Angular-only lifecycle half; the free functions and event
 // subscription plumbing all live in core, shared with React/Vue.
 export { NetworkStateService } from './services/network-state.service/index.js';
-export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, NetworkStateType, } from '../core/index.js';
+export * from '../core/index.js';

package/build/angular/services/network-state.service/index.js

@@ -32,8 +32,8 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { effect, inject, Injectable, Injector, signal } from '@angular/core';
-import { addNetworkStateListener, getNetworkStateAsync } from '../../../core/index.js';
+import { effect, inject, Injectable, Injector, signal, } from '@angular/core';
+import { addNetworkStateListener, getNetworkStateAsync, } from '../../../core/index.js';
 // Angular twin of React's `useNetworkState` hook and Vue's `useNetworkState` composable.
 //
 //   readonly networkState = inject(NetworkStateService).connect();

package/build/core/index.d.ts

@@ -1,3 +1,3 @@
 export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, } from './network';
-export { NetworkStateType, type NetworkState, type NetworkStateEvent } from './types';
+export { NetworkStateType, type NetworkState, type NetworkStateEvent, } from './types';
 export type { EventSubscription } from 'expo-modules-core';

package/build/core/index.js

@@ -1,2 +1,2 @@
 export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, } from './network.js';
-export { NetworkStateType } from './types.js';
+export { NetworkStateType, } from './types.js';

package/build/react/hooks/use-network-state/index.js

@@ -2,7 +2,7 @@
 // value with a one-shot getNetworkStateAsync() call before the first native event fires, matching
 // upstream's own useNetworkState.
 import { useEffect, useState } from 'react';
-import { addNetworkStateListener, getNetworkStateAsync } from '../../../core/index.js';
+import { addNetworkStateListener, getNetworkStateAsync, } from '../../../core/index.js';
 export function useNetworkState() {
     const [networkState, setNetworkState] = useState({});
     useEffect(() => {

package/build/react/index.d.ts

@@ -1,2 +1,2 @@
 export { useNetworkState } from './hooks/use-network-state';
-export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, NetworkStateType, type NetworkState, type NetworkStateEvent, type EventSubscription, } from '../core';
+export * from '../core';

package/build/react/index.js

@@ -1,3 +1,3 @@
 // @symbiote-native/network/react: the React entry over the framework-agnostic core.
 export { useNetworkState } from './hooks/use-network-state/index.js';
-export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, NetworkStateType, } from '../core/index.js';
+export * from '../core/index.js';

package/build/solid/index.d.ts

@@ -0,0 +1,2 @@
+export { createNetworkState } from './primitives/create-network-state';
+export * from '../core';

package/build/solid/index.js

@@ -0,0 +1,5 @@
+// @symbiote-native/network/solid: the Solid entry over the framework-agnostic core — mirrors the
+// lifecycle-bucket naming convention of adapters/solid/src/primitives (never `hooks`/`composables`/
+// `runes`, those are React's, Vue's and Svelte's terms).
+export { createNetworkState } from './primitives/create-network-state.js';
+export * from '../core/index.js';

package/build/solid/primitives/create-network-state.d.ts

@@ -0,0 +1,3 @@
+import { type Accessor } from 'solid-js';
+import { type NetworkState } from '../../core';
+export declare function createNetworkState(): Accessor<NetworkState>;

package/build/solid/primitives/create-network-state.js

@@ -0,0 +1,32 @@
+// createNetworkState — the Solid twin of React's `useNetworkState` hook, Vue's composable and
+// Svelte's rune, over the framework-agnostic core (core/network.ts). Seeds with a one-shot
+// getNetworkStateAsync() call before the first native event fires, matching upstream's own
+// useNetworkState.
+//
+// `primitives/` and `create*`, never `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.
+//
+// Returns an ACCESSOR, never a snapshot: a Solid component body runs ONCE, so a returned object
+// would pin the caller to the empty seed forever.
+//
+// Outside a component or `createRoot` there is no owner for `onCleanup` — Solid warns and the
+// native listener lives for the process. The accessor still tracks; only the teardown is lost.
+import { createSignal, onCleanup } from 'solid-js';
+import { addNetworkStateListener, getNetworkStateAsync, } from '../../core/index.js';
+export function createNetworkState() {
+    const [networkState, setNetworkState] = createSignal({});
+    getNetworkStateAsync().then(state => {
+        setNetworkState(state);
+    });
+    // Subscribed from the primitive body, not from an effect: React/Vue/Svelte start listening a
+    // tick after their seed runs, so a change landing in that window is lost. Both statements here
+    // run in one synchronous tick and nothing can interleave.
+    const subscription = addNetworkStateListener(event => {
+        setNetworkState(event);
+    });
+    onCleanup(() => {
+        subscription.remove();
+    });
+    return networkState;
+}

package/build/svelte/index.d.ts

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

package/build/svelte/index.js

@@ -0,0 +1,5 @@
+// @symbiote-native/network/svelte: the Svelte entry over the framework-agnostic core — mirrors the
+// lifecycle-bucket naming convention of adapters/svelte/src/runes (never `hooks`/`composables`,
+// those are React's and Vue's terms).
+export { useNetworkState } from './runes/use-network-state.svelte';
+export * from '../core/index.js';

package/build/svelte/runes/use-network-state.svelte.d.ts

@@ -0,0 +1,4 @@
+import { type NetworkState } from '../../core';
+export declare function useNetworkState(): {
+    readonly current: NetworkState;
+};

package/build/svelte/runes/use-network-state.svelte.js

@@ -0,0 +1,29 @@
+// Svelte lifecycle wiring over the framework-agnostic core (core/network.ts). Seeds the initial
+// value with a one-shot getNetworkStateAsync() call before the first native event fires, matching
+// upstream's own useNetworkState and the Vue composable's onMounted half.
+//
+// `.svelte.ts` extension: runes ($state/$effect) only work there outside a `.svelte` component;
+// `runes/` is Svelte's name for the lifecycle bucket (React's `hooks/`, Vue's `composables/`).
+// Returns a boxed getter, not a bare `$state`: Svelte 5 reactivity is lexically scoped to the
+// declaring module and doesn't survive being returned raw from a plain function, so the caller
+// reads `.current` like unwrapping Vue's `Ref` via `.value`.
+import { addNetworkStateListener, getNetworkStateAsync, } from '../../core/index.js';
+export function useNetworkState() {
+    let networkState = $state({});
+    $effect(() => {
+        // Write-only touches of `networkState`, so the effect has no dependency on it and runs once
+        // per mount - the twin of Vue's onMounted/onUnmounted pair.
+        getNetworkStateAsync().then(state => {
+            networkState = state;
+        });
+        const subscription = addNetworkStateListener(event => {
+            networkState = event;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return networkState;
+        },
+    };
+}

package/build/vue/index.d.ts

@@ -1,2 +1,2 @@
 export { useNetworkState } from './composables/use-network-state';
-export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, NetworkStateType, type NetworkState, type NetworkStateEvent, type EventSubscription, } from '../core';
+export * from '../core';

package/build/vue/index.js

@@ -1,3 +1,3 @@
 // @symbiote-native/network/vue: the Vue entry over the framework-agnostic core.
 export { useNetworkState } from './composables/use-network-state/index.js';
-export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, NetworkStateType, } from '../core/index.js';
+export * from '../core/index.js';

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

@@ -1,2 +1,2 @@
 export { NetworkStateService } from './services/network-state.service';
-export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, NetworkStateType, type NetworkState, type NetworkStateEvent, type EventSubscription, } from '../core';
+export * from '../core';

package/build-ngc/angular/index.js

@@ -1,5 +1,5 @@
 // NetworkStateService is the Angular-only lifecycle half; the free functions and event
 // subscription plumbing all live in core, shared with React/Vue.
 export { NetworkStateService } from './services/network-state.service';
-export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, NetworkStateType, } 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,uFAAuF;AACvF,iEAAiE;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,0BAA0B,EAC1B,uBAAuB,EACvB,gBAAgB,GAIjB,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,iEAAiE;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,cAAc,SAAS,CAAC"}

package/build-ngc/angular/services/network-state.service/index.js

@@ -1,5 +1,5 @@
-import { effect, inject, Injectable, Injector, signal } from '@angular/core';
-import { addNetworkStateListener, getNetworkStateAsync } from '../../../core';
+import { effect, inject, Injectable, Injector, signal, } from '@angular/core';
+import { addNetworkStateListener, getNetworkStateAsync, } from '../../../core';
 import * as i0 from "@angular/core";
 // Angular twin of React's `useNetworkState` hook and Vue's `useNetworkState` composable.
 //
@@ -17,10 +17,10 @@ export class NetworkStateService {
         }, { injector: this.injector });
         return networkState.asReadonly();
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: NetworkStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: NetworkStateService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: NetworkStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: NetworkStateService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: NetworkStateService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: NetworkStateService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/network-state.service/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAe,MAAM,eAAe,CAAC;AAC1F,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAqB,MAAM,eAAe,CAAC;;AAEjG,yFAAyF;AACzF,EAAE;AACF,mEAAmE;AACnE,2CAA2C;AAE3C,MAAM,OAAO,mBAAmB;IACb,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAE7C,OAAO;QACL,MAAM,YAAY,GAAG,MAAM,CAAe,EAAE;yFAAC,CAAC;QAE9C,MAAM,CACJ,SAAS,CAAC,EAAE;YACV,oBAAoB,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;YAC9D,MAAM,YAAY,GAAG,uBAAuB,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;YAC/E,SAAS,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC;QACzC,CAAC,EACD,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAC5B,CAAC;QAEF,OAAO,YAAY,CAAC,UAAU,EAAE,CAAC;IACnC,CAAC;uGAhBU,mBAAmB;2GAAnB,mBAAmB,cADN,MAAM;;2FACnB,mBAAmB;kBAD/B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/network-state.service/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EACN,MAAM,EACN,UAAU,EACV,QAAQ,EACR,MAAM,GAEP,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,uBAAuB,EACvB,oBAAoB,GAErB,MAAM,eAAe,CAAC;;AAEvB,yFAAyF;AACzF,EAAE;AACF,mEAAmE;AACnE,2CAA2C;AAE3C,MAAM,OAAO,mBAAmB;IACb,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAE7C,OAAO;QACL,MAAM,YAAY,GAAG,MAAM,CAAe,EAAE;yFAAC,CAAC;QAE9C,MAAM,CACJ,SAAS,CAAC,EAAE;YACV,oBAAoB,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;YAC9D,MAAM,YAAY,GAAG,uBAAuB,CAAC,KAAK,CAAC,EAAE,CACnD,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CACxB,CAAC;YACF,SAAS,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC;QACzC,CAAC,EACD,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAC5B,CAAC;QAEF,OAAO,YAAY,CAAC,UAAU,EAAE,CAAC;IACnC,CAAC;uGAlBU,mBAAmB;2GAAnB,mBAAmB,cADN,MAAM;;2FACnB,mBAAmB;kBAD/B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}

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

@@ -1,3 +1,3 @@
 export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, } from './network';
-export { NetworkStateType, type NetworkState, type NetworkStateEvent } from './types';
+export { NetworkStateType, type NetworkState, type NetworkStateEvent, } from './types';
 export type { EventSubscription } from 'expo-modules-core';

package/build-ngc/core/index.js

@@ -1,3 +1,3 @@
 export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, } from './network';
-export { NetworkStateType } from './types';
+export { NetworkStateType, } from './types';
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,0BAA0B,EAC1B,uBAAuB,GACxB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,gBAAgB,EAA6C,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,0BAA0B,EAC1B,uBAAuB,GACxB,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,gBAAgB,GAGjB,MAAM,SAAS,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,wBAAwB,GAAG,aAAa,CAAC;AAc/C,MAAM,CAAC,MAAM,WAAW,GAAG,mBAAmB,CAAuB,wBAAwB,CAAC,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,wBAAwB,GAAG,aAAa,CAAC;AAc/C,MAAM,CAAC,MAAM,WAAW,GAAG,mBAAmB,CAC5C,wBAAwB,CACzB,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"network.js","sourceRoot":"","sources":["../../src/core/network.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,0FAA0F;AAC1F,2DAA2D;AAC3D,OAAO,EAAE,mBAAmB,EAA0B,MAAM,mBAAmB,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG9C,MAAM,kBAAkB,GAAG,cAAc,CAAC;AAE1C,0DAA0D;AAC1D,MAAM,CAAC,KAAK,UAAU,oBAAoB;IACxC,IAAI,CAAC,WAAW,CAAC,oBAAoB,EAAE,CAAC;QACtC,MAAM,IAAI,mBAAmB,CAAC,kBAAkB,EAAE,sBAAsB,CAAC,CAAC;IAC5E,CAAC;IACD,OAAO,WAAW,CAAC,oBAAoB,EAAE,CAAC;AAC5C,CAAC;AAED,gGAAgG;AAChG,MAAM,CAAC,KAAK,UAAU,iBAAiB;IACrC,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC;QACnC,MAAM,IAAI,mBAAmB,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,CAAC;IACzE,CAAC;IACD,OAAO,WAAW,CAAC,iBAAiB,EAAE,CAAC;AACzC,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,0BAA0B;IAC9C,IAAI,CAAC,WAAW,CAAC,0BAA0B,EAAE,CAAC;QAC5C,MAAM,IAAI,mBAAmB,CAAC,kBAAkB,EAAE,4BAA4B,CAAC,CAAC;IAClF,CAAC;IACD,OAAO,WAAW,CAAC,0BAA0B,EAAE,CAAC;AAClD,CAAC;AAED,2FAA2F;AAC3F,MAAM,UAAU,uBAAuB,CACrC,QAA4C;IAE5C,OAAO,WAAW,CAAC,WAAW,CAAC,uBAAuB,EAAE,QAAQ,CAAC,CAAC;AACpE,CAAC"}
+{"version":3,"file":"network.js","sourceRoot":"","sources":["../../src/core/network.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,0FAA0F;AAC1F,2DAA2D;AAC3D,OAAO,EAAE,mBAAmB,EAA0B,MAAM,mBAAmB,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG9C,MAAM,kBAAkB,GAAG,cAAc,CAAC;AAE1C,0DAA0D;AAC1D,MAAM,CAAC,KAAK,UAAU,oBAAoB;IACxC,IAAI,CAAC,WAAW,CAAC,oBAAoB,EAAE,CAAC;QACtC,MAAM,IAAI,mBAAmB,CAAC,kBAAkB,EAAE,sBAAsB,CAAC,CAAC;IAC5E,CAAC;IACD,OAAO,WAAW,CAAC,oBAAoB,EAAE,CAAC;AAC5C,CAAC;AAED,gGAAgG;AAChG,MAAM,CAAC,KAAK,UAAU,iBAAiB;IACrC,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC;QACnC,MAAM,IAAI,mBAAmB,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,CAAC;IACzE,CAAC;IACD,OAAO,WAAW,CAAC,iBAAiB,EAAE,CAAC;AACzC,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,0BAA0B;IAC9C,IAAI,CAAC,WAAW,CAAC,0BAA0B,EAAE,CAAC;QAC5C,MAAM,IAAI,mBAAmB,CAC3B,kBAAkB,EAClB,4BAA4B,CAC7B,CAAC;IACJ,CAAC;IACD,OAAO,WAAW,CAAC,0BAA0B,EAAE,CAAC;AAClD,CAAC;AAED,2FAA2F;AAC3F,MAAM,UAAU,uBAAuB,CACrC,QAA4C;IAE5C,OAAO,WAAW,CAAC,WAAW,CAAC,uBAAuB,EAAE,QAAQ,CAAC,CAAC;AACpE,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@symbiote-native/network",
-  "version": "0.1.0",
-  "description": "expo-network wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, and Angular adapters. Network state (type/connected/internet-reachable) with a change listener, device IP address, and airplane-mode detection.",
+  "version": "0.3.0",
+  "description": "expo-network wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, Svelte, Solid, and Angular adapters. Network state (type/connected/internet-reachable) with a change listener, device IP address, and airplane-mode detection.",
   "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,13 +1,4 @@
 // NetworkStateService is the Angular-only lifecycle half; the free functions and event
 // subscription plumbing all live in core, shared with React/Vue.
 export { NetworkStateService } from './services/network-state.service';
-export {
-  getNetworkStateAsync,
-  getIpAddressAsync,
-  isAirplaneModeEnabledAsync,
-  addNetworkStateListener,
-  NetworkStateType,
-  type NetworkState,
-  type NetworkStateEvent,
-  type EventSubscription,
-} from '../core';
+export * from '../core';

package/src/angular/services/network-state.service/index.ts

@@ -1,5 +1,16 @@
-import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
-import { addNetworkStateListener, getNetworkStateAsync, type NetworkState } from '../../../core';
+import {
+  effect,
+  inject,
+  Injectable,
+  Injector,
+  signal,
+  type Signal,
+} from '@angular/core';
+import {
+  addNetworkStateListener,
+  getNetworkStateAsync,
+  type NetworkState,
+} from '../../../core';
 
 // Angular twin of React's `useNetworkState` hook and Vue's `useNetworkState` composable.
 //
@@ -15,7 +26,9 @@ export class NetworkStateService {
     effect(
       onCleanup => {
         getNetworkStateAsync().then(state => networkState.set(state));
-        const subscription = addNetworkStateListener(event => networkState.set(event));
+        const subscription = addNetworkStateListener(event =>
+          networkState.set(event),
+        );
         onCleanup(() => subscription.remove());
       },
       { injector: this.injector },

package/src/core/index.ts

@@ -4,5 +4,9 @@ export {
   isAirplaneModeEnabledAsync,
   addNetworkStateListener,
 } from './network';
-export { NetworkStateType, type NetworkState, type NetworkStateEvent } from './types';
+export {
+  NetworkStateType,
+  type NetworkState,
+  type NetworkStateEvent,
+} from './types';
 export type { EventSubscription } from 'expo-modules-core';

package/src/core/native-module.ts

@@ -16,4 +16,6 @@ export type INativeNetworkModule = {
   ): EventSubscription;
 };
 
-export const expoNetwork = requireNativeModule<INativeNetworkModule>(EXPO_NETWORK_MODULE_NAME);
+export const expoNetwork = requireNativeModule<INativeNetworkModule>(
+  EXPO_NETWORK_MODULE_NAME,
+);

package/src/core/network.ts

@@ -29,7 +29,10 @@ export async function getIpAddressAsync(): Promise<string> {
  */
 export async function isAirplaneModeEnabledAsync(): Promise<boolean> {
   if (!expoNetwork.isAirplaneModeEnabledAsync) {
-    throw new UnavailabilityError(NATIVE_MODULE_NAME, 'isAirplaneModeEnabledAsync');
+    throw new UnavailabilityError(
+      NATIVE_MODULE_NAME,
+      'isAirplaneModeEnabledAsync',
+    );
   }
   return expoNetwork.isAirplaneModeEnabledAsync();
 }

package/src/react/hooks/use-network-state/index.ts

@@ -2,14 +2,20 @@
 // value with a one-shot getNetworkStateAsync() call before the first native event fires, matching
 // upstream's own useNetworkState.
 import { useEffect, useState } from 'react';
-import { addNetworkStateListener, getNetworkStateAsync, type NetworkState } from '../../../core';
+import {
+  addNetworkStateListener,
+  getNetworkStateAsync,
+  type NetworkState,
+} from '../../../core';
 
 export function useNetworkState(): NetworkState {
   const [networkState, setNetworkState] = useState<NetworkState>({});
 
   useEffect(() => {
     getNetworkStateAsync().then(setNetworkState);
-    const subscription = addNetworkStateListener(event => setNetworkState(event));
+    const subscription = addNetworkStateListener(event =>
+      setNetworkState(event),
+    );
     return () => subscription.remove();
   }, []);
 

package/src/react/index.ts

@@ -1,13 +1,4 @@
 // @symbiote-native/network/react: the React entry over the framework-agnostic core.
 
 export { useNetworkState } from './hooks/use-network-state';
-export {
-  getNetworkStateAsync,
-  getIpAddressAsync,
-  isAirplaneModeEnabledAsync,
-  addNetworkStateListener,
-  NetworkStateType,
-  type NetworkState,
-  type NetworkStateEvent,
-  type EventSubscription,
-} from '../core';
+export * from '../core';

package/src/solid/index.ts

@@ -0,0 +1,6 @@
+// @symbiote-native/network/solid: the Solid entry over the framework-agnostic core — mirrors the
+// lifecycle-bucket naming convention of adapters/solid/src/primitives (never `hooks`/`composables`/
+// `runes`, those are React's, Vue's and Svelte's terms).
+
+export { createNetworkState } from './primitives/create-network-state';
+export * from '../core';

package/src/solid/primitives/create-network-state.ts

@@ -0,0 +1,43 @@
+// createNetworkState — the Solid twin of React's `useNetworkState` hook, Vue's composable and
+// Svelte's rune, over the framework-agnostic core (core/network.ts). Seeds with a one-shot
+// getNetworkStateAsync() call before the first native event fires, matching upstream's own
+// useNetworkState.
+//
+// `primitives/` and `create*`, never `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.
+//
+// Returns an ACCESSOR, never a snapshot: a Solid component body runs ONCE, so a returned object
+// would pin the caller to the empty seed forever.
+//
+// Outside a component or `createRoot` there is no owner for `onCleanup` — Solid warns and the
+// native listener lives for the process. The accessor still tracks; only the teardown is lost.
+
+import { createSignal, onCleanup, type Accessor } from 'solid-js';
+import {
+  addNetworkStateListener,
+  getNetworkStateAsync,
+  type EventSubscription,
+  type NetworkState,
+} from '../../core';
+
+export function createNetworkState(): Accessor<NetworkState> {
+  const [networkState, setNetworkState] = createSignal<NetworkState>({});
+
+  getNetworkStateAsync().then(state => {
+    setNetworkState(state);
+  });
+
+  // Subscribed from the primitive body, not from an effect: React/Vue/Svelte start listening a
+  // tick after their seed runs, so a change landing in that window is lost. Both statements here
+  // run in one synchronous tick and nothing can interleave.
+  const subscription: EventSubscription = addNetworkStateListener(event => {
+    setNetworkState(event);
+  });
+
+  onCleanup(() => {
+    subscription.remove();
+  });
+
+  return networkState;
+}

package/src/svelte/index.ts

@@ -0,0 +1,6 @@
+// @symbiote-native/network/svelte: the Svelte entry over the framework-agnostic core — mirrors the
+// lifecycle-bucket naming convention of adapters/svelte/src/runes (never `hooks`/`composables`,
+// those are React's and Vue's terms).
+
+export { useNetworkState } from './runes/use-network-state.svelte';
+export * from '../core';

package/src/svelte/runes/use-network-state.svelte.ts

@@ -0,0 +1,37 @@
+// Svelte lifecycle wiring over the framework-agnostic core (core/network.ts). Seeds the initial
+// value with a one-shot getNetworkStateAsync() call before the first native event fires, matching
+// upstream's own useNetworkState and the Vue composable's onMounted half.
+//
+// `.svelte.ts` extension: runes ($state/$effect) only work there outside a `.svelte` component;
+// `runes/` is Svelte's name for the lifecycle bucket (React's `hooks/`, Vue's `composables/`).
+// Returns a boxed getter, not a bare `$state`: Svelte 5 reactivity is lexically scoped to the
+// declaring module and doesn't survive being returned raw from a plain function, so the caller
+// reads `.current` like unwrapping Vue's `Ref` via `.value`.
+import {
+  addNetworkStateListener,
+  getNetworkStateAsync,
+  type EventSubscription,
+  type NetworkState,
+} from '../../core';
+
+export function useNetworkState(): { readonly current: NetworkState } {
+  let networkState = $state<NetworkState>({});
+
+  $effect(() => {
+    // Write-only touches of `networkState`, so the effect has no dependency on it and runs once
+    // per mount - the twin of Vue's onMounted/onUnmounted pair.
+    getNetworkStateAsync().then(state => {
+      networkState = state;
+    });
+    const subscription: EventSubscription = addNetworkStateListener(event => {
+      networkState = event;
+    });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): NetworkState {
+      return networkState;
+    },
+  };
+}

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

@@ -1,13 +1,4 @@
 // @symbiote-native/network/vue: the Vue entry over the framework-agnostic core.
 
 export { useNetworkState } from './composables/use-network-state';
-export {
-  getNetworkStateAsync,
-  getIpAddressAsync,
-  isAirplaneModeEnabledAsync,
-  addNetworkStateListener,
-  NetworkStateType,
-  type NetworkState,
-  type NetworkStateEvent,
-  type EventSubscription,
-} from '../core';
+export * from '../core';