@epoch32/visage 0.0.0 → 1.1.0

package/dist/{src/router → router}/index.js

@@ -848,10 +848,12 @@ class Signal {
   _value;
   _subscribers = new Set;
   _equals;
+  _onSet;
   version = 0;
-  constructor(initialValue, equals) {
+  constructor(initialValue, equals, onSet) {
     this._value = initialValue;
     this._equals = equals ?? Object.is;
+    this._onSet = onSet;
   }
   get() {
     if (currentSubscriber !== null && currentSubscriber.state !== 3 /* DISPOSED */) {
@@ -876,6 +878,9 @@ class Signal {
     }
     this._value = newValue;
     this.version++;
+    if (this._onSet) {
+      this._onSet(newValue);
+    }
     batch(() => {
       this.notify();
     });
@@ -901,11 +906,91 @@ class Signal {
     }
   }
 }
+function resolveStorage(storageOption) {
+  if (storageOption && typeof storageOption === "object") {
+    return storageOption;
+  }
+  if (storageOption === "session") {
+    try {
+      if (typeof sessionStorage !== "undefined")
+        return sessionStorage;
+    } catch {}
+    try {
+      if (typeof window !== "undefined" && window.sessionStorage) {
+        return window.sessionStorage;
+      }
+    } catch {}
+    try {
+      if (typeof globalThis !== "undefined" && globalThis.sessionStorage) {
+        return globalThis.sessionStorage;
+      }
+    } catch {}
+    return null;
+  }
+  try {
+    if (typeof localStorage !== "undefined")
+      return localStorage;
+  } catch {}
+  try {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return window.localStorage;
+    }
+  } catch {}
+  try {
+    if (typeof globalThis !== "undefined" && globalThis.localStorage) {
+      return globalThis.localStorage;
+    }
+  } catch {}
+  return null;
+}
 function signal(initialValue, optionsOrEquals) {
   const equals = typeof optionsOrEquals === "function" ? optionsOrEquals : optionsOrEquals?.equals;
   const isInternal = typeof optionsOrEquals === "object" ? optionsOrEquals?.internal : false;
   const customName = typeof optionsOrEquals === "object" ? optionsOrEquals?.name : undefined;
-  const s = new Signal(initialValue, equals);
+  const persistOption = typeof optionsOrEquals === "object" ? optionsOrEquals?.persist : undefined;
+  const persistConfig = persistOption ? typeof persistOption === "string" ? { key: persistOption } : persistOption : undefined;
+  let effectiveInitial = initialValue;
+  const storage = persistConfig ? resolveStorage(persistConfig.storage) : null;
+  const serialize = persistConfig?.serialize ?? JSON.stringify;
+  const deserialize = persistConfig?.deserialize ?? JSON.parse;
+  if (persistConfig && storage) {
+    try {
+      const stored = storage.getItem(persistConfig.key);
+      if (stored !== null) {
+        effectiveInitial = deserialize(stored);
+      }
+    } catch {}
+  }
+  let isSyncing = false;
+  const onSet = persistConfig && storage ? (val) => {
+    if (isSyncing)
+      return;
+    try {
+      storage.setItem(persistConfig.key, serialize(val));
+    } catch {}
+  } : undefined;
+  const s = new Signal(effectiveInitial, equals, onSet);
+  if (persistConfig && storage && (persistConfig.syncTabs ?? true) && typeof window !== "undefined" && typeof window.addEventListener === "function") {
+    const onStorage = (e) => {
+      if (e.key === persistConfig.key) {
+        try {
+          const nextVal = e.newValue !== null ? deserialize(e.newValue) : initialValue;
+          isSyncing = true;
+          try {
+            s.set(nextVal);
+          } finally {
+            isSyncing = false;
+          }
+        } catch {}
+      }
+    };
+    window.addEventListener("storage", onStorage);
+    if (currentScope) {
+      currentScope.addCleanup(() => {
+        window.removeEventListener("storage", onStorage);
+      });
+    }
+  }
   const accessor = (...args) => {
     if (args.length === 0) {
       return s.get();

package/dist/router/router.d.ts

@@ -0,0 +1,91 @@
+import { type Child } from "../dom";
+import { type ReadonlySignal } from "../signals";
+export interface LocationState {
+    pathname: ReadonlySignal<string>;
+    search: ReadonlySignal<string>;
+    hash: ReadonlySignal<string>;
+}
+export interface RouterContextValue {
+    location: LocationState;
+    navigate: (to: string, options?: {
+        replace?: boolean;
+    }) => void;
+    params: ReadonlySignal<Record<string, string>>;
+    base: string;
+    matchedRoute: ReadonlySignal<MatchedRoute | null>;
+    routes: RouteDefinition[];
+    registerRoute: (route: RouteDefinition) => void;
+}
+export interface MatchedRoute {
+    path: string;
+    params: Record<string, string>;
+    component?: (props?: any) => Child;
+    children?: Child;
+}
+export interface RouteDefinition {
+    path: string;
+    component?: (props?: any) => Child;
+    children?: Child;
+    matcher: RegExp;
+    paramNames: string[];
+}
+export interface RouterProps {
+    base?: string;
+    mode?: "history" | "hash";
+    children: Child;
+}
+/**
+ * Root Router provider managing browser location state and URL synchronization
+ */
+export declare function Router(props: RouterProps): Child;
+export interface RouteProps {
+    path: string;
+    component?: (props: any) => Child;
+    children?: Child;
+}
+/**
+ * Route declaration registering URL path pattern and view component
+ */
+export declare function Route(props: RouteProps): Child;
+export interface RoutesProps {
+    children: Child;
+    fallback?: Child;
+}
+/**
+ * Routes outlet matching the current URL to registered Route definitions
+ */
+export declare function Routes(props: RoutesProps): Child;
+export interface LinkProps {
+    href: string;
+    class?: string | (() => string);
+    activeClass?: string;
+    replace?: boolean;
+    children: Child;
+    [key: string]: any;
+}
+/**
+ * Accessible client-side navigation Link with active state highlighting
+ */
+export declare function Link(props: LinkProps): Child;
+/**
+ * Access the active router location state signals
+ */
+export declare function useLocation(): LocationState;
+/**
+ * Access the imperative navigate function
+ */
+export declare function useNavigate(): (to: string, options?: {
+    replace?: boolean;
+}) => void;
+/**
+ * Access reactive URL parameter signals
+ */
+export declare function useParams<T extends Record<string, string> = Record<string, string>>(): () => T;
+/**
+ * Access and manipulate URL query search parameters reactively
+ */
+export declare function useSearchParams(): [
+    () => URLSearchParams,
+    (params: Record<string, string> | URLSearchParams) => void
+];
+export { lazy } from "../dom";

package/dist/rpc/client.d.ts

@@ -0,0 +1,2 @@
+import type { ClientOptions, ClientRouter, Router } from "./types";
+export declare function createClient<TRouter extends Router<any, any>>(options: ClientOptions): ClientRouter<TRouter>;

package/dist/rpc/error.d.ts

@@ -0,0 +1,16 @@
+import type { ValidationIssue } from "../form/schema";
+import type { RPCErrorCode } from "./types";
+export declare const ERROR_CODE_TO_STATUS: Record<RPCErrorCode, number>;
+export declare const STATUS_TO_ERROR_CODE: Record<number, RPCErrorCode>;
+export declare class RPCError extends Error {
+    readonly code: RPCErrorCode;
+    readonly status: number;
+    readonly issues?: ValidationIssue[];
+    constructor(codeOrStatusOrOptions: RPCErrorCode | number | {
+        code: RPCErrorCode;
+        message?: string;
+        issues?: ValidationIssue[];
+        cause?: unknown;
+    }, message?: string);
+    get statusCode(): number;
+}

package/dist/rpc/index.d.ts

@@ -0,0 +1,7 @@
+export { Schema, type SchemaLike, type StandardSchemaV1, type ValidationIssue, type ValidationResult, v, validateWithSchema } from "../form/schema";
+export { createClient } from "./client";
+export { ERROR_CODE_TO_STATUS, RPCError, STATUS_TO_ERROR_CODE } from "./error";
+export { createProcedure, executeProcedure } from "./procedure";
+export { createRouter, mutation, query, RouterImpl, subscription } from "./router";
+export { createFetchHandler } from "./server";
+export type { ClientMutationMethod, ClientOptions, ClientProcedure, ClientQueryMethod, ClientRouter, ClientSubscriptionMethod, CORSOptions, FetchHandlerOptions, InferProcedureInput, InferProcedureOutput, MiddlewareFn, Procedure, ProcedureOptions, ProcedureRecord, ProcedureType, Router, Router as RPCRouter, RPCErrorCode, RPCResponse, RPCResponseError, RPCResponseSuccess, SubscriptionCallbacks, SubscriptionHandle } from "./types";

package/dist/{src/rpc → rpc}/index.js

@@ -1058,10 +1058,12 @@ class Signal {
   _value;
   _subscribers = new Set;
   _equals;
+  _onSet;
   version = 0;
-  constructor(initialValue, equals) {
+  constructor(initialValue, equals, onSet) {
     this._value = initialValue;
     this._equals = equals ?? Object.is;
+    this._onSet = onSet;
   }
   get() {
     if (currentSubscriber !== null && currentSubscriber.state !== 3 /* DISPOSED */) {
@@ -1086,6 +1088,9 @@ class Signal {
     }
     this._value = newValue;
     this.version++;
+    if (this._onSet) {
+      this._onSet(newValue);
+    }
     batch(() => {
       this.notify();
     });
@@ -1111,11 +1116,91 @@ class Signal {
     }
   }
 }
+function resolveStorage(storageOption) {
+  if (storageOption && typeof storageOption === "object") {
+    return storageOption;
+  }
+  if (storageOption === "session") {
+    try {
+      if (typeof sessionStorage !== "undefined")
+        return sessionStorage;
+    } catch {}
+    try {
+      if (typeof window !== "undefined" && window.sessionStorage) {
+        return window.sessionStorage;
+      }
+    } catch {}
+    try {
+      if (typeof globalThis !== "undefined" && globalThis.sessionStorage) {
+        return globalThis.sessionStorage;
+      }
+    } catch {}
+    return null;
+  }
+  try {
+    if (typeof localStorage !== "undefined")
+      return localStorage;
+  } catch {}
+  try {
+    if (typeof window !== "undefined" && window.localStorage) {
+      return window.localStorage;
+    }
+  } catch {}
+  try {
+    if (typeof globalThis !== "undefined" && globalThis.localStorage) {
+      return globalThis.localStorage;
+    }
+  } catch {}
+  return null;
+}
 function signal(initialValue, optionsOrEquals) {
   const equals = typeof optionsOrEquals === "function" ? optionsOrEquals : optionsOrEquals?.equals;
   const isInternal = typeof optionsOrEquals === "object" ? optionsOrEquals?.internal : false;
   const customName = typeof optionsOrEquals === "object" ? optionsOrEquals?.name : undefined;
-  const s = new Signal(initialValue, equals);
+  const persistOption = typeof optionsOrEquals === "object" ? optionsOrEquals?.persist : undefined;
+  const persistConfig = persistOption ? typeof persistOption === "string" ? { key: persistOption } : persistOption : undefined;
+  let effectiveInitial = initialValue;
+  const storage = persistConfig ? resolveStorage(persistConfig.storage) : null;
+  const serialize = persistConfig?.serialize ?? JSON.stringify;
+  const deserialize = persistConfig?.deserialize ?? JSON.parse;
+  if (persistConfig && storage) {
+    try {
+      const stored = storage.getItem(persistConfig.key);
+      if (stored !== null) {
+        effectiveInitial = deserialize(stored);
+      }
+    } catch {}
+  }
+  let isSyncing = false;
+  const onSet = persistConfig && storage ? (val) => {
+    if (isSyncing)
+      return;
+    try {
+      storage.setItem(persistConfig.key, serialize(val));
+    } catch {}
+  } : undefined;
+  const s = new Signal(effectiveInitial, equals, onSet);
+  if (persistConfig && storage && (persistConfig.syncTabs ?? true) && typeof window !== "undefined" && typeof window.addEventListener === "function") {
+    const onStorage = (e) => {
+      if (e.key === persistConfig.key) {
+        try {
+          const nextVal = e.newValue !== null ? deserialize(e.newValue) : initialValue;
+          isSyncing = true;
+          try {
+            s.set(nextVal);
+          } finally {
+            isSyncing = false;
+          }
+        } catch {}
+      }
+    };
+    window.addEventListener("storage", onStorage);
+    if (currentScope) {
+      currentScope.addCleanup(() => {
+        window.removeEventListener("storage", onStorage);
+      });
+    }
+  }
   const accessor = (...args) => {
     if (args.length === 0) {
       return s.get();

package/dist/rpc/procedure.d.ts

@@ -0,0 +1,8 @@
+import type { MiddlewareFn, Procedure, ProcedureOptions, ProcedureType } from "./types";
+export declare function createProcedure<TType extends ProcedureType, TInput = any, TOutput = any, TContext = any>(type: TType, options: ProcedureOptions<TInput, TOutput, TContext>, middlewares?: MiddlewareFn<any, any>[]): Procedure<TType, TInput, TOutput, TContext>;
+export declare function executeProcedure(procedure: Procedure<any, any, any, any>, opts: {
+    rawInput: unknown;
+    ctx: any;
+    req: Request;
+    signal: AbortSignal;
+}): Promise<any>;

package/dist/rpc/router.d.ts

@@ -0,0 +1,19 @@
+import type { MiddlewareFn, Procedure, ProcedureOptions, ProcedureRecord, Router } from "./types";
+export declare class RouterImpl<TRecord extends ProcedureRecord = ProcedureRecord, TContext = any> implements Router<TRecord, TContext> {
+    _def: {
+        record: TRecord;
+        middlewares: MiddlewareFn<any, any>[];
+    };
+    constructor(record?: TRecord, middlewares?: MiddlewareFn<any, any>[]);
+    query(name: string, options: any): any;
+    mutation(name: string, options: any): any;
+    subscription(name: string, options: any): any;
+    use<TNewContext = TContext>(middleware: MiddlewareFn<TContext, TNewContext>): Router<TRecord, TNewContext>;
+    merge<TPrefix extends string, TSubRecord extends ProcedureRecord>(prefix: TPrefix, router: Router<TSubRecord, TContext>): Router<TRecord & {
+        [K in TPrefix]: Router<TSubRecord, TContext>;
+    }, TContext>;
+}
+export declare function createRouter<TRecord extends ProcedureRecord = Record<string, never>, TContext = any>(record?: TRecord): Router<TRecord, TContext>;
+export declare function query<TInput = any, TOutput = any, TContext = any>(options: ProcedureOptions<TInput, TOutput, TContext>): Procedure<"query", TInput, TOutput, TContext>;
+export declare function mutation<TInput = any, TOutput = any, TContext = any>(options: ProcedureOptions<TInput, TOutput, TContext>): Procedure<"mutation", TInput, TOutput, TContext>;
+export declare function subscription<TInput = any, TOutput = any, TContext = any>(options: ProcedureOptions<TInput, TOutput, TContext>): Procedure<"subscription", TInput, TOutput, TContext>;

package/dist/rpc/server.d.ts

@@ -0,0 +1,3 @@
+import type { FetchHandlerOptions, Router } from "./types";
+export declare function matchesRulePattern(pattern: string, urlPath: string, procedurePath: string): boolean;
+export declare function createFetchHandler<TRouter extends Router<any, any>, TContext = any>(options: FetchHandlerOptions<TRouter, TContext>): (request: Request, ...extra: any[]) => Promise<Response>;

package/dist/rpc/types.d.ts

@@ -0,0 +1,200 @@
+import type { InferSchemaType, SchemaLike, ValidationIssue } from "../form/schema";
+import type { CreateQueryOptions, MutationOptions, MutationResult, QueryResult } from "../query/types";
+export type RPCErrorCode = "BAD_REQUEST" | "UNAUTHORIZED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_ALLOWED" | "TIMEOUT" | "CONFLICT" | "UNPROCESSABLE_CONTENT" | "INTERNAL_SERVER_ERROR";
+export type ProcedureType = "query" | "mutation" | "subscription";
+export type MiddlewareFn<TContext = any, TNewContext = TContext> = (opts: {
+    ctx: TContext;
+    req: Request;
+    signal: AbortSignal;
+    next: (opts?: {
+        ctx?: TNewContext;
+    }) => Promise<any>;
+}) => Promise<any>;
+export interface ProcedureOptionsWithInput<TSchema extends SchemaLike<any>, TOutput = any, TContext = any> {
+    input: TSchema;
+    output?: SchemaLike<TOutput>;
+    resolve: (opts: {
+        input: InferSchemaType<TSchema>;
+        ctx: TContext;
+        req: Request;
+        signal: AbortSignal;
+    }) => Promise<TOutput> | TOutput | AsyncIterable<TOutput>;
+}
+export interface ProcedureOptionsWithoutInput<TOutput = any, TContext = any> {
+    input?: undefined;
+    output?: SchemaLike<TOutput>;
+    resolve: (opts: {
+        input: void;
+        ctx: TContext;
+        req: Request;
+        signal: AbortSignal;
+    }) => Promise<TOutput> | TOutput | AsyncIterable<TOutput>;
+}
+export type ProcedureOptions<TInput = any, TOutput = any, TContext = any> = {
+    input?: SchemaLike<TInput>;
+    output?: SchemaLike<TOutput>;
+    resolve: (opts: {
+        input: TInput;
+        ctx: TContext;
+        req: Request;
+        signal: AbortSignal;
+    }) => Promise<TOutput> | TOutput | AsyncIterable<TOutput>;
+};
+export interface Procedure<TType extends ProcedureType = ProcedureType, TInput = any, TOutput = any, TContext = any> {
+    type: TType;
+    inputSchema?: SchemaLike<TInput>;
+    outputSchema?: SchemaLike<TOutput>;
+    middlewares: MiddlewareFn<any, any>[];
+    resolve: (opts: {
+        input: TInput;
+        ctx: TContext;
+        req: Request;
+        signal: AbortSignal;
+    }) => Promise<TOutput> | TOutput | AsyncIterable<TOutput>;
+}
+export type ProcedureRecord = Record<string, Procedure<any, any, any, any> | Router<any, any>>;
+export interface Router<TRecord extends ProcedureRecord = ProcedureRecord, TContext = any> {
+    _def: {
+        record: TRecord;
+        middlewares: MiddlewareFn<any, any>[];
+    };
+    query<TName extends string, TSchema extends SchemaLike<any>, TOutput = any>(name: TName, options: ProcedureOptionsWithInput<TSchema, TOutput, TContext>): Router<TRecord & {
+        [K in TName]: Procedure<"query", InferSchemaType<TSchema>, TOutput, TContext>;
+    }, TContext>;
+    query<TName extends string, TOutput = any>(name: TName, options: ProcedureOptionsWithoutInput<TOutput, TContext>): Router<TRecord & {
+        [K in TName]: Procedure<"query", void, TOutput, TContext>;
+    }, TContext>;
+    mutation<TName extends string, TSchema extends SchemaLike<any>, TOutput = any>(name: TName, options: ProcedureOptionsWithInput<TSchema, TOutput, TContext>): Router<TRecord & {
+        [K in TName]: Procedure<"mutation", InferSchemaType<TSchema>, TOutput, TContext>;
+    }, TContext>;
+    mutation<TName extends string, TOutput = any>(name: TName, options: ProcedureOptionsWithoutInput<TOutput, TContext>): Router<TRecord & {
+        [K in TName]: Procedure<"mutation", void, TOutput, TContext>;
+    }, TContext>;
+    subscription<TName extends string, TSchema extends SchemaLike<any>, TOutput = any>(name: TName, options: ProcedureOptionsWithInput<TSchema, TOutput, TContext>): Router<TRecord & {
+        [K in TName]: Procedure<"subscription", InferSchemaType<TSchema>, TOutput, TContext>;
+    }, TContext>;
+    subscription<TName extends string, TOutput = any>(name: TName, options: ProcedureOptionsWithoutInput<TOutput, TContext>): Router<TRecord & {
+        [K in TName]: Procedure<"subscription", void, TOutput, TContext>;
+    }, TContext>;
+    use<TNewContext = TContext>(middleware: MiddlewareFn<TContext, TNewContext>): Router<TRecord, TNewContext>;
+    merge<TPrefix extends string, TSubRecord extends ProcedureRecord>(prefix: TPrefix, router: Router<TSubRecord, TContext>): Router<TRecord & {
+        [K in TPrefix]: Router<TSubRecord, TContext>;
+    }, TContext>;
+}
+export interface CORSOptions {
+    origin?: string | string[] | ((origin: string) => boolean | string);
+    methods?: string[];
+    allowedHeaders?: string[];
+    exposedHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+}
+export type DynamicHeadersFn = (req: Request, ctx: any) => Promise<Record<string, string>> | Record<string, string>;
+export type HeadersConfig = Record<string, string> | DynamicHeadersFn;
+export interface RouteRule {
+    /**
+     * Response headers to attach to all matching requests.
+     */
+    headers?: HeadersConfig;
+    /**
+     * Required request headers. If any are missing, automatically rejects with HTTP 401 Unauthorized.
+     */
+    requireHeaders?: string[];
+    /**
+     * Required query parameters. If missing on GET requests, rejects with HTTP 400 Bad Request.
+     */
+    requireParams?: string[];
+    /**
+     * Custom guard function for matching requests. Return false or throw RPCError to reject.
+     */
+    guard?: (opts: {
+        req: Request;
+        ctx: any;
+        path: string;
+    }) => Promise<boolean | void> | boolean | void;
+}
+export interface FetchHandlerOptions<TRouter extends Router<any, any> = Router<any, any>, TContext = any> {
+    router: TRouter;
+    endpoint?: string;
+    createContext?: (opts: {
+        req: Request;
+        extra: any[];
+    }) => Promise<TContext> | TContext;
+    onError?: (opts: {
+        error: any;
+        path?: string;
+        req: Request;
+    }) => void;
+    cors?: boolean | CORSOptions;
+    securityHeaders?: boolean | Record<string, string>;
+    /**
+     * Declarative pattern rules matching URL paths or procedure names (e.g. "*", "/api/*", "admin.*").
+     * Supports wildcard matching with '*'.
+     */
+    rules?: Record<string, RouteRule> | Array<{
+        match: string;
+    } & RouteRule>;
+}
+export type ClientHeadersRule = Record<string, string> | (() => Promise<Record<string, string>> | Record<string, string>);
+export interface ClientOptions {
+    baseUrl: string;
+    fetch?: typeof fetch;
+    headers?: Record<string, string> | Record<string, ClientHeadersRule> | (() => Promise<Record<string, string>> | Record<string, string>);
+}
+export interface SubscriptionCallbacks<TData = any> {
+    onData: (data: TData) => void;
+    onError?: (error: any) => void;
+    onComplete?: () => void;
+}
+export interface SubscriptionHandle {
+    unsubscribe: () => void;
+}
+export type InferProcedureInput<P> = P extends Procedure<any, infer TInput, any, any> ? TInput : void;
+export type InferProcedureOutput<P> = P extends Procedure<any, any, infer TOutput, any> ? TOutput : unknown;
+export type ClientQueryMethod<P> = InferProcedureInput<P> extends void | undefined ? (input?: void, options?: {
+    signal?: AbortSignal;
+    headers?: Record<string, string>;
+}) => Promise<InferProcedureOutput<P>> : (input: InferProcedureInput<P>, options?: {
+    signal?: AbortSignal;
+    headers?: Record<string, string>;
+}) => Promise<InferProcedureOutput<P>>;
+export type ClientMutationMethod<P> = InferProcedureInput<P> extends void | undefined ? (input?: void, options?: {
+    signal?: AbortSignal;
+    headers?: Record<string, string>;
+}) => Promise<InferProcedureOutput<P>> : (input: InferProcedureInput<P>, options?: {
+    signal?: AbortSignal;
+    headers?: Record<string, string>;
+}) => Promise<InferProcedureOutput<P>>;
+export type ClientSubscriptionMethod<P> = InferProcedureInput<P> extends void | undefined ? (input: void | undefined, callbacks: SubscriptionCallbacks<InferProcedureOutput<P>>) => SubscriptionHandle : (input: InferProcedureInput<P>, callbacks: SubscriptionCallbacks<InferProcedureOutput<P>>) => SubscriptionHandle;
+export type ClientProcedure<P> = P extends Procedure<"query", infer TInput, infer TOutput, any> ? {
+    query: ClientQueryMethod<P>;
+    createQuery: (input?: TInput | (() => TInput), extra?: Partial<CreateQueryOptions<TOutput, any, TOutput, any>>) => QueryResult<TOutput, any>;
+    useQuery: (input?: TInput | (() => TInput), extra?: Partial<CreateQueryOptions<TOutput, any, TOutput, any>>) => QueryResult<TOutput, any>;
+    queryKey: (input?: TInput) => unknown[];
+    queryOptions: (input?: TInput, extra?: Partial<CreateQueryOptions<TOutput, any, TOutput, any>>) => CreateQueryOptions<TOutput, any, TOutput, any>;
+} : P extends Procedure<"mutation", infer TInput, infer TOutput, any> ? {
+    mutate: ClientMutationMethod<P>;
+    createMutation: (extra?: Partial<MutationOptions<TOutput, any, TInput, any>>) => MutationResult<TOutput, any, TInput, any>;
+    useMutation: (extra?: Partial<MutationOptions<TOutput, any, TInput, any>>) => MutationResult<TOutput, any, TInput, any>;
+    mutationKey: () => unknown[];
+    mutationOptions: (extra?: Partial<MutationOptions<TOutput, any, TInput, any>>) => MutationOptions<TOutput, any, TInput, any>;
+} : P extends Procedure<"subscription", any, any, any> ? {
+    subscribe: ClientSubscriptionMethod<P>;
+} : never;
+export type ClientRouter<R> = R extends Router<infer TRecord, any> ? {
+    [K in keyof TRecord]: TRecord[K] extends Procedure<any, any, any, any> ? ClientProcedure<TRecord[K]> : TRecord[K] extends Router<any, any> ? ClientRouter<TRecord[K]> : never;
+} : never;
+export interface RPCResponseSuccess<T = any> {
+    result: {
+        data: T;
+    };
+}
+export interface RPCResponseError {
+    error: {
+        code: RPCErrorCode;
+        message: string;
+        issues?: ValidationIssue[];
+        data?: any;
+    };
+}
+export type RPCResponse<T = any> = RPCResponseSuccess<T> | RPCResponseError;

package/dist/server/hydrate.d.ts

@@ -0,0 +1,5 @@
+import { type Child } from "../dom/render";
+/**
+ * Hydrate server-rendered HTML by attaching fine-grained signal subscriptions and event listeners
+ */
+export declare function hydrate(fn: () => Child, container: HTMLElement | DocumentFragment): () => void;

package/dist/server/index.d.ts

@@ -0,0 +1,3 @@
+export { hydrate } from "./hydrate";
+export { renderToStream, type StreamOptions } from "./render-to-stream";
+export { renderChildToString, renderToString } from "./render-to-string";