@webjsdev/core 0.7.19 → 0.7.21

package/index-browser.js

@@ -3,7 +3,7 @@
  *
  * Mirror of `./index.js` but with strictly server-only exports
  * removed so the browser bundle never drags `src/render-server.js`
- * (~1100 lines) or `src/expose.js` (~90 lines) over the wire.
+ * (~1100 lines) over the wire.
  *
  * Stripped:
  *   - `renderToString`, `renderToStream` (server SSR pipeline; reach
@@ -11,10 +11,6 @@
  *   - `setCspNonceProvider` (server-side wiring called by
  *     `@webjsdev/server`'s context module; `cspNonce()` stays
  *     because layouts can call it).
- *   - `expose`, `getExposed` (live inside `.server.{js,ts}` files;
- *     framework rewrites the import to an RPC stub on the client
- *     side, so the real module never legitimately reaches the
- *     browser).
  *
  * The framework's own SSR pipeline runs on Node and resolves the
  * package via the package.json `"default"` condition, which still
@@ -61,6 +57,10 @@ export { markStale, registerKeyTags, consumeStale, parseTagHeader, fetchMark } f
 // Client action-abort plumbing (#492): a superseded async render aborts its
 // in-flight action fetches. Inert server-side.
 export { setActiveActionSignal, activeActionSignal } from './src/action-abort-client.js';
+// Streaming RPC wire protocol (#489): the byte framing the client stub decodes.
+export {
+  STREAM_CONTENT_TYPE, FRAME_CHUNK, FRAME_END, FRAME_ERROR, encodeFrame, createFrameDecoder,
+} from './src/action-stream.js';
 
 // Directives, also available via '@webjsdev/core/directives'. The full
 // lit-html-parity set is re-exported here so the dist browser bundle (which

package/index.d.ts

@@ -54,6 +54,16 @@ export type {
   WebjsCspConfig,
 } from './src/webjs-config.d.ts';
 
+// Compile-time serializability typing for server actions (#488): the opt-in
+// guard that makes a non-serializable action arg / return a type error.
+export type {
+  Serializable,
+  SerializableArgs,
+  SerializableResult,
+  SerializableActionFn,
+  NonSerializable,
+} from './src/serializable.d.ts';
+
 export { html, isTemplate, MARKER } from './src/html.js';
 export { css, isCSS, adoptStyles, stylesToString } from './src/css.js';
 export { register, lookup, lookupModuleUrl, isLazy, allTags, primeModuleUrl, tagOf } from './src/registry.js';
@@ -61,7 +71,6 @@ export { renderToString, renderToStream } from './src/render-server.js';
 export { render } from './src/render-client.js';
 export { escapeText, escapeAttr } from './src/escape.js';
 export { notFound, redirect, isNotFound, isRedirect } from './src/nav.js';
-export { expose, getExposed, validateInput } from './src/expose.js';
 export { repeat, isRepeat } from './src/repeat.js';
 export { Suspense, isSuspense } from './src/suspense.js';
 export { connectWS } from './src/websocket-client.js';
@@ -96,6 +105,10 @@ export { markStale, registerKeyTags, consumeStale, parseTagHeader, fetchMark } f
 // Client action-abort plumbing (#492): a superseded async render aborts its
 // in-flight action fetches. Inert server-side.
 export { setActiveActionSignal, activeActionSignal } from './src/action-abort-client.js';
+// Streaming RPC wire protocol (#489).
+export {
+  STREAM_CONTENT_TYPE, FRAME_CHUNK, FRAME_END, FRAME_ERROR, encodeFrame, createFrameDecoder,
+} from './src/action-stream.js';
 export { stringify, parse, serialize, deserialize } from './src/serialize.js';
 export { WebjsFrame } from './src/webjs-frame.js';
 export { WebjsStream, renderStream } from './src/webjs-stream.js';

package/index.js

@@ -15,7 +15,6 @@ export { render } from './src/render-client.js';
 export { escapeText, escapeAttr } from './src/escape.js';
 export { notFound, redirect, isNotFound, isRedirect } from './src/nav.js';
 export { cspNonce, setCspNonceProvider } from './src/csp-nonce.js';
-export { expose, getExposed, validateInput } from './src/expose.js';
 export { repeat, isRepeat } from './src/repeat.js';
 export { Suspense, isSuspense } from './src/suspense.js';
 export { connectWS } from './src/websocket-client.js';
@@ -43,6 +42,11 @@ export { markStale, registerKeyTags, consumeStale, parseTagHeader, fetchMark } f
 // Client action-abort plumbing (#492): a superseded async render aborts its
 // in-flight action fetches. Inert server-side.
 export { setActiveActionSignal, activeActionSignal } from './src/action-abort-client.js';
+// Streaming RPC wire protocol (#489): the byte framing the server encodes a
+// streamed action result with and the client stub decodes. Pure byte ops.
+export {
+  STREAM_CONTENT_TYPE, FRAME_CHUNK, FRAME_END, FRAME_ERROR, encodeFrame, createFrameDecoder,
+} from './src/action-stream.js';
 
 // Directives, also available via '@webjsdev/core/directives'. The full
 // lit-html-parity set is re-exported so the bare specifier exposes the same

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webjsdev/core",
-  "version": "0.7.19",
+  "version": "0.7.21",
   "type": "module",
   "description": "webjs core runtime - html/css tags, WebComponent base, isomorphic renderers",
   "types": "./index.d.ts",

package/src/action-stream.d.ts

@@ -0,0 +1,12 @@
+/** Streaming RPC wire protocol (#489). See action-stream.js. */
+
+export declare const STREAM_CONTENT_TYPE: string;
+export declare const FRAME_CHUNK: number;
+export declare const FRAME_END: number;
+export declare const FRAME_ERROR: number;
+
+export declare function encodeFrame(type: number, payload?: Uint8Array): Uint8Array;
+
+export declare function createFrameDecoder(): {
+  push(chunk: Uint8Array): Array<{ type: number; payload: Uint8Array }>;
+};

package/src/action-stream.js

@@ -0,0 +1,92 @@
+/**
+ * Streaming RPC wire protocol (#489), shared by the server (which frames an
+ * action's streamed result) and the client RPC stub (which decodes it). It lives
+ * in core because both sides need the EXACT same byte format; the server imports
+ * `encodeFrame` and the stub imports `createFrameDecoder` from `@webjsdev/core`.
+ *
+ * An action that returns a `ReadableStream` / async iterable / async generator
+ * streams its chunks over a single RPC response (one fetch, not multiplexed, so
+ * no stream-id is needed). The response carries `STREAM_CONTENT_TYPE`, and its
+ * body is a sequence of length-prefixed frames:
+ *
+ *   ┌────────┬──────────────┬──────────────────────┐
+ *   │ type:1 │  length:4 BE │  payload: length bytes│
+ *   └────────┴──────────────┴──────────────────────┘
+ *
+ *   - CHUNK (1): payload is one serialized chunk value (the same wire format the
+ *     RPC envelope uses, so a rich value round-trips). The client deserializes it
+ *     and yields it from the async iterable the stub returns.
+ *   - END   (2): length 0, no payload. Clean completion; the iterable returns.
+ *   - ERROR (3): payload is the (author-controlled) error message string. The
+ *     stream errored after the first byte, so it cannot change the HTTP status;
+ *     the client throws this message from the iterable instead.
+ *
+ * Pure byte manipulation, no DOM and no `node:*` deps, so it is safe in the
+ * browser bundle and on the server alike.
+ */
+
+/** The RPC content type for a framed streamed result. */
+export const STREAM_CONTENT_TYPE = 'application/vnd.webjs+stream';
+
+/** Frame type: one serialized chunk value. */
+export const FRAME_CHUNK = 1;
+/** Frame type: clean end of stream (empty payload). */
+export const FRAME_END = 2;
+/** Frame type: the stream errored mid-flight (payload is the message). */
+export const FRAME_ERROR = 3;
+
+const EMPTY = new Uint8Array(0);
+
+/**
+ * Frame a payload as `[type:1][length:4 BE][payload]`. `payload` may be omitted
+ * for a zero-length frame (END).
+ * @param {number} type one of FRAME_CHUNK / FRAME_END / FRAME_ERROR
+ * @param {Uint8Array} [payload]
+ * @returns {Uint8Array}
+ */
+export function encodeFrame(type, payload) {
+  const body = payload || EMPTY;
+  const len = body.length;
+  const out = new Uint8Array(5 + len);
+  out[0] = type & 0xff;
+  out[1] = (len >>> 24) & 0xff;
+  out[2] = (len >>> 16) & 0xff;
+  out[3] = (len >>> 8) & 0xff;
+  out[4] = len & 0xff;
+  if (len) out.set(body, 5);
+  return out;
+}
+
+/**
+ * A stateful decoder that turns a stream of arbitrary byte chunks back into
+ * whole frames, buffering across chunk boundaries (a frame may be split over two
+ * network reads, or two frames may arrive in one read). `push(chunk)` returns the
+ * array of complete frames it could parse from the accumulated buffer so far;
+ * partial trailing bytes stay buffered for the next `push`.
+ * @returns {{ push(chunk: Uint8Array): Array<{ type: number, payload: Uint8Array }> }}
+ */
+export function createFrameDecoder() {
+  let buf = EMPTY;
+  return {
+    push(chunk) {
+      if (chunk && chunk.length) {
+        const next = new Uint8Array(buf.length + chunk.length);
+        next.set(buf, 0);
+        next.set(chunk, buf.length);
+        buf = next;
+      }
+      const frames = [];
+      // A frame needs at least the 5-byte header before its length is known.
+      while (buf.length >= 5) {
+        const type = buf[0];
+        const len = ((buf[1] << 24) | (buf[2] << 16) | (buf[3] << 8) | buf[4]) >>> 0;
+        if (buf.length < 5 + len) break; // payload not fully arrived yet
+        // Copy the payload out so it does not alias the (soon-reassigned) buffer.
+        const payload = buf.slice(5, 5 + len);
+        frames.push({ type, payload });
+        buf = buf.slice(5 + len);
+      }
+      return frames;
+    },
+  };
+}

package/src/render-server.js

@@ -361,11 +361,15 @@ const SSR_HTMLELEMENT_METHODS = new Set([
  */
 function browserMemberHint(e) {
   const msg = e && typeof (/** @type any */ (e).message) === 'string' ? /** @type any */ (e).message : '';
-  let m = /^(\w+) is not defined$/.exec(msg);
+  // Match on a word boundary, NOT end-of-string: V8 (Node) ends the message at
+  // "is not defined" / "is not a function", but JSC (Bun) appends a detail
+  // clause (e.g. ". (In '({}).querySelector(\"p\")', '...' is undefined)"), so an
+  // anchored `$` would miss the Bun message and drop the actionable hint.
+  let m = /^(\w+) is not defined\b/.exec(msg);
   if (e instanceof ReferenceError && m && SSR_BROWSER_GLOBALS.has(m[1])) {
     return `\`${m[1]}\` is a browser-only global and is undefined during SSR.`;
   }
-  m = /\.(\w+) is not a function$/.exec(msg);
+  m = /\.(\w+) is not a function\b/.exec(msg);
   if (e instanceof TypeError && m && SSR_HTMLELEMENT_METHODS.has(m[1])) {
     return `\`${m[1]}\` is an HTMLElement method that does not exist on the server-side component instance during SSR.`;
   }

package/src/serializable.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Compile-time serializability typing for server actions (#488).
+ *
+ * A `'use server'` action's arguments and result cross the RPC wire through the
+ * webjs serializer, which round-trips a SPECIFIC set of rich types (`Date`,
+ * `Map`, `Set`, `BigInt`, `Error`, `RegExp`, `URL`, typed arrays, `ArrayBuffer`,
+ * `Blob`, `File`, `FormData`, registered `Symbol`s, plain objects / arrays, and
+ * cycles). It does NOT round-trip a FUNCTION or a class instance's METHODS: a
+ * function silently vanishes from the wire, and a class instance arrives as a
+ * plain object with its prototype (so its methods) gone. That is a runtime
+ * surprise the author never asked for.
+ *
+ * `Serializable<T>` makes it a TYPE error instead. It maps a fully serializable
+ * `T` to itself, and a `T` that carries a function (a method, a callback prop)
+ * to a branded `NonSerializable<...>` marker, so assigning the offending value
+ * fails to typecheck with a message that names the problem. `SerializableArgs`
+ * / `SerializableResult` apply it across an action's parameter tuple and its
+ * (possibly promised) return.
+ *
+ * This is OPT-IN by design: webjs actions stay plain `export async function`s
+ * with no wrapper (the framework rewrites the client import to an RPC stub at
+ * runtime, it does not wrap the authored function). An author who wants the
+ * guard annotates the action with `SerializableActionFn`, e.g.
+ *
+ *   import type { SerializableActionFn } from '@webjsdev/core';
+ *   export const getUser: SerializableActionFn<(id: number) => Promise<User>> =
+ *     async (id) => db.user.find(id);
+ *
+ * If `User` (or any arg) is not serializable, the annotation is a compile-time
+ * error pointing at the offending member. Types only, erased at runtime, zero
+ * cost.
+ */
+
+/** A branded marker a non-serializable position resolves to, so the error names it. */
+export type NonSerializable<Reason extends string = 'this value is not serializable over the webjs RPC wire'> = {
+  readonly __webjsNonSerializable: Reason;
+};
+
+/** Primitives the wire carries verbatim. */
+type SerializablePrimitive = string | number | boolean | bigint | null | undefined;
+
+/**
+ * Built-in rich types the webjs serializer round-trips as themselves (their
+ * identity / methods survive because the serializer reconstructs the instance).
+ * `Map` / `Set` recurse into their members via the top-level mapper.
+ */
+type SerializableBuiltin =
+  | Date
+  | RegExp
+  | URL
+  | Error
+  | ArrayBuffer
+  | Int8Array | Uint8Array | Uint8ClampedArray
+  | Int16Array | Uint16Array
+  | Int32Array | Uint32Array
+  | Float32Array | Float64Array
+  | BigInt64Array | BigUint64Array
+  | Blob
+  | File
+  | FormData;
+
+/**
+ * Map `T` to itself when it is fully serializable, else to a `NonSerializable`
+ * marker at the offending position. A function (a method or a callback-valued
+ * property) is the canonical non-serializable case. Objects and arrays recurse;
+ * `Map` / `Set` recurse into their type parameters.
+ */
+export type Serializable<T> =
+  T extends SerializablePrimitive ? T :
+  // A function never survives the wire (it just disappears).
+  T extends (...args: any[]) => any ? NonSerializable<'a function is not serializable over the webjs RPC wire'> :
+  T extends SerializableBuiltin ? T :
+  T extends Map<infer K, infer V> ? Map<Serializable<K>, Serializable<V>> :
+  T extends Set<infer U> ? Set<Serializable<U>> :
+  T extends Promise<infer U> ? Promise<Serializable<U>> :
+  T extends ReadonlyArray<infer U> ? (T extends Array<infer _W> ? Array<Serializable<U>> : ReadonlyArray<Serializable<U>>) :
+  T extends object ? { [K in keyof T]: Serializable<T[K]> } :
+  T;
+
+/** Apply {@link Serializable} across an action's parameter tuple. */
+export type SerializableArgs<A extends readonly unknown[]> = {
+  [K in keyof A]: Serializable<A[K]>;
+};
+
+/**
+ * Apply {@link Serializable} to an action's return, unwrapping a `Promise` so an
+ * async action is checked against its resolved value (the wire carries the
+ * resolved value, never the promise).
+ */
+export type SerializableResult<R> =
+  R extends Promise<infer U> ? Promise<Serializable<U>> : Serializable<R>;
+
+/**
+ * The opt-in annotation type for a server action: it preserves the function's
+ * exact call signature while constraining every argument and the result to be
+ * serializable. A non-serializable arg or return makes the annotation a
+ * compile-time error.
+ *
+ * @example
+ *   export const getUser: SerializableActionFn<(id: number) => Promise<User>> =
+ *     async (id) => db.user.find(id);
+ */
+export type SerializableActionFn<F extends (...args: any[]) => any> =
+  (...args: SerializableArgs<Parameters<F>>) => SerializableResult<ReturnType<F>>;

package/src/serialize.js

@@ -142,6 +142,12 @@ function newEncodeCtx() {
     emitted: new Set(),   // ids already emitted as the canonical encoding
     nextId: 0,
     blobBytes: new Map(), // Blob → Uint8Array (precomputed during countRefs)
+    // FormData → its entries captured ONCE. Bun returns a FRESH Blob/File
+    // identity on every FormData.entries()/get() call (Node returns a stable
+    // one), so countRefs and encode must iterate the SAME captured array or the
+    // identity-keyed blobBytes lookup misses on Bun (crash). Captured here so
+    // both passes see the same Blob objects on every runtime.
+    fdEntries: new Map(),
   };
 }
 
@@ -164,7 +170,11 @@ async function countRefs(value, ctx) {
       continue;
     }
     if (typeof FormData !== 'undefined' && v instanceof FormData) {
-      for (const [, val] of v.entries()) {
+      // Capture entries ONCE (see fdEntries note) and traverse THOSE Blob
+      // objects, so encode reuses the exact instances whose bytes we precompute.
+      const captured = ctx.fdEntries.get(v) || [...v.entries()];
+      ctx.fdEntries.set(v, captured);
+      for (const [, val] of captured) {
         if (typeof val !== 'string') stack.push(val);
       }
       continue;
@@ -233,8 +243,12 @@ function encodeOne(v, ctx) {
       out = { [TAG]: 'Blob', v: bytesToB64(bytes), t: v.type || '' };
     }
   } else if (typeof FormData !== 'undefined' && v instanceof FormData) {
+    // Reuse the entries captured in countRefs so the Blob/File instances match
+    // the ones whose bytes were precomputed (Bun yields fresh identities per
+    // entries() call; see the fdEntries note in newEncodeCtx).
+    const captured = ctx.fdEntries.get(v) || [...v.entries()];
     const entries = [];
-    for (const [k, val] of v.entries()) entries.push([k, encodeOne(val, ctx)]);
+    for (const [k, val] of captured) entries.push([k, encodeOne(val, ctx)]);
     out = { [TAG]: 'FD', v: entries };
   } else if (ArrayBuffer.isView(v) || v instanceof ArrayBuffer) {
     out = encodeBinary(v);

package/src/expose.js

@@ -1,180 +0,0 @@
-/**
- * Expose a server action as a first-class HTTP endpoint in addition to its
- * internal RPC URL.
- *
- * ```js
- * // actions/posts.server.js
- * 'use server';
- * import { expose } from '@webjsdev/core';
- *
- * export const createPost = expose('POST /api/posts', async ({ title, body }) => {
- *   // same function body you'd write without expose()
- * });
- * ```
- *
- * The action is reachable two ways, both backed by the exact same code:
- *   - from a client component:   `import { createPost } from '.../posts.server.js'`
- *   - from curl / another service: `POST /api/posts` with a JSON body
- *
- * Adapter rules when invoked over HTTP:
- *   - URL path params ({`:slug`}) and query string are merged into a single
- *     object argument.
- *   - For methods with a body (POST/PUT/PATCH/DELETE), the parsed JSON body
- *     is merged on top of params/query. The function receives ONE argument:
- *     the merged object.
- *   - If `opts.validate` is provided, it runs BEFORE the function on EVERY
- *     call path (the REST path here AND the internal RPC path), so a single
- *     validator declared once guards both. The framework calls `validate(input)`
- *     and interprets the return (see the validator contract below):
- *       - a `{ success: true, data? }` envelope passes (the action receives
- *         `data` when present, else the original input);
- *       - a `{ success: false, fieldErrors, message? }` envelope FAILS with a
- *         structured field-error result (422), without calling the action;
- *       - a THROW fails (→ 400 on REST, sanitized error on RPC), preserving the
- *         classic `Schema.parse`-style contract;
- *       - any OTHER returned plain value is treated as the transformed input
- *         (back-compat with the `validate: Schema.parse` transform style).
- *     The zod adapter is three lines and keeps the framework zod-free:
- *       `validate: (i) => { const r = Schema.safeParse(i);
- *          return r.success ? { success: true, data: r.data }
- *            : { success: false, fieldErrors: r.error.flatten().fieldErrors }; }`
- *   - Return value becomes a JSON `Response`; throw or return a `Response`
- *     directly for full control.
- *
- *
- * `cors` toggles browser CORS support for cross-origin callers:
- *   - `true`             - allow any origin (`*`), reflects requested headers
- *   - string             - allow that single origin (sets `Access-Control-Allow-Credentials: true`)
- *   - string[]           - allow-list; non-matching origins are not granted
- *   - { origin, credentials, maxAge, headers }: full control
- *
- * When CORS is enabled, an `OPTIONS` preflight at the same path is auto-served
- * with `Access-Control-Allow-Methods: <route's method>, OPTIONS`.
- *
- * @param {string} pattern e.g. `"POST /api/posts"` or `"GET /api/posts/:slug"`
- * @param {Function} fn the async implementation
- * @param {{
- *   validate?: (input: any) => any,
- *   cors?: boolean | string | string[] | { origin: string | string[], credentials?: boolean, maxAge?: number, headers?: string[] }
- * }} [opts]
- * @returns {Function} same function, tagged with HTTP metadata
- */
-export function expose(pattern, fn, opts) {
-  const match = /^\s*([A-Z]+)\s+(\/\S*)\s*$/.exec(pattern);
-  if (!match) {
-    throw new Error(
-      `expose(): bad pattern ${JSON.stringify(pattern)}: expected "METHOD /path"`
-    );
-  }
-  const [, method, path] = match;
-  /** @type any */ (fn).__webjsHttp = {
-    method,
-    path,
-    validate: opts && typeof opts.validate === 'function' ? opts.validate : null,
-    cors: opts && 'cors' in opts ? normaliseCors(opts.cors) : null,
-  };
-  return fn;
-}
-
-/** @param {any} c */
-function normaliseCors(c) {
-  if (!c) return null;
-  if (c === true) {
-    return { origin: '*', credentials: false, maxAge: 86400, headers: null };
-  }
-  if (typeof c === 'string') {
-    return { origin: c, credentials: true, maxAge: 86400, headers: null };
-  }
-  if (Array.isArray(c)) {
-    return { origin: c, credentials: true, maxAge: 86400, headers: null };
-  }
-  return {
-    origin: c.origin,
-    credentials: !!c.credentials,
-    maxAge: typeof c.maxAge === 'number' ? c.maxAge : 86400,
-    headers: Array.isArray(c.headers) ? c.headers : null,
-  };
-}
-
-/**
- * Attach an input validator to a server action WITHOUT exposing it as a REST
- * endpoint. The validator runs SERVER-SIDE before the action body on BOTH call
- * paths: the internal RPC path (a client component importing the action) AND
- * the `expose()` REST path (if the action is also exposed). This is the shared,
- * declare-once validation surface (#245).
- *
- * It reuses the EXACT same `__webjsHttp` storage `expose()` writes, so the
- * action index's `getExposed(fn)` already surfaces the validator with no new
- * plumbing. The action stays a plain callable function (a direct unit-test
- * import still works, just without the framework running validate).
- *
- * If the action is already `expose()`d, prefer passing `{ validate }` to
- * `expose()` directly; calling both keeps the LAST validator attached.
- *
- * ```js
- * // actions/posts.server.js
- * 'use server';
- * import { validateInput } from '@webjsdev/core';
- *
- * export const createPost = validateInput(
- *   async ({ title }) => { ... },
- *   (input) => {
- *     const errs = {};
- *     if (!input?.title?.trim()) errs.title = 'Title is required';
- *     return Object.keys(errs).length
- *       ? { success: false, fieldErrors: errs }
- *       : { success: true };
- *   },
- * );
- * ```
- *
- * The validator contract (the framework calls `validate(input)`):
- *   - returns `{ success: true, data? }` → valid; the action is called with
- *     `data` if present, else the original input;
- *   - returns `{ success: false, fieldErrors, message? }` (an object with a
- *     boolean `success` of `false`, or with a `fieldErrors`) → FAILED; the
- *     framework returns a structured `ActionResult`
- *     `{ success: false, fieldErrors, error: message?, status: 422 }` without
- *     calling the action body;
- *   - THROWS → mapped to a sanitized failure result (the classic
- *     `Schema.parse` contract);
- *   - returns ANY OTHER plain value → treated as the validated/coerced input
- *     and passed to the action (the `validate: Schema.parse` transform style).
- *
- * Disambiguation: a return is a result-envelope ONLY when it is an object with
- * a boolean `success` property OR a `fieldErrors` property; otherwise it is a
- * transformed input value. Caveat: if your validator returns the input
- * VERBATIM (the bare-transform style) and that input can itself carry a
- * `success` boolean or a `fieldErrors` key, it would be misread as an envelope.
- * Return the explicit `{ success: true, data }` envelope in that case (the zod
- * adapter and the recommended hand-rolled form already do, so they never
- * collide).
- *
- * Server-side only; import inside `.server.{js,ts}` files. The bare
- * `@webjsdev/core` specifier resolves to the browser entry, which excludes
- * `validateInput` (like `expose`), so an import from client-bound code reads
- * `undefined`. The validator itself lives in the `.server` file and never
- * reaches the client.
- *
- * @template {Function} F
- * @param {F} fn the async action implementation
- * @param {(input: any) => any} validate the validator (a plain function or a
- *   zod-`safeParse` adapter)
- * @returns {F} the same function, tagged with the validator
- */
-export function validateInput(fn, validate) {
-  if (typeof fn !== 'function') {
-    throw new Error('validateInput(): first argument must be the action function');
-  }
-  if (typeof validate !== 'function') {
-    throw new Error('validateInput(): second argument must be a validator function');
-  }
-  const existing = /** @type any */ (fn).__webjsHttp || {};
-  /** @type any */ (fn).__webjsHttp = { ...existing, validate };
-  return fn;
-}
-
-/** @param {unknown} fn */
-export function getExposed(fn) {
-  return fn && typeof fn === 'function' ? /** @type any */ (fn).__webjsHttp || null : null;
-}