@domicile-desktop/system-bluetooth 0.0.0-stage → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/LICENSE ADDED
@@ -0,0 +1,21 @@
1
+ MIT License
2
+
3
+ Copyright (c) 2026 Connor Prussin
4
+
5
+ Permission is hereby granted, free of charge, to any person obtaining a copy
6
+ of this software and associated documentation files (the "Software"), to deal
7
+ in the Software without restriction, including without limitation the rights
8
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9
+ copies of the Software, and to permit persons to whom the Software is
10
+ furnished to do so, subject to the following conditions:
11
+
12
+ The above copyright notice and this permission notice shall be included in all
13
+ copies or substantial portions of the Software.
14
+
15
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21
+ SOFTWARE.
package/README.md CHANGED
@@ -1,3 +1,57 @@
1
- # Temporary Holding Version
1
+ # @domicile-desktop/system-bluetooth
2
2
 
3
- This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
3
+ BlueZ for a Domicile shell: each adapter and whether it is powered or
4
+ scanning, the devices it knows, and the requests that change them. Built on
5
+ the desktop's `dbus` namespace ([`@domicile-desktop/sdk`](../chrome-sdk/README.md)).
6
+
7
+ ## Usage
8
+
9
+ ```ts
10
+ import { setPowered, watchBluetooth } from "@domicile-desktop/system-bluetooth/bluetooth";
11
+
12
+ const stop = watchBluetooth(domicile, (bluetooth) => {
13
+ bluetooth.match({
14
+ Err: () => hide(),
15
+ Ok: ({ adapters, devices }) => show(adapters, devices),
16
+ });
17
+ });
18
+ await setPowered(domicile, "/org/bluez/hci0", false);
19
+ ```
20
+
21
+ - Reads `GetManagedObjects` once, then again when an object comes or goes or
22
+ one of these changes: an adapter's `Powered` or `Discovering`, a device's
23
+ `Alias`, `Name`, `Connected` or `Paired`, or its battery's `Percentage`.
24
+ - `devices` holds paired devices and, from a scan, those with a name. Each
25
+ has `battery` (0 through 100) from `org.bluez.Battery1`, or `undefined` when
26
+ it reports none.
27
+ - Requests: `setPowered`, `startDiscovery`, `stopDiscovery`, `connect`,
28
+ `disconnect`, `pair` (then trusts the device) and `forget`.
29
+ - `pair` registers no agent, so only devices that need no code pair.
30
+ - An `Err` is a D-Bus failure, such as BlueZ not running or an adapter
31
+ blocked by rfkill.
32
+ - A bug or an unexpected reply shape throws, logged to the console.
33
+ - **Lock:** `watchBluetooth` works while the desktop is locked, so a lock
34
+ screen can show Bluetooth. Every request fails with `locked`
35
+ ([LOCK.md](/docs/LOCK.md)).
36
+
37
+ See [SHELL-SYSTEM-ACCESS.md](/docs/SHELL-SYSTEM-ACCESS.md).
38
+
39
+ ## React
40
+
41
+ `@domicile-desktop/system-bluetooth/react`, for a shell on
42
+ [`@domicile-desktop/react`](../react/README.md):
43
+
44
+ - `useBluetooth()`: BlueZ's state, `undefined` until it answers.
45
+ - `useHasBluetooth()`: whether `/sys` lists Bluetooth hardware, looked at
46
+ every 10s.
47
+ - `deskBluetooth(domicile)` and `deskBluetoothHardware(domicile)`: the shared
48
+ watches behind them, one per desktop.
49
+
50
+ ## Test
51
+
52
+ ```sh
53
+ bun run turbo test --filter @domicile-desktop/system-bluetooth
54
+ ```
55
+
56
+ Tests replay D-Bus replies, in the compositor's JSON, through an injected
57
+ `System`.
@@ -0,0 +1,71 @@
1
+ import type { Result } from "@cprussin/option-result";
2
+ import type { Dbus } from "@domicile-desktop/sdk/desktop/dbus";
3
+ import type { SystemError } from "@domicile-desktop/sdk/system";
4
+ /** A controller, such as `/org/bluez/hci0`. */
5
+ export type Adapter = {
6
+ path: string;
7
+ powered: boolean;
8
+ discovering: boolean;
9
+ };
10
+ /**
11
+ * A device BlueZ knows. `name` is its alias, which BlueZ fills from its name.
12
+ * `battery` is 0 through 100, for a device that reports it.
13
+ */
14
+ export type Device = {
15
+ path: string;
16
+ adapter: string;
17
+ address: string;
18
+ name: string;
19
+ paired: boolean;
20
+ connected: boolean;
21
+ battery: number | undefined;
22
+ };
23
+ /**
24
+ * Every adapter, and each device that is paired or, found by a scan, has a
25
+ * name. A scan finds many nameless devices, such as beacons.
26
+ */
27
+ export type Bluetooth = {
28
+ adapters: Adapter[];
29
+ devices: Device[];
30
+ };
31
+ /** The calls this library makes. */
32
+ export type BluetoothDesktop = {
33
+ readonly dbus: Pick<Dbus, "call" | "match">;
34
+ };
35
+ /**
36
+ * Calls `onBluetooth` with the adapters and connected devices now and after
37
+ * each change, and returns a function that stops watching.
38
+ *
39
+ * An `Err` is a D-Bus failure, such as BlueZ not running. The watch keeps
40
+ * listening after one, so a later change reads again.
41
+ */
42
+ export declare const watchBluetooth: (domicile: BluetoothDesktop, onBluetooth: (bluetooth: Result<Bluetooth, SystemError>) => void) => (() => void);
43
+ /** Turn the adapter at `adapter` on or off. */
44
+ export declare const setPowered: (domicile: {
45
+ readonly dbus: Pick<Dbus, "call">;
46
+ }, adapter: string, powered: boolean) => Promise<Result<"set", SystemError>>;
47
+ /** Start scanning for devices. BlueZ stops when every scanner has asked. */
48
+ export declare const startDiscovery: (domicile: {
49
+ readonly dbus: Pick<Dbus, "call">;
50
+ }, adapter: string) => Promise<Result<"done", SystemError>>;
51
+ export declare const stopDiscovery: (domicile: {
52
+ readonly dbus: Pick<Dbus, "call">;
53
+ }, adapter: string) => Promise<Result<"done", SystemError>>;
54
+ /** Connect a paired device's profiles. */
55
+ export declare const connect: (domicile: {
56
+ readonly dbus: Pick<Dbus, "call">;
57
+ }, device: string) => Promise<Result<"done", SystemError>>;
58
+ export declare const disconnect: (domicile: {
59
+ readonly dbus: Pick<Dbus, "call">;
60
+ }, device: string) => Promise<Result<"done", SystemError>>;
61
+ /**
62
+ * Pair with a device, then trust it so it can reconnect on its own. With no
63
+ * agent registered, BlueZ pairs only devices that need no code.
64
+ */
65
+ export declare const pair: (domicile: {
66
+ readonly dbus: Pick<Dbus, "call">;
67
+ }, device: string) => Promise<Result<"done", SystemError>>;
68
+ /** Remove a device and its pairing. */
69
+ export declare const forget: (domicile: {
70
+ readonly dbus: Pick<Dbus, "call">;
71
+ }, device: Pick<Device, "adapter" | "path">) => Promise<Result<"done", SystemError>>;
@@ -0,0 +1,213 @@
1
+ // BlueZ over the system bus: adapters and devices, kept current, and the
2
+ // requests that change them. See docs/SHELL-SYSTEM-ACCESS.md.
3
+ import { Err } from "@cprussin/option-result";
4
+ import { Bus, ListenedKind } from "@domicile-desktop/sdk/system";
5
+ import { z } from "zod";
6
+ const SERVICE = "org.bluez";
7
+ const ADAPTER = "org.bluez.Adapter1";
8
+ const DEVICE = "org.bluez.Device1";
9
+ const BATTERY = "org.bluez.Battery1";
10
+ /** The properties whose changes alter a {@link Bluetooth}, by interface. */
11
+ const WATCHED = {
12
+ [ADAPTER]: ["Discovering", "Powered"],
13
+ [BATTERY]: ["Percentage"],
14
+ [DEVICE]: ["Alias", "Connected", "Name", "Paired"],
15
+ };
16
+ /**
17
+ * Calls `onBluetooth` with the adapters and connected devices now and after
18
+ * each change, and returns a function that stops watching.
19
+ *
20
+ * An `Err` is a D-Bus failure, such as BlueZ not running. The watch keeps
21
+ * listening after one, so a later change reads again.
22
+ */
23
+ export const watchBluetooth = (domicile, onBluetooth) => {
24
+ const watch = { listening: undefined, stopped: false };
25
+ const report = (bluetooth) => {
26
+ if (!watch.stopped) {
27
+ onBluetooth(bluetooth);
28
+ }
29
+ };
30
+ follow(domicile, watch, report).catch((error) => {
31
+ // biome-ignore lint/suspicious/noConsole: surfacing a background failure
32
+ console.error("Failed to watch Bluetooth", error);
33
+ });
34
+ return () => {
35
+ watch.stopped = true;
36
+ watch.listening?.stop();
37
+ };
38
+ };
39
+ /** Turn the adapter at `adapter` on or off. */
40
+ export const setPowered = async (domicile, adapter, powered) => (await domicile.dbus.call({
41
+ body: [ADAPTER, "Powered", { signature: "b", value: powered }],
42
+ bus: Bus.System,
43
+ destination: SERVICE,
44
+ interface: "org.freedesktop.DBus.Properties",
45
+ member: "Set",
46
+ path: adapter,
47
+ signature: "ssv",
48
+ })).map(() => "set");
49
+ /** Start scanning for devices. BlueZ stops when every scanner has asked. */
50
+ export const startDiscovery = (domicile, adapter) => call(domicile, adapter, ADAPTER, "StartDiscovery");
51
+ export const stopDiscovery = (domicile, adapter) => call(domicile, adapter, ADAPTER, "StopDiscovery");
52
+ /** Connect a paired device's profiles. */
53
+ export const connect = (domicile, device) => call(domicile, device, DEVICE, "Connect");
54
+ export const disconnect = (domicile, device) => call(domicile, device, DEVICE, "Disconnect");
55
+ /**
56
+ * Pair with a device, then trust it so it can reconnect on its own. With no
57
+ * agent registered, BlueZ pairs only devices that need no code.
58
+ */
59
+ export const pair = async (domicile, device) => (await call(domicile, device, DEVICE, "Pair")).andThenAsync(async () => (await domicile.dbus.call({
60
+ body: [DEVICE, "Trusted", { signature: "b", value: true }],
61
+ bus: Bus.System,
62
+ destination: SERVICE,
63
+ interface: "org.freedesktop.DBus.Properties",
64
+ member: "Set",
65
+ path: device,
66
+ signature: "ssv",
67
+ })).map(() => "done"));
68
+ /** Remove a device and its pairing. */
69
+ export const forget = async (domicile, device) => (await domicile.dbus.call({
70
+ body: [device.path],
71
+ bus: Bus.System,
72
+ destination: SERVICE,
73
+ interface: ADAPTER,
74
+ member: "RemoveDevice",
75
+ path: device.adapter,
76
+ signature: "o",
77
+ })).map(() => "done");
78
+ /** A BlueZ method that takes no arguments. */
79
+ const call = async (domicile, path, iface, member) => (await domicile.dbus.call({
80
+ bus: Bus.System,
81
+ destination: SERVICE,
82
+ interface: iface,
83
+ member,
84
+ path,
85
+ })).map(() => "done");
86
+ /** Listen, read, then read again on each change until the match ends. */
87
+ const follow = async (domicile, watch, report) => {
88
+ const matched = await domicile.dbus.match({
89
+ bus: Bus.System,
90
+ sender: SERVICE,
91
+ });
92
+ await matched.match({
93
+ Err: (error) => {
94
+ report(Err(error));
95
+ return Promise.resolve();
96
+ },
97
+ Ok: async (listening) => {
98
+ watch.listening = listening;
99
+ if (watch.stopped) {
100
+ listening.stop();
101
+ }
102
+ await changes(domicile, listening, report);
103
+ const ended = await listening.ended;
104
+ ended.match({
105
+ Err: (error) => {
106
+ report(Err(error));
107
+ },
108
+ Ok: () => {
109
+ /* stopped by the caller */
110
+ },
111
+ });
112
+ },
113
+ });
114
+ };
115
+ /**
116
+ * Read now, and again on each signal that changes what was read and after a
117
+ * compositor restart.
118
+ */
119
+ const changes = async (domicile, listening, report) => {
120
+ const reader = listening.items.getReader();
121
+ report(await read(domicile));
122
+ for (let next = await reader.read(); !next.done; next = await reader.read()) {
123
+ if (next.value.kind === ListenedKind.Missed || matters(next.value.item)) {
124
+ report(await read(domicile));
125
+ }
126
+ }
127
+ };
128
+ /**
129
+ * Whether `signal` can change a {@link Bluetooth}: an object coming or going,
130
+ * or a watched property. Signal strength and the like change often during a
131
+ * scan and are skipped.
132
+ */
133
+ const matters = (signal) => {
134
+ switch (signal.member) {
135
+ case "InterfacesAdded":
136
+ case "InterfacesRemoved": {
137
+ return true;
138
+ }
139
+ case "PropertiesChanged": {
140
+ const [iface, changed] = propertiesChangedSchema.parse(signal.body);
141
+ return (WATCHED[iface] ?? []).some((name) => name in changed);
142
+ }
143
+ default: {
144
+ return false;
145
+ }
146
+ }
147
+ };
148
+ const read = async (domicile) => (await domicile.dbus.call({
149
+ bus: Bus.System,
150
+ destination: SERVICE,
151
+ interface: "org.freedesktop.DBus.ObjectManager",
152
+ member: "GetManagedObjects",
153
+ path: "/",
154
+ })).map(({ body }) => bluetoothOf(managedObjectsSchema.parse(body)[0]));
155
+ const bluetoothOf = (objects) => {
156
+ const entries = Object.entries(objects);
157
+ return {
158
+ adapters: entries.flatMap(([path, held]) => held[ADAPTER] === undefined
159
+ ? []
160
+ : [
161
+ {
162
+ discovering: held[ADAPTER].Discovering,
163
+ path,
164
+ powered: held[ADAPTER].Powered,
165
+ },
166
+ ]),
167
+ devices: entries.flatMap(([path, held]) => {
168
+ const device = held[DEVICE];
169
+ return device === undefined ||
170
+ (!device.Paired && device.Name === undefined)
171
+ ? []
172
+ : [
173
+ {
174
+ adapter: device.Adapter,
175
+ address: device.Address,
176
+ battery: held[BATTERY]?.Percentage,
177
+ connected: device.Connected,
178
+ name: device.Alias,
179
+ paired: device.Paired,
180
+ path,
181
+ },
182
+ ];
183
+ }),
184
+ };
185
+ };
186
+ /** A `v`, as `domicile_host::dbus_json` writes it, read as its value. */
187
+ const variant = (value) => z.object({ value }).transform(({ value: held }) => held);
188
+ const managedObjectsSchema = z.tuple([
189
+ z.record(z.string(), z.object({
190
+ [ADAPTER]: z
191
+ .object({
192
+ Discovering: variant(z.boolean()),
193
+ Powered: variant(z.boolean()),
194
+ })
195
+ .optional(),
196
+ [BATTERY]: z.object({ Percentage: variant(z.number()) }).optional(),
197
+ [DEVICE]: z
198
+ .object({
199
+ Adapter: variant(z.string()),
200
+ Address: variant(z.string()),
201
+ Alias: variant(z.string()),
202
+ Connected: variant(z.boolean()),
203
+ Name: variant(z.string()).optional(),
204
+ Paired: variant(z.boolean()),
205
+ })
206
+ .optional(),
207
+ })),
208
+ ]);
209
+ const propertiesChangedSchema = z.tuple([
210
+ z.string(),
211
+ z.record(z.string(), z.unknown()),
212
+ z.array(z.string()),
213
+ ]);
@@ -0,0 +1,13 @@
1
+ import type { Result } from "@cprussin/option-result";
2
+ import type { Files } from "@domicile-desktop/sdk/desktop/files";
3
+ import type { SystemError } from "@domicile-desktop/sdk/system";
4
+ /** The calls the check makes. Each works while the desktop is locked. */
5
+ export type SysfsDesktop = {
6
+ readonly files: Pick<Files, "readDir" | "readText">;
7
+ };
8
+ /**
9
+ * Whether there is a Bluetooth controller, or an rfkill switch for one. A
10
+ * radio rfkill blocks can take its controller away with it, and its switch
11
+ * stays.
12
+ */
13
+ export declare const hasBluetoothHardware: (domicile: SysfsDesktop) => Promise<Result<boolean, SystemError>>;
@@ -0,0 +1,44 @@
1
+ // Whether the machine has Bluetooth hardware, from /sys, whether or not BlueZ
2
+ // runs or rfkill has turned the radio off.
3
+ import { Err, None, Ok, Some } from "@cprussin/option-result";
4
+ import { SystemErrorKind } from "@domicile-desktop/sdk/system";
5
+ /**
6
+ * Whether there is a Bluetooth controller, or an rfkill switch for one. A
7
+ * radio rfkill blocks can take its controller away with it, and its switch
8
+ * stays.
9
+ */
10
+ export const hasBluetoothHardware = async (domicile) => (await entriesOf(domicile, "/sys/class/bluetooth")).match({
11
+ Err: (error) => Promise.resolve(Err(error)),
12
+ Ok: async (controllers) => controllers.length > 0
13
+ ? Ok(true)
14
+ : (await entriesOf(domicile, "/sys/class/rfkill")).match({
15
+ Err: (error) => Promise.resolve(Err(error)),
16
+ Ok: (switches) => anyOf(switches, async (name) => (await lineOf(domicile, `/sys/class/rfkill/${name}/type`)).map((type) => type.match({
17
+ None: () => false,
18
+ Some: (is) => is === "bluetooth",
19
+ }))),
20
+ }),
21
+ });
22
+ /** The names in `dir`; none when it does not exist, as when no driver made it. */
23
+ const entriesOf = async (domicile, dir) => (await domicile.files.readDir(dir)).match({
24
+ Err: (error) => error.kind === SystemErrorKind.NotFound ? Ok([]) : Err(error),
25
+ Ok: (entries) => Ok(entries.map(({ name }) => name)),
26
+ });
27
+ /** Whether `test` holds for any of `names`, read one at a time. */
28
+ const anyOf = async (names, test) => {
29
+ const [first, ...rest] = names;
30
+ if (first === undefined) {
31
+ return Ok(false);
32
+ }
33
+ else {
34
+ return (await test(first)).match({
35
+ Err: (error) => Promise.resolve(Err(error)),
36
+ Ok: (found) => (found ? Promise.resolve(Ok(true)) : anyOf(rest, test)),
37
+ });
38
+ }
39
+ };
40
+ /** A one-line file under `/sys`, without its newline; `None` when missing. */
41
+ const lineOf = async (domicile, path) => (await domicile.files.readText(path)).match({
42
+ Err: (error) => error.kind === SystemErrorKind.NotFound ? Ok(None()) : Err(error),
43
+ Ok: (text) => Ok(Some(text.trim())),
44
+ });
@@ -0,0 +1,12 @@
1
+ import type { Result } from "@cprussin/option-result";
2
+ import type { SharedWatch } from "@domicile-desktop/react/shared-watch";
3
+ import type { SystemError } from "@domicile-desktop/sdk/system";
4
+ import type { Bluetooth } from "./bluetooth";
5
+ /** BlueZ, watched once per desktop. */
6
+ export declare const deskBluetooth: (domicile: import("@domicile-desktop/sdk/desktop/desktop").Domicile) => SharedWatch<Result<Bluetooth, SystemError>>;
7
+ /** Whether the machine has Bluetooth hardware, looked for once per desktop. */
8
+ export declare const deskBluetoothHardware: (domicile: import("@domicile-desktop/sdk/desktop/desktop").Domicile) => SharedWatch<Result<boolean, SystemError>>;
9
+ /** BlueZ's adapter and devices, or `undefined` before BlueZ says. */
10
+ export declare const useBluetooth: () => Result<Bluetooth, SystemError> | undefined;
11
+ /** Whether the machine has Bluetooth hardware, or `undefined` before it was looked for. */
12
+ export declare const useHasBluetooth: () => Result<boolean, SystemError> | undefined;
package/dist/react.js ADDED
@@ -0,0 +1,16 @@
1
+ // Bluetooth for a React shell: one watch per desktop, however many parts
2
+ // read it.
3
+ import { perDesktop } from "@domicile-desktop/react/per-desktop";
4
+ import { sharedWatch } from "@domicile-desktop/react/shared-watch";
5
+ import { useDeskWatch } from "@domicile-desktop/react/use-shared-watch";
6
+ import { watchPresence } from "@domicile-desktop/react/watch-presence";
7
+ import { watchBluetooth } from "./bluetooth";
8
+ import { hasBluetoothHardware } from "./hardware";
9
+ /** BlueZ, watched once per desktop. */
10
+ export const deskBluetooth = perDesktop((domicile) => sharedWatch((onBluetooth) => watchBluetooth(domicile, onBluetooth)));
11
+ /** Whether the machine has Bluetooth hardware, looked for once per desktop. */
12
+ export const deskBluetoothHardware = perDesktop((domicile) => sharedWatch((onPresent) => watchPresence(() => hasBluetoothHardware(domicile), onPresent)));
13
+ /** BlueZ's adapter and devices, or `undefined` before BlueZ says. */
14
+ export const useBluetooth = () => useDeskWatch(deskBluetooth);
15
+ /** Whether the machine has Bluetooth hardware, or `undefined` before it was looked for. */
16
+ export const useHasBluetooth = () => useDeskWatch(deskBluetoothHardware);
package/package.json CHANGED
@@ -1,6 +1,59 @@
1
1
  {
2
+ "dependencies": {
3
+ "@cprussin/option-result": "^2.0.1",
4
+ "@domicile-desktop/react": "0.0.0",
5
+ "@domicile-desktop/sdk": "1.0.0",
6
+ "zod": "^4.5.4"
7
+ },
8
+ "description": "BlueZ for a Domicile shell: whether each adapter is powered and which devices are connected, kept current, and turning adapters on and off.",
9
+ "devDependencies": {
10
+ "@cprussin/tsconfig": "^5.0.0",
11
+ "@domicile-desktop/test-support": "0.0.1",
12
+ "@types/bun": "^1.4.2",
13
+ "@types/react": "^19.2.18",
14
+ "react": "^19.2.8",
15
+ "typescript": "^7.0.2"
16
+ },
17
+ "engines": {
18
+ "bun": ">=1.4.2",
19
+ "node": ">=24"
20
+ },
21
+ "exports": {
22
+ "./bluetooth": {
23
+ "types": "./dist/bluetooth.d.ts",
24
+ "default": "./dist/bluetooth.js"
25
+ },
26
+ "./hardware": {
27
+ "types": "./dist/hardware.d.ts",
28
+ "default": "./dist/hardware.js"
29
+ },
30
+ "./react": {
31
+ "types": "./dist/react.d.ts",
32
+ "default": "./dist/react.js"
33
+ }
34
+ },
35
+ "files": [
36
+ "dist/**"
37
+ ],
38
+ "license": "MIT",
2
39
  "name": "@domicile-desktop/system-bluetooth",
3
- "version": "0.0.0-stage",
4
- "stub": true,
5
- "description": "Temporary package placeholder for staged publishing"
6
- }
40
+ "peerDependencies": {
41
+ "react": "^19.2.8"
42
+ },
43
+ "private": false,
44
+ "publishConfig": {
45
+ "access": "public"
46
+ },
47
+ "repository": {
48
+ "directory": "packages/system-bluetooth",
49
+ "type": "git",
50
+ "url": "git+https://github.com/cprussin/domicile.git"
51
+ },
52
+ "scripts": {
53
+ "build": "tsc -p tsconfig.build.json",
54
+ "test:types": "tsc --noEmit",
55
+ "test:unit": "bun test"
56
+ },
57
+ "type": "module",
58
+ "version": "1.0.0"
59
+ }