@party-stack/node-runtime 0.3.1 → 0.4.0

package/README.md

@@ -0,0 +1,32 @@
+# Node runtime
+
+`make`, `layer`, and `createNodeRuntime(owner, namespace)` acquire a scoped Effect
+`Runtime` backed by SQLite, filesystem bytes, browser authentication, and the native
+OS keyring. `createNodeRuntimeWithOptions({ dataDirectory })` returns the same
+Effect-based provider with a configured data directory.
+
+```ts
+import * as NodeRuntime from "@party-stack/node-runtime";
+import { Runtime } from "@party-stack/runtime";
+import { Effect } from "effect";
+
+const program = Effect.gen(function* () {
+    const runtime = yield* Runtime;
+    yield* runtime.bytes.write("example", new Blob(["hello"]));
+    yield* Effect.never;
+});
+
+Effect.runFork(program.pipe(Effect.provide(NodeRuntime.layer({ owner: "user", namespace: "app" }))));
+```
+
+Defining a Layer opens nothing. Building it opens SQLite; completion, failure or
+interruption closes the database. Platform runtimes have no Promise factory or
+manual cleanup method. An application's outer Effect or ManagedRuntime owns them.
+Installations accept these Effect-based providers directly.
+
+Native credentials and device encryption keys use `@party-stack/effect-node-keyring`.
+The native module is loaded lazily on first credential/key access. Keys stay outside
+SQLite, and cached decrypted property values remain encrypted on device. The native
+keyring must be available; there is no CLI, plaintext-file or volatile fallback.
+No biometric/session-unlock policy is implied. See the keyring package for Linux
+Secret Service requirements.

package/lib/NodeFileSystemBlobBytesStore.d.ts

@@ -1,15 +1,16 @@
-import { BlobBytesStore } from "@party-stack/runtime";
+import { BlobBytesService, ByteInput, ByteSource } from "@party-stack/runtime";
+import { Effect } from "effect";
 //#region src/NodeFileSystemBlobBytesStore.d.ts
 export interface NodeFileSystemBlobBytesStoreOptions {
   directory: string;
 }
-export declare class NodeFileSystemBlobBytesStore implements BlobBytesStore {
+export declare class NodeFileSystemBlobBytesStore implements BlobBytesService {
   #private;
+  readonly write: (id: string, value: ByteInput) => Effect.Effect<void, unknown, never>;
+  readonly read: (id: string) => Effect.Effect<ByteSource | undefined, import("effect/Cause").UnknownError, never>;
+  readonly delete: (id: string) => Effect.Effect<void, import("effect/Cause").UnknownError, never>;
+  readonly clear: () => Effect.Effect<void, import("effect/Cause").UnknownError, never>;
   constructor(options: NodeFileSystemBlobBytesStoreOptions);
-  write(id: string, blob: Blob): Promise<void>;
-  read(id: string): Promise<Blob>;
-  delete(id: string): Promise<void>;
-  clear(): Promise<void>;
 }
 //#endregion
 //# sourceMappingURL=NodeFileSystemBlobBytesStore.d.ts.map

package/lib/NodeFileSystemBlobBytesStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeFileSystemBlobBytesStore.d.ts","names":[],"sources":["../src/NodeFileSystemBlobBytesStore.ts"],"mappings":";;iBAKiB;EACb;;qBAOS,wCAAwC;;EAGjD,YAAY,SAAS;EAIf,MAAM,YAAY,MAAM,OAAO;EAY/B,KAAK,aAAa,QAAQ;EAa1B,OAAO,aAAa;EAIpB,SAAS"}
+{"version":3,"file":"NodeFileSystemBlobBytesStore.d.ts","names":[],"sources":["../src/NodeFileSystemBlobBytesStore.ts"],"mappings":";;;iBAeiB;EACb;;qBAOS,wCAAwC;;WAGxC,QAAK,YAAc,OAAS,cAAS,OAAA;WACrC,OAAI,eAAc,OAAA,OAAA,+CAAA;WAIlB,SAAM,eAAc,OAAA,oCAAA;WACpB,aAAK,OAAA,oCAAA;EAEd,YAAY,SAAS"}

package/lib/NodeFileSystemBlobBytesStore.js

@@ -1,38 +1,53 @@
 import { createHash, randomUUID } from "node:crypto";
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { createReadStream, createWriteStream } from "node:fs";
+import { mkdir, rename, rm, stat } from "node:fs/promises";
 import { join } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { byteIO, byteSource } from "@party-stack/runtime";
+import { Effect, Stream } from "effect";
 //#region src/NodeFileSystemBlobBytesStore.ts
 function fileName(id) {
 	return createHash("sha256").update(id).digest("hex");
 }
 var NodeFileSystemBlobBytesStore = class {
 	#directory;
+	write = (id, value) => byteIO((signal) => this.#write(id, value, signal));
+	read = (id) => Effect.tryPromise(() => this.#read(id)).pipe(Effect.map((value) => value === void 0 ? void 0 : byteSource(value)));
+	delete = (id) => Effect.tryPromise(() => this.#delete(id));
+	clear = () => Effect.tryPromise(() => this.#clear());
 	constructor(options) {
 		this.#directory = options.directory;
 	}
-	async write(id, blob) {
+	async #write(id, input, signal) {
 		await mkdir(this.#directory, { recursive: true });
 		const target = this.#path(id);
 		const temporary = join(this.#directory, `.${fileName(id)}.${randomUUID()}.tmp`);
 		try {
-			await writeFile(temporary, new Uint8Array(await blob.arrayBuffer()));
+			await pipeline(Readable.from(Stream.toAsyncIterable(byteSource(input).stream)), createWriteStream(temporary), { signal });
+			signal?.throwIfAborted();
 			await rename(temporary, target);
 		} finally {
 			await rm(temporary, { force: true });
 		}
 	}
-	async read(id) {
+	async #read(id) {
 		try {
-			return new Blob([await readFile(this.#path(id))]);
+			const path = this.#path(id);
+			return {
+				size: (await stat(path)).size,
+				type: "application/octet-stream",
+				stream: Stream.suspend(() => Stream.fromAsyncIterable(createReadStream(path), (cause) => cause))
+			};
 		} catch (error) {
-			if (error instanceof Error && "code" in error && error.code === "ENOENT") throw new Error(`Blob bytes not found for "${id}".`, { cause: error });
+			if (error instanceof Error && "code" in error && error.code === "ENOENT") return;
 			throw error;
 		}
 	}
-	async delete(id) {
+	async #delete(id) {
 		await rm(this.#path(id), { force: true });
 	}
-	async clear() {
+	async #clear() {
 		await rm(this.#directory, {
 			recursive: true,
 			force: true

package/lib/NodeFileSystemBlobBytesStore.js.map

@@ -1 +1 @@
-{"version":3,"file":"NodeFileSystemBlobBytesStore.js","names":[],"sources":["../src/NodeFileSystemBlobBytesStore.ts"],"sourcesContent":["import { createHash, randomUUID } from \"node:crypto\";\nimport { mkdir, readFile, rename, rm, writeFile } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport type { BlobBytesStore } from \"@party-stack/runtime\";\n\nexport interface NodeFileSystemBlobBytesStoreOptions {\n    directory: string;\n}\n\nfunction fileName(id: string): string {\n    return createHash(\"sha256\").update(id).digest(\"hex\");\n}\n\nexport class NodeFileSystemBlobBytesStore implements BlobBytesStore {\n    readonly #directory: string;\n\n    constructor(options: NodeFileSystemBlobBytesStoreOptions) {\n        this.#directory = options.directory;\n    }\n\n    async write(id: string, blob: Blob): Promise<void> {\n        await mkdir(this.#directory, { recursive: true });\n        const target = this.#path(id);\n        const temporary = join(this.#directory, `.${fileName(id)}.${randomUUID()}.tmp`);\n        try {\n            await writeFile(temporary, new Uint8Array(await blob.arrayBuffer()));\n            await rename(temporary, target);\n        } finally {\n            await rm(temporary, { force: true });\n        }\n    }\n\n    async read(id: string): Promise<Blob> {\n        try {\n            return new Blob([await readFile(this.#path(id))]);\n        } catch (error) {\n            if (error instanceof Error && \"code\" in error && error.code === \"ENOENT\") {\n                throw new Error(`Blob bytes not found for \"${id}\".`, {\n                    cause: error,\n                });\n            }\n            throw error;\n        }\n    }\n\n    async delete(id: string): Promise<void> {\n        await rm(this.#path(id), { force: true });\n    }\n\n    async clear(): Promise<void> {\n        await rm(this.#directory, { recursive: true, force: true });\n    }\n\n    #path(id: string): string {\n        return join(this.#directory, fileName(id));\n    }\n}\n"],"mappings":";;;;AASA,SAAS,SAAS,IAAoB;CAClC,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,OAAO,KAAK;AACvD;AAEA,IAAa,+BAAb,MAAoE;CAChE;CAEA,YAAY,SAA8C;EACtD,KAAK,aAAa,QAAQ;CAC9B;CAEA,MAAM,MAAM,IAAY,MAA2B;EAC/C,MAAM,MAAM,KAAK,YAAY,EAAE,WAAW,KAAK,CAAC;EAChD,MAAM,SAAS,KAAK,MAAM,EAAE;EAC5B,MAAM,YAAY,KAAK,KAAK,YAAY,IAAI,SAAS,EAAE,EAAE,GAAG,WAAW,EAAE,KAAK;EAC9E,IAAI;GACA,MAAM,UAAU,WAAW,IAAI,WAAW,MAAM,KAAK,YAAY,CAAC,CAAC;GACnE,MAAM,OAAO,WAAW,MAAM;EAClC,UAAU;GACN,MAAM,GAAG,WAAW,EAAE,OAAO,KAAK,CAAC;EACvC;CACJ;CAEA,MAAM,KAAK,IAA2B;EAClC,IAAI;GACA,OAAO,IAAI,KAAK,CAAC,MAAM,SAAS,KAAK,MAAM,EAAE,CAAC,CAAC,CAAC;EACpD,SAAS,OAAO;GACZ,IAAI,iBAAiB,SAAS,UAAU,SAAS,MAAM,SAAS,UAC5D,MAAM,IAAI,MAAM,6BAA6B,GAAG,KAAK,EACjD,OAAO,MACX,CAAC;GAEL,MAAM;EACV;CACJ;CAEA,MAAM,OAAO,IAA2B;EACpC,MAAM,GAAG,KAAK,MAAM,EAAE,GAAG,EAAE,OAAO,KAAK,CAAC;CAC5C;CAEA,MAAM,QAAuB;EACzB,MAAM,GAAG,KAAK,YAAY;GAAE,WAAW;GAAM,OAAO;EAAK,CAAC;CAC9D;CAEA,MAAM,IAAoB;EACtB,OAAO,KAAK,KAAK,YAAY,SAAS,EAAE,CAAC;CAC7C;AACJ"}
+{"version":3,"file":"NodeFileSystemBlobBytesStore.js","names":[],"sources":["../src/NodeFileSystemBlobBytesStore.ts"],"sourcesContent":["import { createHash, randomUUID } from \"node:crypto\";\nimport { createReadStream, createWriteStream } from \"node:fs\";\nimport { mkdir, stat, rename, rm } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport { Readable } from \"node:stream\";\nimport { pipeline } from \"node:stream/promises\";\nimport {\n    byteSource,\n    type ByteInput,\n    type ByteSource,\n    byteIO,\n    type BlobBytesService,\n} from \"@party-stack/runtime\";\nimport { Effect, Stream } from \"effect\";\n\nexport interface NodeFileSystemBlobBytesStoreOptions {\n    directory: string;\n}\n\nfunction fileName(id: string): string {\n    return createHash(\"sha256\").update(id).digest(\"hex\");\n}\n\nexport class NodeFileSystemBlobBytesStore implements BlobBytesService {\n    readonly #directory: string;\n\n    readonly write = (id: string, value: ByteInput) => byteIO((signal) => this.#write(id, value, signal));\n    readonly read = (id: string) =>\n        Effect.tryPromise(() => this.#read(id)).pipe(\n            Effect.map((value) => (value === undefined ? undefined : byteSource(value)))\n        );\n    readonly delete = (id: string) => Effect.tryPromise(() => this.#delete(id));\n    readonly clear = () => Effect.tryPromise(() => this.#clear());\n\n    constructor(options: NodeFileSystemBlobBytesStoreOptions) {\n        this.#directory = options.directory;\n    }\n\n    async #write(id: string, input: ByteInput, signal?: AbortSignal): Promise<void> {\n        await mkdir(this.#directory, { recursive: true });\n        const target = this.#path(id);\n        const temporary = join(this.#directory, `.${fileName(id)}.${randomUUID()}.tmp`);\n        try {\n            await pipeline(\n                Readable.from(Stream.toAsyncIterable(byteSource(input).stream)),\n                createWriteStream(temporary),\n                { signal }\n            );\n            signal?.throwIfAborted();\n            await rename(temporary, target);\n        } finally {\n            await rm(temporary, { force: true });\n        }\n    }\n\n    async #read(id: string): Promise<ByteSource | undefined> {\n        try {\n            const path = this.#path(id);\n            const info = await stat(path);\n            return {\n                size: info.size,\n                type: \"application/octet-stream\",\n                stream: Stream.suspend(() =>\n                    Stream.fromAsyncIterable(createReadStream(path), (cause) => cause)\n                ),\n            };\n        } catch (error) {\n            if (error instanceof Error && \"code\" in error && error.code === \"ENOENT\") {\n                return undefined;\n            }\n            throw error;\n        }\n    }\n\n    async #delete(id: string): Promise<void> {\n        await rm(this.#path(id), { force: true });\n    }\n\n    async #clear(): Promise<void> {\n        await rm(this.#directory, { recursive: true, force: true });\n    }\n\n    #path(id: string): string {\n        return join(this.#directory, fileName(id));\n    }\n}\n"],"mappings":";;;;;;;;;AAmBA,SAAS,SAAS,IAAoB;CAClC,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,OAAO,KAAK;AACvD;AAEA,IAAa,+BAAb,MAAsE;CAClE;CAEA,SAAkB,IAAY,UAAqB,QAAQ,WAAW,KAAK,OAAO,IAAI,OAAO,MAAM,CAAC;CACpG,QAAiB,OACb,OAAO,iBAAiB,KAAK,MAAM,EAAE,CAAC,CAAC,CAAC,KACpC,OAAO,KAAK,UAAW,UAAU,KAAA,IAAY,KAAA,IAAY,WAAW,KAAK,CAAE,CAC/E;CACJ,UAAmB,OAAe,OAAO,iBAAiB,KAAK,QAAQ,EAAE,CAAC;CAC1E,cAAuB,OAAO,iBAAiB,KAAK,OAAO,CAAC;CAE5D,YAAY,SAA8C;EACtD,KAAK,aAAa,QAAQ;CAC9B;CAEA,MAAM,OAAO,IAAY,OAAkB,QAAqC;EAC5E,MAAM,MAAM,KAAK,YAAY,EAAE,WAAW,KAAK,CAAC;EAChD,MAAM,SAAS,KAAK,MAAM,EAAE;EAC5B,MAAM,YAAY,KAAK,KAAK,YAAY,IAAI,SAAS,EAAE,EAAE,GAAG,WAAW,EAAE,KAAK;EAC9E,IAAI;GACA,MAAM,SACF,SAAS,KAAK,OAAO,gBAAgB,WAAW,KAAK,CAAC,CAAC,MAAM,CAAC,GAC9D,kBAAkB,SAAS,GAC3B,EAAE,OAAO,CACb;GACA,QAAQ,eAAe;GACvB,MAAM,OAAO,WAAW,MAAM;EAClC,UAAU;GACN,MAAM,GAAG,WAAW,EAAE,OAAO,KAAK,CAAC;EACvC;CACJ;CAEA,MAAM,MAAM,IAA6C;EACrD,IAAI;GACA,MAAM,OAAO,KAAK,MAAM,EAAE;GAE1B,OAAO;IACH,OAAM,MAFS,KAAK,IAAI,EAAA,CAEb;IACX,MAAM;IACN,QAAQ,OAAO,cACX,OAAO,kBAAkB,iBAAiB,IAAI,IAAI,UAAU,KAAK,CACrE;GACJ;EACJ,SAAS,OAAO;GACZ,IAAI,iBAAiB,SAAS,UAAU,SAAS,MAAM,SAAS,UAC5D;GAEJ,MAAM;EACV;CACJ;CAEA,MAAM,QAAQ,IAA2B;EACrC,MAAM,GAAG,KAAK,MAAM,EAAE,GAAG,EAAE,OAAO,KAAK,CAAC;CAC5C;CAEA,MAAM,SAAwB;EAC1B,MAAM,GAAG,KAAK,YAAY;GAAE,WAAW;GAAM,OAAO;EAAK,CAAC;CAC9D;CAEA,MAAM,IAAoB;EACtB,OAAO,KAAK,KAAK,YAAY,SAAS,EAAE,CAAC;CAC7C;AACJ"}

package/lib/NodeKeyMaterialStore.d.ts

@@ -0,0 +1,14 @@
+import { RuntimeError } from "@party-stack/runtime";
+import { Effect } from "effect";
+//#region src/NodeKeyMaterialStore.d.ts
+export interface NodeKeyMaterialStoreOptions {
+  service: string;
+}
+/** The native service is loaded on first use, once per scoped runtime. */
+export declare const makeKeyMaterialStore: (options: NodeKeyMaterialStoreOptions) => Effect.Effect<{
+  get: (key: string) => Effect.Effect<string | undefined, RuntimeError, never>;
+  set: (key: string, value: string) => Effect.Effect<void, RuntimeError, never>;
+  delete: (key: string) => Effect.Effect<void, RuntimeError, never>;
+}, never, never>;
+//#endregion
+//# sourceMappingURL=NodeKeyMaterialStore.d.ts.map

package/lib/NodeKeyMaterialStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeKeyMaterialStore.d.ts","names":[],"sources":["../src/NodeKeyMaterialStore.ts"],"mappings":";;;iBAKiB;EACb;;;qBAOS,uBAAoB,SAAA,gCAAA,OAAA"}

package/lib/NodeKeyMaterialStore.js

@@ -0,0 +1,29 @@
+import { createHash } from "node:crypto";
+import { RuntimeError } from "@party-stack/runtime";
+import { Effect, Redacted } from "effect";
+import { make } from "@party-stack/effect-node-keyring";
+//#region src/NodeKeyMaterialStore.ts
+function encodeIdentifier(value) {
+	return `party-stack.${createHash("sha256").update(value).digest("hex")}`;
+}
+/** The native service is loaded on first use, once per scoped runtime. */
+const makeKeyMaterialStore = Effect.fnUntraced(function* (options) {
+	const service = encodeIdentifier(options.service);
+	const keyring = yield* Effect.cached(make.pipe(Effect.mapError(() => new RuntimeError({
+		operation: "secrets.open",
+		cause: /* @__PURE__ */ new Error("Native keyring unavailable.")
+	}))));
+	const operation = (effect) => effect.pipe(Effect.mapError(() => new RuntimeError({
+		operation: "secrets",
+		cause: /* @__PURE__ */ new Error("Native credential operation failed.")
+	})));
+	return {
+		get: (key) => operation(Effect.flatMap(keyring, (native) => native.getPassword(service, encodeIdentifier(key)))).pipe(Effect.map((value) => value === void 0 ? void 0 : Redacted.value(value))),
+		set: (key, value) => operation(Effect.flatMap(keyring, (native) => native.setPassword(service, encodeIdentifier(key), Redacted.make(value)))),
+		delete: (key) => operation(Effect.flatMap(keyring, (native) => native.deleteCredential(service, encodeIdentifier(key)))).pipe(Effect.asVoid)
+	};
+});
+//#endregion
+export { makeKeyMaterialStore };
+
+//# sourceMappingURL=NodeKeyMaterialStore.js.map

package/lib/NodeKeyMaterialStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeKeyMaterialStore.js","names":["makeNodeKeyring"],"sources":["../src/NodeKeyMaterialStore.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { make as makeNodeKeyring } from \"@party-stack/effect-node-keyring\";\nimport { RuntimeError, type KeyMaterialStore } from \"@party-stack/runtime\";\nimport { Effect, Redacted } from \"effect\";\n\nexport interface NodeKeyMaterialStoreOptions {\n    service: string;\n}\nfunction encodeIdentifier(value: string): string {\n    return `party-stack.${createHash(\"sha256\").update(value).digest(\"hex\")}`;\n}\n\n/** The native service is loaded on first use, once per scoped runtime. */\nexport const makeKeyMaterialStore = Effect.fnUntraced(function* (options: NodeKeyMaterialStoreOptions) {\n    const service = encodeIdentifier(options.service);\n    const keyring = yield* Effect.cached(\n        makeNodeKeyring.pipe(\n            Effect.mapError(\n                () =>\n                    new RuntimeError({\n                        operation: \"secrets.open\",\n                        cause: new Error(\"Native keyring unavailable.\"),\n                    })\n            )\n        )\n    );\n    const operation = <A>(effect: Effect.Effect<A, unknown>) =>\n        effect.pipe(\n            Effect.mapError(\n                () =>\n                    new RuntimeError({\n                        operation: \"secrets\",\n                        cause: new Error(\"Native credential operation failed.\"),\n                    })\n            )\n        );\n    return {\n        get: (key) =>\n            operation(\n                Effect.flatMap(keyring, (native) => native.getPassword(service, encodeIdentifier(key)))\n            ).pipe(Effect.map((value) => (value === undefined ? undefined : Redacted.value(value)))),\n        set: (key, value) =>\n            operation(\n                Effect.flatMap(keyring, (native) =>\n                    native.setPassword(service, encodeIdentifier(key), Redacted.make(value))\n                )\n            ),\n        delete: (key) =>\n            operation(\n                Effect.flatMap(keyring, (native) => native.deleteCredential(service, encodeIdentifier(key)))\n            ).pipe(Effect.asVoid),\n    } satisfies KeyMaterialStore;\n});\n"],"mappings":";;;;;AAQA,SAAS,iBAAiB,OAAuB;CAC7C,OAAO,eAAe,WAAW,QAAQ,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,OAAO,KAAK;AACzE;;AAGA,MAAa,uBAAuB,OAAO,WAAW,WAAW,SAAsC;CACnG,MAAM,UAAU,iBAAiB,QAAQ,OAAO;CAChD,MAAM,UAAU,OAAO,OAAO,OAC1BA,KAAgB,KACZ,OAAO,eAEC,IAAI,aAAa;EACb,WAAW;EACX,uBAAO,IAAI,MAAM,6BAA6B;CAClD,CAAC,CACT,CACJ,CACJ;CACA,MAAM,aAAgB,WAClB,OAAO,KACH,OAAO,eAEC,IAAI,aAAa;EACb,WAAW;EACX,uBAAO,IAAI,MAAM,qCAAqC;CAC1D,CAAC,CACT,CACJ;CACJ,OAAO;EACH,MAAM,QACF,UACI,OAAO,QAAQ,UAAU,WAAW,OAAO,YAAY,SAAS,iBAAiB,GAAG,CAAC,CAAC,CAC1F,CAAC,CAAC,KAAK,OAAO,KAAK,UAAW,UAAU,KAAA,IAAY,KAAA,IAAY,SAAS,MAAM,KAAK,CAAE,CAAC;EAC3F,MAAM,KAAK,UACP,UACI,OAAO,QAAQ,UAAU,WACrB,OAAO,YAAY,SAAS,iBAAiB,GAAG,GAAG,SAAS,KAAK,KAAK,CAAC,CAC3E,CACJ;EACJ,SAAS,QACL,UACI,OAAO,QAAQ,UAAU,WAAW,OAAO,iBAAiB,SAAS,iBAAiB,GAAG,CAAC,CAAC,CAC/F,CAAC,CAAC,KAAK,OAAO,MAAM;CAC5B;AACJ,CAAC"}

package/lib/createNodeBrowserAuthentication.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createNodeBrowserAuthentication.d.ts","names":[],"sources":["../src/createNodeBrowserAuthentication.ts"],"mappings":";;iBASiB;EACb,WAAW,gBAAgB;EAC3B;;wBAuBY,gCACZ,UAAS,yCACV"}
+{"version":3,"file":"createNodeBrowserAuthentication.d.ts","names":[],"sources":["../src/createNodeBrowserAuthentication.ts"],"mappings":";;iBAQiB;EACb,WAAW,gBAAgB;EAC3B;;wBAGY,gCACZ,UAAS,yCACV"}

package/lib/createNodeBrowserAuthentication.js

@@ -1,105 +1,128 @@
+import { BrowserAuthenticationError } from "@party-stack/runtime";
+import { Effect } from "effect";
 import { serve } from "@hono/node-server";
-import { BrowserAuthenticationCancelledError } from "@party-stack/runtime";
 import { Hono } from "hono";
 import open from "open";
 //#region src/createNodeBrowserAuthentication.ts
-const DEFAULT_TIMEOUT_MS = 3e5;
 const LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
 	"localhost",
 	"127.0.0.1",
 	"::1",
 	"[::1]"
 ]);
-function closeServer(server) {
-	if (!server?.listening) return Promise.resolve();
-	return new Promise((resolve, reject) => {
-		server.close((error) => {
-			if (error) reject(error);
-			else resolve();
-		});
-	});
-}
-function validateRedirectUrl(redirectUrl) {
-	const url = new URL(redirectUrl);
-	if (url.protocol !== "http:" || !LOOPBACK_HOSTS.has(url.hostname) || !url.port) throw new Error("Node browser authentication requires an http:// loopback redirect URL with an explicit port.");
-	return url;
-}
 function createNodeBrowserAuthentication(options = {}) {
 	const openUrl = options.openUrl ?? ((url) => open(url));
-	const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-	return { start({ redirectUrl }) {
-		const redirect = validateRedirectUrl(redirectUrl);
+	return { start: Effect.fnUntraced(function* ({ redirectUrl }) {
+		const redirect = yield* Effect.try({
+			try: () => {
+				const url = new URL(redirectUrl);
+				if (url.protocol !== "http:" || !LOOPBACK_HOSTS.has(url.hostname) || !url.port) throw new Error("Node browser authentication requires an http:// loopback redirect URL with an explicit port.");
+				return url;
+			},
+			catch: (cause) => new BrowserAuthenticationError({
+				reason: "Configuration",
+				message: cause instanceof Error ? cause.message : "Invalid redirect URL.",
+				cause
+			})
+		});
 		let server;
-		let rejectPending;
-		let timer;
-		let settled = false;
-		const finish = async () => {
-			if (timer) clearTimeout(timer);
-			timer = void 0;
-			rejectPending = void 0;
-			await closeServer(server);
-			server = void 0;
-		};
-		return {
-			open(authorizationUrl) {
-				if (server || settled) return Promise.reject(/* @__PURE__ */ new Error("This browser authentication session has already been used."));
-				return new Promise((resolve, reject) => {
-					rejectPending = reject;
-					const app = new Hono();
-					app.get(redirect.pathname, (context) => {
-						if (settled) return context.text("Authentication session is already complete.", 409);
-						settled = true;
-						const callbackUrl = context.req.url;
-						setImmediate(() => {
-							finish().then(() => resolve({ callbackUrl }), reject);
-						});
-						return context.html(`<!doctype html>
-<html lang="en">
-<head><meta charset="utf-8"><title>Authentication complete</title></head>
-<body>
-<p>Authentication complete. Returning to the terminal…</p>
-<script>window.close()<\/script>
-</body>
-</html>`);
-					});
+		let closing;
+		let listenFailed = false;
+		let cancel;
+		let used = false;
+		let closed = false;
+		const closeServer = () => closing ??= new Promise((resolve, reject) => {
+			if (!server || listenFailed) {
+				resolve();
+				return;
+			}
+			const active = server;
+			const stop = () => {
+				active.removeListener("error", failed);
+				active.close((error) => error ? reject(error) : resolve());
+				active.closeAllConnections();
+			};
+			const failed = () => {
+				active.removeListener("listening", stop);
+				resolve();
+			};
+			if (active.listening) stop();
+			else {
+				active.once("listening", stop);
+				active.once("error", failed);
+			}
+		});
+		yield* Effect.addFinalizer(() => Effect.sync(() => {
+			closed = true;
+			cancel?.();
+		}).pipe(Effect.andThen(Effect.promise(closeServer))));
+		return { open: (authorizationUrl) => Effect.suspend(() => {
+			if (used || closed) return Effect.fail(new BrowserAuthenticationError({
+				reason: "Configuration",
+				message: "This authentication session has already been used or closed."
+			}));
+			used = true;
+			return Effect.callback((resume) => {
+				let settled = false;
+				const finish = (result) => {
+					if (settled) return;
+					settled = true;
+					cancel = void 0;
+					resume(result);
+				};
+				cancel = () => finish(Effect.fail(new BrowserAuthenticationError({
+					reason: "Cancelled",
+					message: "Browser authentication was cancelled."
+				})));
+				const app = new Hono();
+				app.get(redirect.pathname, (context) => {
+					if (settled) return context.text("Authentication session is already complete.", 409);
+					const callbackUrl = context.req.url;
+					setImmediate(() => finish(Effect.succeed({ callbackUrl })));
+					return context.html("<!doctype html><html lang=\"en\"><head><title>Authentication complete</title></head><body><p>Authentication complete. Returning to the terminal…</p><script>window.close()<\/script></body></html>");
+				});
+				try {
 					server = serve({
 						fetch: app.fetch,
 						hostname: redirect.hostname.replace(/^\[|\]$/g, ""),
 						port: Number(redirect.port)
 					});
-					server.once("error", (error) => {
-						if (settled) return;
-						settled = true;
-						finish().finally(() => reject(error));
+					server.once("error", (cause) => {
+						listenFailed = true;
+						finish(Effect.fail(new BrowserAuthenticationError({
+							reason: "Platform",
+							message: "Could not start the authentication callback server.",
+							cause
+						})));
 					});
 					server.once("listening", () => {
 						if (settled) return;
-						Promise.resolve().then(() => openUrl(authorizationUrl)).catch((error) => {
-							if (settled) return;
-							settled = true;
-							const reason = error instanceof Error ? error : new Error(String(error));
-							finish().finally(() => reject(reason));
-						});
+						Promise.resolve().then(() => openUrl(authorizationUrl)).catch((cause) => finish(Effect.fail(new BrowserAuthenticationError({
+							reason: "Platform",
+							message: "Could not open browser authorization.",
+							cause
+						}))));
 					});
-					timer = setTimeout(() => {
-						if (settled) return;
-						settled = true;
-						finish().finally(() => reject(new BrowserAuthenticationCancelledError("Browser authentication timed out.")));
-					}, timeoutMs);
-				});
-			},
-			async close() {
-				if (settled) {
-					await finish();
-					return;
+				} catch (cause) {
+					finish(Effect.fail(new BrowserAuthenticationError({
+						reason: "Platform",
+						message: "Could not start browser authentication.",
+						cause
+					})));
 				}
-				settled = true;
-				const reject = rejectPending;
-				await finish();
-				reject?.(new BrowserAuthenticationCancelledError());
-			}
-		};
-	} };
+				return Effect.sync(() => {
+					settled = true;
+					cancel = void 0;
+				}).pipe(Effect.andThen(Effect.promise(closeServer)));
+			}).pipe(Effect.timeoutOrElse({
+				duration: options.timeoutMs ?? 3e5,
+				orElse: () => Effect.fail(new BrowserAuthenticationError({
+					reason: "Cancelled",
+					message: "Browser authentication timed out."
+				}))
+			}));
+		}) };
+	}) };
 }
 //#endregion
 export { createNodeBrowserAuthentication };

package/lib/createNodeBrowserAuthentication.js.map

@@ -1 +1 @@
-{"version":3,"file":"createNodeBrowserAuthentication.js","names":[],"sources":["../src/createNodeBrowserAuthentication.ts"],"sourcesContent":["import { serve } from \"@hono/node-server\";\nimport { BrowserAuthenticationCancelledError, type BrowserAuthentication } from \"@party-stack/runtime\";\nimport { Hono } from \"hono\";\nimport open from \"open\";\nimport type { Server } from \"node:http\";\n\nconst DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;\nconst LOOPBACK_HOSTS = new Set([\"localhost\", \"127.0.0.1\", \"::1\", \"[::1]\"]);\n\nexport interface CreateNodeBrowserAuthenticationOptions {\n    openUrl?: (url: string) => Promise<unknown>;\n    timeoutMs?: number;\n}\n\nfunction closeServer(server: Server | undefined): Promise<void> {\n    if (!server?.listening) return Promise.resolve();\n    return new Promise((resolve, reject) => {\n        server.close((error) => {\n            if (error) reject(error);\n            else resolve();\n        });\n    });\n}\n\nfunction validateRedirectUrl(redirectUrl: string): URL {\n    const url = new URL(redirectUrl);\n    if (url.protocol !== \"http:\" || !LOOPBACK_HOSTS.has(url.hostname) || !url.port) {\n        throw new Error(\n            \"Node browser authentication requires an http:// loopback redirect URL with an explicit port.\"\n        );\n    }\n    return url;\n}\n\nexport function createNodeBrowserAuthentication(\n    options: CreateNodeBrowserAuthenticationOptions = {}\n): BrowserAuthentication {\n    const openUrl = options.openUrl ?? ((url: string) => open(url));\n    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;\n\n    return {\n        start({ redirectUrl }) {\n            const redirect = validateRedirectUrl(redirectUrl);\n            let server: Server | undefined;\n            let rejectPending: ((error: Error) => void) | undefined;\n            let timer: ReturnType<typeof setTimeout> | undefined;\n            let settled = false;\n\n            const finish = async () => {\n                if (timer) clearTimeout(timer);\n                timer = undefined;\n                rejectPending = undefined;\n                await closeServer(server);\n                server = undefined;\n            };\n\n            return {\n                open(authorizationUrl) {\n                    if (server || settled) {\n                        return Promise.reject(\n                            new Error(\"This browser authentication session has already been used.\")\n                        );\n                    }\n\n                    return new Promise<{ callbackUrl: string }>((resolve, reject) => {\n                        rejectPending = reject;\n                        const app = new Hono();\n                        app.get(redirect.pathname, (context) => {\n                            if (settled) {\n                                return context.text(\"Authentication session is already complete.\", 409);\n                            }\n                            settled = true;\n                            const callbackUrl = context.req.url;\n                            setImmediate(() => {\n                                void finish().then(\n                                    () =>\n                                        resolve({\n                                            callbackUrl,\n                                        }),\n                                    reject\n                                );\n                            });\n                            return context.html(`<!doctype html>\n<html lang=\"en\">\n<head><meta charset=\"utf-8\"><title>Authentication complete</title></head>\n<body>\n<p>Authentication complete. Returning to the terminal…</p>\n<script>window.close()</script>\n</body>\n</html>`);\n                        });\n\n                        server = serve({\n                            fetch: app.fetch,\n                            hostname: redirect.hostname.replace(/^\\[|\\]$/g, \"\"),\n                            port: Number(redirect.port),\n                        }) as Server;\n                        server.once(\"error\", (error) => {\n                            if (settled) return;\n                            settled = true;\n                            void finish().finally(() => reject(error));\n                        });\n                        server.once(\"listening\", () => {\n                            if (settled) return;\n                            void Promise.resolve()\n                                .then(() => openUrl(authorizationUrl))\n                                .catch((error: unknown) => {\n                                    if (settled) return;\n                                    settled = true;\n                                    const reason = error instanceof Error ? error : new Error(String(error));\n                                    void finish().finally(() => reject(reason));\n                                });\n                        });\n                        timer = setTimeout(() => {\n                            if (settled) return;\n                            settled = true;\n                            void finish().finally(() =>\n                                reject(\n                                    new BrowserAuthenticationCancelledError(\n                                        \"Browser authentication timed out.\"\n                                    )\n                                )\n                            );\n                        }, timeoutMs);\n                    });\n                },\n                async close() {\n                    if (settled) {\n                        await finish();\n                        return;\n                    }\n                    settled = true;\n                    const reject = rejectPending;\n                    await finish();\n                    reject?.(new BrowserAuthenticationCancelledError());\n                },\n            };\n        },\n    };\n}\n"],"mappings":";;;;;AAMA,MAAM,qBAAqB;AAC3B,MAAM,iCAAiB,IAAI,IAAI;CAAC;CAAa;CAAa;CAAO;AAAO,CAAC;AAOzE,SAAS,YAAY,QAA2C;CAC5D,IAAI,CAAC,QAAQ,WAAW,OAAO,QAAQ,QAAQ;CAC/C,OAAO,IAAI,SAAS,SAAS,WAAW;EACpC,OAAO,OAAO,UAAU;GACpB,IAAI,OAAO,OAAO,KAAK;QAClB,QAAQ;EACjB,CAAC;CACL,CAAC;AACL;AAEA,SAAS,oBAAoB,aAA0B;CACnD,MAAM,MAAM,IAAI,IAAI,WAAW;CAC/B,IAAI,IAAI,aAAa,WAAW,CAAC,eAAe,IAAI,IAAI,QAAQ,KAAK,CAAC,IAAI,MACtE,MAAM,IAAI,MACN,8FACJ;CAEJ,OAAO;AACX;AAEA,SAAgB,gCACZ,UAAkD,CAAC,GAC9B;CACrB,MAAM,UAAU,QAAQ,aAAa,QAAgB,KAAK,GAAG;CAC7D,MAAM,YAAY,QAAQ,aAAa;CAEvC,OAAO,EACH,MAAM,EAAE,eAAe;EACnB,MAAM,WAAW,oBAAoB,WAAW;EAChD,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI,UAAU;EAEd,MAAM,SAAS,YAAY;GACvB,IAAI,OAAO,aAAa,KAAK;GAC7B,QAAQ,KAAA;GACR,gBAAgB,KAAA;GAChB,MAAM,YAAY,MAAM;GACxB,SAAS,KAAA;EACb;EAEA,OAAO;GACH,KAAK,kBAAkB;IACnB,IAAI,UAAU,SACV,OAAO,QAAQ,uBACX,IAAI,MAAM,4DAA4D,CAC1E;IAGJ,OAAO,IAAI,SAAkC,SAAS,WAAW;KAC7D,gBAAgB;KAChB,MAAM,MAAM,IAAI,KAAK;KACrB,IAAI,IAAI,SAAS,WAAW,YAAY;MACpC,IAAI,SACA,OAAO,QAAQ,KAAK,+CAA+C,GAAG;MAE1E,UAAU;MACV,MAAM,cAAc,QAAQ,IAAI;MAChC,mBAAmB;OACf,OAAY,CAAC,CAAC,WAEN,QAAQ,EACJ,YACJ,CAAC,GACL,MACJ;MACJ,CAAC;MACD,OAAO,QAAQ,KAAK;;;;;;;QAOxC;KACgB,CAAC;KAED,SAAS,MAAM;MACX,OAAO,IAAI;MACX,UAAU,SAAS,SAAS,QAAQ,YAAY,EAAE;MAClD,MAAM,OAAO,SAAS,IAAI;KAC9B,CAAC;KACD,OAAO,KAAK,UAAU,UAAU;MAC5B,IAAI,SAAS;MACb,UAAU;MACV,OAAY,CAAC,CAAC,cAAc,OAAO,KAAK,CAAC;KAC7C,CAAC;KACD,OAAO,KAAK,mBAAmB;MAC3B,IAAI,SAAS;MACb,QAAa,QAAQ,CAAC,CACjB,WAAW,QAAQ,gBAAgB,CAAC,CAAC,CACrC,OAAO,UAAmB;OACvB,IAAI,SAAS;OACb,UAAU;OACV,MAAM,SAAS,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;OACvE,OAAY,CAAC,CAAC,cAAc,OAAO,MAAM,CAAC;MAC9C,CAAC;KACT,CAAC;KACD,QAAQ,iBAAiB;MACrB,IAAI,SAAS;MACb,UAAU;MACV,OAAY,CAAC,CAAC,cACV,OACI,IAAI,oCACA,mCACJ,CACJ,CACJ;KACJ,GAAG,SAAS;IAChB,CAAC;GACL;GACA,MAAM,QAAQ;IACV,IAAI,SAAS;KACT,MAAM,OAAO;KACb;IACJ;IACA,UAAU;IACV,MAAM,SAAS;IACf,MAAM,OAAO;IACb,SAAS,IAAI,oCAAoC,CAAC;GACtD;EACJ;CACJ,EACJ;AACJ"}
+{"version":3,"file":"createNodeBrowserAuthentication.js","names":[],"sources":["../src/createNodeBrowserAuthentication.ts"],"sourcesContent":["import { serve } from \"@hono/node-server\";\nimport { BrowserAuthenticationError, type BrowserAuthentication } from \"@party-stack/runtime\";\nimport { Effect } from \"effect\";\nimport { Hono } from \"hono\";\nimport open from \"open\";\nimport type { Server } from \"node:http\";\n\nconst LOOPBACK_HOSTS = new Set([\"localhost\", \"127.0.0.1\", \"::1\", \"[::1]\"]);\nexport interface CreateNodeBrowserAuthenticationOptions {\n    openUrl?: (url: string) => Promise<unknown>;\n    timeoutMs?: number;\n}\n\nexport function createNodeBrowserAuthentication(\n    options: CreateNodeBrowserAuthenticationOptions = {}\n): BrowserAuthentication {\n    const openUrl = options.openUrl ?? ((url: string) => open(url));\n    return {\n        start: Effect.fnUntraced(function* ({ redirectUrl }) {\n            const redirect = yield* Effect.try({\n                try: () => {\n                    const url = new URL(redirectUrl);\n                    if (url.protocol !== \"http:\" || !LOOPBACK_HOSTS.has(url.hostname) || !url.port)\n                        throw new Error(\n                            \"Node browser authentication requires an http:// loopback redirect URL with an explicit port.\"\n                        );\n                    return url;\n                },\n                catch: (cause) =>\n                    new BrowserAuthenticationError({\n                        reason: \"Configuration\",\n                        message: cause instanceof Error ? cause.message : \"Invalid redirect URL.\",\n                        cause,\n                    }),\n            });\n            let server: Server | undefined;\n            let closing: Promise<void> | undefined;\n            let listenFailed = false;\n            let cancel: (() => void) | undefined;\n            let used = false;\n            let closed = false;\n            const closeServer = () =>\n                (closing ??= new Promise<void>((resolve, reject) => {\n                    if (!server || listenFailed) {\n                        resolve();\n                        return;\n                    }\n                    const active = server;\n                    const stop = () => {\n                        active.removeListener(\"error\", failed);\n                        active.close((error) => (error ? reject(error) : resolve()));\n                        active.closeAllConnections();\n                    };\n                    const failed = () => {\n                        active.removeListener(\"listening\", stop);\n                        resolve();\n                    };\n                    if (active.listening) stop();\n                    else {\n                        active.once(\"listening\", stop);\n                        active.once(\"error\", failed);\n                    }\n                }));\n            yield* Effect.addFinalizer(() =>\n                Effect.sync(() => {\n                    closed = true;\n                    cancel?.();\n                }).pipe(Effect.andThen(Effect.promise(closeServer)))\n            );\n            return {\n                open: (authorizationUrl: string) =>\n                    Effect.suspend(() => {\n                        if (used || closed)\n                            return Effect.fail(\n                                new BrowserAuthenticationError({\n                                    reason: \"Configuration\",\n                                    message: \"This authentication session has already been used or closed.\",\n                                })\n                            );\n                        used = true;\n                        return Effect.callback<{ callbackUrl: string }, BrowserAuthenticationError>(\n                            (resume) => {\n                                let settled = false;\n                                const finish = (\n                                    result: Effect.Effect<{ callbackUrl: string }, BrowserAuthenticationError>\n                                ) => {\n                                    if (settled) return;\n                                    settled = true;\n                                    cancel = undefined;\n                                    resume(result);\n                                };\n                                cancel = () =>\n                                    finish(\n                                        Effect.fail(\n                                            new BrowserAuthenticationError({\n                                                reason: \"Cancelled\",\n                                                message: \"Browser authentication was cancelled.\",\n                                            })\n                                        )\n                                    );\n                                const app = new Hono();\n                                app.get(redirect.pathname, (context) => {\n                                    if (settled)\n                                        return context.text(\n                                            \"Authentication session is already complete.\",\n                                            409\n                                        );\n                                    const callbackUrl = context.req.url;\n                                    setImmediate(() => finish(Effect.succeed({ callbackUrl })));\n                                    return context.html(\n                                        '<!doctype html><html lang=\"en\"><head><title>Authentication complete</title></head><body><p>Authentication complete. Returning to the terminal…</p><script>window.close()</script></body></html>'\n                                    );\n                                });\n                                try {\n                                    server = serve({\n                                        fetch: app.fetch,\n                                        hostname: redirect.hostname.replace(/^\\[|\\]$/g, \"\"),\n                                        port: Number(redirect.port),\n                                    }) as Server;\n                                    server.once(\"error\", (cause) => {\n                                        listenFailed = true;\n                                        finish(\n                                            Effect.fail(\n                                                new BrowserAuthenticationError({\n                                                    reason: \"Platform\",\n                                                    message:\n                                                        \"Could not start the authentication callback server.\",\n                                                    cause,\n                                                })\n                                            )\n                                        );\n                                    });\n                                    server.once(\"listening\", () => {\n                                        if (settled) return;\n                                        void Promise.resolve()\n                                            .then(() => openUrl(authorizationUrl))\n                                            .catch((cause: unknown) =>\n                                                finish(\n                                                    Effect.fail(\n                                                        new BrowserAuthenticationError({\n                                                            reason: \"Platform\",\n                                                            message: \"Could not open browser authorization.\",\n                                                            cause,\n                                                        })\n                                                    )\n                                                )\n                                            );\n                                    });\n                                } catch (cause) {\n                                    finish(\n                                        Effect.fail(\n                                            new BrowserAuthenticationError({\n                                                reason: \"Platform\",\n                                                message: \"Could not start browser authentication.\",\n                                                cause,\n                                            })\n                                        )\n                                    );\n                                }\n                                return Effect.sync(() => {\n                                    settled = true;\n                                    cancel = undefined;\n                                }).pipe(Effect.andThen(Effect.promise(closeServer)));\n                            }\n                        ).pipe(\n                            Effect.timeoutOrElse({\n                                duration: options.timeoutMs ?? 5 * 60 * 1000,\n                                orElse: () =>\n                                    Effect.fail(\n                                        new BrowserAuthenticationError({\n                                            reason: \"Cancelled\",\n                                            message: \"Browser authentication timed out.\",\n                                        })\n                                    ),\n                            })\n                        );\n                    }),\n            };\n        }),\n    };\n}\n"],"mappings":"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"}

package/lib/createNodeRuntime.d.ts

@@ -1,10 +1,11 @@
-import { RuntimeAdapterProvider } from "@party-stack/runtime";
-import "temporal-polyfill/global";
+import { Runtime, RuntimeError, RuntimePartition, Runtimes } from "@party-stack/runtime";
+import { Effect, Layer } from "effect";
 //#region src/createNodeRuntime.d.ts
 export interface CreateNodeRuntimeOptions {
   dataDirectory?: string;
 }
-export declare function createNodeRuntimeWithOptions(options: CreateNodeRuntimeOptions): RuntimeAdapterProvider;
-export declare const createNodeRuntime: RuntimeAdapterProvider;
+export declare const make: (options?: CreateNodeRuntimeOptions | undefined) => Effect.Effect<import("@party-stack/runtime").RuntimeService, import("@party-stack/ontology-storage").OntologyStorageError | RuntimeError, RuntimePartition | import("effect/Scope").Scope>;
+export declare const layer: (options?: CreateNodeRuntimeOptions) => Layer.Layer<Runtime, import("@party-stack/ontology-storage").OntologyStorageError | RuntimeError, RuntimePartition>;
+export declare const nodeRuntime: (options?: CreateNodeRuntimeOptions) => Layer.Layer<Runtimes, never, never>;
 //#endregion
 //# sourceMappingURL=createNodeRuntime.d.ts.map

package/lib/createNodeRuntime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createNodeRuntime.d.ts","names":[],"sources":["../src/createNodeRuntime.ts"],"mappings":";;;iBAciB;EACb;;wBAmBY,6BAA6B,SAAS,2BAA2B;qBA0CpE,mBAAiB"}
+{"version":3,"file":"createNodeRuntime.d.ts","names":[],"sources":["../src/createNodeRuntime.ts"],"mappings":";;;iBAiBiB;EACb;;qBAmBS,OAAI,UAAA,yCAAA,OAAA,sCAAA,wDAAA,uBAAA,cAAA,0CAAA;qBAgEJ,QAAK,UAAa,6BAAwB,MAAA,MAAA,iDAAA,uBAAA,cAAA;qBAC1C,cAAW,UAAa,6BAAwB,MAAA,MAAA"}

package/lib/createNodeRuntime.js

@@ -1,15 +1,18 @@
 import { NodeFileSystemBlobBytesStore } from "./NodeFileSystemBlobBytesStore.js";
-import { NodeSecretStore } from "./NodeSecretStore.js";
+import { makeKeyMaterialStore } from "./NodeKeyMaterialStore.js";
 import { createNodeBrowserAuthentication } from "./createNodeBrowserAuthentication.js";
 import { createHash } from "node:crypto";
-import { mkdir, rm } from "node:fs/promises";
+import { mkdir, rm, statfs } from "node:fs/promises";
 import { join } from "node:path";
-import { defineRuntime } from "@party-stack/runtime";
-import "temporal-polyfill/global";
+import { Runtime, RuntimeError, RuntimePartition, Runtimes, makeKeyMaterialStoreKeyring } from "@party-stack/runtime";
+import { Effect, Layer } from "effect";
 import { homedir } from "node:os";
-import { SingleProcessCoordination } from "@party-stack/coordination";
-import { createNodeSQLitePersistence } from "@tanstack/node-db-sqlite-persistence";
+import { storageError } from "@party-stack/ontology-storage/driver";
+import * as SQLite from "@party-stack/sql-ontology-storage/sqlite";
+import * as SqlTables from "@party-stack/sql-ontology-storage/tables";
 import Database from "better-sqlite3";
+import * as Reactivity from "effect/reactivity/Reactivity";
+import * as SqlClient from "effect/sql/SqlClient";
 //#region src/createNodeRuntime.ts
 function defaultDataDirectory() {
 	if (process.platform === "darwin") return join(homedir(), "Library", "Application Support", "party-stack");
@@ -19,35 +22,71 @@ function defaultDataDirectory() {
 function runtimeId(owner, namespace) {
 	return createHash("sha256").update(JSON.stringify([owner, namespace])).digest("hex");
 }
-function createNodeRuntimeWithOptions(options) {
-	return defineRuntime(async (owner, namespace) => {
-		const scope = `party-stack:${owner}:${namespace}`;
-		const directory = join(options.dataDirectory ?? defaultDataDirectory(), runtimeId(owner, namespace));
-		await mkdir(directory, { recursive: true });
-		const database = new Database(join(directory, "collections.sqlite"));
-		const persistence = createNodeSQLitePersistence({ database });
-		const coordination = new SingleProcessCoordination({ scope });
-		return {
-			owner,
-			namespace,
-			blobBytes: new NodeFileSystemBlobBytesStore({ directory: join(directory, "blobs") }),
-			browserAuthentication: createNodeBrowserAuthentication(),
-			secrets: new NodeSecretStore({ service: `party-stack:${runtimeId(owner, namespace)}:secrets` }),
-			coordination,
-			persistence,
-			cleanup: async () => {
-				await coordination.close();
-				database.close();
-			},
-			destroy: () => rm(directory, {
+const make = Effect.fn("NodeRuntime.make")(function* (options = {}) {
+	const { owner, namespace } = yield* RuntimePartition;
+	const directory = join(options.dataDirectory ?? defaultDataDirectory(), runtimeId(owner, namespace));
+	yield* Effect.tryPromise({
+		try: () => mkdir(directory, { recursive: true }),
+		catch: (cause) => new RuntimeError({
+			operation: "nodeRuntime.directory",
+			cause
+		})
+	});
+	const tables = Effect.gen(function* () {
+		const storageDatabase = yield* Effect.acquireRelease(Effect.try({
+			try: () => new Database(join(directory, "storage.sqlite")),
+			catch: (cause) => storageError("sql", "open", cause)
+		}), (database) => Effect.sync(() => database.close()));
+		const sql = yield* SQLite.makeClient(storageDatabase).pipe(Effect.provide(Reactivity.layer), Effect.mapError((cause) => storageError("sql", "open", cause)));
+		return yield* SqlTables.make().pipe(Effect.provideService(SqlClient.SqlClient, sql));
+	});
+	const blobBytes = new NodeFileSystemBlobBytesStore({ directory: join(directory, "blobs") });
+	const secrets = yield* makeKeyMaterialStore({ service: `party-stack:${runtimeId(owner, namespace)}:secrets` });
+	const ownedTables = yield* tables;
+	const encryptionKeyring = yield* makeKeyMaterialStoreKeyring(secrets);
+	return yield* Runtime.make({
+		blobBytes,
+		capacity: {
+			memory: Effect.sync(() => ({
+				scope: "process",
+				usedBytes: process.memoryUsage().rss,
+				availableBytes: process.availableMemory(),
+				limitBytes: process.constrainedMemory() || void 0
+			})),
+			storage: Effect.tryPromise({
+				try: async () => {
+					const stats = await statfs(directory);
+					return {
+						scope: "filesystem",
+						limitBytes: stats.blocks * stats.bsize,
+						availableBytes: stats.bavail * stats.bsize,
+						usedBytes: (stats.blocks - stats.bfree) * stats.bsize
+					};
+				},
+				catch: (cause) => new RuntimeError({
+					operation: "capacity.storage",
+					cause
+				})
+			})
+		},
+		browserAuthentication: createNodeBrowserAuthentication(),
+		encryptionKeyring,
+		tables: ownedTables,
+		destroy: Effect.tryPromise({
+			try: () => rm(directory, {
 				recursive: true,
 				force: true
+			}),
+			catch: (cause) => new RuntimeError({
+				operation: "destroy",
+				cause
 			})
-		};
+		})
 	});
-}
-const createNodeRuntime = createNodeRuntimeWithOptions({});
+});
+const layer = (options = {}) => Layer.effect(Runtime, make(options));
+const nodeRuntime = (options = {}) => Runtimes.layer(layer(options), { browserAuthentication: createNodeBrowserAuthentication() });
 //#endregion
-export { createNodeRuntime, createNodeRuntimeWithOptions };
+export { layer, make, nodeRuntime };
 
 //# sourceMappingURL=createNodeRuntime.js.map

package/lib/createNodeRuntime.js.map

@@ -1 +1 @@
-{"version":3,"file":"createNodeRuntime.js","names":[],"sources":["../src/createNodeRuntime.ts"],"sourcesContent":["// SQLite persistence revives Temporal values through the registered global constructors.\nimport \"temporal-polyfill/global\";\nimport { createHash } from \"node:crypto\";\nimport { mkdir, rm } from \"node:fs/promises\";\nimport { homedir } from \"node:os\";\nimport { join } from \"node:path\";\nimport { SingleProcessCoordination } from \"@party-stack/coordination\";\nimport { defineRuntime, type RuntimeAdapterProvider } from \"@party-stack/runtime\";\nimport { createNodeSQLitePersistence } from \"@tanstack/node-db-sqlite-persistence\";\nimport Database from \"better-sqlite3\";\nimport { createNodeBrowserAuthentication } from \"./createNodeBrowserAuthentication.js\";\nimport { NodeFileSystemBlobBytesStore } from \"./NodeFileSystemBlobBytesStore.js\";\nimport { NodeSecretStore } from \"./NodeSecretStore.js\";\n\nexport interface CreateNodeRuntimeOptions {\n    dataDirectory?: string;\n}\n\nfunction defaultDataDirectory(): string {\n    if (process.platform === \"darwin\") {\n        return join(homedir(), \"Library\", \"Application Support\", \"party-stack\");\n    }\n    if (process.platform === \"win32\") {\n        return join(process.env.LOCALAPPDATA ?? join(homedir(), \"AppData\", \"Local\"), \"party-stack\");\n    }\n    return join(process.env.XDG_DATA_HOME ?? join(homedir(), \".local\", \"share\"), \"party-stack\");\n}\n\nfunction runtimeId(owner: string, namespace: string): string {\n    return createHash(\"sha256\")\n        .update(JSON.stringify([owner, namespace]))\n        .digest(\"hex\");\n}\n\nexport function createNodeRuntimeWithOptions(options: CreateNodeRuntimeOptions): RuntimeAdapterProvider {\n    return defineRuntime(async (owner, namespace) => {\n        const scope = `party-stack:${owner}:${namespace}`;\n        const directory = join(options.dataDirectory ?? defaultDataDirectory(), runtimeId(owner, namespace));\n        await mkdir(directory, {\n            recursive: true,\n        });\n\n        const database = new Database(join(directory, \"collections.sqlite\"));\n        const persistence = createNodeSQLitePersistence({\n            database,\n        });\n        const coordination = new SingleProcessCoordination({\n            scope,\n        });\n        const blobBytes = new NodeFileSystemBlobBytesStore({\n            directory: join(directory, \"blobs\"),\n        });\n\n        return {\n            owner,\n            namespace,\n            blobBytes,\n            browserAuthentication: createNodeBrowserAuthentication(),\n            secrets: new NodeSecretStore({\n                service: `party-stack:${runtimeId(owner, namespace)}:secrets`,\n            }),\n            coordination,\n            persistence,\n            cleanup: async () => {\n                await coordination.close();\n                database.close();\n            },\n            destroy: () =>\n                rm(directory, {\n                    recursive: true,\n                    force: true,\n                }),\n        };\n    });\n}\n\nexport const createNodeRuntime = createNodeRuntimeWithOptions({});\n"],"mappings":";;;;;;;;;;;;;AAkBA,SAAS,uBAA+B;CACpC,IAAI,QAAQ,aAAa,UACrB,OAAO,KAAK,QAAQ,GAAG,WAAW,uBAAuB,aAAa;CAE1E,IAAI,QAAQ,aAAa,SACrB,OAAO,KAAK,QAAQ,IAAI,gBAAgB,KAAK,QAAQ,GAAG,WAAW,OAAO,GAAG,aAAa;CAE9F,OAAO,KAAK,QAAQ,IAAI,iBAAiB,KAAK,QAAQ,GAAG,UAAU,OAAO,GAAG,aAAa;AAC9F;AAEA,SAAS,UAAU,OAAe,WAA2B;CACzD,OAAO,WAAW,QAAQ,CAAC,CACtB,OAAO,KAAK,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC,CAC1C,OAAO,KAAK;AACrB;AAEA,SAAgB,6BAA6B,SAA2D;CACpG,OAAO,cAAc,OAAO,OAAO,cAAc;EAC7C,MAAM,QAAQ,eAAe,MAAM,GAAG;EACtC,MAAM,YAAY,KAAK,QAAQ,iBAAiB,qBAAqB,GAAG,UAAU,OAAO,SAAS,CAAC;EACnG,MAAM,MAAM,WAAW,EACnB,WAAW,KACf,CAAC;EAED,MAAM,WAAW,IAAI,SAAS,KAAK,WAAW,oBAAoB,CAAC;EACnE,MAAM,cAAc,4BAA4B,EAC5C,SACJ,CAAC;EACD,MAAM,eAAe,IAAI,0BAA0B,EAC/C,MACJ,CAAC;EAKD,OAAO;GACH;GACA;GACA,WAAA,IAPkB,6BAA6B,EAC/C,WAAW,KAAK,WAAW,OAAO,EACtC,CAKY;GACR,uBAAuB,gCAAgC;GACvD,SAAS,IAAI,gBAAgB,EACzB,SAAS,eAAe,UAAU,OAAO,SAAS,EAAE,UACxD,CAAC;GACD;GACA;GACA,SAAS,YAAY;IACjB,MAAM,aAAa,MAAM;IACzB,SAAS,MAAM;GACnB;GACA,eACI,GAAG,WAAW;IACV,WAAW;IACX,OAAO;GACX,CAAC;EACT;CACJ,CAAC;AACL;AAEA,MAAa,oBAAoB,6BAA6B,CAAC,CAAC"}
+{"version":3,"file":"createNodeRuntime.js","names":[],"sources":["../src/createNodeRuntime.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { mkdir, rm, statfs } from \"node:fs/promises\";\nimport { homedir } from \"node:os\";\nimport { join } from \"node:path\";\nimport { storageError } from \"@party-stack/ontology-storage/driver\";\nimport { Runtime, RuntimeError, makeKeyMaterialStoreKeyring, RuntimePartition } from \"@party-stack/runtime\";\nimport { Runtimes } from \"@party-stack/runtime\";\nimport * as SQLite from \"@party-stack/sql-ontology-storage/sqlite\";\nimport * as SqlTables from \"@party-stack/sql-ontology-storage/tables\";\nimport Database from \"better-sqlite3\";\nimport { Effect, Layer } from \"effect\";\nimport * as Reactivity from \"effect/reactivity/Reactivity\";\nimport * as SqlClient from \"effect/sql/SqlClient\";\nimport { createNodeBrowserAuthentication } from \"./createNodeBrowserAuthentication.js\";\nimport { NodeFileSystemBlobBytesStore } from \"./NodeFileSystemBlobBytesStore.js\";\nimport { makeKeyMaterialStore } from \"./NodeKeyMaterialStore.js\";\n\nexport interface CreateNodeRuntimeOptions {\n    dataDirectory?: string;\n}\n\nfunction defaultDataDirectory(): string {\n    if (process.platform === \"darwin\") {\n        return join(homedir(), \"Library\", \"Application Support\", \"party-stack\");\n    }\n    if (process.platform === \"win32\") {\n        return join(process.env.LOCALAPPDATA ?? join(homedir(), \"AppData\", \"Local\"), \"party-stack\");\n    }\n    return join(process.env.XDG_DATA_HOME ?? join(homedir(), \".local\", \"share\"), \"party-stack\");\n}\n\nfunction runtimeId(owner: string, namespace: string): string {\n    return createHash(\"sha256\")\n        .update(JSON.stringify([owner, namespace]))\n        .digest(\"hex\");\n}\n\nexport const make = Effect.fn(\"NodeRuntime.make\")(function* (options: CreateNodeRuntimeOptions = {}) {\n    const { owner, namespace } = yield* RuntimePartition;\n    const directory = join(options.dataDirectory ?? defaultDataDirectory(), runtimeId(owner, namespace));\n    yield* Effect.tryPromise({\n        try: () => mkdir(directory, { recursive: true }),\n        catch: (cause) => new RuntimeError({ operation: \"nodeRuntime.directory\", cause }),\n    });\n\n    const tables = Effect.gen(function* () {\n        const storageDatabase = yield* Effect.acquireRelease(\n            Effect.try({\n                try: () => new Database(join(directory, \"storage.sqlite\")),\n                catch: (cause) => storageError(\"sql\", \"open\", cause),\n            }),\n            (database) => Effect.sync(() => database.close())\n        );\n        const sql = yield* SQLite.makeClient(storageDatabase).pipe(\n            Effect.provide(Reactivity.layer),\n            Effect.mapError((cause) => storageError(\"sql\", \"open\", cause))\n        );\n        return yield* SqlTables.make().pipe(Effect.provideService(SqlClient.SqlClient, sql));\n    });\n    const blobBytes = new NodeFileSystemBlobBytesStore({\n        directory: join(directory, \"blobs\"),\n    });\n\n    const secrets = yield* makeKeyMaterialStore({\n        service: `party-stack:${runtimeId(owner, namespace)}:secrets`,\n    });\n    const ownedTables = yield* tables;\n    const encryptionKeyring = yield* makeKeyMaterialStoreKeyring(secrets);\n    return yield* Runtime.make({\n        blobBytes,\n        capacity: {\n            memory: Effect.sync(() => ({\n                scope: \"process\" as const,\n                usedBytes: process.memoryUsage().rss,\n                availableBytes: process.availableMemory(),\n                limitBytes: process.constrainedMemory() || undefined,\n            })),\n            storage: Effect.tryPromise({\n                try: async () => {\n                    const stats = await statfs(directory);\n                    return {\n                        scope: \"filesystem\" as const,\n                        limitBytes: stats.blocks * stats.bsize,\n                        availableBytes: stats.bavail * stats.bsize,\n                        usedBytes: (stats.blocks - stats.bfree) * stats.bsize,\n                    };\n                },\n                catch: (cause) => new RuntimeError({ operation: \"capacity.storage\", cause }),\n            }),\n        },\n        browserAuthentication: createNodeBrowserAuthentication(),\n        encryptionKeyring,\n\n        tables: ownedTables,\n        destroy: Effect.tryPromise({\n            try: () => rm(directory, { recursive: true, force: true }),\n            catch: (cause) => new RuntimeError({ operation: \"destroy\", cause }),\n        }),\n    });\n});\n\nexport const layer = (options: CreateNodeRuntimeOptions = {}) => Layer.effect(Runtime, make(options));\nexport const nodeRuntime = (options: CreateNodeRuntimeOptions = {}) =>\n    Runtimes.layer(layer(options), { browserAuthentication: createNodeBrowserAuthentication() });\n"],"mappings":"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"}

package/lib/index.d.ts

@@ -1,2 +1,2 @@
-import { CreateNodeRuntimeOptions, createNodeRuntime, createNodeRuntimeWithOptions } from "./createNodeRuntime.js";
-export { type CreateNodeRuntimeOptions, createNodeRuntime, createNodeRuntimeWithOptions };
+import { CreateNodeRuntimeOptions, layer, make, nodeRuntime } from "./createNodeRuntime.js";
+export { type CreateNodeRuntimeOptions, layer, make, nodeRuntime };

package/lib/index.js

@@ -1,2 +1 @@
-import { createNodeRuntime, createNodeRuntimeWithOptions } from "./createNodeRuntime.js";
-export { createNodeRuntime, createNodeRuntimeWithOptions };
+export { layer, make, nodeRuntime } from "./createNodeRuntime.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@party-stack/node-runtime",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "files": [
     "lib"
   ],
@@ -13,21 +13,22 @@
   },
   "dependencies": {
     "@hono/node-server": "^2.1.1",
-    "@tanstack/node-db-sqlite-persistence": "0.2.30",
     "better-sqlite3": "^12.9.0",
-    "cross-keychain": "^1.1.0",
+    "effect": "^4.0.5",
     "hono": "^4.13.5",
     "open": "^11.0.1",
     "temporal-polyfill": "^0.3.0",
-    "@party-stack/coordination": "0.3.1",
-    "@party-stack/runtime": "0.4.1"
+    "@party-stack/effect-node-keyring": "0.1.0",
+    "@party-stack/ontology-storage": "0.2.0",
+    "@party-stack/runtime": "0.5.0",
+    "@party-stack/sql-ontology-storage": "0.2.0"
   },
   "devDependencies": {
-    "@tanstack/db-sqlite-persistence-core": "0.4.5",
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^24.10.1",
     "typescript": "~7.0.2",
-    "vite-plus": "1.1.0",
-    "@party-stack/build-config": "0.1.1"
+    "vite": "npm:@voidzero-dev/vite-plus-core@1.2.0",
+    "vite-plus": "1.2.0",
+    "@party-stack/build-config": "0.2.0"
   }
 }

package/lib/NodeSecretStore.d.ts

@@ -1,14 +0,0 @@
-import { SecretStore } from "@party-stack/runtime";
-//#region src/NodeSecretStore.d.ts
-export interface NodeSecretStoreOptions {
-  service: string;
-}
-export declare class NodeSecretStore implements SecretStore {
-  #private;
-  constructor(options: NodeSecretStoreOptions);
-  get(key: string): Promise<string | undefined>;
-  set(key: string, value: string): Promise<void>;
-  delete(key: string): Promise<void>;
-}
-//#endregion
-//# sourceMappingURL=NodeSecretStore.d.ts.map

package/lib/NodeSecretStore.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NodeSecretStore.d.ts","names":[],"sources":["../src/NodeSecretStore.ts"],"mappings":";;iBAaiB;EACb;;qBAmBS,2BAA2B;;EAIpC,YAAY,SAAS;EAIf,IAAI,cAAc;EAKlB,IAAI,aAAa,gBAAgB;EAKjC,OAAO,cAAc"}

package/lib/NodeSecretStore.js

@@ -1,46 +0,0 @@
-import { createHash } from "node:crypto";
-import { getAllBackends } from "cross-keychain";
-//#region src/NodeSecretStore.ts
-const ALLOWED_BACKEND_IDS = /* @__PURE__ */ new Set([
-	"native-macos",
-	"macos",
-	"native-linux",
-	"secret-service",
-	"native-windows",
-	"windows"
-]);
-async function selectOSKeychainBackend() {
-	const candidates = (await getAllBackends()).filter((backend) => ALLOWED_BACKEND_IDS.has(backend.id));
-	if (candidates.length === 0) throw new Error("No OS keychain is available. Install or enable macOS Keychain, Windows Credential Manager, or a Linux Secret Service provider.");
-	return candidates.reduce((selected, candidate) => candidate.priority > selected.priority ? candidate : selected);
-}
-function encodeIdentifier(value) {
-	return `party-stack.${createHash("sha256").update(value).digest("hex")}`;
-}
-var NodeSecretStore = class {
-	#service;
-	#backend;
-	constructor(options) {
-		this.#service = encodeIdentifier(options.service);
-	}
-	async get(key) {
-		return await (await this.#getBackend()).getPassword(this.#service, encodeIdentifier(key)) ?? void 0;
-	}
-	async set(key, value) {
-		await (await this.#getBackend()).setPassword(this.#service, encodeIdentifier(key), value);
-	}
-	async delete(key) {
-		const backend = await this.#getBackend();
-		const account = encodeIdentifier(key);
-		if (await backend.getPassword(this.#service, account) === null) return;
-		await backend.deletePassword(this.#service, account);
-	}
-	#getBackend() {
-		this.#backend ??= selectOSKeychainBackend();
-		return this.#backend;
-	}
-};
-//#endregion
-export { NodeSecretStore };
-
-//# sourceMappingURL=NodeSecretStore.js.map

package/lib/NodeSecretStore.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"NodeSecretStore.js","names":[],"sources":["../src/NodeSecretStore.ts"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { getAllBackends, type SecretStorageBackend } from \"cross-keychain\";\nimport type { SecretStore } from \"@party-stack/runtime\";\n\nconst ALLOWED_BACKEND_IDS = new Set([\n    \"native-macos\",\n    \"macos\",\n    \"native-linux\",\n    \"secret-service\",\n    \"native-windows\",\n    \"windows\",\n]);\n\nexport interface NodeSecretStoreOptions {\n    service: string;\n}\n\nasync function selectOSKeychainBackend(): Promise<SecretStorageBackend> {\n    const candidates = (await getAllBackends()).filter((backend) => ALLOWED_BACKEND_IDS.has(backend.id));\n    if (candidates.length === 0) {\n        throw new Error(\n            \"No OS keychain is available. Install or enable macOS Keychain, Windows Credential Manager, or a Linux Secret Service provider.\"\n        );\n    }\n    return candidates.reduce((selected, candidate) =>\n        candidate.priority > selected.priority ? candidate : selected\n    );\n}\n\nfunction encodeIdentifier(value: string): string {\n    return `party-stack.${createHash(\"sha256\").update(value).digest(\"hex\")}`;\n}\n\nexport class NodeSecretStore implements SecretStore {\n    readonly #service: string;\n    #backend?: Promise<SecretStorageBackend>;\n\n    constructor(options: NodeSecretStoreOptions) {\n        this.#service = encodeIdentifier(options.service);\n    }\n\n    async get(key: string): Promise<string | undefined> {\n        const backend = await this.#getBackend();\n        return (await backend.getPassword(this.#service, encodeIdentifier(key))) ?? undefined;\n    }\n\n    async set(key: string, value: string): Promise<void> {\n        const backend = await this.#getBackend();\n        await backend.setPassword(this.#service, encodeIdentifier(key), value);\n    }\n\n    async delete(key: string): Promise<void> {\n        const backend = await this.#getBackend();\n        const account = encodeIdentifier(key);\n        if ((await backend.getPassword(this.#service, account)) === null) {\n            return;\n        }\n        await backend.deletePassword(this.#service, account);\n    }\n\n    #getBackend(): Promise<SecretStorageBackend> {\n        this.#backend ??= selectOSKeychainBackend();\n        return this.#backend;\n    }\n}\n"],"mappings":";;;AAIA,MAAM,sCAAsB,IAAI,IAAI;CAChC;CACA;CACA;CACA;CACA;CACA;AACJ,CAAC;AAMD,eAAe,0BAAyD;CACpE,MAAM,cAAc,MAAM,eAAe,EAAA,CAAG,QAAQ,YAAY,oBAAoB,IAAI,QAAQ,EAAE,CAAC;CACnG,IAAI,WAAW,WAAW,GACtB,MAAM,IAAI,MACN,gIACJ;CAEJ,OAAO,WAAW,QAAQ,UAAU,cAChC,UAAU,WAAW,SAAS,WAAW,YAAY,QACzD;AACJ;AAEA,SAAS,iBAAiB,OAAuB;CAC7C,OAAO,eAAe,WAAW,QAAQ,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,OAAO,KAAK;AACzE;AAEA,IAAa,kBAAb,MAAoD;CAChD;CACA;CAEA,YAAY,SAAiC;EACzC,KAAK,WAAW,iBAAiB,QAAQ,OAAO;CACpD;CAEA,MAAM,IAAI,KAA0C;EAEhD,OAAQ,OAAM,MADQ,KAAK,YAAY,EAAA,CACjB,YAAY,KAAK,UAAU,iBAAiB,GAAG,CAAC,KAAM,KAAA;CAChF;CAEA,MAAM,IAAI,KAAa,OAA8B;EAEjD,OAAM,MADgB,KAAK,YAAY,EAAA,CACzB,YAAY,KAAK,UAAU,iBAAiB,GAAG,GAAG,KAAK;CACzE;CAEA,MAAM,OAAO,KAA4B;EACrC,MAAM,UAAU,MAAM,KAAK,YAAY;EACvC,MAAM,UAAU,iBAAiB,GAAG;EACpC,IAAK,MAAM,QAAQ,YAAY,KAAK,UAAU,OAAO,MAAO,MACxD;EAEJ,MAAM,QAAQ,eAAe,KAAK,UAAU,OAAO;CACvD;CAEA,cAA6C;EACzC,KAAK,aAAa,wBAAwB;EAC1C,OAAO,KAAK;CAChB;AACJ"}