@domicile-desktop/system-network 0.0.0-alpha-44d0983a58ce → 0.0.0-alpha-56dd6c187f4e

package/README.md

@@ -4,15 +4,16 @@ The network for a Domicile shell, from NetworkManager, iwd or wpa_supplicant:
 connectivity and the primary connection, with the Wi-Fi network's name and
 signal. The Wi-Fi device, from NetworkManager or iwd: its networks and
 connection, and the requests that change them. Built on
-[`@domicile-desktop/sdk/system`](../chrome-sdk/README.md).
+the `dbus`, `files` and `processes` namespaces of
+[`desktop(domicile)`](../chrome-sdk/README.md).
 
 ## Usage
 
 ```ts
-import { system } from "@domicile-desktop/sdk/system";
+import { desktop } from "@domicile-desktop/sdk/desktop/desktop";
 import { watchNetwork } from "@domicile-desktop/system-network/network";
 
-const stop = watchNetwork(system(domicile), (network) => {
+const stop = watchNetwork(desktop(domicile), (network) => {
   network.match({
     Err: () => hide(),
     Ok: ({ connectivity, link }) => show(connectivity, link),
@@ -111,4 +112,4 @@ bun run turbo test --filter @domicile-desktop/system-network
 ```
 
 Tests replay D-Bus replies, in the compositor's JSON, through an injected
-`System`.
+`dbus` namespace.

package/dist/follow.d.ts

@@ -1,6 +1,6 @@
 import type { Result } from "@cprussin/option-result";
 import type { DbusMatch, DbusSignal, SystemError } from "@domicile-desktop/sdk/system";
-import type { NetworkSystem } from "./network-state";
+import type { NetworkDesktop } from "./network-state";
 /** What one read found, and which signals can change it. */
 export type Reading<T extends NonNullable<unknown>> = {
     value: Result<T, SystemError>;
@@ -10,4 +10,4 @@ export type Reading<T extends NonNullable<unknown>> = {
  * Calls `onValue` with what `read` finds now and after each signal that
  * matters, and returns a function that stops watching.
  */
-export declare const followBus: <T extends NonNullable<unknown>>(system: NetworkSystem, match: DbusMatch, read: () => Promise<Reading<T>>, onValue: (value: Result<T, SystemError>) => void) => (() => void);
+export declare const followBus: <T extends NonNullable<unknown>>(domicile: NetworkDesktop, match: DbusMatch, read: () => Promise<Reading<T>>, onValue: (value: Result<T, SystemError>) => void) => (() => void);

package/dist/follow.js

@@ -6,14 +6,14 @@ import { ListenedKind } from "@domicile-desktop/sdk/system";
  * Calls `onValue` with what `read` finds now and after each signal that
  * matters, and returns a function that stops watching.
  */
-export const followBus = (system, match, read, onValue) => {
+export const followBus = (domicile, match, read, onValue) => {
     const watch = { listening: undefined, stopped: false };
     const report = (value) => {
         if (!watch.stopped) {
             onValue(value);
         }
     };
-    follow(system, match, read, watch, report).catch((error) => {
+    follow(domicile, match, read, watch, report).catch((error) => {
         // biome-ignore lint/suspicious/noConsole: surfacing a background failure
         console.error("Failed to watch the network", error);
     });
@@ -22,8 +22,8 @@ export const followBus = (system, match, read, onValue) => {
         watch.listening?.stop();
     };
 };
-const follow = async (system, match, read, watch, report) => {
-    const matched = await system.dbusMatch(match);
+const follow = async (domicile, match, read, watch, report) => {
+    const matched = await domicile.dbus.match(match);
     await matched.match({
         Err: (error) => {
             report(Err(error));

package/dist/has-owner.d.ts

@@ -1,8 +1,8 @@
 import type { Result } from "@cprussin/option-result";
 import type { SystemError } from "@domicile-desktop/sdk/system";
-import type { NetworkSystem } from "./network-state";
+import type { NetworkDesktop } from "./network-state";
 /**
  * Whether `name` has an owner on the system bus. `NameHasOwner` does not start
  * a service that D-Bus can activate, as a call to the service would.
  */
-export declare const hasOwner: (system: NetworkSystem, name: string) => Promise<Result<boolean, SystemError>>;
+export declare const hasOwner: (domicile: NetworkDesktop, name: string) => Promise<Result<boolean, SystemError>>;

package/dist/has-owner.js

@@ -4,7 +4,7 @@ import { z } from "zod";
  * Whether `name` has an owner on the system bus. `NameHasOwner` does not start
  * a service that D-Bus can activate, as a call to the service would.
  */
-export const hasOwner = async (system, name) => (await system.dbusCall({
+export const hasOwner = async (domicile, name) => (await domicile.dbus.call({
     body: [name],
     bus: Bus.System,
     destination: "org.freedesktop.DBus",

package/dist/interfaces.d.ts

@@ -1,5 +1,7 @@
 import type { Result } from "@cprussin/option-result";
-import type { System, SystemError } from "@domicile-desktop/sdk/system";
+import type { Files } from "@domicile-desktop/sdk/desktop/files";
+import type { Processes } from "@domicile-desktop/sdk/desktop/processes";
+import type { SystemError } from "@domicile-desktop/sdk/system";
 export declare enum InterfaceKind {
     Wired = 0,
     Wireless = 1
@@ -22,26 +24,32 @@ export type Addressing = {
     gateway: string | undefined;
 };
 /** The calls {@link readInterfaces} makes. Each works while the desktop is locked. */
-export type InterfaceSystem = Pick<System, "readDir" | "readTextFile" | "stat">;
+export type InterfaceDesktop = {
+    readonly files: Pick<Files, "readDir" | "readText" | "stat">;
+};
 /**
  * The interfaces with hardware behind them, by name. Virtual ones, such as
  * the loopback, a bridge or a VPN, have no `device` link and are left out.
  */
-export declare const readInterfaces: (system: InterfaceSystem) => Promise<Result<NetworkInterface[], SystemError>>;
+export declare const readInterfaces: (domicile: InterfaceDesktop) => Promise<Result<NetworkInterface[], SystemError>>;
 /**
  * Calls `onInterfaces` with {@link readInterfaces} now and whenever it
  * changes, and returns a function that stops watching. Reads every 5 seconds.
  */
-export declare const watchInterfaces: (system: InterfaceSystem, onInterfaces: (interfaces: Result<NetworkInterface[], SystemError>) => void, every?: typeof everyInterval) => (() => void);
+export declare const watchInterfaces: (domicile: InterfaceDesktop, onInterfaces: (interfaces: Result<NetworkInterface[], SystemError>) => void, every?: typeof everyInterval) => (() => void);
 /**
  * Calls `onAddresses` with {@link readAddresses} now and whenever it changes,
  * and returns a function that stops watching. Reads every 5 seconds.
  */
-export declare const watchAddresses: (system: Pick<System, "run">, onAddresses: (addresses: Result<Map<string, Addressing>, SystemError>) => void, every?: typeof everyInterval) => (() => void);
+export declare const watchAddresses: (domicile: {
+    readonly processes: Pick<Processes, "run">;
+}, onAddresses: (addresses: Result<Map<string, Addressing>, SystemError>) => void, every?: typeof everyInterval) => (() => void);
 /**
  * Each interface's global addresses in use and default gateway, by name, from
  * `ip -j`. `ip` must be on the compositor's `PATH`.
  */
-export declare const readAddresses: (system: Pick<System, "run">) => Promise<Result<Map<string, Addressing>, SystemError>>;
+export declare const readAddresses: (domicile: {
+    readonly processes: Pick<Processes, "run">;
+}) => Promise<Result<Map<string, Addressing>, SystemError>>;
 declare const everyInterval: (ms: number, tick: () => void) => (() => void);
 export {};

package/dist/interfaces.js

@@ -16,13 +16,13 @@ export var InterfaceKind;
  * The interfaces with hardware behind them, by name. Virtual ones, such as
  * the loopback, a bridge or a VPN, have no `device` link and are left out.
  */
-export const readInterfaces = async (system) => (await system.readDir(NET)).match({
+export const readInterfaces = async (domicile) => (await domicile.files.readDir(NET)).match({
     Err: (error) => Promise.resolve(Err(error)),
     Ok: async (entries) => {
         const read = await Promise.all(entries
             .map(({ name }) => name)
             .toSorted()
-            .map((name) => interfaceOf(system, name)));
+            .map((name) => interfaceOf(domicile, name)));
         return read.reduce((all, each) => all.andThen((found) => each.map((one) => one.match({ None: () => found, Some: (it) => [...found, it] }))), Ok([]));
     },
 });
@@ -30,19 +30,19 @@ export const readInterfaces = async (system) => (await system.readDir(NET)).matc
  * Calls `onInterfaces` with {@link readInterfaces} now and whenever it
  * changes, and returns a function that stops watching. Reads every 5 seconds.
  */
-export const watchInterfaces = (system, onInterfaces, every = everyInterval) => poll(() => readInterfaces(system), onInterfaces, every);
+export const watchInterfaces = (domicile, onInterfaces, every = everyInterval) => poll(() => readInterfaces(domicile), onInterfaces, every);
 /**
  * Calls `onAddresses` with {@link readAddresses} now and whenever it changes,
  * and returns a function that stops watching. Reads every 5 seconds.
  */
-export const watchAddresses = (system, onAddresses, every = everyInterval) => poll(() => readAddresses(system), onAddresses, every);
+export const watchAddresses = (domicile, onAddresses, every = everyInterval) => poll(() => readAddresses(domicile), onAddresses, every);
 /**
  * Each interface's global addresses in use and default gateway, by name, from
  * `ip -j`. `ip` must be on the compositor's `PATH`.
  */
-export const readAddresses = async (system) => {
-    const addresses = await ip(system, ["address", "show"], addressesSchema);
-    const routes = await ip(system, ["route", "show", "default"], routesSchema);
+export const readAddresses = async (domicile) => {
+    const addresses = await ip(domicile, ["address", "show"], addressesSchema);
+    const routes = await ip(domicile, ["route", "show", "default"], routesSchema);
     return addresses.andThen((listed) => routes.map((defaults) => new Map(listed.map(({ addr_info: info, ifname }) => [
         ifname,
         {
@@ -93,24 +93,24 @@ const everyInterval = (ms, tick) => {
     };
 };
 /** The interface `name`, or `None` for a virtual one. */
-const interfaceOf = async (system, name) => {
+const interfaceOf = async (domicile, name) => {
     const at = `${NET}/${name}`;
-    return (await exists(system, `${at}/device`)).match({
+    return (await exists(domicile, `${at}/device`)).match({
         Err: (error) => Promise.resolve(Err(error)),
         Ok: async (physical) => physical
-            ? (await hardwareOf(system, name)).map(Some)
+            ? (await hardwareOf(domicile, name)).map(Some)
             : Ok(None()),
     });
 };
 /** The interface `name`, which has a `device`. */
-const hardwareOf = async (system, name) => {
+const hardwareOf = async (domicile, name) => {
     const at = `${NET}/${name}`;
-    const wireless = await exists(system, `${at}/wireless`);
-    const address = await line(system, `${at}/address`);
-    const state = await line(system, `${at}/operstate`);
+    const wireless = await exists(domicile, `${at}/wireless`);
+    const address = await line(domicile, `${at}/address`);
+    const state = await line(domicile, `${at}/operstate`);
     const up = state.map((operstate) => operstate === "up");
     const speed = up.unwrapOr(false) && !wireless.unwrapOr(true)
-        ? await speedOf(system, at)
+        ? await speedOf(domicile, at)
         : undefined;
     return wireless.andThen((isWireless) => address.andThen((hardwareAddress) => up.map((linked) => ({
         hardwareAddress,
@@ -121,17 +121,17 @@ const hardwareOf = async (system, name) => {
     }))));
 };
 /** Whether `path` exists. */
-const exists = async (system, path) => (await system.stat(path)).match({
+const exists = async (domicile, path) => (await domicile.files.stat(path)).match({
     Err: (error) => error.kind === SystemErrorKind.NotFound ? Ok(false) : Err(error),
     Ok: () => Ok(true),
 });
 /** A one-line file under `/sys`, without its newline. */
-const line = async (system, path) => (await system.readTextFile(path)).map((text) => text.trim());
+const line = async (domicile, path) => (await domicile.files.readText(path)).map((text) => text.trim());
 /**
  * A wired link's speed. The kernel fails the read, or answers `-1`, when the
  * driver does not know it, which is no speed to show.
  */
-const speedOf = async (system, at) => (await line(system, `${at}/speed`)).match({
+const speedOf = async (domicile, at) => (await line(domicile, `${at}/speed`)).match({
     Err: () => undefined,
     Ok: (text) => {
         const mbits = Number.parseInt(text, 10);
@@ -139,7 +139,7 @@ const speedOf = async (system, at) => (await line(system, `${at}/speed`)).match(
     },
 });
 /** `ip -j` with `argv`, parsed with `schema`. */
-const ip = async (system, argv, schema) => (await system.run(["ip", "-j", ...argv])).andThen(({ code, stderr, stdout }) => code === 0
+const ip = async (domicile, argv, schema) => (await domicile.processes.run(["ip", "-j", ...argv])).andThen(({ code, stderr, stdout }) => code === 0
     ? Ok(schema.parse(JSON.parse(stdout)))
     : Err({
         kind: SystemErrorKind.Other,

package/dist/iwd-wifi.d.ts

@@ -1,7 +1,7 @@
 import type { Option, Result } from "@cprussin/option-result";
 import type { SystemError } from "@domicile-desktop/sdk/system";
-import type { NetworkSystem } from "./network-state";
-import type { Wifi, WifiDevice, WifiNetwork, WifiSystem } from "./wifi-state";
+import type { NetworkDesktop } from "./network-state";
+import type { Wifi, WifiDesktop, WifiDevice, WifiNetwork } from "./wifi-state";
 /**
  * Calls `onWifi` with the first station device now and after each change, and
  * returns a function that stops watching. `None` is a machine without one.
@@ -9,16 +9,16 @@ import type { Wifi, WifiDevice, WifiNetwork, WifiSystem } from "./wifi-state";
  * An `Err` is a D-Bus failure, such as iwd not running. The watch keeps
  * listening after one, so a later change reads again.
  */
-export declare const watchIwdWifi: (system: NetworkSystem, onWifi: (wifi: Result<Option<Wifi>, SystemError>) => void) => (() => void);
+export declare const watchIwdWifi: (domicile: NetworkDesktop, onWifi: (wifi: Result<Option<Wifi>, SystemError>) => void) => (() => void);
 /** Turn the device on or off. */
-export declare const setIwdWifiEnabled: (system: NetworkSystem, wifi: WifiDevice, enabled: boolean) => Promise<Result<"done", SystemError>>;
+export declare const setIwdWifiEnabled: (domicile: NetworkDesktop, wifi: WifiDevice, enabled: boolean) => Promise<Result<"done", SystemError>>;
 /** Ask for a scan. Networks it finds arrive as changes. */
-export declare const scanIwdWifi: (system: NetworkSystem, wifi: WifiDevice) => Promise<Result<"done", SystemError>>;
+export declare const scanIwdWifi: (domicile: NetworkDesktop, wifi: WifiDevice) => Promise<Result<"done", SystemError>>;
 /**
  * Join `network`. A known or open network joins over D-Bus. A new secured one
  * joins through `iwctl`, which answers iwd's request for the passphrase: iwd
  * asks an agent for it, and a page cannot serve one.
  */
-export declare const connectIwdWifi: (system: WifiSystem, wifi: WifiDevice, network: WifiNetwork, passphrase: string | undefined) => Promise<Result<"done", SystemError>>;
+export declare const connectIwdWifi: (domicile: WifiDesktop, wifi: WifiDevice, network: WifiNetwork, passphrase: string | undefined) => Promise<Result<"done", SystemError>>;
 /** Leave the current network, until asked to join one. */
-export declare const disconnectIwdWifi: (system: NetworkSystem, wifi: WifiDevice) => Promise<Result<"done", SystemError>>;
+export declare const disconnectIwdWifi: (domicile: NetworkDesktop, wifi: WifiDevice) => Promise<Result<"done", SystemError>>;

package/dist/iwd-wifi.js

@@ -21,29 +21,29 @@ const WATCHED = [DEVICE, STATION, NETWORK];
  * An `Err` is a D-Bus failure, such as iwd not running. The watch keeps
  * listening after one, so a later change reads again.
  */
-export const watchIwdWifi = (system, onWifi) => followBus(system, { bus: Bus.System, sender: SERVICE }, async () => ({ matters, value: await read(system) }), onWifi);
+export const watchIwdWifi = (domicile, onWifi) => followBus(domicile, { bus: Bus.System, sender: SERVICE }, async () => ({ matters, value: await read(domicile) }), onWifi);
 /** Turn the device on or off. */
-export const setIwdWifiEnabled = async (system, wifi, enabled) => done(await system.dbusCall({
+export const setIwdWifiEnabled = async (domicile, wifi, enabled) => done(await domicile.dbus.call({
     ...request(wifi.device, "org.freedesktop.DBus.Properties", "Set"),
     body: [DEVICE, "Powered", { signature: "b", value: enabled }],
     signature: "ssv",
 }));
 /** Ask for a scan. Networks it finds arrive as changes. */
-export const scanIwdWifi = async (system, wifi) => done(await system.dbusCall(request(wifi.device, STATION, "Scan")));
+export const scanIwdWifi = async (domicile, wifi) => done(await domicile.dbus.call(request(wifi.device, STATION, "Scan")));
 /**
  * Join `network`. A known or open network joins over D-Bus. A new secured one
  * joins through `iwctl`, which answers iwd's request for the passphrase: iwd
  * asks an agent for it, and a page cannot serve one.
  */
-export const connectIwdWifi = async (system, wifi, network, passphrase) => {
+export const connectIwdWifi = async (domicile, wifi, network, passphrase) => {
     if (network.profile !== undefined || !network.secured) {
-        return done(await system.dbusCall(request(network.path, NETWORK, "Connect")));
+        return done(await domicile.dbus.call(request(network.path, NETWORK, "Connect")));
     }
     else if (passphrase === undefined) {
         throw new Error(`joining ${network.ssid} needs a passphrase`);
     }
     else {
-        const ran = await system.run([
+        const ran = await domicile.processes.run([
             "iwctl",
             "--passphrase",
             passphrase,
@@ -61,7 +61,7 @@ export const connectIwdWifi = async (system, wifi, network, passphrase) => {
     }
 };
 /** Leave the current network, until asked to join one. */
-export const disconnectIwdWifi = async (system, wifi) => done(await system.dbusCall(request(wifi.device, STATION, "Disconnect")));
+export const disconnectIwdWifi = async (domicile, wifi) => done(await domicile.dbus.call(request(wifi.device, STATION, "Disconnect")));
 const request = (path, iface, member) => ({
     bus: Bus.System,
     destination: SERVICE,
@@ -86,7 +86,7 @@ const matters = (signal) => {
         }
     }
 };
-const read = async (system) => (await system.dbusCall({
+const read = async (domicile) => (await domicile.dbus.call({
     bus: Bus.System,
     destination: SERVICE,
     interface: "org.freedesktop.DBus.ObjectManager",
@@ -100,9 +100,9 @@ const read = async (system) => (await system.dbusCall({
     })[0];
     return station === undefined
         ? Ok(None())
-        : (await wifiOf(system, objects, station.path, station.device, station.held)).map((wifi) => Some(wifi));
+        : (await wifiOf(domicile, objects, station.path, station.device, station.held)).map((wifi) => Some(wifi));
 });
-const wifiOf = async (system, objects, path, device, held) => {
+const wifiOf = async (domicile, objects, path, device, held) => {
     const off = {
         backend: WifiBackend.Iwd,
         connection: undefined,
@@ -116,16 +116,16 @@ const wifiOf = async (system, objects, path, device, held) => {
     const station = held[STATION];
     return station === undefined
         ? Ok(off)
-        : (await stationOf(system, objects, path, station, held[DIAGNOSTIC])).map((found) => ({ ...off, ...found }));
+        : (await stationOf(domicile, objects, path, station, held[DIAGNOSTIC])).map((found) => ({ ...off, ...found }));
 };
-const stationOf = async (system, objects, path, station, diagnostic) => (await system.dbusCall(request(path, STATION, "GetOrderedNetworks"))).andThenAsync(async ({ body }) => {
+const stationOf = async (domicile, objects, path, station, diagnostic) => (await domicile.dbus.call(request(path, STATION, "GetOrderedNetworks"))).andThenAsync(async ({ body }) => {
     const networks = orderedNetworksSchema
         .parse(body)[0]
         .map(([network, signal]) => networkOf(objects, network, signal));
     const connected = networks.find(({ connected: on }) => on);
     const connection = connected === undefined
         ? Ok(None())
-        : (await diagnosticsOf(system, path, diagnostic)).map((found) => Some({
+        : (await diagnosticsOf(domicile, path, diagnostic)).map((found) => Some({
             ...found,
             ip: undefined,
             ssid: connected.ssid,
@@ -157,9 +157,9 @@ const networkOf = (objects, path, signal) => {
     }
 };
 /** The link's frequency and bitrate, when iwd offers diagnostics. */
-const diagnosticsOf = async (system, path, diagnostic) => diagnostic === undefined
+const diagnosticsOf = async (domicile, path, diagnostic) => diagnostic === undefined
     ? Ok({ bitrate: undefined, frequency: undefined })
-    : (await system.dbusCall(request(path, DIAGNOSTIC, "GetDiagnostics"))).map(({ body }) => {
+    : (await domicile.dbus.call(request(path, DIAGNOSTIC, "GetDiagnostics"))).map(({ body }) => {
         const [found] = diagnosticsSchema.parse(body);
         return { bitrate: found.RxBitrate / 10, frequency: found.Frequency };
     });

package/dist/iwd.d.ts

@@ -1,6 +1,6 @@
 import type { Result } from "@cprussin/option-result";
 import type { SystemError } from "@domicile-desktop/sdk/system";
-import type { Network, NetworkSystem } from "./network-state";
+import type { Network, NetworkDesktop } from "./network-state";
 /**
  * Calls `onNetwork` with iwd's network now and after each change, and returns
  * a function that stops watching.
@@ -10,4 +10,4 @@ import type { Network, NetworkSystem } from "./network-state";
  * not running. The watch keeps listening after one, so a later change reads
  * again.
  */
-export declare const watchIwd: (system: NetworkSystem, onNetwork: (network: Result<Network, SystemError>) => void) => (() => void);
+export declare const watchIwd: (domicile: NetworkDesktop, onNetwork: (network: Result<Network, SystemError>) => void) => (() => void);

package/dist/iwd.js

@@ -24,7 +24,7 @@ const WATCHED = ["ConnectedNetwork", "Scanning", "State"];
  * not running. The watch keeps listening after one, so a later change reads
  * again.
  */
-export const watchIwd = (system, onNetwork) => followBus(system, { bus: Bus.System, sender: SERVICE }, async () => ({ matters, value: await read(system) }), onNetwork);
+export const watchIwd = (domicile, onNetwork) => followBus(domicile, { bus: Bus.System, sender: SERVICE }, async () => ({ matters, value: await read(domicile) }), onNetwork);
 /**
  * Whether `signal` can change the network: an object coming or going, or a
  * watched station property.
@@ -44,8 +44,8 @@ const matters = (signal) => {
         }
     }
 };
-const read = async (system) => {
-    const objects = await system.dbusCall({
+const read = async (domicile) => {
+    const objects = await domicile.dbus.call({
         bus: Bus.System,
         destination: SERVICE,
         interface: "org.freedesktop.DBus.ObjectManager",
@@ -54,11 +54,11 @@ const read = async (system) => {
     });
     return objects.match({
         Err: (error) => Promise.resolve(Err(error)),
-        Ok: async ({ body }) => (await linkOf(system, managedObjectsSchema.parse(body)[0])).map((link) => ({ connectivity: Connectivity.Unknown, link })),
+        Ok: async ({ body }) => (await linkOf(domicile, managedObjectsSchema.parse(body)[0])).map((link) => ({ connectivity: Connectivity.Unknown, link })),
     });
 };
 /** The first connected station's network, or `None`. */
-const linkOf = async (system, objects) => {
+const linkOf = async (domicile, objects) => {
     const station = Object.entries(objects).flatMap(([path, held]) => held[STATION] !== undefined && isOnline(held[STATION].State)
         ? [{ network: connectedNetwork(path, held[STATION]), path }]
         : [])[0];
@@ -66,7 +66,7 @@ const linkOf = async (system, objects) => {
         return Ok(Link.None());
     }
     else {
-        const ordered = await system.dbusCall({
+        const ordered = await domicile.dbus.call({
             bus: Bus.System,
             destination: SERVICE,
             interface: STATION,

package/dist/network-state.d.ts

@@ -1,4 +1,4 @@
-import type { System } from "@domicile-desktop/sdk/system";
+import type { Dbus } from "@domicile-desktop/sdk/desktop/dbus";
 /** Whether the host reaches the internet. */
 export declare enum Connectivity {
     Unknown = 0,
@@ -42,4 +42,6 @@ export type Network = {
     link: Link;
 };
 /** The calls this library makes. */
-export type NetworkSystem = Pick<System, "dbusCall" | "dbusMatch">;
+export type NetworkDesktop = {
+    readonly dbus: Pick<Dbus, "call" | "match">;
+};

package/dist/network.d.ts

@@ -1,7 +1,7 @@
 import type { Result } from "@cprussin/option-result";
 import type { SystemError } from "@domicile-desktop/sdk/system";
-import type { Network, NetworkSystem } from "./network-state";
-export type { Network, NetworkSystem } from "./network-state";
+import type { Network, NetworkDesktop } from "./network-state";
+export type { Network, NetworkDesktop } from "./network-state";
 export { Connectivity, Link, LinkKind } from "./network-state";
 /**
  * Calls `onNetwork` with the network now and after each change, and returns a
@@ -12,4 +12,4 @@ export { Connectivity, Link, LinkKind } from "./network-state";
  * watch. An `Err` is a D-Bus failure, such as none of them running. When the
  * bus cannot say which runs, the watch reports that `Err` and ends.
  */
-export declare const watchNetwork: (system: NetworkSystem, onNetwork: (network: Result<Network, SystemError>) => void) => (() => void);
+export declare const watchNetwork: (domicile: NetworkDesktop, onNetwork: (network: Result<Network, SystemError>) => void) => (() => void);

package/dist/network.js

@@ -23,9 +23,9 @@ const BACKENDS = [
  * watch. An `Err` is a D-Bus failure, such as none of them running. When the
  * bus cannot say which runs, the watch reports that `Err` and ends.
  */
-export const watchNetwork = (system, onNetwork) => {
+export const watchNetwork = (domicile, onNetwork) => {
     const watch = { stop: undefined, stopped: false };
-    detect(system, BACKENDS)
+    detect(domicile, BACKENDS)
         .then((found) => {
         if (!watch.stopped) {
             found.match({
@@ -33,7 +33,7 @@ export const watchNetwork = (system, onNetwork) => {
                     onNetwork(Err(error));
                 },
                 Ok: (backend) => {
-                    watch.stop = backend(system, onNetwork);
+                    watch.stop = backend(domicile, onNetwork);
                 },
             });
         }
@@ -48,17 +48,17 @@ export const watchNetwork = (system, onNetwork) => {
     };
 };
 /** The first backend whose service has an owner on the bus. */
-const detect = async (system, backends) => {
+const detect = async (domicile, backends) => {
     const [first, ...rest] = backends;
     if (first === undefined) {
         return Ok(watchNetworkManager);
     }
     else {
         const [name, backend] = first;
-        const owned = await hasOwner(system, name);
+        const owned = await hasOwner(domicile, name);
         return owned.match({
             Err: (error) => Promise.resolve(Err(error)),
-            Ok: (has) => (has ? Promise.resolve(Ok(backend)) : detect(system, rest)),
+            Ok: (has) => has ? Promise.resolve(Ok(backend)) : detect(domicile, rest),
         });
     }
 };

package/dist/networkmanager-wifi.d.ts

@@ -1,7 +1,7 @@
 import type { Option } from "@cprussin/option-result";
 import { Result } from "@cprussin/option-result";
 import type { SystemError } from "@domicile-desktop/sdk/system";
-import type { NetworkSystem } from "./network-state";
+import type { NetworkDesktop } from "./network-state";
 import type { Wifi, WifiDevice, WifiNetwork } from "./wifi-state";
 /** A read's outcome: Wi-Fi, if there is a device, or the first failure. */
 type Found = Result<Option<Wifi>, SystemError>;
@@ -12,16 +12,16 @@ type Found = Result<Option<Wifi>, SystemError>;
  * An `Err` is a D-Bus failure, such as NetworkManager not running. The watch
  * keeps listening after one, so a later change reads again.
  */
-export declare const watchNetworkManagerWifi: (system: NetworkSystem, onWifi: (wifi: Found) => void) => (() => void);
+export declare const watchNetworkManagerWifi: (domicile: NetworkDesktop, onWifi: (wifi: Found) => void) => (() => void);
 /** Turn the Wi-Fi radio on or off. */
-export declare const setNetworkManagerWifiEnabled: (system: NetworkSystem, _wifi: WifiDevice, enabled: boolean) => Promise<Result<"done", SystemError>>;
+export declare const setNetworkManagerWifiEnabled: (domicile: NetworkDesktop, _wifi: WifiDevice, enabled: boolean) => Promise<Result<"done", SystemError>>;
 /** Ask for a scan. Networks it finds arrive as changes. */
-export declare const scanNetworkManagerWifi: (system: NetworkSystem, wifi: WifiDevice) => Promise<Result<"done", SystemError>>;
+export declare const scanNetworkManagerWifi: (domicile: NetworkDesktop, wifi: WifiDevice) => Promise<Result<"done", SystemError>>;
 /**
  * Join `network`: through its saved profile if it has one, or with a new
  * profile, which needs `passphrase` when the network is secured.
  */
-export declare const connectNetworkManagerWifi: (system: NetworkSystem, wifi: WifiDevice, network: WifiNetwork, passphrase: string | undefined) => Promise<Result<"done", SystemError>>;
+export declare const connectNetworkManagerWifi: (domicile: NetworkDesktop, wifi: WifiDevice, network: WifiNetwork, passphrase: string | undefined) => Promise<Result<"done", SystemError>>;
 /** Leave the current network, until asked to join one. */
-export declare const disconnectNetworkManagerWifi: (system: NetworkSystem, wifi: WifiDevice) => Promise<Result<"done", SystemError>>;
+export declare const disconnectNetworkManagerWifi: (domicile: NetworkDesktop, wifi: WifiDevice) => Promise<Result<"done", SystemError>>;
 export {};

package/dist/networkmanager-wifi.js

@@ -22,20 +22,20 @@ const WIFI_DEVICE = 2;
  * An `Err` is a D-Bus failure, such as NetworkManager not running. The watch
  * keeps listening after one, so a later change reads again.
  */
-export const watchNetworkManagerWifi = (system, onWifi) => followBus(system, { bus: Bus.System, sender: SERVICE }, () => read(system), onWifi);
+export const watchNetworkManagerWifi = (domicile, onWifi) => followBus(domicile, { bus: Bus.System, sender: SERVICE }, () => read(domicile), onWifi);
 /** Turn the Wi-Fi radio on or off. */
-export const setNetworkManagerWifiEnabled = async (system, _wifi, enabled) => done(await system.dbusCall(request(ROOT, "org.freedesktop.DBus.Properties", "Set", "ssv", [
+export const setNetworkManagerWifiEnabled = async (domicile, _wifi, enabled) => done(await domicile.dbus.call(request(ROOT, "org.freedesktop.DBus.Properties", "Set", "ssv", [
     SERVICE,
     "WirelessEnabled",
     { signature: "b", value: enabled },
 ])));
 /** Ask for a scan. Networks it finds arrive as changes. */
-export const scanNetworkManagerWifi = async (system, wifi) => done(await system.dbusCall(request(wifi.device, WIRELESS, "RequestScan", "a{sv}", [{}])));
+export const scanNetworkManagerWifi = async (domicile, wifi) => done(await domicile.dbus.call(request(wifi.device, WIRELESS, "RequestScan", "a{sv}", [{}])));
 /**
  * Join `network`: through its saved profile if it has one, or with a new
  * profile, which needs `passphrase` when the network is secured.
  */
-export const connectNetworkManagerWifi = async (system, wifi, network, passphrase) => done(await system.dbusCall(network.profile === undefined
+export const connectNetworkManagerWifi = async (domicile, wifi, network, passphrase) => done(await domicile.dbus.call(network.profile === undefined
     ? request(ROOT, SERVICE, "AddAndActivateConnection", "a{sa{sv}}oo", [
         newProfile(network, passphrase),
         wifi.device,
@@ -47,7 +47,7 @@ export const connectNetworkManagerWifi = async (system, wifi, network, passphras
         network.path,
     ])));
 /** Leave the current network, until asked to join one. */
-export const disconnectNetworkManagerWifi = async (system, wifi) => done(await system.dbusCall({
+export const disconnectNetworkManagerWifi = async (domicile, wifi) => done(await domicile.dbus.call({
     bus: Bus.System,
     destination: SERVICE,
     interface: DEVICE,
@@ -85,9 +85,9 @@ const newProfile = (network, passphrase) => {
  * Read Wi-Fi. A property change on an object read for it matters, as does an
  * access point or a device coming or going.
  */
-const read = async (system) => {
+const read = async (domicile) => {
     const paths = new Set([ROOT]);
-    const value = await readWifi(system, paths);
+    const value = await readWifi(domicile, paths);
     return { matters: (signal) => matters(paths, signal), value };
 };
 const matters = (paths, signal) => {
@@ -108,31 +108,31 @@ const matters = (paths, signal) => {
     }
 };
 /** Read Wi-Fi, adding each object read to `paths`. */
-const readWifi = async (system, paths) => (await properties(system, ROOT, SERVICE, rootSchema)).andThenAsync(async ({ WirelessEnabled: enabled }) => (await call(system, ROOT, SERVICE, "GetDevices")).andThenAsync(async ({ body }) => {
+const readWifi = async (domicile, paths) => (await properties(domicile, ROOT, SERVICE, rootSchema)).andThenAsync(async ({ WirelessEnabled: enabled }) => (await call(domicile, ROOT, SERVICE, "GetDevices")).andThenAsync(async ({ body }) => {
     const listed = devicesSchema.parse(body)[0];
     for (const path of listed) {
         paths.add(path);
     }
-    const devices = Result.collect(await Promise.all(listed.map(async (path) => (await properties(system, path, DEVICE, deviceSchema)).map((device) => ({ device, path })))));
+    const devices = Result.collect(await Promise.all(listed.map(async (path) => (await properties(domicile, path, DEVICE, deviceSchema)).map((device) => ({ device, path })))));
     return devices.andThenAsync(async (read) => {
         const found = read.find(({ device }) => device.DeviceType === WIFI_DEVICE);
         return found === undefined
             ? Ok(None())
-            : (await wifiOf(system, paths, found.path, found.device, enabled)).map((wifi) => Some(wifi));
+            : (await wifiOf(domicile, paths, found.path, found.device, enabled)).map((wifi) => Some(wifi));
     });
 }));
 /** The Wi-Fi device at `path`. */
-const wifiOf = async (system, paths, path, device, enabled) => (await properties(system, path, WIRELESS, wirelessSchema)).andThenAsync(async (radio) => {
+const wifiOf = async (domicile, paths, path, device, enabled) => (await properties(domicile, path, WIRELESS, wirelessSchema)).andThenAsync(async (radio) => {
     for (const point of radio.AccessPoints) {
         paths.add(point);
     }
     paths.add(device.Ip4Config);
     const [points, profiles, ip] = await Promise.all([
-        accessPoints(system, radio.AccessPoints),
-        savedProfiles(system, device.AvailableConnections),
+        accessPoints(domicile, radio.AccessPoints),
+        savedProfiles(domicile, device.AvailableConnections),
         radio.ActiveAccessPoint === NO_OBJECT || device.Ip4Config === NO_OBJECT
             ? Promise.resolve(Ok(None()))
-            : ipOf(system, device.Ip4Config),
+            : ipOf(domicile, device.Ip4Config),
     ]);
     return points.andThen((read) => profiles.andThen((saved) => ip.map((address) => ({
         backend: WifiBackend.NetworkManager,
@@ -145,16 +145,16 @@ const wifiOf = async (system, paths, path, device, enabled) => (await properties
         scanning: false,
     }))));
 });
-const accessPoints = async (system, listed) => Result.collect(await Promise.all(listed.map(async (path) => (await properties(system, path, `${SERVICE}.AccessPoint`, accessPointSchema)).map((point) => ({ ...point, path })))));
+const accessPoints = async (domicile, listed) => Result.collect(await Promise.all(listed.map(async (path) => (await properties(domicile, path, `${SERVICE}.AccessPoint`, accessPointSchema)).map((point) => ({ ...point, path })))));
 /** Each saved Wi-Fi profile's path, by its network's name. */
-const savedProfiles = async (system, listed) => Result.collect(await Promise.all(listed.map(async (path) => (await call(system, path, `${SERVICE}.Settings.Connection`, "GetSettings")).map(({ body }) => ({
+const savedProfiles = async (domicile, listed) => Result.collect(await Promise.all(listed.map(async (path) => (await call(domicile, path, `${SERVICE}.Settings.Connection`, "GetSettings")).map(({ body }) => ({
     path,
     settings: settingsSchema.parse(body)[0],
 }))))).map((saved) => new Map(saved.flatMap(({ path, settings }) => {
     const ssid = settings["802-11-wireless"]?.ssid;
     return ssid === undefined ? [] : [[ssid, path]];
 })));
-const ipOf = async (system, path) => (await properties(system, path, `${SERVICE}.IP4Config`, ip4Schema)).map((config) => Some({
+const ipOf = async (domicile, path) => (await properties(domicile, path, `${SERVICE}.IP4Config`, ip4Schema)).map((config) => Some({
     addresses: config.AddressData.map(({ address, prefix }) => `${address}/${prefix}`),
     dns: config.NameserverData.map(({ address }) => address),
     gateway: config.Gateway === "" ? undefined : config.Gateway,
@@ -198,7 +198,7 @@ const connectionOf = (points, radio, ip) => {
 };
 /** `NM_802_11_AP_FLAGS_PRIVACY`, or any WPA or RSN flag. */
 const isSecured = (point) => (point.Flags & 1) !== 0 || point.WpaFlags !== 0 || point.RsnFlags !== 0;
-const call = (system, path, iface, member) => system.dbusCall({
+const call = (domicile, path, iface, member) => domicile.dbus.call({
     bus: Bus.System,
     destination: SERVICE,
     interface: iface,
@@ -206,7 +206,7 @@ const call = (system, path, iface, member) => system.dbusCall({
     path,
 });
 /** `Properties.GetAll` on one of NetworkManager's objects, parsed. */
-const properties = async (system, path, interfaceName, schema) => (await system.dbusCall({
+const properties = async (domicile, path, interfaceName, schema) => (await domicile.dbus.call({
     body: [interfaceName],
     bus: Bus.System,
     destination: SERVICE,

package/dist/networkmanager.d.ts

@@ -1,6 +1,6 @@
 import type { Result } from "@cprussin/option-result";
 import type { SystemError } from "@domicile-desktop/sdk/system";
-import type { Network, NetworkSystem } from "./network-state";
+import type { Network, NetworkDesktop } from "./network-state";
 /**
  * Calls `onNetwork` with NetworkManager's network now and after each change,
  * and returns a function that stops watching.
@@ -8,4 +8,4 @@ import type { Network, NetworkSystem } from "./network-state";
  * An `Err` is a D-Bus failure, such as NetworkManager not running. The watch
  * keeps listening after one, so a later change reads again.
  */
-export declare const watchNetworkManager: (system: NetworkSystem, onNetwork: (network: Result<Network, SystemError>) => void) => (() => void);
+export declare const watchNetworkManager: (domicile: NetworkDesktop, onNetwork: (network: Result<Network, SystemError>) => void) => (() => void);

package/dist/networkmanager.js

@@ -17,22 +17,22 @@ const NO_OBJECT = "/";
  * An `Err` is a D-Bus failure, such as NetworkManager not running. The watch
  * keeps listening after one, so a later change reads again.
  */
-export const watchNetworkManager = (system, onNetwork) => followBus(system, {
+export const watchNetworkManager = (domicile, onNetwork) => followBus(domicile, {
     bus: Bus.System,
     interface: "org.freedesktop.DBus.Properties",
     member: "PropertiesChanged",
     sender: SERVICE,
-}, () => read(system), onNetwork);
+}, () => read(domicile), onNetwork);
 /** Read the network; a change to any object read for it matters. */
-const read = async (system) => {
-    const root = await properties(system, ROOT, SERVICE, rootSchema);
+const read = async (domicile) => {
+    const root = await properties(domicile, ROOT, SERVICE, rootSchema);
     return root.match({
         Err: (error) => Promise.resolve({
             matters: ({ path }) => path === ROOT,
             value: Err(error),
         }),
         Ok: async ({ Connectivity: connectivity, PrimaryConnection: primary }) => {
-            const link = await linkOf(system, primary);
+            const link = await linkOf(domicile, primary);
             const paths = new Set([ROOT, ...link.paths]);
             return {
                 matters: ({ path }) => paths.has(path),
@@ -45,18 +45,18 @@ const read = async (system) => {
     });
 };
 /** The primary connection at `path`. */
-const linkOf = async (system, path) => {
+const linkOf = async (domicile, path) => {
     if (path === NO_OBJECT) {
         return { paths: [], result: Ok(Link.None()) };
     }
     else {
-        const active = await properties(system, path, `${SERVICE}.Connection.Active`, activeSchema);
+        const active = await properties(domicile, path, `${SERVICE}.Connection.Active`, activeSchema);
         return active.match({
             Err: (error) => Promise.resolve({ paths: [path], result: Err(error) }),
             Ok: async ({ Id: name, SpecificObject: specific, Type: type, }) => {
                 switch (type) {
                     case "802-11-wireless": {
-                        const point = await properties(system, specific, `${SERVICE}.AccessPoint`, accessPointSchema);
+                        const point = await properties(domicile, specific, `${SERVICE}.AccessPoint`, accessPointSchema);
                         return {
                             paths: [path, specific],
                             result: point.map(({ Ssid: ssid, Strength: strength }) => Link.Wifi(new TextDecoder().decode(new Uint8Array(ssid)), strength / 100)),
@@ -74,7 +74,7 @@ const linkOf = async (system, path) => {
     }
 };
 /** `Properties.GetAll` on one of NetworkManager's objects, parsed. */
-const properties = async (system, path, interfaceName, schema) => (await system.dbusCall({
+const properties = async (domicile, path, interfaceName, schema) => (await domicile.dbus.call({
     body: [interfaceName],
     bus: Bus.System,
     destination: SERVICE,

package/dist/portal.d.ts

@@ -1,5 +1,6 @@
 import type { Option, Result } from "@cprussin/option-result";
-import type { System, SystemError } from "@domicile-desktop/sdk/system";
+import type { Processes } from "@domicile-desktop/sdk/desktop/processes";
+import type { SystemError } from "@domicile-desktop/sdk/system";
 /** Chrome's portal probe: `204 No Content` on the open internet. Plain http, so a portal can intercept it. */
 export declare const PORTAL_PROBE = "http://www.gstatic.com/generate_204";
 /**
@@ -9,4 +10,6 @@ export declare const PORTAL_PROBE = "http://www.gstatic.com/generate_204";
  * Retries a probe that gets no answer, since an address or a route can arrive
  * a moment after the network does. An `Err` is a probe that never got one.
  */
-export declare const checkPortal: (system: Pick<System, "run">) => Promise<Result<Option<string>, SystemError>>;
+export declare const checkPortal: (domicile: {
+    readonly processes: Pick<Processes, "run">;
+}) => Promise<Result<Option<string>, SystemError>>;

package/dist/portal.js

@@ -16,7 +16,7 @@ const RETRIES = "3";
  * Retries a probe that gets no answer, since an address or a route can arrive
  * a moment after the network does. An `Err` is a probe that never got one.
  */
-export const checkPortal = async (system) => (await system.run([
+export const checkPortal = async (domicile) => (await domicile.processes.run([
     "curl",
     "--silent",
     "--output",

package/dist/wifi-state.d.ts

@@ -1,4 +1,5 @@
-import type { System } from "@domicile-desktop/sdk/system";
+import type { Dbus } from "@domicile-desktop/sdk/desktop/dbus";
+import type { Processes } from "@domicile-desktop/sdk/desktop/processes";
 /** The service that manages the Wi-Fi device. */
 export declare enum WifiBackend {
     NetworkManager = 0,
@@ -51,4 +52,7 @@ export type Wifi = {
 /** What a request needs of the device. */
 export type WifiDevice = Pick<Wifi, "backend" | "device" | "interface">;
 /** The calls this library makes for Wi-Fi. */
-export type WifiSystem = Pick<System, "dbusCall" | "dbusMatch" | "run">;
+export type WifiDesktop = {
+    readonly dbus: Pick<Dbus, "call" | "match">;
+    readonly processes: Pick<Processes, "run">;
+};

package/dist/wifi.d.ts

@@ -1,7 +1,7 @@
 import type { Option, Result } from "@cprussin/option-result";
 import type { SystemError } from "@domicile-desktop/sdk/system";
-import type { Wifi, WifiDevice, WifiNetwork, WifiSystem } from "./wifi-state";
-export type { Ip, Wifi, WifiConnection, WifiDevice, WifiNetwork, WifiSystem, } from "./wifi-state";
+import type { Wifi, WifiDesktop, WifiDevice, WifiNetwork } from "./wifi-state";
+export type { Ip, Wifi, WifiConnection, WifiDesktop, WifiDevice, WifiNetwork, } from "./wifi-state";
 export { WifiBackend } from "./wifi-state";
 /**
  * Calls `onWifi` with the Wi-Fi device now and after each change, and returns
@@ -11,15 +11,15 @@ export { WifiBackend } from "./wifi-state";
  * `None` is no Wi-Fi device, or neither service: wpa_supplicant alone is not
  * controlled. An `Err` is a D-Bus failure.
  */
-export declare const watchWifi: (system: WifiSystem, onWifi: (wifi: Result<Option<Wifi>, SystemError>) => void) => (() => void);
+export declare const watchWifi: (domicile: WifiDesktop, onWifi: (wifi: Result<Option<Wifi>, SystemError>) => void) => (() => void);
 /** Turn the radio on or off. */
-export declare const setWifiEnabled: (system: WifiSystem, wifi: WifiDevice, enabled: boolean) => Promise<Result<"done", SystemError>>;
+export declare const setWifiEnabled: (domicile: WifiDesktop, wifi: WifiDevice, enabled: boolean) => Promise<Result<"done", SystemError>>;
 /** Ask for a scan. Networks it finds arrive through the watch. */
-export declare const scanWifi: (system: WifiSystem, wifi: WifiDevice) => Promise<Result<"done", SystemError>>;
+export declare const scanWifi: (domicile: WifiDesktop, wifi: WifiDevice) => Promise<Result<"done", SystemError>>;
 /**
  * Join `network`. A secured network with no saved profile needs `passphrase`;
  * the call throws without one.
  */
-export declare const connectWifi: (system: WifiSystem, wifi: WifiDevice, network: WifiNetwork, passphrase: string | undefined) => Promise<Result<"done", SystemError>>;
+export declare const connectWifi: (domicile: WifiDesktop, wifi: WifiDevice, network: WifiNetwork, passphrase: string | undefined) => Promise<Result<"done", SystemError>>;
 /** Leave the current network. */
-export declare const disconnectWifi: (system: WifiSystem, wifi: WifiDevice) => Promise<Result<"done", SystemError>>;
+export declare const disconnectWifi: (domicile: WifiDesktop, wifi: WifiDevice) => Promise<Result<"done", SystemError>>;

package/dist/wifi.js

@@ -21,9 +21,9 @@ const BACKENDS = [
  * `None` is no Wi-Fi device, or neither service: wpa_supplicant alone is not
  * controlled. An `Err` is a D-Bus failure.
  */
-export const watchWifi = (system, onWifi) => {
+export const watchWifi = (domicile, onWifi) => {
     const watch = { stop: undefined, stopped: false };
-    detect(system, BACKENDS)
+    detect(domicile, BACKENDS)
         .then((found) => {
         if (!watch.stopped) {
             found.match({
@@ -36,7 +36,7 @@ export const watchWifi = (system, onWifi) => {
                             onWifi(Ok(None()));
                         },
                         Some: (chosen) => {
-                            watch.stop = watchBackend(chosen)(system, onWifi);
+                            watch.stop = watchBackend(chosen)(domicile, onWifi);
                         },
                     });
                 },
@@ -53,42 +53,42 @@ export const watchWifi = (system, onWifi) => {
     };
 };
 /** Turn the radio on or off. */
-export const setWifiEnabled = (system, wifi, enabled) => {
+export const setWifiEnabled = (domicile, wifi, enabled) => {
     switch (wifi.backend) {
         case WifiBackend.NetworkManager:
-            return setNetworkManagerWifiEnabled(system, wifi, enabled);
+            return setNetworkManagerWifiEnabled(domicile, wifi, enabled);
         case WifiBackend.Iwd:
-            return setIwdWifiEnabled(system, wifi, enabled);
+            return setIwdWifiEnabled(domicile, wifi, enabled);
     }
 };
 /** Ask for a scan. Networks it finds arrive through the watch. */
-export const scanWifi = (system, wifi) => {
+export const scanWifi = (domicile, wifi) => {
     switch (wifi.backend) {
         case WifiBackend.NetworkManager:
-            return scanNetworkManagerWifi(system, wifi);
+            return scanNetworkManagerWifi(domicile, wifi);
         case WifiBackend.Iwd:
-            return scanIwdWifi(system, wifi);
+            return scanIwdWifi(domicile, wifi);
     }
 };
 /**
  * Join `network`. A secured network with no saved profile needs `passphrase`;
  * the call throws without one.
  */
-export const connectWifi = (system, wifi, network, passphrase) => {
+export const connectWifi = (domicile, wifi, network, passphrase) => {
     switch (wifi.backend) {
         case WifiBackend.NetworkManager:
-            return connectNetworkManagerWifi(system, wifi, network, passphrase);
+            return connectNetworkManagerWifi(domicile, wifi, network, passphrase);
         case WifiBackend.Iwd:
-            return connectIwdWifi(system, wifi, network, passphrase);
+            return connectIwdWifi(domicile, wifi, network, passphrase);
     }
 };
 /** Leave the current network. */
-export const disconnectWifi = (system, wifi) => {
+export const disconnectWifi = (domicile, wifi) => {
     switch (wifi.backend) {
         case WifiBackend.NetworkManager:
-            return disconnectNetworkManagerWifi(system, wifi);
+            return disconnectNetworkManagerWifi(domicile, wifi);
         case WifiBackend.Iwd:
-            return disconnectIwdWifi(system, wifi);
+            return disconnectIwdWifi(domicile, wifi);
     }
 };
 const watchBackend = (backend) => {
@@ -100,17 +100,17 @@ const watchBackend = (backend) => {
     }
 };
 /** The first backend whose service has an owner on the bus, if any. */
-const detect = async (system, backends) => {
+const detect = async (domicile, backends) => {
     const [first, ...rest] = backends;
     if (first === undefined) {
         return Ok(None());
     }
     else {
         const [name, backend] = first;
-        const owned = await hasOwner(system, name);
+        const owned = await hasOwner(domicile, name);
         return owned.match({
             Err: (error) => Promise.resolve(Err(error)),
-            Ok: (has) => has ? Promise.resolve(Ok(Some(backend))) : detect(system, rest),
+            Ok: (has) => has ? Promise.resolve(Ok(Some(backend))) : detect(domicile, rest),
         });
     }
 };

package/dist/wpa-supplicant.d.ts

@@ -1,6 +1,6 @@
 import { Result } from "@cprussin/option-result";
 import type { SystemError } from "@domicile-desktop/sdk/system";
-import type { Network, NetworkSystem } from "./network-state";
+import type { Network, NetworkDesktop } from "./network-state";
 /**
  * Calls `onNetwork` with wpa_supplicant's network now and after each change,
  * and returns a function that stops watching. wpa_supplicant is on the bus
@@ -11,4 +11,4 @@ import type { Network, NetworkSystem } from "./network-state";
  * such as wpa_supplicant not on the bus. The watch keeps listening after one,
  * so a later change reads again.
  */
-export declare const watchWpaSupplicant: (system: NetworkSystem, onNetwork: (network: Result<Network, SystemError>) => void) => (() => void);
+export declare const watchWpaSupplicant: (domicile: NetworkDesktop, onNetwork: (network: Result<Network, SystemError>) => void) => (() => void);

package/dist/wpa-supplicant.js

@@ -19,13 +19,13 @@ const ROOT = "/fi/w1/wpa_supplicant1";
  * such as wpa_supplicant not on the bus. The watch keeps listening after one,
  * so a later change reads again.
  */
-export const watchWpaSupplicant = (system, onNetwork) => followBus(system, { bus: Bus.System, sender: SERVICE }, () => read(system), onNetwork);
+export const watchWpaSupplicant = (domicile, onNetwork) => followBus(domicile, { bus: Bus.System, sender: SERVICE }, () => read(domicile), onNetwork);
 /**
  * Read the network. An interface coming or going matters, as does a property
  * change on an object read for it.
  */
-const read = async (system) => {
-    const found = await readPaths(system);
+const read = async (domicile) => {
+    const found = await readPaths(domicile);
     return {
         matters: (signal) => matters(found.paths, signal),
         value: found.network.map((link) => ({
@@ -53,12 +53,12 @@ const matters = (paths, signal) => {
         }
     }
 };
-const readPaths = async (system) => {
-    const root = await properties(system, ROOT, SERVICE, rootSchema);
+const readPaths = async (domicile) => {
+    const root = await properties(domicile, ROOT, SERVICE, rootSchema);
     return root.match({
         Err: (error) => Promise.resolve({ network: Err(error), paths: new Set() }),
         Ok: async ({ Interfaces: paths }) => {
-            const interfaces = Result.collect(await Promise.all(paths.map(async (path) => (await properties(system, path, `${SERVICE}.Interface`, interfaceSchema)).map((held) => ({ ...held, path })))));
+            const interfaces = Result.collect(await Promise.all(paths.map(async (path) => (await properties(domicile, path, `${SERVICE}.Interface`, interfaceSchema)).map((held) => ({ ...held, path })))));
             return interfaces.match({
                 Err: (error) => Promise.resolve({ network: Err(error), paths: new Set(paths) }),
                 Ok: async (held) => {
@@ -66,7 +66,7 @@ const readPaths = async (system) => {
                     return connected === undefined
                         ? { network: Ok(Link.None()), paths: new Set(paths) }
                         : {
-                            network: await linkOf(system, connected.CurrentBSS),
+                            network: await linkOf(domicile, connected.CurrentBSS),
                             paths: new Set([...paths, connected.CurrentBSS]),
                         };
                 },
@@ -99,9 +99,9 @@ const isOnline = (state) => {
     }
 };
 /** The network at the BSS `path`. */
-const linkOf = async (system, path) => (await properties(system, path, `${SERVICE}.BSS`, bssSchema)).map(({ SSID: ssid, Signal: signal }) => Link.Wifi(new TextDecoder().decode(new Uint8Array(ssid)), strengthOfDbm(signal)));
+const linkOf = async (domicile, path) => (await properties(domicile, path, `${SERVICE}.BSS`, bssSchema)).map(({ SSID: ssid, Signal: signal }) => Link.Wifi(new TextDecoder().decode(new Uint8Array(ssid)), strengthOfDbm(signal)));
 /** `Properties.GetAll` on one of wpa_supplicant's objects, parsed. */
-const properties = async (system, path, interfaceName, schema) => (await system.dbusCall({
+const properties = async (domicile, path, interfaceName, schema) => (await domicile.dbus.call({
     body: [interfaceName],
     bus: Bus.System,
     destination: SERVICE,

package/package.json

@@ -1,7 +1,7 @@
 {
   "dependencies": {
     "@cprussin/option-result": "^2.0.1",
-    "@domicile-desktop/sdk": "0.0.0-alpha-44d0983a58ce",
+    "@domicile-desktop/sdk": "0.0.0-alpha-56dd6c187f4e",
     "zod": "^4.5.4"
   },
   "description": "The network for a Domicile shell, from NetworkManager, iwd or wpa_supplicant: connectivity and the primary connection, with its Wi-Fi network and signal, kept current.",
@@ -64,5 +64,5 @@
     "test:unit": "bun test"
   },
   "type": "module",
-  "version": "0.0.0-alpha-44d0983a58ce"
+  "version": "0.0.0-alpha-56dd6c187f4e"
 }