@solidjs/web 2.0.0-rc.2 → 2.0.0-rc.3

package/types/server-functions/registry.d.ts

@@ -0,0 +1,63 @@
+export type { ServerFunction, ServerFunctionMetadata, ServerFunctionRPC } from "./shared.js";
+export declare const SERVER_FUNCTION_METADATA: unique symbol;
+/**
+ * Reads a server function reference's declaration metadata (e.g.
+ * `method: "GET"` for `GET(fn)` references). Returns undefined when `fn`
+ * is not a server function reference; plain references carry an empty
+ * metadata object.
+ */
+export declare function getServerFunctionMetadata(fn: any): any;
+/**
+ * Whether `fn` is a server function reference (a client proxy or a
+ * server-side registered callable). Detection is by the registered-symbol
+ * metadata brand, so it holds across duplicated module instances.
+ */
+export declare function isServerFunction(fn: any): boolean;
+/**
+ * Attaches user-declared transport metadata to a server function reference
+ * (client proxy or server-registered callable) and returns the reference.
+ * Writes ride the same channel `GET` uses: later writes shallow-merge over
+ * earlier ones, and `getServerFunctionMetadata(fn)` reads the merged bag —
+ * so `withMeta` composes with `GET` in either order.
+ *
+ * The pattern is declare-on-function, react-in-hook: metadata declared
+ * here is what `prepareRequest` receives as `context.meta`, letting
+ * session-dynamic transport policy key on declarations instead of
+ * comparing function ids:
+ *
+ * ```ts
+ * export const chargeCard = withMeta(async (amount: number) => {
+ *   "use server";
+ *   // ...
+ * }, { requiresAuth: true });
+ *
+ * configureServerFunctionsClient({
+ *   prepareRequest(init, { meta }) {
+ *     if (meta?.requiresAuth) {
+ *       return {
+ *         ...init,
+ *         headers: { ...init.headers, Authorization: `Bearer ${session.token()}` }
+ *       };
+ *     }
+ *     return init;
+ *   }
+ * });
+ * ```
+ */
+export declare function withMeta(fn: any, meta: any): any;
+export declare const LIVE_SOURCE: unique symbol;
+/**
+ * Fills the RPC seam. Called by the transport halves (client fetch RPC,
+ * server in-process dispatch) when the first server function reference is
+ * created; first write wins — both halves register equivalent surfaces, and
+ * a per-build half never coexists with the other build's.
+ * @internal
+ */
+export declare function provideServerFunctionRPC(rpc: any): void;
+/**
+ * The registered RPC surface, or undefined when no server function exists
+ * in this build's graph. Integration plumbing (routers): gate every use of
+ * the transport/codec behind this read instead of importing it.
+ * @internal
+ */
+export declare function getServerFunctionRPC(): any;

package/types/server-functions/rich-args.d.ts

@@ -1,10 +1 @@
-/**
- * Opt-in codec encoding for server-function ARGUMENTS. By default the client
- * sends argument lists as plain JSON (no serializer in the bundle) and
- * throws on values JSON can't carry faithfully. Call once at startup to
- * send Dates, Maps, Sets, typed arrays, cyclic structures, etc. through the
- * codec — at the cost of the serializer's write half (~5 KB gz on top of
- * the decode half responses already need). The handler accepts both
- * encodings unconditionally.
- */
-export function enableRichArguments(): void;
+export declare function enableRichArguments(): void;