@lovrozagar/flare 0.1.0

package/src/components/theme-script.tsx

@@ -0,0 +1,22 @@
+import type { JSX } from "solid-js";
+import { NoHydration } from "solid-js/web";
+import type { ThemeConfig } from "../theme.ts";
+import { getThemeScript } from "../theme.ts";
+import { useSSRContext } from "./ssr-context.tsx";
+
+export interface ThemeScriptProps {
+	config?: ThemeConfig;
+}
+
+export function ThemeScript(props: ThemeScriptProps): JSX.Element {
+	const ctx = useSSRContext();
+	const nonce = ctx?.nonce ?? "";
+	const config = props.config ?? ctx?.theme;
+	const script = getThemeScript(config);
+
+	return (
+		<NoHydration>
+			<script innerHTML={script} nonce={nonce} />
+		</NoHydration>
+	) as unknown as JSX.Element;
+}

package/src/components/view-transition-css.tsx

@@ -0,0 +1,21 @@
+import type { JSX } from "solid-js";
+import { useSSRContext } from "./ssr-context.tsx";
+
+/* Duplicated from index.ts to avoid circular import (index re-exports this component) */
+function buildViewTransitionCss(duration: number): string {
+	return `@view-transition{navigation:auto}::view-transition-old(*),::view-transition-new(*){animation-duration:${duration}ms}`;
+}
+
+const DEFAULT_CSS = buildViewTransitionCss(175);
+
+export interface ViewTransitionCSSProps {
+	duration?: number;
+}
+
+export function ViewTransitionCSS(props: ViewTransitionCSSProps): JSX.Element {
+	const ctx = useSSRContext();
+	const nonce = ctx?.nonce ?? "";
+	const css = props.duration !== undefined ? buildViewTransitionCss(props.duration) : DEFAULT_CSS;
+
+	return (<style innerHTML={css} nonce={nonce} />) as unknown as JSX.Element;
+}

package/src/config/index.ts

@@ -0,0 +1,84 @@
+export interface GlobalBoundariesConfig {
+	error?: string;
+	notFound?: string;
+	unauthorized?: string;
+}
+
+export interface CssConfig {
+	scoped?: boolean;
+}
+
+export interface ServerFnConfig {
+	exclude?: RegExp;
+	include?: RegExp;
+}
+
+export interface FlareBuildConfig {
+	clientEntryFilePath?: string;
+	css?: CssConfig | false;
+	generated?: {
+		routesFilePath?: string;
+		typesFilePath?: string;
+	};
+	globalBoundaries?: GlobalBoundariesConfig;
+	ignorePrefix?: string;
+	serverEntryFilePath?: string;
+	serverFn?: ServerFnConfig | false;
+	viewTransitions?: boolean;
+}
+
+const MARKER = Symbol.for("flare/build-config");
+
+export interface MarkedFlareBuildConfig extends FlareBuildConfig {
+	[key: symbol]: true;
+}
+
+export function createFlareBuild(config: FlareBuildConfig): MarkedFlareBuildConfig {
+	return { ...config, [MARKER]: true } as MarkedFlareBuildConfig;
+}
+
+export function isFlareBuildConfig(value: unknown): value is MarkedFlareBuildConfig {
+	return (
+		value !== null &&
+		value !== undefined &&
+		typeof value === "object" &&
+		MARKER in (value as Record<symbol, unknown>) &&
+		(value as Record<symbol, unknown>)[MARKER] === true
+	);
+}
+
+export function validateFlareBuildConfig(value: unknown): string[] {
+	const errors: string[] = [];
+
+	if (!isFlareBuildConfig(value)) {
+		errors.push("Config missing flare/build-config marker — use createFlareBuild()");
+		return errors;
+	}
+
+	const config = value as FlareBuildConfig;
+
+	if (config.ignorePrefix !== undefined && typeof config.ignorePrefix !== "string") {
+		errors.push(`ignorePrefix must be a string, got ${typeof config.ignorePrefix}`);
+	}
+
+	if (config.serverFn !== undefined && config.serverFn !== false) {
+		if (typeof config.serverFn !== "object" || config.serverFn === null) {
+			errors.push(`serverFn must be an object or false, got ${typeof config.serverFn}`);
+		} else {
+			if (config.serverFn.include !== undefined && !(config.serverFn.include instanceof RegExp)) {
+				errors.push(`serverFn.include must be a RegExp, got ${typeof config.serverFn.include}`);
+			}
+			if (config.serverFn.exclude !== undefined && !(config.serverFn.exclude instanceof RegExp)) {
+				errors.push(`serverFn.exclude must be a RegExp, got ${typeof config.serverFn.exclude}`);
+			}
+		}
+	}
+
+	if (config.css !== undefined && config.css !== false) {
+		if (typeof config.css !== "object" || config.css === null) {
+			errors.push(`css must be an object or false, got ${typeof config.css}`);
+		}
+	}
+
+	return errors;
+}

package/src/create-client-only-fn.ts

@@ -0,0 +1 @@
+export { createClientOnlyFn } from "./env-fn.ts";

package/src/create-isomorphic-fn.ts

@@ -0,0 +1,2 @@
+export type { ClientBoundFn, IsomorphicFn, IsomorphicFnBuilder, ServerBoundFn } from "./env-fn.ts";
+export { createIsomorphicFn } from "./env-fn.ts";

package/src/create-layout.ts

@@ -0,0 +1 @@
+export { createLayout } from "./route-builder/index.ts";

package/src/create-page.ts

@@ -0,0 +1 @@
+export { createPage } from "./route-builder/index.ts";

package/src/create-path-segment.ts

@@ -0,0 +1 @@
+export { createPathSegment } from "./route-builder/index.ts";

package/src/create-query-client-getter.ts

@@ -0,0 +1,2 @@
+export type { QueryClientGetterOptions } from "./query-client/index.tsx";
+export { createQueryClientGetter } from "./query-client/index.tsx";

package/src/create-root-layout.ts

@@ -0,0 +1 @@
+export { createRootLayout } from "./route-builder/index.ts";

package/src/create-router.ts

@@ -0,0 +1,8 @@
+export type {
+	PrefetchStrategy,
+	RouterCacheConfig,
+	RouterConfig,
+	TrailingSlashMode,
+	ViewTransitionDefaults,
+} from "./router-config/index.ts";
+export { createRouter } from "./router-config/index.ts";

package/src/create-server-only-fn.ts

@@ -0,0 +1 @@
+export { createServerOnlyFn } from "./env-fn.ts";

package/src/dedupe/index.ts

@@ -0,0 +1,151 @@
+import { warn } from "../logger.ts";
+import { getServerRequestContext } from "@lovrozagar/flare/server-context";
+
+const DEDUPE_CACHE_KEY = "__flare_dedupe";
+const FETCH_CACHE_KEY = "__flare_fetch_dedupe";
+
+let fnCounter = 0;
+
+function getDedupeCache(): Map<string, Promise<unknown>> {
+	const ctx = getServerRequestContext();
+	let cache = ctx.get<Map<string, Promise<unknown>>>(DEDUPE_CACHE_KEY);
+	if (!cache) {
+		cache = new Map();
+		ctx.set(DEDUPE_CACHE_KEY, cache);
+	}
+	return cache;
+}
+
+function getFetchCache(): Map<string, Promise<Response>> | undefined {
+	try {
+		const ctx = getServerRequestContext();
+		let cache = ctx.get<Map<string, Promise<Response>>>(FETCH_CACHE_KEY);
+		if (!cache) {
+			cache = new Map();
+			ctx.set(FETCH_CACHE_KEY, cache);
+		}
+		return cache;
+	} catch {
+		return undefined;
+	}
+}
+
+export function dedupe<TArgs extends unknown[], TResult>(
+	fn: (...args: TArgs) => Promise<TResult>,
+): (...args: TArgs) => Promise<TResult> {
+	fnCounter = (fnCounter + 1) % Number.MAX_SAFE_INTEGER;
+	const fnId = fnCounter;
+	return (...args: TArgs): Promise<TResult> => {
+		const cache = getDedupeCache();
+		/* JSON.stringify maps both undefined and null to "null" — replacer preserves distinction */
+		const key = `${fnId}:${JSON.stringify(args, (_, v) => (v === undefined ? "\x00" : v))}`;
+		const existing = cache.get(key);
+		if (existing) return existing as Promise<TResult>;
+		const promise = fn(...args);
+		cache.set(key, promise);
+		return promise;
+	};
+}
+
+const EXCLUDED_HEADERS = new Set(["traceparent", "tracestate", "x-request-id", "x-correlation-id"]);
+
+function getFetchCacheKey(input: RequestInfo | URL, init?: RequestInit): string | undefined {
+	let method = "GET";
+	let url: string;
+
+	if (input instanceof Request) {
+		method = input.method.toUpperCase();
+		url = input.url;
+	} else if (input instanceof URL) {
+		url = input.toString();
+	} else {
+		url = input;
+	}
+
+	if (init?.method) {
+		method = init.method.toUpperCase();
+	}
+
+	if (method !== "GET" && method !== "HEAD") {
+		return undefined;
+	}
+
+	let headersKey = "";
+	const headers = init?.headers ?? (input instanceof Request ? input.headers : undefined);
+	if (headers) {
+		const entries: Array<[string, string]> = [];
+		if (headers instanceof Headers) {
+			headers.forEach((v, k) => {
+				if (!EXCLUDED_HEADERS.has(k.toLowerCase())) {
+					entries.push([k.toLowerCase(), v]);
+				}
+			});
+		} else if (Array.isArray(headers)) {
+			for (const [k, v] of headers) {
+				if (!EXCLUDED_HEADERS.has(k.toLowerCase())) {
+					entries.push([k.toLowerCase(), v]);
+				}
+			}
+		} else {
+			for (const k of Object.keys(headers)) {
+				if (!EXCLUDED_HEADERS.has(k.toLowerCase())) {
+					entries.push([k.toLowerCase(), headers[k] as string]);
+				}
+			}
+		}
+		entries.sort((a, b) => a[0].localeCompare(b[0]));
+		headersKey = JSON.stringify(entries);
+	}
+
+	return `fetch:${method}:${url}:${headersKey}`;
+}
+
+let originalFetch: typeof globalThis.fetch | undefined;
+let enableCount = 0;
+
+function createDedupedFetch(baseFetch: typeof globalThis.fetch): typeof globalThis.fetch {
+	return async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+		const key = getFetchCacheKey(input, init);
+		if (!key) return baseFetch(input, init);
+
+		const cache = getFetchCache();
+		if (!cache) return baseFetch(input, init);
+
+		const existing = cache.get(key);
+		if (existing) return (await existing).clone();
+
+		const promise = baseFetch(input, init);
+		cache.set(key, promise);
+		/* Clean up cache on rejection so retries within same request can succeed */
+		promise.catch((e: unknown) => {
+			warn("dedupe", "fetch failed, clearing cache", e);
+			cache.delete(key);
+		});
+		return (await promise).clone();
+	};
+}
+
+/**
+ * Reference-counted enable/disable to avoid race conditions
+ * when concurrent requests share the same isolate.
+ */
+export function enableFetchDedupe(): void {
+	enableCount++;
+	if (enableCount === 1) {
+		originalFetch = globalThis.fetch;
+		globalThis.fetch = createDedupedFetch(originalFetch);
+	}
+}
+
+export function disableFetchDedupe(): void {
+	enableCount--;
+	if (enableCount <= 0) {
+		if (originalFetch) globalThis.fetch = originalFetch;
+		originalFetch = undefined;
+		enableCount = 0;
+	}
+}
+
+export function isFetchDedupeEnabled(): boolean {
+	return enableCount > 0;
+}

package/src/defer/index.ts

@@ -0,0 +1,82 @@
+import type { StaticDeferMode } from "../route-builder/types.ts";
+
+export interface Deferred<T> {
+	__deferred: true;
+	error?: unknown;
+	key: string;
+	prerender?: StaticDeferMode;
+	promise: Promise<T>;
+}
+
+export interface DeferContext {
+	defer: DeferFn;
+	entries: () => DeferredEntry[];
+}
+
+export type DeferFn = <T>(fn: () => Promise<T>, options?: { key?: string; prerender?: StaticDeferMode }) => Deferred<T>;
+
+export interface DeferredEntry {
+	key: string;
+	matchId: string;
+	prerender?: StaticDeferMode;
+	promise: Promise<unknown>;
+}
+
+export interface DeferContextOptions {
+	prefetch?: boolean;
+}
+
+export function createDeferContext(matchId: string, opts?: DeferContextOptions): DeferContext {
+	const isPrefetch = opts?.prefetch ?? false;
+	let counter = 0;
+	const cache = new Map<string, Deferred<unknown>>();
+	const entryList: DeferredEntry[] = [];
+
+	const defer: DeferFn = <T>(
+		fn: () => Promise<T>,
+		options?: { key?: string; prerender?: StaticDeferMode },
+	): Deferred<T> => {
+		const key = options?.key ?? `d${counter++}`;
+		const existing = cache.get(key);
+		if (existing) return existing as Deferred<T>;
+
+		if (isPrefetch) {
+			const deferred: Deferred<T> = { __deferred: true, key, promise: new Promise<T>(() => {}) };
+			cache.set(key, deferred as Deferred<unknown>);
+			return deferred;
+		}
+
+		let promise: Promise<T>;
+		try {
+			promise = fn();
+		} catch (e) {
+			promise = Promise.reject(e);
+		}
+		const deferred: Deferred<T> = { __deferred: true, key, prerender: options?.prerender, promise };
+
+		/* Prevent unhandled rejection for both sync throw and async reject paths.
+		 * Error surfaces when consumer awaits the promise via Promise.allSettled.
+		 * Also capture error on the deferred object for direct access. */
+		promise.catch((e) => {
+			deferred.error = e;
+		});
+		cache.set(key, deferred as Deferred<unknown>);
+		entryList.push({ key, matchId, prerender: options?.prerender, promise });
+		return deferred;
+	};
+
+	return {
+		defer,
+		entries: () => entryList,
+	};
+}
+
+export function isDeferred(value: unknown): value is Deferred<unknown> {
+	return (
+		value !== null &&
+		value !== undefined &&
+		typeof value === "object" &&
+		"__deferred" in value &&
+		(value as Record<string, unknown>).__deferred === true
+	);
+}

package/src/direction/index.tsx

@@ -0,0 +1,163 @@
+import {
+	createContext,
+	createEffect,
+	createSignal,
+	type JSX,
+	on,
+	onCleanup,
+	onMount,
+	sharedConfig,
+	useContext,
+} from "solid-js";
+
+export type Direction = "ltr" | "rtl";
+
+export interface DirectionConfig {
+	attribute?: string;
+	defaultDir?: Direction;
+	rtlLocales?: readonly string[];
+	storageKey?: string;
+}
+
+const DEFAULT_CONFIG: Required<DirectionConfig> = {
+	attribute: "data-dir",
+	defaultDir: "ltr",
+	rtlLocales: ["ar", "he", "fa", "ur"],
+	storageKey: "flare.dir",
+};
+
+/* Escape for safe interpolation into JS double-quoted strings inside <script> */
+function escapeJsString(s: string): string {
+	return s
+		.replace(/\\/g, "\\\\")
+		.replace(/"/g, '\\"')
+		.replace(/<\//g, "<\\/")
+		.replace(/\n/g, "\\n")
+		.replace(/\r/g, "\\r")
+		.replace(/\u2028/g, "\\u2028")
+		.replace(/\u2029/g, "\\u2029");
+}
+
+export function getDirectionScript(opts?: DirectionConfig): string {
+	const attr = escapeJsString(opts?.attribute ?? DEFAULT_CONFIG.attribute);
+	const defaultDir = escapeJsString(opts?.defaultDir ?? DEFAULT_CONFIG.defaultDir);
+	const storageKey = escapeJsString(opts?.storageKey ?? DEFAULT_CONFIG.storageKey);
+	return `((k,d,a)=>{const e=document.documentElement;let v;try{v=localStorage.getItem(k)}catch{}v=v||e.getAttribute("dir")||d;e.setAttribute(a,v);e.setAttribute("dir",v)})("${storageKey}","${defaultDir}","${attr}")`;
+}
+
+export function getDirFromLocale(locale: string | undefined, rtlLocales?: readonly string[]): Direction {
+	if (!locale) return "ltr";
+	const base = locale.split("-")[0]?.toLowerCase() ?? "";
+	return (rtlLocales ?? DEFAULT_CONFIG.rtlLocales).includes(base) ? "rtl" : "ltr";
+}
+
+/* ── Context ──────────────────────────────────────────────────────── */
+
+export interface DirectionContextValue {
+	direction: () => Direction;
+	getDirFromLocale: (locale: string | undefined) => Direction;
+	setDirection: (dir: Direction) => void;
+	toggleDirection: () => void;
+}
+
+const DirectionCtx = createContext<DirectionContextValue>();
+
+export function DirectionProvider(props: { children: JSX.Element; config?: DirectionConfig }): JSX.Element {
+	/* SSR: pass through children (context not needed on server, scripts handle direction) */
+	if (sharedConfig.context) {
+		return props.children;
+	}
+
+	const cfg: Required<DirectionConfig> = {
+		attribute: props.config?.attribute ?? DEFAULT_CONFIG.attribute,
+		defaultDir: props.config?.defaultDir ?? DEFAULT_CONFIG.defaultDir,
+		rtlLocales: props.config?.rtlLocales ?? DEFAULT_CONFIG.rtlLocales,
+		storageKey: props.config?.storageKey ?? DEFAULT_CONFIG.storageKey,
+	};
+
+	/* Read initial direction from localStorage, DOM dir attr, or default */
+	let initial: Direction = cfg.defaultDir;
+	if (typeof localStorage !== "undefined") {
+		try {
+			const stored = localStorage.getItem(cfg.storageKey);
+			if (stored === "ltr" || stored === "rtl") {
+				initial = stored;
+			}
+		} catch {
+			/* noop */
+		}
+	}
+	if (initial === cfg.defaultDir && typeof document !== "undefined") {
+		const domDir = document.documentElement.getAttribute("dir");
+		if (domDir === "ltr" || domDir === "rtl") {
+			initial = domDir;
+		}
+	}
+
+	const [direction, setDirectionSignal] = createSignal<Direction>(initial);
+
+	/* Sync direction to DOM */
+	createEffect(() => {
+		const dir = direction();
+		if (typeof document === "undefined") return;
+		const el = document.documentElement;
+		el.setAttribute(cfg.attribute, dir);
+		el.setAttribute("dir", dir);
+	});
+
+	/* Cross-tab sync: StorageEvent fires in OTHER tabs only */
+	onMount(() => {
+		const handler = (e: StorageEvent) => {
+			if (e.key !== cfg.storageKey || e.storageArea !== localStorage) return;
+			const v = e.newValue;
+			if (v === "ltr" || v === "rtl") {
+				setDirectionSignal(v);
+			}
+		};
+		window.addEventListener("storage", handler);
+		onCleanup(() => window.removeEventListener("storage", handler));
+	});
+
+	/* Persist to localStorage on changes */
+	createEffect(
+		on(
+			direction,
+			(dir) => {
+				try {
+					localStorage.setItem(cfg.storageKey, dir);
+				} catch {
+					/* noop */
+				}
+			},
+			{ defer: true },
+		),
+	);
+
+	const setDirection = (dir: Direction): void => {
+		setDirectionSignal(dir);
+	};
+
+	const toggleDirection = (): void => {
+		const current = direction();
+		setDirection(current === "ltr" ? "rtl" : "ltr");
+	};
+
+	const dirFromLocale = (locale: string | undefined): Direction => {
+		return getDirFromLocale(locale, cfg.rtlLocales);
+	};
+
+	const value: DirectionContextValue = {
+		direction,
+		getDirFromLocale: dirFromLocale,
+		setDirection,
+		toggleDirection,
+	};
+
+	return <DirectionCtx.Provider value={value}>{props.children}</DirectionCtx.Provider>;
+}
+
+export function useDirection(): DirectionContextValue {
+	const ctx = useContext(DirectionCtx);
+	if (!ctx) throw new Error("useDirection() called outside DirectionProvider. Wrap your app with <DirectionProvider>.");
+	return ctx;
+}

package/src/direction.ts

@@ -0,0 +1,3 @@
+export { DirectionScript } from "./components/direction-script.tsx";
+export type { Direction, DirectionConfig, DirectionContextValue } from "./direction/index.tsx";
+export { DirectionProvider, getDirectionScript, getDirFromLocale, useDirection } from "./direction/index.tsx";

package/src/duration/index.ts

@@ -0,0 +1,18 @@
+export type Duration = number | `${number}${"d" | "h" | "m" | "s"}`;
+
+const UNITS: Record<string, number> = { d: 86400, h: 3600, m: 60, s: 1 };
+const DURATION_RE = /^(\d+)(s|m|h|d)$/;
+
+export function parseSeconds(value: Duration): number {
+	if (typeof value === "number") return value;
+	const match = value.match(DURATION_RE);
+	if (!match || !match[1] || !match[2]) throw new Error(`Invalid duration: ${value}`);
+	const unit = UNITS[match[2]];
+	if (unit === undefined) throw new Error(`Invalid duration: ${value}`);
+	return Number(match[1]) * unit;
+}
+
+export function parseMilliseconds(value: Duration): number {
+	if (typeof value === "number") return value;
+	return parseSeconds(value) * 1000;
+}

package/src/env-fn/index.ts

@@ -0,0 +1,101 @@
+/// <reference types="vite/client" />
+
+/* ── createServerOnlyFn ─────────────────────────────────────────────── */
+
+/**
+ * Marks a function as server-only. On client builds, the Vite plugin
+ * replaces the implementation with a throwing stub and tree-shakes
+ * any server-only imports the function body references.
+ *
+ * Runtime fallback (tests, no plugin): uses `import.meta.env.SSR`.
+ */
+export function createServerOnlyFn<TArgs extends unknown[], TReturn>(
+	fn: (...args: TArgs) => TReturn,
+): (...args: TArgs) => TReturn {
+	if (import.meta.env.SSR) return fn;
+	return (..._args: TArgs): never => {
+		throw new Error("Server-only function called on client");
+	};
+}
+
+/* ── createClientOnlyFn ─────────────────────────────────────────────── */
+
+/**
+ * Marks a function as client-only. On SSR builds, the Vite plugin
+ * replaces the implementation with a throwing stub and tree-shakes
+ * any client-only imports the function body references.
+ *
+ * Runtime fallback (tests, no plugin): uses `import.meta.env.SSR`.
+ */
+export function createClientOnlyFn<TArgs extends unknown[], TReturn>(
+	fn: (...args: TArgs) => TReturn,
+): (...args: TArgs) => TReturn {
+	if (!import.meta.env.SSR) return fn;
+	return (..._args: TArgs): never => {
+		throw new Error("Client-only function called on server");
+	};
+}
+
+/* ── createIsomorphicFn ─────────────────────────────────────────────── */
+
+/**
+ * Creates a function with different implementations per environment.
+ * The Vite plugin extracts the env-specific implementation at build time,
+ * eliminating the unused branch and its imports from the bundle.
+ *
+ * ```ts
+ * const getUser = createIsomorphicFn()
+ *   .server(() => db.getUser(cookies()))
+ *   .client(() => JSON.parse(localStorage.getItem("user")!))
+ * ```
+ *
+ * Runtime fallback (tests, no plugin): uses `import.meta.env.SSR`.
+ */
+
+export type IsomorphicFn<TArgs extends unknown[] = [], TServer = undefined, TClient = undefined> = (
+	...args: TArgs
+) => TClient | TServer;
+
+export interface ServerBoundFn<TArgs extends unknown[], TServer> extends IsomorphicFn<TArgs, TServer> {
+	client: <TClient>(clientImpl: (...args: TArgs) => TClient) => IsomorphicFn<TArgs, TServer, TClient>;
+}
+
+export interface ClientBoundFn<TArgs extends unknown[], TClient> extends IsomorphicFn<TArgs, undefined, TClient> {
+	server: <TServer>(serverImpl: (...args: TArgs) => TServer) => IsomorphicFn<TArgs, TServer, TClient>;
+}
+
+export interface IsomorphicFnBuilder {
+	client: <TArgs extends unknown[], TClient>(clientImpl: (...args: TArgs) => TClient) => ClientBoundFn<TArgs, TClient>;
+	server: <TArgs extends unknown[], TServer>(serverImpl: (...args: TArgs) => TServer) => ServerBoundFn<TArgs, TServer>;
+}
+
+function buildIsomorphic<TArgs extends unknown[], TServer, TClient>(
+	serverImpl: ((...args: TArgs) => TServer) | null,
+	clientImpl: ((...args: TArgs) => TClient) | null,
+): IsomorphicFn<TArgs, TServer, TClient> {
+	return ((...args: TArgs) => {
+		if (import.meta.env.SSR) return serverImpl ? serverImpl(...args) : undefined;
+		return clientImpl ? clientImpl(...args) : undefined;
+	}) as IsomorphicFn<TArgs, TServer, TClient>;
+}
+
+export function createIsomorphicFn(): IsomorphicFnBuilder {
+	return {
+		client<TArgs extends unknown[], TClient>(clientImpl: (...args: TArgs) => TClient) {
+			const fn = buildIsomorphic<TArgs, undefined, TClient>(null, clientImpl);
+			return Object.assign(fn, {
+				server<TServer>(serverImpl: (...args: TArgs) => TServer) {
+					return buildIsomorphic<TArgs, TServer, TClient>(serverImpl, clientImpl);
+				},
+			}) as ClientBoundFn<TArgs, TClient>;
+		},
+		server<TArgs extends unknown[], TServer>(serverImpl: (...args: TArgs) => TServer) {
+			const fn = buildIsomorphic<TArgs, TServer, undefined>(serverImpl, null);
+			return Object.assign(fn, {
+				client<TClient>(clientImpl: (...args: TArgs) => TClient) {
+					return buildIsomorphic<TArgs, TServer, TClient>(serverImpl, clientImpl);
+				},
+			}) as ServerBoundFn<TArgs, TServer>;
+		},
+	};
+}