devframe 0.8.2 → 0.9.0-beta.10

package/dist/utils/remote-assets.d.mts

@@ -0,0 +1,15 @@
+import { a as RemoteAssetsStore, o as StaticAssetsSource } from "../remote-assets-Bg4gCUZ_.mjs";
+//#region src/utils/remote-assets.d.ts
+/**
+ * Normalize a {@link StaticAssetsSource} into something servable: a local
+ * directory (strings pass through; a remote source short-circuits to a
+ * locally installed copy of its package when present) or a caching
+ * {@link RemoteAssetsStore} back-proxy. Remote caches live under
+ * `<projectStorageDir>/.remote-assets/<package>@<version>/`.
+ *
+ * A remote source's `package`/`version` are validated first (`DF0065`) — both
+ * are interpolated into CDN URLs and the cache path.
+ */
+declare function resolveStaticAssetsSource(source: StaticAssetsSource, projectStorageDir: string): string | RemoteAssetsStore;
+//#endregion
+export { resolveStaticAssetsSource };

package/dist/utils/remote-assets.mjs

@@ -0,0 +1,2 @@
+import { t as resolveStaticAssetsSource } from "../remote-assets-nTTxY2MU.mjs";
+export { resolveStaticAssetsSource };

package/dist/utils/serve-static.d.mts

@@ -1,6 +1,12 @@
+import { a as RemoteAssetsStore } from "../remote-assets-Bg4gCUZ_.mjs";
 import { IncomingMessage, ServerResponse } from "node:http";
 import { EventHandler, H3 } from "h3";
 //#region src/utils/serve-static.d.ts
+/**
+ * What the static-serving engine accepts: a local directory, or a resolved
+ * {@link RemoteAssetsStore} back-proxy (from `devframe/utils/remote-assets`).
+ */
+type ServableAssets = string | RemoteAssetsStore;
 interface ServeStaticOptions {
   /** Default: `['index.html']`. */
   indexNames?: string[];
@@ -8,7 +14,9 @@ interface ServeStaticOptions {
   single?: boolean;
 }
 /**
- * h3 event handler that serves files from `dir` with SPA fallback.
+ * h3 event handler that serves files from `source` with SPA fallback — a
+ * local directory, or a {@link RemoteAssetsStore} whose files stream through
+ * the CDN back-proxy into the local cache.
  *
  * Drop-in replacement for `fromNodeMiddleware(sirv(dir, { dev: true, single: true }))`
  * when the surrounding server is an h3 app — no `Cache-Control` beyond
@@ -16,7 +24,7 @@ interface ServeStaticOptions {
  * file extension falls back to `<dir>/index.html` so client-side routing
  * works.
  */
-declare function serveStaticHandler(dir: string, options?: ServeStaticOptions): EventHandler;
+declare function serveStaticHandler(source: ServableAssets, options?: ServeStaticOptions): EventHandler;
 /**
  * Mount {@link serveStaticHandler} on an h3 app at `base`.
  *
@@ -24,7 +32,7 @@ declare function serveStaticHandler(dir: string, options?: ServeStaticOptions):
  * from `event.url.pathname`, so the file resolver sees paths relative to
  * `dir`.
  */
-declare function mountStaticHandler(app: H3, base: string, dir: string, options?: ServeStaticOptions): void;
+declare function mountStaticHandler(app: H3, base: string, source: ServableAssets, options?: ServeStaticOptions): void;
 /**
  * Connect/Express-style Node middleware variant of {@link serveStaticHandler}.
  *
@@ -32,6 +40,6 @@ declare function mountStaticHandler(app: H3, base: string, dir: string, options?
  * Connect stack — avoids forcing the host package to depend on h3 just to
  * adapt an event handler back into Node middleware.
  */
-declare function serveStaticNodeMiddleware(dir: string, options?: ServeStaticOptions): (req: IncomingMessage, res: ServerResponse, next?: (err?: Error) => void) => void;
+declare function serveStaticNodeMiddleware(source: ServableAssets, options?: ServeStaticOptions): (req: IncomingMessage, res: ServerResponse, next?: (err?: Error) => void) => void;
 //#endregion
-export { ServeStaticOptions, mountStaticHandler, serveStaticHandler, serveStaticNodeMiddleware };
+export { ServableAssets, ServeStaticOptions, mountStaticHandler, serveStaticHandler, serveStaticNodeMiddleware };

package/dist/utils/serve-static.mjs

@@ -1,9 +1,10 @@
+import { DEVFRAME_REMOTE_ASSETS_ERROR_MESSAGE_TYPE } from "../constants.mjs";
 import { createReadStream } from "node:fs";
-import { extname, join, normalize, resolve, sep } from "pathe";
-import { H3, defineHandler } from "h3";
 import { stat } from "node:fs/promises";
 import { Readable } from "node:stream";
 import { lookup } from "mrmime";
+import { extname, join, normalize, resolve, sep } from "pathe";
+import { H3, defineHandler } from "h3";
 //#region src/utils/serve-static.ts
 const HTML_EXTENSIONS = [".html", ".htm"];
 async function statFile(abs) {
@@ -74,7 +75,43 @@ function normalizeOptions(options) {
 	};
 }
 /**
-* h3 event handler that serves files from `dir` with SPA fallback.
+* Drive one request through a {@link RemoteAssetsStore}: the store's
+* `Response` on a hit, a 404 on a miss, or a 502 (styled error page for HTML
+* navigations) on provider failure — shared between the h3 and connect flavors.
+*/
+async function remoteResponse(store, urlPath, accept) {
+	try {
+		return await store.serve(urlPath) ?? new Response(null, { status: 404 });
+	} catch (error) {
+		if (typeof accept === "string" && accept.includes("text/html")) return new Response(remoteErrorPage(store.assets.package, store.assets.version, error instanceof Error ? error.message : String(error)), {
+			status: 502,
+			headers: { "Content-Type": "text/html; charset=utf-8" }
+		});
+		return new Response(null, { status: 502 });
+	}
+}
+function serveRemoteAssetsHandler(store) {
+	return defineHandler(async (event) => {
+		const method = event.req.method;
+		if (method !== "GET" && method !== "HEAD") {
+			event.res.status = 405;
+			event.res.headers.set("Allow", "GET, HEAD");
+			return "";
+		}
+		const res = await remoteResponse(store, event.url.pathname, event.req.headers.get("accept"));
+		event.res.status = res.status;
+		res.headers.forEach((v, k) => event.res.headers.set(k, v));
+		if (method === "HEAD") {
+			await res.body?.cancel().catch(() => {});
+			return "";
+		}
+		return res.body ?? "";
+	});
+}
+/**
+* h3 event handler that serves files from `source` with SPA fallback — a
+* local directory, or a {@link RemoteAssetsStore} whose files stream through
+* the CDN back-proxy into the local cache.
 *
 * Drop-in replacement for `fromNodeMiddleware(sirv(dir, { dev: true, single: true }))`
 * when the surrounding server is an h3 app — no `Cache-Control` beyond
@@ -82,8 +119,9 @@ function normalizeOptions(options) {
 * file extension falls back to `<dir>/index.html` so client-side routing
 * works.
 */
-function serveStaticHandler(dir, options) {
-	const absDir = resolve(dir);
+function serveStaticHandler(source, options) {
+	if (typeof source !== "string") return serveRemoteAssetsHandler(source);
+	const absDir = resolve(source);
 	const opts = normalizeOptions(options);
 	return defineHandler(async (event) => {
 		const method = event.req.method;
@@ -109,9 +147,9 @@ function serveStaticHandler(dir, options) {
 * from `event.url.pathname`, so the file resolver sees paths relative to
 * `dir`.
 */
-function mountStaticHandler(app, base, dir, options) {
+function mountStaticHandler(app, base, source, options) {
 	const staticApp = new H3();
-	staticApp.use(serveStaticHandler(dir, options));
+	staticApp.use(serveStaticHandler(source, options));
 	app.mount(base.replace(/\/$/, ""), staticApp);
 }
 /**
@@ -121,8 +159,8 @@ function mountStaticHandler(app, base, dir, options) {
 * Connect stack — avoids forcing the host package to depend on h3 just to
 * adapt an event handler back into Node middleware.
 */
-function serveStaticNodeMiddleware(dir, options) {
-	const absDir = resolve(dir);
+function serveStaticNodeMiddleware(source, options) {
+	const absDir = typeof source === "string" ? resolve(source) : void 0;
 	const opts = normalizeOptions(options);
 	return (req, res, next) => {
 		(async () => {
@@ -138,6 +176,22 @@ function serveStaticNodeMiddleware(dir, options) {
 				return;
 			}
 			const url = req.url ?? "/";
+			if (absDir === void 0) {
+				const response = await remoteResponse(source, url, req.headers.accept);
+				if (response.status === 404 && next) {
+					next();
+					return;
+				}
+				res.statusCode = response.status;
+				response.headers.forEach((v, k) => res.setHeader(k, v));
+				if (method === "HEAD" || !response.body) {
+					await response.body?.cancel().catch(() => {});
+					res.end();
+					return;
+				}
+				Readable.fromWeb(response.body).pipe(res);
+				return;
+			}
 			const file = await resolveTarget(absDir, url, opts.indexNames, opts.single);
 			if (!file) {
 				if (next) {
@@ -164,5 +218,61 @@ function serveStaticNodeMiddleware(dir, options) {
 		});
 	};
 }
+/**
+* Minimal, dependency-free HTML shown when a remote-assets request cannot
+* be satisfied (no installed package, no cache, provider unreachable).
+*
+* The page stands on its own when a devframe is opened directly, and
+* announces itself over `postMessage` when it loads inside a viewer's iframe
+* ({@link DEVFRAME_REMOTE_ASSETS_ERROR_MESSAGE_TYPE}) so the viewer can show
+* the same failure in its own UI instead.
+*/
+function remoteErrorPage(pkg, version, reason) {
+	const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+	const name = esc(pkg);
+	const ver = esc(version);
+	const payload = JSON.stringify({
+		type: DEVFRAME_REMOTE_ASSETS_ERROR_MESSAGE_TYPE,
+		package: pkg,
+		version,
+		reason
+	}).replace(/</g, "\\u003c");
+	return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Client assets unavailable</title>
+<style>
+  :root { color-scheme: light dark; }
+  body { margin: 0; min-height: 100vh; display: grid; place-items: center; font: 14px/1.6 ui-sans-serif, system-ui, sans-serif; background: #fafafa; color: #27272a; }
+  main { max-width: 32rem; padding: 2rem; }
+  h1 { font-size: 1rem; font-weight: 600; margin: 0 0 .5rem; }
+  p { margin: .5rem 0; opacity: .8; }
+  pre { font: 12px/1.6 ui-monospace, monospace; background: rgb(125 125 125 / .12); border-radius: 6px; padding: .75rem 1rem; overflow-x: auto; }
+  button { font: inherit; padding: .35rem 1rem; border-radius: 6px; border: 1px solid rgb(125 125 125 / .3); background: transparent; color: inherit; cursor: pointer; }
+  button:hover { background: rgb(125 125 125 / .08); }
+  .muted { opacity: .55; font-size: 12px; }
+  @media (prefers-color-scheme: dark) { body { background: #111; color: #d4d4d8; } }
+</style>
+</head>
+<body>
+<main>
+  <h1>Client assets unavailable</h1>
+  <p>The UI for this tool is served from <code>${name}@${ver}</code>, which could not be reached.</p>
+  <pre>${esc(reason)}</pre>
+  <p>To use it without network access, install the assets package locally:</p>
+  <pre>npm install ${name}@${ver}</pre>
+  <button onclick="location.reload()">Retry</button>
+  <p class="muted">devframe remote assets</p>
+</main>
+<script>
+  if (window.parent !== window)
+    window.parent.postMessage(${payload}, '*')
+<\/script>
+</body>
+</html>
+`;
+}
 //#endregion
 export { mountStaticHandler, serveStaticHandler, serveStaticNodeMiddleware };

package/dist/utils/shared-state.d.mts

@@ -1,2 +1,2 @@
-import { _t as SharedStateOptions, dt as ImmutableArray, ft as ImmutableMap, gt as SharedStateEvents, ht as SharedState, mt as ImmutableSet, pt as ImmutableObject, ut as Immutable, vt as SharedStatePatch, yt as createSharedState } from "../devframe-mQ4qZAuo.mjs";
+import { at as ImmutableArray, ct as ImmutableSet, dt as SharedStateOptions, ft as SharedStatePatch, it as Immutable, lt as SharedState, ot as ImmutableMap, pt as createSharedState, st as ImmutableObject, ut as SharedStateEvents } from "../devframe-DJMg0WLe.mjs";
 export { Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableSet, SharedState, SharedStateEvents, SharedStateOptions, SharedStatePatch, createSharedState };

package/dist/utils/shared-state.mjs

@@ -1,2 +1,2 @@
-import { t as createSharedState } from "../shared-state-6kHolYZy.mjs";
+import { t as createSharedState } from "../shared-state-fRRbRUtD.mjs";
 export { createSharedState };

package/dist/utils/simple-schema.d.mts

@@ -1,2 +1,102 @@
-import { a as literal, c as number, d as picklist, f as record, g as voidType, h as union, i as describe, l as object, m as string, n as array, o as nullType, p as s, r as boolean, s as nullable, t as SimpleSchema, u as optional } from "../simple-schema-BDzLeJDk.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region src/utils/simple-schema.d.ts
+/**
+ * A tiny, zero-dependency [Standard Schema](https://standardschema.dev/)
+ * builder.
+ *
+ * ⚠️ **Discouraged for app code.** This is a deliberately minimal,
+ * best-effort validator that exists only so devframe's own first-party
+ * packages (recipes, built-in plugins) can declare `args`/`returns`/flag
+ * schemas without taking on a validator dependency. It implements a small
+ * subset of primitives and approximates refinements — it is not a
+ * general-purpose validator.
+ *
+ * For your own code, prefer a real Standard Schema validator — **valibot**,
+ * **zod**, or **arktype**. Devframe's RPC and CLI-flag layers accept any of
+ * them; install the one you like and use it directly:
+ *
+ * ```ts
+ * import * as v from 'valibot' // npm i valibot
+ *
+ * defineRpcFunction({
+ *   name: 'greet',
+ *   args: [v.object({ name: v.string() })],
+ *   returns: v.string(),
+ *   handler: ({ name }) => `hi ${name}`,
+ * })
+ * ```
+ */
+/**
+ * A Standard Schema produced by the {@link s} builder. It carries a
+ * duck-typed `type` marker (and `wrapped` for wrappers) alongside the
+ * standard `~standard` prop so the CLI-flags adapter can introspect the
+ * schema kind without importing any validator.
+ */
+interface SimpleSchema<Input, Output = Input> extends StandardSchemaV1<Input, Output> {
+  /** Schema kind marker, e.g. `'string'`, `'boolean'`, `'optional'`. */
+  readonly type: string;
+  /** Inner schema for wrapper kinds (`optional` / `nullable`). */
+  readonly wrapped?: StandardSchemaV1;
+  /** Optional human description (surfaced as CLI option help). */
+  readonly description?: string;
+}
+/** Any string. */
+declare function string(): SimpleSchema<string>;
+/** A finite number (rejects `NaN`). */
+declare function number(): SimpleSchema<number>;
+/** A boolean. */
+declare function boolean(): SimpleSchema<boolean>;
+/** `undefined` — mirrors valibot's `void`. */
+declare function voidType(): SimpleSchema<void>;
+/** `null`. */
+declare function nullType(): SimpleSchema<null>;
+/** One of a fixed set of literal values. */
+declare function picklist<const T extends readonly (string | number | boolean)[]>(values: T): SimpleSchema<T[number]>;
+/** A single literal value (string / number / boolean). */
+declare function literal<const T extends string | number | boolean>(value: T): SimpleSchema<T>;
+/** A value matching any one of the given schemas. */
+declare function union<const T extends readonly StandardSchemaV1[]>(options: T): SimpleSchema<StandardSchemaV1.InferInput<T[number]>, StandardSchemaV1.InferOutput<T[number]>>;
+/** A record with string keys whose values each satisfy the value schema. */
+declare function record<V extends StandardSchemaV1>(_key: StandardSchemaV1, value: V): SimpleSchema<Record<string, StandardSchemaV1.InferInput<V>>, Record<string, StandardSchemaV1.InferOutput<V>>>;
+/** An array whose every element satisfies the item schema. */
+declare function array<T extends StandardSchemaV1>(item: T): SimpleSchema<StandardSchemaV1.InferInput<T>[], StandardSchemaV1.InferOutput<T>[]>;
+/** Flatten an intersection into a single object literal for readable types. */
+type Prettify<T> = { [K in keyof T]: T[K]; } & {};
+/**
+ * Map a shape to its object type, turning fields whose type includes
+ * `undefined` (i.e. `optional()`) into optional keys — mirroring how
+ * valibot/zod render `optional` object entries.
+ */
+type InferField<T extends StandardSchemaV1, Mode extends 'input' | 'output'> = Mode extends 'input' ? StandardSchemaV1.InferInput<T> : StandardSchemaV1.InferOutput<T>;
+type InferObject<T extends Record<string, StandardSchemaV1>, Mode extends 'input' | 'output'> = Prettify<{ [K in keyof T as undefined extends InferField<T[K], Mode> ? never : K]: InferField<T[K], Mode>; } & { [K in keyof T as undefined extends InferField<T[K], Mode> ? K : never]?: InferField<T[K], Mode>; }>;
+/** An object whose known keys each satisfy their schema (extra keys are kept). */
+declare function object<T extends Record<string, StandardSchemaV1>>(shape: T): SimpleSchema<InferObject<T, 'input'>, InferObject<T, 'output'>>;
+/** Allow `undefined` in addition to the inner schema. */
+declare function optional<T extends StandardSchemaV1>(inner: T): SimpleSchema<StandardSchemaV1.InferInput<T> | undefined, StandardSchemaV1.InferOutput<T> | undefined>;
+/** Allow `null` in addition to the inner schema. */
+declare function nullable<T extends StandardSchemaV1>(inner: T): SimpleSchema<StandardSchemaV1.InferInput<T> | null, StandardSchemaV1.InferOutput<T> | null>;
+/** Attach a human-readable description (used for CLI option help). */
+declare function describe<T extends SimpleSchema<any, any>>(schema: T, description: string): T;
+/**
+ * Grouped access to every builder — `s.string()`, `s.object({ ... })`,
+ * `s.void()`, etc. Handy for a valibot-like `import { s } from
+ * 'devframe/utils/simple-schema'` call site.
+ */
+declare const s: {
+  readonly string: typeof string;
+  readonly number: typeof number;
+  readonly boolean: typeof boolean;
+  readonly void: typeof voidType;
+  readonly null: typeof nullType;
+  readonly literal: typeof literal;
+  readonly picklist: typeof picklist;
+  readonly union: typeof union;
+  readonly record: typeof record;
+  readonly array: typeof array;
+  readonly object: typeof object;
+  readonly optional: typeof optional;
+  readonly nullable: typeof nullable;
+  readonly describe: typeof describe;
+};
+//#endregion
 export { SimpleSchema, array, boolean, describe, literal, nullType, nullable, number, object, optional, picklist, record, s, string, union, voidType };

package/dist/utils/streaming-channel.d.mts

@@ -1,2 +1,2 @@
-import { at as StreamReader, ct as createStreamReader, it as StreamErrorPayload, lt as createStreamSink, nt as CreateStreamReaderOptions, ot as StreamSink, rt as CreateStreamSinkOptions, st as StreamSinkEvents, tt as BufferedChunk } from "../devframe-mQ4qZAuo.mjs";
+import { $ as StreamReader, Q as StreamErrorPayload, X as CreateStreamReaderOptions, Y as BufferedChunk, Z as CreateStreamSinkOptions, et as StreamSink, nt as createStreamReader, rt as createStreamSink, tt as StreamSinkEvents } from "../devframe-DJMg0WLe.mjs";
 export { BufferedChunk, CreateStreamReaderOptions, CreateStreamSinkOptions, StreamErrorPayload, StreamReader, StreamSink, StreamSinkEvents, createStreamReader, createStreamSink };

package/dist/validation-CpXFB6Dz.mjs

@@ -0,0 +1,266 @@
+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 };