devframe 0.9.1 → 0.9.3

package/dist/validation-YrZH6atx.mjs

@@ -0,0 +1,311 @@
+import { t as diagnostics } from "./diagnostics-CD8nlgll.mjs";
+import { createHash } from "node:crypto";
+//#region ../../node_modules/.pnpm/ohash@2.0.12/node_modules/ohash/dist/_chunks/is-equal.mjs
+function serialize(input) {
+	if (typeof input === "string") return `'${input}'`;
+	return new Serializer().serialize(input);
+}
+const asciiOrder = " _-,;:!?.'\"()[]{}@*/\\&#%`^+<=>|~$0123456789abcdefghijklmnopqrstuvwxyz";
+const asciiWeights = /*@__PURE__*/ (function() {
+	const weights = /* @__PURE__ */ new Uint8Array(128);
+	for (let i = 0; i < 69; i++) weights[asciiOrder.charCodeAt(i)] = i + 1;
+	for (let code = 65; code <= 90; code++) weights[code] = weights[code + 32];
+	return weights;
+})();
+function compareStrings(a, b) {
+	if (a === b) return 0;
+	const length = Math.min(a.length, b.length);
+	let tieBreaker = 0;
+	for (let i = 0; i < length; i++) {
+		const codeA = a.charCodeAt(i);
+		const codeB = b.charCodeAt(i);
+		if (codeA === codeB) continue;
+		const weightA = codeA < 128 && asciiWeights[codeA] ? asciiWeights[codeA] : codeA + 128;
+		const weightB = codeB < 128 && asciiWeights[codeB] ? asciiWeights[codeB] : codeB + 128;
+		if (weightA !== weightB) return weightA < weightB ? -1 : 1;
+		if (tieBreaker === 0) tieBreaker = codeA > codeB ? -1 : 1;
+	}
+	if (a.length !== b.length) return a.length < b.length ? -1 : 1;
+	return tieBreaker;
+}
+const Serializer = /*@__PURE__*/ (function() {
+	class Serializer {
+		#context = /* @__PURE__ */ new Map();
+		compare(a, b) {
+			const typeA = typeof a;
+			const typeB = typeof b;
+			if (typeA === "string" && typeB === "string") return compareStrings(a, b);
+			if (typeA === "number" && typeB === "number") return a - b;
+			return compareStrings(this.serialize(a, true), this.serialize(b, true));
+		}
+		serialize(value, noQuotes) {
+			if (value === null) return "null";
+			switch (typeof value) {
+				case "string": return noQuotes ? value : `'${value}'`;
+				case "bigint": return `${value}n`;
+				case "object": return this.$object(value);
+				case "function": return this.$function(value);
+			}
+			return String(value);
+		}
+		serializeObject(object) {
+			const objString = Object.prototype.toString.call(object);
+			if (objString !== "[object Object]") return this.serializeBuiltInType(objString.length < 10 ? `unknown:${objString}` : objString.slice(8, -1), object);
+			const constructor = object.constructor;
+			const objName = constructor === Object || constructor === void 0 ? "" : constructor.name;
+			if (objName !== "" && globalThis[objName] === constructor) return this.serializeBuiltInType(objName, object);
+			if ("toJSON" in object && typeof object.toJSON === "function") {
+				const json = object.toJSON();
+				return objName + (json !== null && typeof json === "object" ? this.$object(json) : `(${this.serialize(json)})`);
+			}
+			const keys = Object.keys(object).sort(compareStrings);
+			let content = `${objName}{`;
+			for (let i = 0; i < keys.length; i++) {
+				const key = keys[i];
+				content += `${key}:${this.serialize(object[key])}`;
+				if (i < keys.length - 1) content += ",";
+			}
+			return content + "}";
+		}
+		serializeBuiltInType(type, object) {
+			const handler = this["$" + type];
+			if (handler) return handler.call(this, object);
+			if (typeof object.entries === "function") return this.serializeObjectEntries(type, object.entries());
+			throw new Error(`Cannot serialize ${type}`);
+		}
+		serializeObjectEntries(type, entries) {
+			const sortedEntries = Array.from(entries).sort((a, b) => this.compare(a[0], b[0]));
+			let content = `${type}{`;
+			for (let i = 0; i < sortedEntries.length; i++) {
+				const [key, value] = sortedEntries[i];
+				content += `${this.serialize(key, true)}:${this.serialize(value)}`;
+				if (i < sortedEntries.length - 1) content += ",";
+			}
+			return content + "}";
+		}
+		$object(object) {
+			let content = this.#context.get(object);
+			if (content === void 0) {
+				this.#context.set(object, `#${this.#context.size}`);
+				content = this.serializeObject(object);
+				this.#context.set(object, content);
+			}
+			return content;
+		}
+		$function(fn) {
+			const fnStr = Function.prototype.toString.call(fn);
+			if (fnStr.slice(-15) === "[native code] }") return `${fn.name || ""}()[native]`;
+			return `${fn.name}(${fn.length})${fnStr.replace(/\s*\n\s*/g, "")}`;
+		}
+		$Array(arr) {
+			let content = "[";
+			for (let i = 0; i < arr.length; i++) {
+				content += this.serialize(arr[i]);
+				if (i < arr.length - 1) content += ",";
+			}
+			return content + "]";
+		}
+		$Date(date) {
+			try {
+				return `Date(${date.toISOString()})`;
+			} catch {
+				return `Date(null)`;
+			}
+		}
+		$ArrayBuffer(arr) {
+			return `ArrayBuffer[${new Uint8Array(arr).join(",")}]`;
+		}
+		$Set(set) {
+			return `Set${this.$Array(Array.from(set).sort((a, b) => this.compare(a, b)))}`;
+		}
+		$Map(map) {
+			return this.serializeObjectEntries("Map", map.entries());
+		}
+	}
+	for (const type of [
+		"Error",
+		"RegExp",
+		"URL"
+	]) Serializer.prototype["$" + type] = function(val) {
+		return `${type}(${val})`;
+	};
+	for (const type of [
+		"Int8Array",
+		"Uint8Array",
+		"Uint8ClampedArray",
+		"Int16Array",
+		"Uint16Array",
+		"Int32Array",
+		"Uint32Array",
+		"Float32Array",
+		"Float64Array"
+	]) Serializer.prototype["$" + type] = function(arr) {
+		return `${type}[${arr.join(",")}]`;
+	};
+	for (const type of ["BigInt64Array", "BigUint64Array"]) Serializer.prototype["$" + type] = function(arr) {
+		return `${type}[${arr.join("n,")}${arr.length > 0 ? "n" : ""}]`;
+	};
+	return Serializer;
+})();
+//#endregion
+//#region ../../node_modules/.pnpm/ohash@2.0.12/node_modules/ohash/dist/crypto/node/index.mjs
+const fastHash = /*@__PURE__*/ (() => globalThis.process?.getBuiltinModule?.("crypto")?.hash)();
+const algorithm = "sha256";
+const encoding = "base64url";
+function digest(data) {
+	if (fastHash) return fastHash(algorithm, data, encoding);
+	const h = createHash(algorithm).update(data);
+	return globalThis.process?.versions?.webcontainer ? h.digest().toString(encoding) : h.digest(encoding);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/ohash@2.0.12/node_modules/ohash/dist/index.mjs
+function hash$1(input) {
+	return digest(serialize(input));
+}
+//#endregion
+//#region src/utils/hash.ts
+/**
+* Stable, deterministic hash of any structured-cloneable value.
+*/
+function hash(value) {
+	return hash$1(value);
+}
+//#endregion
+//#region src/rpc/validate-io.ts
+/**
+* Run a single [Standard Schema](https://standardschema.dev) validator,
+* awaiting the result when the validator is asynchronous.
+*/
+async function runStandardSchema(schema, value) {
+	const result = schema["~standard"].validate(value);
+	return result instanceof Promise ? await result : result;
+}
+/**
+* Render Standard Schema issues into a single human-readable line for a
+* diagnostic message, prefixing each with its dotted path when present.
+*/
+function formatIssues(issues) {
+	return issues.map((issue) => {
+		const path = issue.path?.map((segment) => typeof segment === "object" ? segment.key : segment).join(".");
+		return path ? `${path}: ${issue.message}` : issue.message;
+	}).join("; ");
+}
+/**
+* Validate positional arguments against their declared schemas. Only
+* indices with a schema are checked; extra arguments pass through
+* untouched. Throws `DF0038` on the first failing argument.
+*
+* Validation guards the payload without rewriting it: the original values
+* are handed to the handler unchanged, so a schema that describes a subset
+* of an object never silently strips the sender's extra fields (and any
+* declared transforms stay a purely type-level concern).
+*
+* @internal
+*/
+async function validateRpcArgs(name, argsSchema, args) {
+	const original = args.slice();
+	if (!argsSchema || argsSchema.length === 0) return original;
+	for (let index = 0; index < argsSchema.length; index++) {
+		const schema = argsSchema[index];
+		if (!schema) continue;
+		const result = await runStandardSchema(schema, args[index]);
+		if (result.issues) throw diagnostics.DF0043({
+			name,
+			index,
+			issues: formatIssues(result.issues)
+		});
+	}
+	return original;
+}
+/**
+* Validate a handler's resolved return value against its declared schema.
+* Throws `DF0039` when the value fails the schema, otherwise returns the
+* original value unchanged (guard-only, never rewriting the payload — see
+* {@link validateRpcArgs}). Passes through when no return schema is set.
+*
+* @internal
+*/
+async function validateRpcReturn(name, returnSchema, value) {
+	if (!returnSchema) return value;
+	const result = await runStandardSchema(returnSchema, value);
+	if (result.issues) throw diagnostics.DF0044({
+		name,
+		issues: formatIssues(result.issues)
+	});
+	return value;
+}
+//#endregion
+//#region src/rpc/handler.ts
+async function getRpcResolvedSetupResult(definition, context) {
+	if (!definition.setup) return {};
+	if (typeof context === "object" && context !== null) {
+		definition.__cache ??= /* @__PURE__ */ new WeakMap();
+		const cache = definition.__cache;
+		let promise = cache.get(context);
+		if (!promise) {
+			promise = Promise.resolve(definition.setup(context));
+			promise.catch(() => {
+				if (cache.get(context) === promise) cache.delete(context);
+			});
+			cache.set(context, promise);
+		}
+		return await promise;
+	}
+	if (!definition.__promise) {
+		const promise = Promise.resolve(definition.setup(context));
+		promise.catch(() => {
+			if (definition.__promise === promise) definition.__promise = void 0;
+		});
+		definition.__promise = promise;
+	}
+	return await definition.__promise;
+}
+async function getRpcHandler(definition, context) {
+	let handler = definition.handler;
+	if (!handler) {
+		const result = await getRpcResolvedSetupResult(definition, context);
+		if (!result.handler) throw diagnostics.DF0024({ name: definition.name });
+		handler = result.handler;
+	}
+	const argsSchema = definition.args;
+	const returnSchema = definition.returns;
+	if (!argsSchema && !returnSchema) return handler;
+	const inner = handler;
+	const validating = async (...args) => {
+		const validatedArgs = await validateRpcArgs(definition.name, argsSchema, args);
+		const output = await inner(...validatedArgs);
+		return await validateRpcReturn(definition.name, returnSchema, output);
+	};
+	return validating;
+}
+//#endregion
+//#region src/rpc/validation.ts
+/**
+* Validates RPC function definitions.
+* Action and event functions cannot have dumps (side effects should not be cached).
+*
+* @throws {Error} If an action or event function has a dump configuration
+*/
+function validateDefinitions(definitions) {
+	for (const definition of definitions) {
+		const type = definition.type || "query";
+		if ((type === "action" || type === "event") && definition.dump) throw diagnostics.DF0027({
+			name: definition.name,
+			type
+		});
+		if (definition.snapshot && type !== "query") throw diagnostics.DF0028({
+			name: definition.name,
+			type
+		});
+	}
+}
+/**
+* Validates a single RPC function definition.
+*
+* @throws {Error} If an action or event function has a dump configuration
+*/
+function validateDefinition(definition) {
+	validateDefinitions([definition]);
+}
+//#endregion
+export { validateRpcArgs as a, getRpcResolvedSetupResult as i, validateDefinitions as n, validateRpcReturn as o, getRpcHandler as r, hash as s, validateDefinition as t };

package/dist/{ws-client-DhjNyQo3.d.mts → ws-client-Bo2t6hES.d.mts}

@@ -1,4 +1,4 @@
-import { v as RpcFunctionDefinitionAny } from "./types-Djq7CBXh.mjs";
+import { v as RpcFunctionDefinitionAny } from "./types-BBLeGfpt.mjs";
 import { ChannelOptions } from "birpc";
 //#region src/rpc/transports/ws-client.d.ts
 interface WsRpcChannelOptions {

package/dist/{ws-server-D1d3QM9f.d.mts → ws-server-DLtEoLdR.d.mts}

@@ -1,4 +1,4 @@
-import { v as RpcFunctionDefinitionAny } from "./types-Djq7CBXh.mjs";
+import { v as RpcFunctionDefinitionAny } from "./types-BBLeGfpt.mjs";
 import { BirpcGroup, ChannelOptions } from "birpc";
 import { Hooks, Peer } from "crossws";
 import { NodeAdapter } from "crossws/adapters/node";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "devframe",
   "type": "module",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "Framework for building one portable devtool integration that runs in any viewer.",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -41,6 +41,7 @@
     "./rpc/transports/sse-client": "./dist/rpc/transports/sse-client.mjs",
     "./rpc/transports/sse-server": "./dist/rpc/transports/sse-server.mjs",
     "./rpc/transports/ws-bun": "./dist/rpc/transports/ws-bun.mjs",
+    "./rpc/transports/ws-deno": "./dist/rpc/transports/ws-deno.mjs",
     "./rpc/transports/ws-client": "./dist/rpc/transports/ws-client.mjs",
     "./rpc/transports/ws-server": "./dist/rpc/transports/ws-server.mjs",
     "./types": "./dist/types/index.mjs",
@@ -103,11 +104,11 @@
     "@modelcontextprotocol/server": "^2.0.0",
     "cac": "^7.0.0",
     "get-port-please": "^3.2.0",
-    "immer": "^11.1.16",
+    "immer": "^11.1.17",
     "launch-editor": "^2.14.1",
     "mlly": "^1.8.2",
     "obug": "^2.1.4",
-    "ohash": "^2.0.11",
+    "ohash": "^2.0.12",
     "p-limit": "^7.3.1",
     "perfect-debounce": "^2.1.0",
     "structured-clone-es": "^2.0.1",

package/skills/devframe/SKILL.md

@@ -558,7 +558,7 @@ Devframe re-exports a curated set of helpers under `devframe/utils/*`. They are
 | `createStreamSink` / `createStreamReader` from `devframe/utils/streaming-channel` | - | Low-level streaming primitives |
 | `evaluateWhen` / `WhenExpression` from `devframe/utils/when` | `whenexpr` | When-clause expressions |
 
-For "open file in editor" + "reveal in finder", prefer the prebuilt `commonRpcFunctions` RPC recipe (`devframe/recipes/common-rpc-functions`) - it wires the two utilities into named RPC functions ready to register.
+For "open file in editor" + "reveal in finder", prefer the `@devframes/service-open` wire service (declare `services: [{ package: '@devframes/service-open' }]` on the definition, gate client UI on `rpc.services.has(...)`) - one host-level installation shared by every plugin, with workspace-root path containment. The older `commonRpcFunctions` recipe (`devframe/recipes/common-rpc-functions`) still works but is deprecated.
 
 ## Security (secure by default)
 

package/dist/hash-KtDZYXDN.mjs

@@ -1,266 +0,0 @@
-//#region ../../node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/shared/ohash.D__AXeF1.mjs
-function serialize(o) {
-	return typeof o == "string" ? `'${o}'` : new c().serialize(o);
-}
-const c = /*@__PURE__*/ function() {
-	class o {
-		#t = /* @__PURE__ */ new Map();
-		compare(t, r) {
-			const e = typeof t, n = typeof r;
-			return e === "string" && n === "string" ? t.localeCompare(r) : e === "number" && n === "number" ? t - r : String.prototype.localeCompare.call(this.serialize(t, true), this.serialize(r, true));
-		}
-		serialize(t, r) {
-			if (t === null) return "null";
-			switch (typeof t) {
-				case "string": return r ? t : `'${t}'`;
-				case "bigint": return `${t}n`;
-				case "object": return this.$object(t);
-				case "function": return this.$function(t);
-			}
-			return String(t);
-		}
-		serializeObject(t) {
-			const r = Object.prototype.toString.call(t);
-			if (r !== "[object Object]") return this.serializeBuiltInType(r.length < 10 ? `unknown:${r}` : r.slice(8, -1), t);
-			const e = t.constructor, n = e === Object || e === void 0 ? "" : e.name;
-			if (n !== "" && globalThis[n] === e) return this.serializeBuiltInType(n, t);
-			if (typeof t.toJSON == "function") {
-				const i = t.toJSON();
-				return n + (i !== null && typeof i == "object" ? this.$object(i) : `(${this.serialize(i)})`);
-			}
-			return this.serializeObjectEntries(n, Object.entries(t));
-		}
-		serializeBuiltInType(t, r) {
-			const e = this["$" + t];
-			if (e) return e.call(this, r);
-			if (typeof r?.entries == "function") return this.serializeObjectEntries(t, r.entries());
-			throw new Error(`Cannot serialize ${t}`);
-		}
-		serializeObjectEntries(t, r) {
-			const e = Array.from(r).sort((i, a) => this.compare(i[0], a[0]));
-			let n = `${t}{`;
-			for (let i = 0; i < e.length; i++) {
-				const [a, l] = e[i];
-				n += `${this.serialize(a, true)}:${this.serialize(l)}`, i < e.length - 1 && (n += ",");
-			}
-			return n + "}";
-		}
-		$object(t) {
-			let r = this.#t.get(t);
-			return r === void 0 && (this.#t.set(t, `#${this.#t.size}`), r = this.serializeObject(t), this.#t.set(t, r)), r;
-		}
-		$function(t) {
-			const r = Function.prototype.toString.call(t);
-			return r.slice(-15) === "[native code] }" ? `${t.name || ""}()[native]` : `${t.name}(${t.length})${r.replace(/\s*\n\s*/g, "")}`;
-		}
-		$Array(t) {
-			let r = "[";
-			for (let e = 0; e < t.length; e++) r += this.serialize(t[e]), e < t.length - 1 && (r += ",");
-			return r + "]";
-		}
-		$Date(t) {
-			try {
-				return `Date(${t.toISOString()})`;
-			} catch {
-				return "Date(null)";
-			}
-		}
-		$ArrayBuffer(t) {
-			return `ArrayBuffer[${new Uint8Array(t).join(",")}]`;
-		}
-		$Set(t) {
-			return `Set${this.$Array(Array.from(t).sort((r, e) => this.compare(r, e)))}`;
-		}
-		$Map(t) {
-			return this.serializeObjectEntries("Map", t.entries());
-		}
-	}
-	for (const s of [
-		"Error",
-		"RegExp",
-		"URL"
-	]) o.prototype["$" + s] = function(t) {
-		return `${s}(${t})`;
-	};
-	for (const s of [
-		"Int8Array",
-		"Uint8Array",
-		"Uint8ClampedArray",
-		"Int16Array",
-		"Uint16Array",
-		"Int32Array",
-		"Uint32Array",
-		"Float32Array",
-		"Float64Array"
-	]) o.prototype["$" + s] = function(t) {
-		return `${s}[${t.join(",")}]`;
-	};
-	for (const s of ["BigInt64Array", "BigUint64Array"]) o.prototype["$" + s] = function(t) {
-		return `${s}[${t.join("n,")}${t.length > 0 ? "n" : ""}]`;
-	};
-	return o;
-}();
-//#endregion
-//#region ../../node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/crypto/js/index.mjs
-const z = [
-	1779033703,
-	-1150833019,
-	1013904242,
-	-1521486534,
-	1359893119,
-	-1694144372,
-	528734635,
-	1541459225
-];
-const R = [
-	1116352408,
-	1899447441,
-	-1245643825,
-	-373957723,
-	961987163,
-	1508970993,
-	-1841331548,
-	-1424204075,
-	-670586216,
-	310598401,
-	607225278,
-	1426881987,
-	1925078388,
-	-2132889090,
-	-1680079193,
-	-1046744716,
-	-459576895,
-	-272742522,
-	264347078,
-	604807628,
-	770255983,
-	1249150122,
-	1555081692,
-	1996064986,
-	-1740746414,
-	-1473132947,
-	-1341970488,
-	-1084653625,
-	-958395405,
-	-710438585,
-	113926993,
-	338241895,
-	666307205,
-	773529912,
-	1294757372,
-	1396182291,
-	1695183700,
-	1986661051,
-	-2117940946,
-	-1838011259,
-	-1564481375,
-	-1474664885,
-	-1035236496,
-	-949202525,
-	-778901479,
-	-694614492,
-	-200395387,
-	275423344,
-	430227734,
-	506948616,
-	659060556,
-	883997877,
-	958139571,
-	1322822218,
-	1537002063,
-	1747873779,
-	1955562222,
-	2024104815,
-	-2067236844,
-	-1933114872,
-	-1866530822,
-	-1538233109,
-	-1090935817,
-	-965641998
-];
-const S = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
-const r = [];
-var k = class {
-	_data = new l();
-	_hash = new l([...z]);
-	_nDataBytes = 0;
-	_minBufferSize = 0;
-	finalize(e) {
-		e && this._append(e);
-		const s = this._nDataBytes * 8, t = this._data.sigBytes * 8;
-		return this._data.words[t >>> 5] |= 128 << 24 - t % 32, this._data.words[(t + 64 >>> 9 << 4) + 14] = Math.floor(s / 4294967296), this._data.words[(t + 64 >>> 9 << 4) + 15] = s, this._data.sigBytes = this._data.words.length * 4, this._process(), this._hash;
-	}
-	_doProcessBlock(e, s) {
-		const t = this._hash.words;
-		let i = t[0], o = t[1], a = t[2], c = t[3], h = t[4], g = t[5], f = t[6], y = t[7];
-		for (let n = 0; n < 64; n++) {
-			if (n < 16) r[n] = e[s + n] | 0;
-			else {
-				const d = r[n - 15], j = (d << 25 | d >>> 7) ^ (d << 14 | d >>> 18) ^ d >>> 3, B = r[n - 2], x = (B << 15 | B >>> 17) ^ (B << 13 | B >>> 19) ^ B >>> 10;
-				r[n] = j + r[n - 7] + x + r[n - 16];
-			}
-			const m = h & g ^ ~h & f, p = i & o ^ i & a ^ o & a, u = (i << 30 | i >>> 2) ^ (i << 19 | i >>> 13) ^ (i << 10 | i >>> 22), b = (h << 26 | h >>> 6) ^ (h << 21 | h >>> 11) ^ (h << 7 | h >>> 25), w = y + b + m + R[n] + r[n], M = u + p;
-			y = f, f = g, g = h, h = c + w | 0, c = a, a = o, o = i, i = w + M | 0;
-		}
-		t[0] = t[0] + i | 0, t[1] = t[1] + o | 0, t[2] = t[2] + a | 0, t[3] = t[3] + c | 0, t[4] = t[4] + h | 0, t[5] = t[5] + g | 0, t[6] = t[6] + f | 0, t[7] = t[7] + y | 0;
-	}
-	_append(e) {
-		typeof e == "string" && (e = l.fromUtf8(e)), this._data.concat(e), this._nDataBytes += e.sigBytes;
-	}
-	_process(e) {
-		let s, t = this._data.sigBytes / 64;
-		e ? t = Math.ceil(t) : t = Math.max((t | 0) - this._minBufferSize, 0);
-		const i = t * 16, o = Math.min(i * 4, this._data.sigBytes);
-		if (i) {
-			for (let a = 0; a < i; a += 16) this._doProcessBlock(this._data.words, a);
-			s = this._data.words.splice(0, i), this._data.sigBytes -= o;
-		}
-		return new l(s, o);
-	}
-};
-var l = class l {
-	words;
-	sigBytes;
-	constructor(e, s) {
-		e = this.words = e || [], this.sigBytes = s === void 0 ? e.length * 4 : s;
-	}
-	static fromUtf8(e) {
-		const s = unescape(encodeURIComponent(e)), t = s.length, i = [];
-		for (let o = 0; o < t; o++) i[o >>> 2] |= (s.charCodeAt(o) & 255) << 24 - o % 4 * 8;
-		return new l(i, t);
-	}
-	toBase64() {
-		const e = [];
-		for (let s = 0; s < this.sigBytes; s += 3) {
-			const t = this.words[s >>> 2] >>> 24 - s % 4 * 8 & 255, i = this.words[s + 1 >>> 2] >>> 24 - (s + 1) % 4 * 8 & 255, o = this.words[s + 2 >>> 2] >>> 24 - (s + 2) % 4 * 8 & 255, a = t << 16 | i << 8 | o;
-			for (let c = 0; c < 4 && s * 8 + c * 6 < this.sigBytes * 8; c++) e.push(S.charAt(a >>> 6 * (3 - c) & 63));
-		}
-		return e.join("");
-	}
-	concat(e) {
-		if (this.words[this.sigBytes >>> 2] &= 4294967295 << 32 - this.sigBytes % 4 * 8, this.words.length = Math.ceil(this.sigBytes / 4), this.sigBytes % 4) for (let s = 0; s < e.sigBytes; s++) {
-			const t = e.words[s >>> 2] >>> 24 - s % 4 * 8 & 255;
-			this.words[this.sigBytes + s >>> 2] |= t << 24 - (this.sigBytes + s) % 4 * 8;
-		}
-		else for (let s = 0; s < e.sigBytes; s += 4) this.words[this.sigBytes + s >>> 2] = e.words[s >>> 2];
-		this.sigBytes += e.sigBytes;
-	}
-};
-function digest(_) {
-	return new k().finalize(_).toBase64();
-}
-//#endregion
-//#region ../../node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/index.mjs
-function hash$1(input) {
-	return digest(serialize(input));
-}
-//#endregion
-//#region src/utils/hash.ts
-/**
-* Stable, deterministic hash of any structured-cloneable value.
-*/
-function hash(value) {
-	return hash$1(value);
-}
-//#endregion
-export { hash as t };