devframe 0.9.0 → 0.9.2

package/dist/validation-CpXFB6Dz.mjs

@@ -1,266 +0,0 @@
-import { t as diagnostics } from "./diagnostics-CD8nlgll.mjs";
-import { createHash } from "node:crypto";
-//#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/node/index.mjs
-const e = globalThis.process?.getBuiltinModule?.("crypto")?.hash;
-const r = "sha256";
-const s = "base64url";
-function digest(t) {
-	if (e) return e(r, t, s);
-	const o = createHash(r).update(t);
-	return globalThis.process?.versions?.webcontainer ? o.digest().toString(s) : o.digest(s);
-}
-//#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
-//#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/{host-h3-Crkzm42q.mjs → host-h3-fRbF9yor.mjs}

@@ -1,5 +1,5 @@
-import { join } from "pathe";
 import process from "node:process";
+import { join } from "pathe";
 import { homedir } from "node:os";
 //#region src/node/host-h3.ts
 /**