toiljs 0.0.115 → 0.0.117

package/src/client/routing/loader.ts

@@ -1,381 +0,0 @@
-/**
- * Route data loaders. A route file may export a `loader` alongside its default component; the
- * loader runs on navigation, in parallel with the route's chunk load, and the page suspends until
- * it resolves (so `loading.tsx` shows and `useNavigationPending` is true). The page reads the
- * result with `useLoaderData<typeof loader>()`.
- *
- * Caching: results are cached by URL (`pathname + search`). Re-renders reuse the cached result (the
- * loader does not re-run). Across navigations, the cache policy comes from the route's optional
- * `export const revalidate` ({@link Revalidate}): by default the loader re-runs on every navigation;
- * a number keeps data fresh for that many seconds; `false` caches until manual invalidation.
- * `revalidate()` / `router.refresh()` bust the cache to force a refetch.
- */
-import { type ComponentType, createContext, useContext } from 'react';
-
-import type { HeadSpec } from '../head/head.js';
-import { type GenerateMetadata, type Metadata, resolveMetadata } from '../head/metadata.js';
-import { navigationEpoch, refresh as rerender } from '../navigation/navigation.js';
-import type { RouteDef } from '../types.js';
-import type { RouteParams } from './match.js';
-
-/** Argument passed to a route `loader`. */
-export interface LoaderArgs {
-    readonly params: RouteParams;
-    readonly searchParams: URLSearchParams;
-}
-
-/** A route `loader`: `export const loader = ({ params }) => …` (sync or async). */
-export type LoaderFunction<T = unknown> = (args: LoaderArgs) => T | Promise<T>;
-
-/** One concrete set of route params (a dynamic segment maps to a string, a catch-all to a string[]). */
-export type StaticParams = Record<string, string | string[]>;
-
-/**
- * A route's `export const generateStaticParams`: returns the concrete param sets to pre-render at
- * build time (SSG). toil enumerates them, runs the route's `generateMetadata` per set, and bakes a
- * `<url>/index.html` + sitemap entry for each, so dynamic routes get build-time SEO. Build-only.
- */
-export type GenerateStaticParams = () => StaticParams[] | Promise<StaticParams[]>;
-
-/**
- * Per-route cache policy, set with `export const revalidate` in a route file:
- * - `0` (default): re-run the loader on every navigation to the route.
- * - a positive number: reuse cached data across navigations for that many **seconds**, then refetch.
- * - `false`: cache indefinitely until manually invalidated (`revalidate()` / `router.refresh()`).
- */
-export type Revalidate = number | false;
-
-/** Resolves the data type for {@link useLoaderData}: `typeof loader` → its (awaited) return, else `T`. */
-export type LoaderData<T> = T extends (...args: never[]) => infer R ? Awaited<R> : T;
-
-interface RouteModule {
-    default: ComponentType;
-    loader?: LoaderFunction;
-    revalidate?: Revalidate;
-    metadata?: Metadata;
-    generateMetadata?: GenerateMetadata;
-}
-interface RouteData {
-    Component: ComponentType;
-    data: unknown;
-    /** Resolved baseline head from the route's `metadata` / `generateMetadata`, if any. */
-    head?: HeadSpec;
-}
-interface Entry {
-    status: 'pending' | 'done' | 'error';
-    promise: Promise<void>;
-    value?: RouteData;
-    error?: unknown;
-    /** `Date.now()` when the fetch settled (`0` while pending). */
-    loadedAt: number;
-    /** Cache policy captured from the route module once loaded. */
-    revalidate: Revalidate;
-    /** Navigation epoch at which this entry was (re)fetched. */
-    epoch: number;
-    /** Whether the route exports a `loader`, a route without one has no data that can change. */
-    hasLoader: boolean;
-    /**
-     * Fetched ahead of navigation (hover/visible prefetch), not yet consumed by a navigation. Such an
-     * entry is reused once by the next navigation even under `revalidate: 0`, then behaves normally.
-     */
-    prefetched: boolean;
-}
-
-const cache = new Map<string, Entry>();
-const MAX_ENTRIES = 32;
-
-// Dev-cache observers (the dev toolbar's Data tab). The emit calls are no-ops in production builds,
-// where the toolbar (the only subscriber) is dead-code-eliminated.
-const cacheListeners = new Set<() => void>();
-// Cached snapshot for useSyncExternalStore: getSnapshot must return a stable reference between
-// changes, so we recompute only when the cache mutates (in emitCache), not on every read. Returning
-// a fresh array per call makes React think the store changed every render -> infinite loop.
-let cacheSnapshot: LoaderCacheSnapshot[] = [];
-function emitCache(): void {
-    cacheSnapshot = [...cache.entries()].map(([key, e]) => ({
-        key,
-        status: e.status,
-        hasLoader: e.hasLoader,
-        revalidate: e.revalidate,
-        loadedAt: e.loadedAt,
-        epoch: e.epoch,
-        data: e.value?.data,
-    }));
-    for (const l of cacheListeners) l();
-}
-/** Subscribes to loader-cache changes (dev toolbar). Returns an unsubscribe. */
-export function subscribeLoaderCache(listener: () => void): () => void {
-    cacheListeners.add(listener);
-    return () => {
-        cacheListeners.delete(listener);
-    };
-}
-/** A read-only snapshot of one cached loader entry (dev toolbar). */
-export interface LoaderCacheSnapshot {
-    readonly key: string;
-    readonly status: Entry['status'];
-    readonly hasLoader: boolean;
-    readonly revalidate: Revalidate;
-    readonly loadedAt: number;
-    readonly epoch: number;
-    readonly data: unknown;
-}
-/** Snapshots the live loader cache (dev toolbar). Returns a stable reference between changes. */
-export function inspectLoaderCache(): LoaderCacheSnapshot[] {
-    return cacheSnapshot;
-}
-
-/** Cache key for a URL: path + query (hash is ignored, it never changes loader data). */
-export function loaderKey(pathname: string, search: string): string {
-    return `${pathname}${search}`;
-}
-
-/**
- * Warms a route's chunk *and* loader data for a URL ahead of navigation (the prefetcher calls this on
- * link hover/focus), so the eventual click commits synchronously instead of suspending. The entry is
- * flagged `prefetched` so the next navigation reuses it once even under the default `revalidate: 0`.
- * No-op when the URL is already cached or its fetch is already in flight. Errors are swallowed into
- * the entry (the real navigation will retry and surface them via the route's `error.tsx`).
- */
-export function prefetchRouteData(
-    route: RouteDef,
-    params: RouteParams,
-    pathname: string,
-    search: string,
-): void {
-    const key = loaderKey(pathname, search);
-    const existing = cache.get(key);
-    if (existing && existing.status !== 'error') return;
-    startFetch(route, params, key, navigationEpoch(), search, true);
-}
-
-/** Loads the route module and runs its loader (if any), in parallel where possible. */
-async function loadRoute(
-    route: RouteDef,
-    params: RouteParams,
-    search: string,
-): Promise<{ data: RouteData; revalidate: Revalidate; hasLoader: boolean }> {
-    const mod: RouteModule = await route.load();
-    const searchParams = new URLSearchParams(search);
-    const data = mod.loader ? await mod.loader({ params, searchParams }) : undefined;
-    let head: HeadSpec | undefined;
-    if (mod.generateMetadata) {
-        head = resolveMetadata(await mod.generateMetadata({ params, searchParams, data }));
-    } else if (mod.metadata) {
-        head = resolveMetadata(mod.metadata);
-    }
-    return {
-        data: { Component: mod.default, data, head },
-        revalidate: mod.revalidate ?? 0,
-        hasLoader: mod.loader != null,
-    };
-}
-
-/** Whether a settled entry must be refetched for the current navigation. */
-function isStale(entry: Entry, epoch: number): boolean {
-    if (entry.status === 'error') return true; // always retry a failed load
-    // A route with no loader has no data that can change, keep it cached so repeat navigations
-    // render synchronously (instant) instead of re-suspending and remounting on every switch.
-    if (!entry.hasLoader) return false;
-    if (entry.revalidate === false) return false; // cache forever
-    if (entry.revalidate === 0) {
-        // A just-prefetched entry is the fetch for this very navigation, reuse it once (consumed in
-        // readRouteData, so the *next* navigation refetches as `revalidate: 0` normally requires).
-        if (entry.prefetched) return false;
-        return entry.epoch !== epoch; // otherwise refetch once per navigation
-    }
-    return Date.now() - entry.loadedAt >= entry.revalidate * 1000; // time-based staleness
-}
-
-/** Starts (and caches) a fresh fetch for `key`. */
-function startFetch(
-    route: RouteDef,
-    params: RouteParams,
-    key: string,
-    epoch: number,
-    search: string,
-    prefetched = false,
-): Entry {
-    const created: Entry = {
-        status: 'pending',
-        promise: Promise.resolve(),
-        loadedAt: 0,
-        revalidate: 0,
-        epoch,
-        hasLoader: false,
-        prefetched,
-    };
-    created.promise = loadRoute(route, params, search).then(
-        (result) => {
-            created.value = result.data;
-            created.revalidate = result.revalidate;
-            created.hasLoader = result.hasLoader;
-            created.loadedAt = Date.now();
-            created.status = 'done';
-            emitCache();
-        },
-        (error: unknown) => {
-            created.error = error;
-            created.loadedAt = Date.now();
-            created.status = 'error';
-            emitCache();
-        },
-    );
-    cache.set(key, created);
-    while (cache.size > MAX_ENTRIES) {
-        const oldest = cache.keys().next().value;
-        if (oldest === undefined || oldest === key) break;
-        cache.delete(oldest);
-    }
-    emitCache();
-    return created;
-}
-
-/**
- * Reads (or starts) the route's module + loader data for the URL `key`, suspending until ready.
- * Throws the loader's error so the route's `error.tsx` boundary can catch it. `epoch` is the current
- * navigation epoch, used to refetch once-per-navigation under the default cache policy.
- */
-export function readRouteData(
-    route: RouteDef,
-    params: RouteParams,
-    key: string,
-    epoch: number,
-): RouteData {
-    const search = typeof window === 'undefined' ? '' : window.location.search;
-    let entry = cache.get(key);
-    if (entry && entry.status !== 'pending' && isStale(entry, epoch)) {
-        entry = undefined; // stale → drop and refetch below
-    }
-    entry ??= startFetch(route, params, key, epoch, search);
-    if (entry.status === 'pending') throw entry.promise;
-    if (entry.status === 'error') throw entry.error;
-    if (!entry.value) throw entry.promise;
-    // Claim a prefetched entry for this navigation: clear the flag and stamp the current epoch so the
-    // next navigation re-evaluates its revalidate policy (a `revalidate: 0` route refetches again).
-    if (entry.prefetched) {
-        entry.prefetched = false;
-        entry.epoch = epoch;
-    }
-    return entry.value;
-}
-
-/**
- * Seed the loader cache from server-rendered hydration state, BEFORE the first
- * client render (called by `mount` on an SSR document). The route's module
- * still loads (the browser needs the component), but its `loader` does NOT
- * re-run: the server's `data` is used, so the first client render reproduces
- * the server HTML and `hydrateRoot` stays clean. The entry is `prefetched`, so
- * the NEXT navigation re-evaluates the route's `revalidate` policy normally.
- *
- * For a flash-free hydrate the SSR document should modulepreload the route
- * chunk, so `route.load()` resolves in a microtask and the root never suspends.
- */
-export function hydrateLoaderData(
-    route: RouteDef,
-    params: RouteParams,
-    pathname: string,
-    search: string,
-    data: unknown,
-): void {
-    const key = loaderKey(pathname, search);
-    if (cache.has(key)) return;
-    const epoch = navigationEpoch();
-    const entry: Entry = {
-        status: 'pending',
-        promise: Promise.resolve(),
-        loadedAt: 0,
-        revalidate: 0,
-        epoch,
-        hasLoader: true,
-        prefetched: true,
-    };
-    entry.promise = route.load().then(
-        async (mod: RouteModule) => {
-            const searchParams = new URLSearchParams(search);
-            let head: HeadSpec | undefined;
-            if (mod.generateMetadata) {
-                head = resolveMetadata(await mod.generateMetadata({ params, searchParams, data }));
-            } else if (mod.metadata) {
-                head = resolveMetadata(mod.metadata);
-            }
-            entry.value = { Component: mod.default, data, head };
-            entry.revalidate = mod.revalidate ?? 0;
-            entry.loadedAt = Date.now();
-            entry.status = 'done';
-            emitCache();
-        },
-        (error: unknown) => {
-            entry.error = error;
-            entry.loadedAt = Date.now();
-            entry.status = 'error';
-            emitCache();
-        },
-    );
-    cache.set(key, entry);
-    emitCache();
-}
-
-/** Clears all cached loader data, so the next render re-runs loaders (used by router.refresh). */
-export function clearLoaderData(): void {
-    cache.clear();
-    emitCache();
-}
-
-/** Cache key for an href (relative or absolute), matching {@link loaderKey}. */
-function keyForHref(href: string): string | undefined {
-    if (typeof window === 'undefined') return undefined;
-    try {
-        const url = new URL(href, window.location.href);
-        return loaderKey(url.pathname, url.search);
-    } catch {
-        return undefined;
-    }
-}
-
-/**
- * Invalidates cached loader data so it refetches on the next render. With no argument, clears every
- * route; with an `href`, clears just that route's entry. Pair with a re-render (the active route
- * refetches and suspends), see {@link revalidate}.
- */
-export function invalidateLoaderData(href?: string): void {
-    if (href === undefined) {
-        cache.clear();
-        emitCache();
-        return;
-    }
-    const key = keyForHref(href);
-    if (key !== undefined) cache.delete(key);
-    emitCache();
-}
-
-/**
- * Invalidates loader data and re-renders so the active route refetches. Call after a mutation to
- * refresh the current route (`revalidate()`), or target another route by href
- * (`revalidate('/posts')`). Usable outside React (e.g. in an event handler after a `fetch`).
- */
-export function revalidate(href?: string): void {
-    invalidateLoaderData(href);
-    rerender();
-}
-
-/** Holds the active route's loader data; provided by the Router, read by {@link useLoaderData}. */
-export const LoaderDataContext = createContext<unknown>(undefined);
-
-/**
- * The data returned by the active route's `loader`. Three ways to type it, easiest first:
- *
- * 1. **Pass the loader**, zero generics, fully inferred from your loader's return:
- *    `const data = useLoaderData(loader);`
- * 2. Pass `typeof loader` as a type argument: `useLoaderData<typeof loader>();`
- * 3. Pass an explicit shape: `useLoaderData<Post>();`
- *
- * With no argument and no type, it returns `unknown` (never `any`), so the data is there at runtime,
- * but you must annotate or narrow before using it. There's no way to infer the type from a bare call:
- * TypeScript can't tell which file (and so which `loader`) the call belongs to, hence option 1.
- */
-export function useLoaderData<L extends LoaderFunction>(loader: L): Awaited<ReturnType<L>>;
-export function useLoaderData<T = unknown>(): LoaderData<T>;
-export function useLoaderData(_loader?: LoaderFunction): unknown {
-    return useContext(LoaderDataContext);
-}

package/src/client/routing/match.ts

@@ -1,47 +0,0 @@
-/** Extracted dynamic route parameters, e.g. `{ id: "42" }` for `/blog/:id` matching `/blog/42`. */
-export type RouteParams = Record<string, string>;
-
-/**
- * Matches a route pattern against a pathname, returning extracted params or `null` if no match.
- * Pure and runtime-agnostic (used by the router and unit-tested directly).
- *   matchRoute('/', '/')                  -> {}
- *   matchRoute('/blog/:id', '/blog/42')   -> { id: '42' }
- *   matchRoute('/docs/*slug', '/docs/a/b') -> { slug: 'a/b' }   (catch-all, 1+ segments)
- *   matchRoute('/docs/**slug', '/docs')   -> { slug: '' }       (optional catch-all, 0+ segments)
- *   matchRoute('/about', '/x')            -> null
- */
-export function matchRoute(pattern: string, pathname: string): RouteParams | null {
-    const patternSegs = pattern.split('/').filter(Boolean);
-    const pathSegs = pathname.split('/').filter(Boolean);
-
-    const params: RouteParams = {};
-    for (let i = 0; i < patternSegs.length; i++) {
-        const p = patternSegs[i];
-
-        // Optional catch-all (`**slug`): captures the rest of the path, matching zero or more segments.
-        if (p.startsWith('**')) {
-            params[p.slice(2)] = pathSegs
-                .slice(i)
-                .map((s) => decodeURIComponent(s))
-                .join('/');
-            return params;
-        }
-
-        if (p.startsWith('*')) {
-            const rest = pathSegs.slice(i);
-            if (rest.length === 0) return null;
-            params[p.slice(1)] = rest.map((s) => decodeURIComponent(s)).join('/');
-            return params;
-        }
-
-        if (i >= pathSegs.length) return null;
-        const value = pathSegs[i];
-        if (p.startsWith(':')) {
-            params[p.slice(1)] = decodeURIComponent(value);
-        } else if (p !== value) {
-            return null;
-        }
-    }
-
-    return patternSegs.length === pathSegs.length ? params : null;
-}

package/src/client/routing/mount.tsx

@@ -1,90 +0,0 @@
-import { createRoot, hydrateRoot } from 'react-dom/client';
-
-import { initNavigation } from '../navigation/navigation.js';
-import { startPrefetcher } from '../navigation/prefetch.js';
-import { Router } from './Router.js';
-import type { ErrorComponentLoader, LayoutLoader, NotFoundLoader, RouteDef } from '../types.js';
-
-/** An edge-SSR document carries a `<* id="__toil_ssr">` marker baked into the
- * template; its presence means the server rendered real first-paint HTML into
- * `#root`, so `mount` hydrates it in place rather than client-rendering. */
-function isSsrDocument(): boolean {
-    return typeof document !== 'undefined' && document.getElementById('__toil_ssr') !== null;
-}
-
-/**
- * Mounts the toil client app into `#root` and starts idle link prefetching. Called by the
- * compiler-generated `.toil/entry.tsx`.
- */
-export function mount(
-    routes: RouteDef[],
-    layout: LayoutLoader = null,
-    notFound: NotFoundLoader = null,
-    globalError: ErrorComponentLoader = null,
-    slots: Record<string, RouteDef[]> = {},
-): void {
-    const el = document.getElementById('root');
-    if (!el) throw new Error('toil: #root element not found');
-    initNavigation();
-    const app = (
-        <Router
-            routes={routes}
-            layout={layout}
-            notFound={notFound}
-            globalError={globalError}
-            slots={slots}
-        />
-    );
-    // In dev, wrap the app in the error overlay + dev toolbar so uncaught errors surface and dev info
-    // is available. The guard is the literal `import.meta.env.DEV`, and the dev modules are pulled in
-    // with DYNAMIC `import()` INSIDE this branch. A production build dead-code-eliminates the whole
-    // branch - the `import()` calls included - so the devtools/overlay never enter the bundle, not even
-    // as an unreferenced chunk. (A static top-level import would otherwise survive into production unless
-    // the package opts into tree-shaking via a `sideEffects` declaration.)
-    if ((import.meta as unknown as { env: { DEV: boolean } }).env.DEV) {
-        void (async () => {
-            const { DevToolbar } = await import('../dev/devtools.js');
-            const { DevErrorBoundary, DevErrorOverlay, initDevErrorOverlay } = await import(
-                '../dev/error-overlay.js'
-            );
-            initDevErrorOverlay();
-            // Dev tools (error overlay + toolbar) render into their OWN body-level container, never
-            // inside `#root`, so `#root` holds only the app markup. That lets an SSR document hydrate
-            // cleanly (the server only rendered the app into `#root`), and is harmless for a plain
-            // client-rendered page.
-            const devEl = document.createElement('div');
-            devEl.id = '__toil_dev';
-            document.body.appendChild(devEl);
-            createRoot(devEl).render(
-                <>
-                    <DevErrorOverlay />
-                    <DevToolbar
-                        routes={routes}
-                        slots={slots}
-                    />
-                </>,
-            );
-            const tree = <DevErrorBoundary>{app}</DevErrorBoundary>;
-            if (isSsrDocument()) {
-                // Edge-SSR: hydrate the server-rendered markup in place.
-                hydrateRoot(el, tree);
-                // The dev shell inlined `<style data-toil-dev-ssr>` so the server-rendered first paint
-                // was already styled (no FOUC). Vite has since injected the same CSS via the entry's
-                // imports (HMR-managed), so drop the static style to avoid a stale copy surviving a hot edit.
-                document.querySelectorAll('[data-toil-dev-ssr]').forEach((n) => {
-                    n.remove();
-                });
-            } else {
-                createRoot(el).render(tree);
-            }
-        })();
-    } else if (isSsrDocument()) {
-        // Edge-SSR: the document already holds server-rendered markup; hydrate it
-        // (reuse the DOM) rather than client-rendering from scratch.
-        hydrateRoot(el, app);
-    } else {
-        createRoot(el).render(app);
-    }
-    // Prefetch across the main tree and every slot tree (one prefetcher owns the whole table).
-    startPrefetcher([...routes, ...Object.values(slots).flat()]);
-}

package/src/client/routing/params-context.ts

@@ -1,10 +0,0 @@
-/**
- * React context carrying the current route's dynamic params. The provider is set by {@link Router};
- * read it with the {@link useParams} hook rather than consuming the context directly.
- */
-import { createContext } from 'react';
-
-import type { RouteParams } from './match.js';
-
-/** Holds the params extracted from the active route (e.g. `{ id }` for `/blog/:id`). */
-export const ParamsContext = createContext<RouteParams>({});

package/src/client/routing/slot-context.ts

@@ -1,7 +0,0 @@
-/**
- * Context carrying the rendered element for each parallel-route slot (`@slot`), keyed by name.
- * Provided by the Router for the current URL, consumed by {@link Slot}.
- */
-import { createContext, type ReactNode } from 'react';
-
-export const SlotContext = createContext<Record<string, ReactNode>>({});

package/src/client/rpc.ts

@@ -1,97 +0,0 @@
-/**
- * The client-callable server surface (`Server`). Its TYPED shape is generated by
- * the toilscript server build into the project's `shared/server.ts`
- * (`declare global { const Server }`); this module is the runtime behind it.
- *
- * Three surfaces live under `Server`, all attached by the generated `shared/server.ts` on import:
- *   - `Server.REST.<controller>.<route>(args)` - a fetch client (`globalThis.__toilRest`).
- *   - `Server.Stream.<class>.connect()` - the stream client (`globalThis.__toilStream`).
- *   - `Server.<service>.<method>(args)` and a free `Server.<remote>(args)` - the RPC client
- *     (`globalThis.__toilRpc`): each POSTs to `/__toil_rpc` with a method id and @data-encoded args.
- * Build the server (`npm run build:server`) to (re)generate the typed surface + attach the clients.
- */
-
-/** A recursive proxy that throws on call, used when the REST client hasn't loaded. */
-function restMissingStub(path: string): unknown {
-    const call = (): never => {
-        throw new Error(
-            `toiljs REST: ${path}() is unavailable. The generated REST client has not loaded - ` +
-                `run 'npm run build:server' to generate shared/server.ts; the client then attaches automatically.`,
-        );
-    };
-    return new Proxy(call, {
-        get(_target, prop) {
-            if (typeof prop === 'symbol' || prop === 'then') return undefined;
-            return restMissingStub(`${path}.${prop}`);
-        },
-        apply() {
-            return call();
-        },
-    });
-}
-
-/** A recursive proxy that throws on call, used when the stream client hasn't loaded. */
-function streamMissingStub(path: string): unknown {
-    const call = (): never => {
-        throw new Error(
-            `toiljs Stream: ${path}() is unavailable. The generated stream client has not loaded - ` +
-                `run 'npm run build:server' to generate shared/server.ts; the client then attaches automatically.`,
-        );
-    };
-    return new Proxy(call, {
-        get(_target, prop) {
-            if (typeof prop === 'symbol' || prop === 'then') return undefined;
-            return streamMissingStub(`${path}.${prop}`);
-        },
-        apply() {
-            return call();
-        },
-    });
-}
-
-/** Builds a recursive proxy that throws on call, supporting `Server.svc.method()`. */
-function rpcStub(path: string): unknown {
-    const call = (): never => {
-        throw new Error(
-            `toiljs RPC: ${path}() is unavailable. The generated RPC client has not loaded - ` +
-                `run 'npm run build:server' to generate shared/server.ts; the client then attaches automatically.`,
-        );
-    };
-    return new Proxy(call, {
-        get(_target, prop) {
-            // Not thenable, and ignore symbol probes (e.g. from awaiting/inspection).
-            if (typeof prop === 'symbol' || prop === 'then') return undefined;
-            // `Server.REST` surfaces the generated fetch client attached by shared/server.ts.
-            if (path === 'Server' && prop === 'REST') {
-                const rest = (globalThis as { __toilRest?: unknown }).__toilRest;
-                return rest !== undefined ? rest : restMissingStub('Server.REST');
-            }
-            // `Server.Stream` surfaces the generated stream client attached by shared/server.ts.
-            if (path === 'Server' && prop === 'Stream') {
-                const stream = (globalThis as { __toilStream?: unknown }).__toilStream;
-                return stream !== undefined ? stream : streamMissingStub('Server.Stream');
-            }
-            // `Server.<service>` / `Server.<remote>` surface the generated RPC client. Its top-level
-            // keys are the @service names (-> a `{ method }` object) and free @remote functions.
-            if (path === 'Server') {
-                const rpc = (globalThis as { __toilRpc?: Record<string, unknown> }).__toilRpc;
-                if (rpc !== undefined && prop in rpc) return rpc[prop];
-            }
-            return rpcStub(`${path}.${prop}`);
-        },
-        apply() {
-            return call();
-        },
-    });
-}
-
-/**
- * Runtime value for the global `Server`. Typed as `unknown` here; the real types
- * come from the generated `shared/server.ts`. toiljs assigns this to `globalThis`.
- */
-export const Server: unknown = rpcStub('Server');
-
-// Back the generated `declare global { const Server }` (shared/server.ts) with a runtime value, so an
-// app reaches `Server.REST` / `Server.Stream.<Name>` via the global without an import (the design note
-// above). Idempotent - the proxy is a singleton; importing `toiljs/client` evaluates this once.
-(globalThis as Record<string, unknown>).Server = Server;