@powerlines/engine 0.46.6 → 0.47.1

package/dist/rpc/serialization.d.mts

@@ -0,0 +1,46 @@
+import { deserialize as structuredCloneDeserialize, parse as structuredCloneParse, serialize as structuredCloneSerialize, stringify as structuredCloneStringify } from "structured-clone-es";
+
+//#region src/rpc/serialization.d.ts
+/**
+ * Wire format used by the WS RPC transport.
+ *
+ * - **JSON (default, unprefixed):** payload is plain JSON text. Used when
+ *   the dispatched method is declared `jsonSerializable: true`. Encoded
+ *   via {@link strictJsonStringify} (rejects non-JSON values), decoded
+ *   via `JSON.parse`.
+ * - **Structured-clone (`s:` prefix):** payload is `s:` followed by
+ *   `structured-clone-es` text. Used when the method is declared
+ *   `jsonSerializable: false` (or omitted, the default). Round-trips
+ *   `Map`, `Set`, `Date`, `BigInt`, cycles, and class instances.
+ *
+ * birpc envelopes always start with `{`, so a leading byte that is not
+ * `s` is unambiguously JSON. Each direction independently chooses its
+ * encoding from local definitions — request and response are not
+ * coupled by a mirror rule.
+ */
+declare const STRUCTURED_CLONE_PREFIX = "s:";
+/**
+ * `JSON.stringify` with a single-pass strict replacer.
+ *
+ * Throws `DF0020` synchronously when the value contains a type JSON
+ * cannot round-trip losslessly: `Map`, `Set`, `Date`, `BigInt`, class
+ * instances, or `undefined` inside an array (silently becomes `null`).
+ *
+ * Native pass-throughs (no extra work needed):
+ *   - circular references — `JSON.stringify` raises `TypeError`.
+ *   - `BigInt` at top level — caught here for a friendlier error path.
+ *
+ * Lenient cases (allowed without throwing):
+ *   - `undefined` as an object property — legitimate optional field;
+ *     JSON.stringify just omits it.
+ *   - `undefined` at the root — legitimate "action returned nothing".
+ *   - `Symbol` / `Function` values — semantically "drop me" in JSON.
+ *
+ * `fnName` is used only for the diagnostic message — pass the RPC
+ * function name when calling from a wire serializer / dump writer so
+ * the error points at the offending function.
+ */
+declare function strictJsonStringify(value: unknown, fnName?: string): string;
+//#endregion
+export { STRUCTURED_CLONE_PREFIX, strictJsonStringify, structuredCloneDeserialize, structuredCloneParse, structuredCloneSerialize, structuredCloneStringify };
+//# sourceMappingURL=serialization.d.mts.map

package/dist/rpc/serialization.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialization.d.mts","names":[],"sources":["../../src/rpc/serialization.ts"],"mappings":";;;;AAiDA;;;;;AAuBA;;;;;;;;;;;cAvBa,uBAAA;;;;;;;;;;;;;;;;;;;;;;iBAuBG,mBAAA,CACd,KAAA,WACA,MAAA"}

package/dist/rpc/serialization.mjs

@@ -0,0 +1,76 @@
+import { deserialize as structuredCloneDeserialize, parse as structuredCloneParse, serialize as structuredCloneSerialize, stringify as structuredCloneStringify } from "structured-clone-es";
+
+//#region src/rpc/serialization.ts
+/**
+* Wire format used by the WS RPC transport.
+*
+* - **JSON (default, unprefixed):** payload is plain JSON text. Used when
+*   the dispatched method is declared `jsonSerializable: true`. Encoded
+*   via {@link strictJsonStringify} (rejects non-JSON values), decoded
+*   via `JSON.parse`.
+* - **Structured-clone (`s:` prefix):** payload is `s:` followed by
+*   `structured-clone-es` text. Used when the method is declared
+*   `jsonSerializable: false` (or omitted, the default). Round-trips
+*   `Map`, `Set`, `Date`, `BigInt`, cycles, and class instances.
+*
+* birpc envelopes always start with `{`, so a leading byte that is not
+* `s` is unambiguously JSON. Each direction independently chooses its
+* encoding from local definitions — request and response are not
+* coupled by a mirror rule.
+*/
+const STRUCTURED_CLONE_PREFIX = "s:";
+/**
+* `JSON.stringify` with a single-pass strict replacer.
+*
+* Throws `DF0020` synchronously when the value contains a type JSON
+* cannot round-trip losslessly: `Map`, `Set`, `Date`, `BigInt`, class
+* instances, or `undefined` inside an array (silently becomes `null`).
+*
+* Native pass-throughs (no extra work needed):
+*   - circular references — `JSON.stringify` raises `TypeError`.
+*   - `BigInt` at top level — caught here for a friendlier error path.
+*
+* Lenient cases (allowed without throwing):
+*   - `undefined` as an object property — legitimate optional field;
+*     JSON.stringify just omits it.
+*   - `undefined` at the root — legitimate "action returned nothing".
+*   - `Symbol` / `Function` values — semantically "drop me" in JSON.
+*
+* `fnName` is used only for the diagnostic message — pass the RPC
+* function name when calling from a wire serializer / dump writer so
+* the error points at the offending function.
+*/
+function strictJsonStringify(value, fnName = "") {
+	return JSON.stringify(value, function strictReplacer(key, val) {
+		const holder = this;
+		const original = holder != null ? holder[key] : val;
+		if (original === void 0) {
+			if (Array.isArray(holder)) throw nonJsonAt(fnName, "undefined", holder, key);
+			return val;
+		}
+		if (original === null) return val;
+		if (typeof original === "bigint") throw nonJsonAt(fnName, "BigInt", holder, key);
+		if (typeof original === "object") {
+			if (original instanceof Map) throw nonJsonAt(fnName, "Map", holder, key);
+			if (original instanceof Set) throw nonJsonAt(fnName, "Set", holder, key);
+			if (original instanceof Date) throw nonJsonAt(fnName, "Date", holder, key);
+			if (Array.isArray(original)) return val;
+			const proto = Object.getPrototypeOf(original);
+			if (proto !== null && proto !== Object.prototype) throw nonJsonAt(fnName, original.constructor?.name ?? "class instance", holder, key);
+		}
+		return val;
+	});
+}
+function nonJsonAt(fnName, type, parent, key) {
+	const path = formatPath(parent, key);
+	return /* @__PURE__ */ new Error(`Serialization error: ${fnName || "<anonymous>"} - ${type} at ${path}`);
+}
+function formatPath(parent, key) {
+	if (Array.isArray(parent)) return `[${key}]`;
+	if (key === "") return "<root>";
+	return key;
+}
+
+//#endregion
+export { STRUCTURED_CLONE_PREFIX, strictJsonStringify, structuredCloneDeserialize, structuredCloneParse, structuredCloneSerialize, structuredCloneStringify };
+//# sourceMappingURL=serialization.mjs.map

package/dist/rpc/serialization.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialization.mjs","names":[],"sources":["../../src/rpc/serialization.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport {\n  deserialize as structuredCloneDeserialize,\n  parse as structuredCloneParse,\n  serialize as structuredCloneSerialize,\n  stringify as structuredCloneStringify\n} from \"structured-clone-es\";\n\nexport {\n  structuredCloneDeserialize,\n  structuredCloneParse,\n  structuredCloneSerialize,\n  structuredCloneStringify\n};\n\n/**\n * Wire format used by the WS RPC transport.\n *\n * - **JSON (default, unprefixed):** payload is plain JSON text. Used when\n *   the dispatched method is declared `jsonSerializable: true`. Encoded\n *   via {@link strictJsonStringify} (rejects non-JSON values), decoded\n *   via `JSON.parse`.\n * - **Structured-clone (`s:` prefix):** payload is `s:` followed by\n *   `structured-clone-es` text. Used when the method is declared\n *   `jsonSerializable: false` (or omitted, the default). Round-trips\n *   `Map`, `Set`, `Date`, `BigInt`, cycles, and class instances.\n *\n * birpc envelopes always start with `{`, so a leading byte that is not\n * `s` is unambiguously JSON. Each direction independently chooses its\n * encoding from local definitions — request and response are not\n * coupled by a mirror rule.\n */\nexport const STRUCTURED_CLONE_PREFIX = \"s:\";\n\n/**\n * `JSON.stringify` with a single-pass strict replacer.\n *\n * Throws `DF0020` synchronously when the value contains a type JSON\n * cannot round-trip losslessly: `Map`, `Set`, `Date`, `BigInt`, class\n * instances, or `undefined` inside an array (silently becomes `null`).\n *\n * Native pass-throughs (no extra work needed):\n *   - circular references — `JSON.stringify` raises `TypeError`.\n *   - `BigInt` at top level — caught here for a friendlier error path.\n *\n * Lenient cases (allowed without throwing):\n *   - `undefined` as an object property — legitimate optional field;\n *     JSON.stringify just omits it.\n *   - `undefined` at the root — legitimate \"action returned nothing\".\n *   - `Symbol` / `Function` values — semantically \"drop me\" in JSON.\n *\n * `fnName` is used only for the diagnostic message — pass the RPC\n * function name when calling from a wire serializer / dump writer so\n * the error points at the offending function.\n */\nexport function strictJsonStringify(\n  value: unknown,\n  fnName: string = \"\"\n): string {\n  return JSON.stringify(\n    value,\n    function strictReplacer(this: unknown, key: string, val: unknown): unknown {\n      // The replacer receives the value AFTER any `toJSON()` coercion\n      // (e.g. `Date` already became an ISO string). To detect raw types,\n      // peek at the holder's original property via `this[key]`. At the\n      // root, `this` is the wrapper `{ '': value }` so `this['']` is the\n      // raw root value.\n      const holder = this as Record<string, unknown> | unknown[] | undefined;\n      const original = holder != null ? (holder as any)[key] : val;\n\n      if (original === undefined) {\n        if (Array.isArray(holder))\n          throw nonJsonAt(fnName, \"undefined\", holder, key);\n        return val;\n      }\n      if (original === null) return val;\n\n      if (typeof original === \"bigint\")\n        throw nonJsonAt(fnName, \"BigInt\", holder, key);\n\n      if (typeof original === \"object\") {\n        if (original instanceof Map)\n          throw nonJsonAt(fnName, \"Map\", holder, key);\n        if (original instanceof Set)\n          throw nonJsonAt(fnName, \"Set\", holder, key);\n        if (original instanceof Date)\n          throw nonJsonAt(fnName, \"Date\", holder, key);\n        if (Array.isArray(original)) return val;\n        const proto = Object.getPrototypeOf(original);\n        if (proto !== null && proto !== Object.prototype) {\n          const ctorName =\n            (original as { constructor?: { name?: string } }).constructor\n              ?.name ?? \"class instance\";\n          throw nonJsonAt(fnName, ctorName, holder, key);\n        }\n      }\n\n      return val;\n    }\n  );\n}\n\nfunction nonJsonAt(\n  fnName: string,\n  type: string,\n  parent: unknown,\n  key: string\n): Error {\n  const path = formatPath(parent, key);\n\n  return new Error(\n    `Serialization error: ${fnName || \"<anonymous>\"} - ${type} at ${path}`\n  );\n}\n\nfunction formatPath(parent: unknown, key: string): string {\n  if (Array.isArray(parent)) return `[${key}]`;\n  if (key === \"\") return \"<root>\";\n  return key;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAiDA,MAAa,0BAA0B;;;;;;;;;;;;;;;;;;;;;;AAuBvC,SAAgB,oBACd,OACA,SAAiB,IACT;AACR,QAAO,KAAK,UACV,OACA,SAAS,eAA8B,KAAa,KAAuB;EAMzE,MAAM,SAAS;EACf,MAAM,WAAW,UAAU,OAAQ,OAAe,OAAO;AAEzD,MAAI,aAAa,QAAW;AAC1B,OAAI,MAAM,QAAQ,OAAO,CACvB,OAAM,UAAU,QAAQ,aAAa,QAAQ,IAAI;AACnD,UAAO;;AAET,MAAI,aAAa,KAAM,QAAO;AAE9B,MAAI,OAAO,aAAa,SACtB,OAAM,UAAU,QAAQ,UAAU,QAAQ,IAAI;AAEhD,MAAI,OAAO,aAAa,UAAU;AAChC,OAAI,oBAAoB,IACtB,OAAM,UAAU,QAAQ,OAAO,QAAQ,IAAI;AAC7C,OAAI,oBAAoB,IACtB,OAAM,UAAU,QAAQ,OAAO,QAAQ,IAAI;AAC7C,OAAI,oBAAoB,KACtB,OAAM,UAAU,QAAQ,QAAQ,QAAQ,IAAI;AAC9C,OAAI,MAAM,QAAQ,SAAS,CAAE,QAAO;GACpC,MAAM,QAAQ,OAAO,eAAe,SAAS;AAC7C,OAAI,UAAU,QAAQ,UAAU,OAAO,UAIrC,OAAM,UAAU,QAFb,SAAiD,aAC9C,QAAQ,kBACoB,QAAQ,IAAI;;AAIlD,SAAO;GAEV;;AAGH,SAAS,UACP,QACA,MACA,QACA,KACO;CACP,MAAM,OAAO,WAAW,QAAQ,IAAI;AAEpC,wBAAO,IAAI,MACT,wBAAwB,UAAU,cAAc,KAAK,KAAK,MAAM,OACjE;;AAGH,SAAS,WAAW,QAAiB,KAAqB;AACxD,KAAI,MAAM,QAAQ,OAAO,CAAE,QAAO,IAAI,IAAI;AAC1C,KAAI,QAAQ,GAAI,QAAO;AACvB,QAAO"}

package/dist/rpc/server.cjs

@@ -0,0 +1,69 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-C0xms8kb.cjs');
+const require_rpc_serialization = require('./serialization.cjs');
+let birpc = require("birpc");
+let structured_clone_es = require("structured-clone-es");
+
+//#region src/rpc/server.ts
+function createRpcServer(functions, options = {}) {
+	return (0, birpc.createBirpcGroup)(functions, [], {
+		...options.rpcOptions,
+		proxify: false
+	});
+}
+function NOOP() {}
+const EMPTY_DEFS = /* @__PURE__ */ new Map();
+/**
+* Build a birpc `ChannelOptions` object backed by a browser `WebSocket`.
+* Pass the result straight to `createRpcClient`'s `channel` option.
+*/
+function createWsRpcChannel(options) {
+	const { onConnected = NOOP, onError = NOOP, onDisconnected = NOOP, definitions = EMPTY_DEFS } = options;
+	const ws = new WebSocket(options.url);
+	ws.addEventListener("open", (e) => {
+		onConnected(e);
+	});
+	ws.addEventListener("error", (e) => {
+		onError(e instanceof Error ? e : new Error(e.type));
+	});
+	ws.addEventListener("close", (e) => {
+		onDisconnected(e);
+	});
+	const pendingRequestMethods = /* @__PURE__ */ new Map();
+	return {
+		on: (handler) => {
+			ws.addEventListener("message", (e) => {
+				handler(e.data);
+			});
+		},
+		post: (data) => {
+			if (ws.readyState === WebSocket.OPEN) ws.send(data);
+			else {
+				function handler() {
+					ws.send(data);
+					ws.removeEventListener("open", handler);
+				}
+				ws.addEventListener("open", handler);
+			}
+		},
+		serialize: (msg) => {
+			let method;
+			if (msg.t === "q") method = msg.m;
+			else {
+				method = pendingRequestMethods.get(msg.i);
+				pendingRequestMethods.delete(msg.i);
+			}
+			if (!!method && definitions.get(method)?.jsonSerializable === true) return require_rpc_serialization.strictJsonStringify(msg, method ?? "");
+			return `${"s:"}${(0, structured_clone_es.stringify)(msg)}`;
+		},
+		deserialize: (raw) => {
+			const msg = raw.startsWith("s:") ? (0, structured_clone_es.parse)(raw.slice("s:".length)) : JSON.parse(raw);
+			if (msg.t === "q" && msg.i && msg.m) pendingRequestMethods.set(msg.i, msg.m);
+			return msg;
+		}
+	};
+}
+
+//#endregion
+exports.createRpcServer = createRpcServer;
+exports.createWsRpcChannel = createWsRpcChannel;

package/dist/rpc/server.d.cts

@@ -0,0 +1,29 @@
+import { RpcFunctionDefinitionAny } from "./types.cjs";
+import { BirpcGroup, ChannelOptions, EventOptions } from "birpc";
+
+//#region src/rpc/server.d.ts
+declare function createRpcServer<ClientFunctions extends object = Record<string, never>, ServerFunctions extends object = Record<string, never>>(functions: ServerFunctions, options?: {
+  rpcOptions?: EventOptions<ClientFunctions, ServerFunctions, false>;
+}): BirpcGroup<ClientFunctions, ServerFunctions, false>;
+interface WsRpcChannelOptions {
+  url: string;
+  onConnected?: (e: Event) => void;
+  onError?: (e: Error) => void;
+  onDisconnected?: (e: CloseEvent) => void;
+  /**
+   * RPC function definitions (or just the `jsonSerializable` flag per
+   * method) used to dispatch the per-call wire serializer. Pass an
+   * empty / partial map on clients that don't have the full registry —
+   * encoding falls back to structured-clone (the safer superset) and
+   * decoding still routes correctly via the wire prefix.
+   */
+  definitions?: ReadonlyMap<string, Pick<RpcFunctionDefinitionAny, "jsonSerializable">>;
+}
+/**
+ * Build a birpc `ChannelOptions` object backed by a browser `WebSocket`.
+ * Pass the result straight to `createRpcClient`'s `channel` option.
+ */
+declare function createWsRpcChannel(options: WsRpcChannelOptions): ChannelOptions;
+//#endregion
+export { WsRpcChannelOptions, createRpcServer, createWsRpcChannel };
+//# sourceMappingURL=server.d.cts.map

package/dist/rpc/server.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.cts","names":[],"sources":["../../src/rpc/server.ts"],"mappings":";;;;iBA4BgB,eAAA,kCACmB,MAAA,kDACA,MAAA,gBAAA,CAEjC,SAAA,EAAW,eAAA,EACX,OAAA;EACE,UAAA,GAAa,YAAA,CAAa,eAAA,EAAiB,eAAA;AAAA,IAE5C,UAAA,CAAW,eAAA,EAAiB,eAAA;AAAA,UAWd,mBAAA;EACf,GAAA;EACA,WAAA,IAAe,CAAA,EAAG,KAAA;EAClB,OAAA,IAAW,CAAA,EAAG,KAAA;EACd,cAAA,IAAkB,CAAA,EAAG,UAAA;EAjBO;;;;;;;EAyB5B,WAAA,GAAc,WAAA,SAEZ,IAAA,CAAK,wBAAA;AAAA;;;;;iBAeO,kBAAA,CACd,OAAA,EAAS,mBAAA,GACR,cAAA"}

package/dist/rpc/server.d.mts

@@ -0,0 +1,29 @@
+import { RpcFunctionDefinitionAny } from "./types.mjs";
+import { BirpcGroup, ChannelOptions, EventOptions } from "birpc";
+
+//#region src/rpc/server.d.ts
+declare function createRpcServer<ClientFunctions extends object = Record<string, never>, ServerFunctions extends object = Record<string, never>>(functions: ServerFunctions, options?: {
+  rpcOptions?: EventOptions<ClientFunctions, ServerFunctions, false>;
+}): BirpcGroup<ClientFunctions, ServerFunctions, false>;
+interface WsRpcChannelOptions {
+  url: string;
+  onConnected?: (e: Event) => void;
+  onError?: (e: Error) => void;
+  onDisconnected?: (e: CloseEvent) => void;
+  /**
+   * RPC function definitions (or just the `jsonSerializable` flag per
+   * method) used to dispatch the per-call wire serializer. Pass an
+   * empty / partial map on clients that don't have the full registry —
+   * encoding falls back to structured-clone (the safer superset) and
+   * decoding still routes correctly via the wire prefix.
+   */
+  definitions?: ReadonlyMap<string, Pick<RpcFunctionDefinitionAny, "jsonSerializable">>;
+}
+/**
+ * Build a birpc `ChannelOptions` object backed by a browser `WebSocket`.
+ * Pass the result straight to `createRpcClient`'s `channel` option.
+ */
+declare function createWsRpcChannel(options: WsRpcChannelOptions): ChannelOptions;
+//#endregion
+export { WsRpcChannelOptions, createRpcServer, createWsRpcChannel };
+//# sourceMappingURL=server.d.mts.map

package/dist/rpc/server.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.mts","names":[],"sources":["../../src/rpc/server.ts"],"mappings":";;;;iBA4BgB,eAAA,kCACmB,MAAA,kDACA,MAAA,gBAAA,CAEjC,SAAA,EAAW,eAAA,EACX,OAAA;EACE,UAAA,GAAa,YAAA,CAAa,eAAA,EAAiB,eAAA;AAAA,IAE5C,UAAA,CAAW,eAAA,EAAiB,eAAA;AAAA,UAWd,mBAAA;EACf,GAAA;EACA,WAAA,IAAe,CAAA,EAAG,KAAA;EAClB,OAAA,IAAW,CAAA,EAAG,KAAA;EACd,cAAA,IAAkB,CAAA,EAAG,UAAA;EAjBO;;;;;;;EAyB5B,WAAA,GAAc,WAAA,SAEZ,IAAA,CAAK,wBAAA;AAAA;;;;;iBAeO,kBAAA,CACd,OAAA,EAAS,mBAAA,GACR,cAAA"}

package/dist/rpc/server.mjs

@@ -0,0 +1,66 @@
+import { STRUCTURED_CLONE_PREFIX, strictJsonStringify, structuredCloneParse, structuredCloneStringify } from "./serialization.mjs";
+import { createBirpcGroup } from "birpc";
+
+//#region src/rpc/server.ts
+function createRpcServer(functions, options = {}) {
+	return createBirpcGroup(functions, [], {
+		...options.rpcOptions,
+		proxify: false
+	});
+}
+function NOOP() {}
+const EMPTY_DEFS = /* @__PURE__ */ new Map();
+/**
+* Build a birpc `ChannelOptions` object backed by a browser `WebSocket`.
+* Pass the result straight to `createRpcClient`'s `channel` option.
+*/
+function createWsRpcChannel(options) {
+	const { onConnected = NOOP, onError = NOOP, onDisconnected = NOOP, definitions = EMPTY_DEFS } = options;
+	const ws = new WebSocket(options.url);
+	ws.addEventListener("open", (e) => {
+		onConnected(e);
+	});
+	ws.addEventListener("error", (e) => {
+		onError(e instanceof Error ? e : new Error(e.type));
+	});
+	ws.addEventListener("close", (e) => {
+		onDisconnected(e);
+	});
+	const pendingRequestMethods = /* @__PURE__ */ new Map();
+	return {
+		on: (handler) => {
+			ws.addEventListener("message", (e) => {
+				handler(e.data);
+			});
+		},
+		post: (data) => {
+			if (ws.readyState === WebSocket.OPEN) ws.send(data);
+			else {
+				function handler() {
+					ws.send(data);
+					ws.removeEventListener("open", handler);
+				}
+				ws.addEventListener("open", handler);
+			}
+		},
+		serialize: (msg) => {
+			let method;
+			if (msg.t === "q") method = msg.m;
+			else {
+				method = pendingRequestMethods.get(msg.i);
+				pendingRequestMethods.delete(msg.i);
+			}
+			if (!!method && definitions.get(method)?.jsonSerializable === true) return strictJsonStringify(msg, method ?? "");
+			return `${"s:"}${structuredCloneStringify(msg)}`;
+		},
+		deserialize: (raw) => {
+			const msg = raw.startsWith("s:") ? structuredCloneParse(raw.slice("s:".length)) : JSON.parse(raw);
+			if (msg.t === "q" && msg.i && msg.m) pendingRequestMethods.set(msg.i, msg.m);
+			return msg;
+		}
+	};
+}
+
+//#endregion
+export { createRpcServer, createWsRpcChannel };
+//# sourceMappingURL=server.mjs.map

package/dist/rpc/server.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.mjs","names":[],"sources":["../../src/rpc/server.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                   ⚡ Storm Software - Powerlines\n\n This code was released as part of the Powerlines project. Powerlines\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/powerlines.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/powerlines\n Documentation:            https://docs.stormsoftware.com/projects/powerlines\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nimport type { BirpcGroup, ChannelOptions, EventOptions } from \"birpc\";\nimport { createBirpcGroup } from \"birpc\";\nimport {\n  strictJsonStringify,\n  STRUCTURED_CLONE_PREFIX,\n  structuredCloneParse,\n  structuredCloneStringify\n} from \"./serialization\";\nimport { RpcFunctionDefinitionAny } from \"./types\";\n\nexport function createRpcServer<\n  ClientFunctions extends object = Record<string, never>,\n  ServerFunctions extends object = Record<string, never>\n>(\n  functions: ServerFunctions,\n  options: {\n    rpcOptions?: EventOptions<ClientFunctions, ServerFunctions, false>;\n  } = {}\n): BirpcGroup<ClientFunctions, ServerFunctions, false> {\n  return createBirpcGroup<ClientFunctions, ServerFunctions, false>(\n    functions,\n    [],\n    {\n      ...options.rpcOptions,\n      proxify: false\n    }\n  );\n}\n\nexport interface WsRpcChannelOptions {\n  url: string;\n  onConnected?: (e: Event) => void;\n  onError?: (e: Error) => void;\n  onDisconnected?: (e: CloseEvent) => void;\n  /**\n   * RPC function definitions (or just the `jsonSerializable` flag per\n   * method) used to dispatch the per-call wire serializer. Pass an\n   * empty / partial map on clients that don't have the full registry —\n   * encoding falls back to structured-clone (the safer superset) and\n   * decoding still routes correctly via the wire prefix.\n   */\n  definitions?: ReadonlyMap<\n    string,\n    Pick<RpcFunctionDefinitionAny, \"jsonSerializable\">\n  >;\n}\n\nfunction NOOP() {}\n\nconst EMPTY_DEFS: ReadonlyMap<\n  string,\n  Pick<RpcFunctionDefinitionAny, \"jsonSerializable\">\n> = new Map();\n\n/**\n * Build a birpc `ChannelOptions` object backed by a browser `WebSocket`.\n * Pass the result straight to `createRpcClient`'s `channel` option.\n */\nexport function createWsRpcChannel(\n  options: WsRpcChannelOptions\n): ChannelOptions {\n  const {\n    onConnected = NOOP,\n    onError = NOOP,\n    onDisconnected = NOOP,\n    definitions = EMPTY_DEFS\n  } = options;\n\n  const ws = new WebSocket(options.url);\n\n  ws.addEventListener(\"open\", e => {\n    onConnected(e);\n  });\n\n  ws.addEventListener(\"error\", e => {\n    const _e = e instanceof Error ? e : new Error(e.type);\n    onError(_e);\n  });\n\n  ws.addEventListener(\"close\", e => {\n    onDisconnected(e);\n  });\n\n  // Per-channel state: maps an incoming request id to its method name\n  // so the matching outgoing response can independently look the\n  // method up in `definitions` and pick the right encoder.\n  const pendingRequestMethods = new Map<string, string>();\n\n  return {\n    on: (handler: (data: string) => void) => {\n      ws.addEventListener(\"message\", e => {\n        handler(e.data);\n      });\n    },\n    post: (data: string) => {\n      if (ws.readyState === WebSocket.OPEN) {\n        ws.send(data);\n      } else {\n        function handler() {\n          ws.send(data);\n          ws.removeEventListener(\"open\", handler);\n        }\n        ws.addEventListener(\"open\", handler);\n      }\n    },\n    serialize: (msg: any): string => {\n      let method: string | undefined;\n      if (msg.t === \"q\") {\n        method = msg.m;\n      } else {\n        method = pendingRequestMethods.get(msg.i);\n        pendingRequestMethods.delete(msg.i);\n      }\n      const useJson =\n        !!method && definitions.get(method)?.jsonSerializable === true;\n      if (useJson) return strictJsonStringify(msg, method ?? \"\");\n      return `${STRUCTURED_CLONE_PREFIX}${structuredCloneStringify(msg)}`;\n    },\n    deserialize: (raw: string): any => {\n      const msg: any = raw.startsWith(STRUCTURED_CLONE_PREFIX)\n        ? structuredCloneParse(raw.slice(STRUCTURED_CLONE_PREFIX.length))\n        : JSON.parse(raw);\n      if (msg.t === \"q\" && msg.i && msg.m)\n        pendingRequestMethods.set(msg.i, msg.m);\n      return msg;\n    }\n  };\n}\n"],"mappings":";;;;AA4BA,SAAgB,gBAId,WACA,UAEI,EAAE,EAC+C;AACrD,QAAO,iBACL,WACA,EAAE,EACF;EACE,GAAG,QAAQ;EACX,SAAS;EACV,CACF;;AAqBH,SAAS,OAAO;AAEhB,MAAM,6BAGF,IAAI,KAAK;;;;;AAMb,SAAgB,mBACd,SACgB;CAChB,MAAM,EACJ,cAAc,MACd,UAAU,MACV,iBAAiB,MACjB,cAAc,eACZ;CAEJ,MAAM,KAAK,IAAI,UAAU,QAAQ,IAAI;AAErC,IAAG,iBAAiB,SAAQ,MAAK;AAC/B,cAAY,EAAE;GACd;AAEF,IAAG,iBAAiB,UAAS,MAAK;AAEhC,UADW,aAAa,QAAQ,IAAI,IAAI,MAAM,EAAE,KAAK,CAC1C;GACX;AAEF,IAAG,iBAAiB,UAAS,MAAK;AAChC,iBAAe,EAAE;GACjB;CAKF,MAAM,wCAAwB,IAAI,KAAqB;AAEvD,QAAO;EACL,KAAK,YAAoC;AACvC,MAAG,iBAAiB,YAAW,MAAK;AAClC,YAAQ,EAAE,KAAK;KACf;;EAEJ,OAAO,SAAiB;AACtB,OAAI,GAAG,eAAe,UAAU,KAC9B,IAAG,KAAK,KAAK;QACR;IACL,SAAS,UAAU;AACjB,QAAG,KAAK,KAAK;AACb,QAAG,oBAAoB,QAAQ,QAAQ;;AAEzC,OAAG,iBAAiB,QAAQ,QAAQ;;;EAGxC,YAAY,QAAqB;GAC/B,IAAI;AACJ,OAAI,IAAI,MAAM,IACZ,UAAS,IAAI;QACR;AACL,aAAS,sBAAsB,IAAI,IAAI,EAAE;AACzC,0BAAsB,OAAO,IAAI,EAAE;;AAIrC,OADE,CAAC,CAAC,UAAU,YAAY,IAAI,OAAO,EAAE,qBAAqB,KAC/C,QAAO,oBAAoB,KAAK,UAAU,GAAG;AAC1D,UAAO,UAA6B,yBAAyB,IAAI;;EAEnE,cAAc,QAAqB;GACjC,MAAM,MAAW,IAAI,gBAAmC,GACpD,qBAAqB,IAAI,WAA8B,OAAO,CAAC,GAC/D,KAAK,MAAM,IAAI;AACnB,OAAI,IAAI,MAAM,OAAO,IAAI,KAAK,IAAI,EAChC,uBAAsB,IAAI,IAAI,GAAG,IAAI,EAAE;AACzC,UAAO;;EAEV"}

package/dist/rpc/types.d.cts

@@ -0,0 +1,70 @@
+import { GenericSchema, InferInput } from "valibot";
+
+//#region src/rpc/types.d.ts
+/** Valibot schema array for validating function arguments */
+type RpcArgsSchema = readonly GenericSchema[];
+/** Valibot schema for validating function return value */
+type RpcReturnSchema = GenericSchema;
+/** Infers TypeScript tuple type from Valibot schema array */
+type InferArgsType<S extends RpcArgsSchema | undefined> = S extends readonly [] ? [] : S extends readonly [infer H, ...infer T] ? H extends GenericSchema ? T extends readonly GenericSchema[] ? [InferInput<H>, ...InferArgsType<T>] : never : never : never;
+/** Infers TypeScript return type from Valibot return schema */
+type InferReturnType<S extends RpcReturnSchema | undefined> = S extends RpcReturnSchema ? InferInput<S> : void;
+/**
+ * RPC function definition with optional dump support.
+ */
+type RpcFunctionDefinition<TName extends string, TArgs extends any[] = [], TReturns = void, TArgsSchema extends RpcArgsSchema | undefined = undefined, TReturnSchema extends RpcReturnSchema | undefined = undefined> = [TArgsSchema, TReturnSchema] extends [undefined, undefined] ? {
+  /**
+   * Function name (unique identifier)
+   */
+  name: TName;
+  /**
+   * Valibot schema array for validating function arguments
+   */
+  args?: TArgsSchema;
+  /**
+   * Valibot schema for validating function return value
+   */
+  returns?: TReturnSchema;
+  /**
+   * Declares whether this function's args/return are JSON-serializable
+   * (no Map/Set/Date/BigInt/cycles/class instances/undefined/Symbol/Function).
+   *
+   * - `true` — wire and dump use strict `JSON.stringify`; misshapen
+   *   values throw `DF0019` at the call site. Required for `agent`.
+   * - `false` (default) — `structured-clone-es` round-trips fancy
+   *   types. Cannot be `agent`-exposed (registration throws `DF0018`).
+   */
+  jsonSerializable?: boolean;
+  /**
+   * Function implementation (required if setup doesn't provide one)
+   */
+  handler: (...args: TArgs) => TReturns;
+} : {
+  /**
+   * Function name (unique identifier)
+   */
+  name: TName;
+  /**
+   * Valibot schema array for validating function arguments
+   */
+  args?: TArgsSchema;
+  /**
+   * Valibot schema for validating function return value
+   */
+  returns?: TReturnSchema;
+  /**
+   * Declares whether this function's args/return are JSON-serializable
+   * (no Map/Set/Date/BigInt/cycles/class instances/undefined/Symbol/Function).
+   *
+   * - `true` — wire and dump use strict `JSON.stringify`; misshapen
+   *   values throw `DF0019` at the call site. Required for `agent`.
+   * - `false` (default) — `structured-clone-es` round-trips fancy
+   *   types. Cannot be `agent`-exposed (registration throws `DF0018`).
+   */
+  jsonSerializable?: boolean; /** Function implementation (required if setup doesn't provide one) */
+  handler?: (...args: InferArgsType<TArgsSchema>) => InferReturnType<TReturnSchema>;
+};
+type RpcFunctionDefinitionAny = RpcFunctionDefinition<string, any, any, any, any>;
+//#endregion
+export { InferArgsType, InferReturnType, RpcArgsSchema, RpcFunctionDefinition, RpcFunctionDefinitionAny, RpcReturnSchema };
+//# sourceMappingURL=types.d.cts.map

package/dist/rpc/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/rpc/types.ts"],"mappings":";;;;KAqBY,aAAA,YAAyB,aAAA;AAArC;AAAA,KAEY,eAAA,GAAkB,aAAA;;KAGlB,aAAA,WAAwB,aAAA,gBAClC,CAAA,4BAEI,CAAA,0CACE,CAAA,SAAU,aAAA,GACR,CAAA,kBAAmB,aAAA,MAChB,UAAA,CAAW,CAAA,MAAO,aAAA,CAAc,CAAA;;KAMjC,eAAA,WAA0B,eAAA,gBACpC,CAAA,SAAU,eAAA,GAAkB,UAAA,CAAW,CAAA;;;;KAK7B,qBAAA,sFAIU,aAAA,gDACE,eAAA,6BACnB,WAAA,EAAa,aAAA;EAxBN;;;EA6BN,IAAA,EAAM,KAAA;EA5BV;;;EAiCI,IAAA,GAAO,WAAA;EA5BW;;;EAiClB,OAAA,GAAU,aAAA;EAjC4B;;;;;;;;;EA4CtC,gBAAA;EA7CI;;;EAkDJ,OAAA,MAAa,IAAA,EAAM,KAAA,KAAU,QAAA;AAAA;EAjDU;;;EAuDvC,IAAA,EAAM,KAAA;EAjDe;;;EAsDrB,IAAA,GAAO,WAAA;EArDD;;;EA0DN,OAAA,GAAU,aAAA;EA1DwB;;;;;;;;;EAqElC,gBAAA,YAhE2B;EAmE3B,OAAA,OACK,IAAA,EAAM,aAAA,CAAc,WAAA,MACpB,eAAA,CAAgB,aAAA;AAAA;AAAA,KAGf,wBAAA,GAA2B,qBAAA"}

package/dist/rpc/types.d.mts

@@ -0,0 +1,70 @@
+import { GenericSchema, InferInput } from "valibot";
+
+//#region src/rpc/types.d.ts
+/** Valibot schema array for validating function arguments */
+type RpcArgsSchema = readonly GenericSchema[];
+/** Valibot schema for validating function return value */
+type RpcReturnSchema = GenericSchema;
+/** Infers TypeScript tuple type from Valibot schema array */
+type InferArgsType<S extends RpcArgsSchema | undefined> = S extends readonly [] ? [] : S extends readonly [infer H, ...infer T] ? H extends GenericSchema ? T extends readonly GenericSchema[] ? [InferInput<H>, ...InferArgsType<T>] : never : never : never;
+/** Infers TypeScript return type from Valibot return schema */
+type InferReturnType<S extends RpcReturnSchema | undefined> = S extends RpcReturnSchema ? InferInput<S> : void;
+/**
+ * RPC function definition with optional dump support.
+ */
+type RpcFunctionDefinition<TName extends string, TArgs extends any[] = [], TReturns = void, TArgsSchema extends RpcArgsSchema | undefined = undefined, TReturnSchema extends RpcReturnSchema | undefined = undefined> = [TArgsSchema, TReturnSchema] extends [undefined, undefined] ? {
+  /**
+   * Function name (unique identifier)
+   */
+  name: TName;
+  /**
+   * Valibot schema array for validating function arguments
+   */
+  args?: TArgsSchema;
+  /**
+   * Valibot schema for validating function return value
+   */
+  returns?: TReturnSchema;
+  /**
+   * Declares whether this function's args/return are JSON-serializable
+   * (no Map/Set/Date/BigInt/cycles/class instances/undefined/Symbol/Function).
+   *
+   * - `true` — wire and dump use strict `JSON.stringify`; misshapen
+   *   values throw `DF0019` at the call site. Required for `agent`.
+   * - `false` (default) — `structured-clone-es` round-trips fancy
+   *   types. Cannot be `agent`-exposed (registration throws `DF0018`).
+   */
+  jsonSerializable?: boolean;
+  /**
+   * Function implementation (required if setup doesn't provide one)
+   */
+  handler: (...args: TArgs) => TReturns;
+} : {
+  /**
+   * Function name (unique identifier)
+   */
+  name: TName;
+  /**
+   * Valibot schema array for validating function arguments
+   */
+  args?: TArgsSchema;
+  /**
+   * Valibot schema for validating function return value
+   */
+  returns?: TReturnSchema;
+  /**
+   * Declares whether this function's args/return are JSON-serializable
+   * (no Map/Set/Date/BigInt/cycles/class instances/undefined/Symbol/Function).
+   *
+   * - `true` — wire and dump use strict `JSON.stringify`; misshapen
+   *   values throw `DF0019` at the call site. Required for `agent`.
+   * - `false` (default) — `structured-clone-es` round-trips fancy
+   *   types. Cannot be `agent`-exposed (registration throws `DF0018`).
+   */
+  jsonSerializable?: boolean; /** Function implementation (required if setup doesn't provide one) */
+  handler?: (...args: InferArgsType<TArgsSchema>) => InferReturnType<TReturnSchema>;
+};
+type RpcFunctionDefinitionAny = RpcFunctionDefinition<string, any, any, any, any>;
+//#endregion
+export { InferArgsType, InferReturnType, RpcArgsSchema, RpcFunctionDefinition, RpcFunctionDefinitionAny, RpcReturnSchema };
+//# sourceMappingURL=types.d.mts.map

package/dist/rpc/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/rpc/types.ts"],"mappings":";;;;KAqBY,aAAA,YAAyB,aAAA;AAArC;AAAA,KAEY,eAAA,GAAkB,aAAA;;KAGlB,aAAA,WAAwB,aAAA,gBAClC,CAAA,4BAEI,CAAA,0CACE,CAAA,SAAU,aAAA,GACR,CAAA,kBAAmB,aAAA,MAChB,UAAA,CAAW,CAAA,MAAO,aAAA,CAAc,CAAA;;KAMjC,eAAA,WAA0B,eAAA,gBACpC,CAAA,SAAU,eAAA,GAAkB,UAAA,CAAW,CAAA;;;;KAK7B,qBAAA,sFAIU,aAAA,gDACE,eAAA,6BACnB,WAAA,EAAa,aAAA;EAxBN;;;EA6BN,IAAA,EAAM,KAAA;EA5BV;;;EAiCI,IAAA,GAAO,WAAA;EA5BW;;;EAiClB,OAAA,GAAU,aAAA;EAjC4B;;;;;;;;;EA4CtC,gBAAA;EA7CI;;;EAkDJ,OAAA,MAAa,IAAA,EAAM,KAAA,KAAU,QAAA;AAAA;EAjDU;;;EAuDvC,IAAA,EAAM,KAAA;EAjDe;;;EAsDrB,IAAA,GAAO,WAAA;EArDD;;;EA0DN,OAAA,GAAU,aAAA;EA1DwB;;;;;;;;;EAqElC,gBAAA,YAhE2B;EAmE3B,OAAA,OACK,IAAA,EAAM,aAAA,CAAc,WAAA,MACpB,eAAA,CAAgB,aAAA;AAAA;AAAA,KAGf,wBAAA,GAA2B,qBAAA"}

package/dist/rpc/types.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/schemas.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_fs = require('./fs-XogSgMqT.cjs');
+const require_fs = require('./fs-CeEdzPKE.cjs');
 
 exports.FileId = require_fs.FileId;
 exports.FileMetadata = require_fs.FileMetadata;

package/dist/schemas.mjs

@@ -1,3 +1,3 @@
-import { a as FileSystem, i as FileStorage, n as FileMetadata, o as _capnpFileId, r as FileMetadata_KeyValuePair, t as FileId } from "./fs-D1nIP45P.mjs";
+import { a as FileSystem, i as FileStorage, n as FileMetadata, o as _capnpFileId, r as FileMetadata_KeyValuePair, t as FileId } from "./fs-Dcle8lUp.mjs";
 
 export { FileId, FileMetadata, FileMetadata_KeyValuePair, FileStorage, FileSystem, _capnpFileId };