@bleedingdev/modern-js-plugin-tanstack 3.2.0-ultramodern.0

package/dist/esm-node/runtime/routeTree.mjs

@@ -0,0 +1,453 @@
+import "node:module";
+import { createRootRoute, createRoute, notFound, redirect } from "@tanstack/react-router";
+import { DefaultNotFound } from "./DefaultNotFound.mjs";
+import { isTanstackRscPayloadNavigationEnabled, loadTanstackRscRouteData } from "./rsc/payloadRouter.mjs";
+function createTanstackRoute(options) {
+    return createRoute(options);
+}
+function createTanstackRootRoute(options) {
+    return createRootRoute(options);
+}
+function toTanstackPath(pathname) {
+    return pathname.split('/').map((segment)=>{
+        if (!segment) return segment;
+        if ('*' === segment) return '$';
+        if (segment.startsWith(':')) {
+            const name = segment.slice(1);
+            if (name.endsWith('?')) return `{-$${name.slice(0, -1)}}`;
+            return `$${name}`;
+        }
+        return segment;
+    }).join('/');
+}
+function isResponse(value) {
+    const record = value;
+    return null != record && 'object' == typeof record && 'number' == typeof record.status && 'object' == typeof record.headers;
+}
+function isTanstackRedirect(value) {
+    return isResponse(value) && 'object' == typeof value.options;
+}
+const redirectStatusCodes = new Set([
+    301,
+    302,
+    303,
+    307,
+    308
+]);
+function isRedirectResponse(res) {
+    return redirectStatusCodes.has(res.status);
+}
+function isModernDeferredData(value) {
+    if (!value || 'object' != typeof value) return false;
+    const deferred = value;
+    return true === deferred.__modern_deferred && Boolean(deferred.data) && 'object' == typeof deferred.data && !Array.isArray(deferred.data);
+}
+function normalizeModernLoaderResult(result) {
+    return isModernDeferredData(result) ? result.data : result;
+}
+function normalizeModernLoaderResponse(result) {
+    if (isResponse(result)) {
+        if (isRedirectResponse(result)) {
+            const location = result.headers.get('Location') || '/';
+            throwTanstackRedirect(location);
+        }
+        if (404 === result.status) throw notFound();
+    }
+    return normalizeModernLoaderResult(result);
+}
+function isAbsoluteUrl(value) {
+    try {
+        new URL(value);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function throwTanstackRedirect(location) {
+    const target = location || '/';
+    if (isAbsoluteUrl(target)) throw redirect({
+        href: target
+    });
+    throw redirect({
+        to: target
+    });
+}
+function mapParamsForModernLoader({ modernRoute, params }) {
+    if ('nested' === modernRoute.type && modernRoute.path?.includes('*')) {
+        const { _splat, ...rest } = params;
+        if (void 0 !== _splat) return {
+            ...rest,
+            '*': _splat
+        };
+        return rest;
+    }
+    return params;
+}
+function createModernRequest(input, signal) {
+    return new Request(input, {
+        signal
+    });
+}
+function getModernUrlFromLoaderContext(ctx) {
+    const href = 'string' == typeof ctx?.location ? ctx.location : ctx?.location?.publicHref || ctx?.location?.href || ctx?.location?.url?.href || '/';
+    const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
+    const baseUrl = baseRequest?.url || ("u" > typeof window ? window.origin : 'http://localhost');
+    return new URL(href || '/', baseUrl);
+}
+function rememberRouteLocation(state, ctx) {
+    state.currentUrl = getModernUrlFromLoaderContext(ctx);
+    state.currentParams = ctx?.params || {};
+}
+function createModernShouldReload(shouldRevalidate, state) {
+    if ('function' != typeof shouldRevalidate) return;
+    const revalidate = shouldRevalidate;
+    return (ctx)=>{
+        const nextUrl = getModernUrlFromLoaderContext(ctx);
+        const nextParams = ctx?.params || {};
+        const result = revalidate({
+            currentUrl: state.currentUrl || nextUrl,
+            currentParams: state.currentParams || nextParams,
+            nextUrl,
+            nextParams,
+            defaultShouldRevalidate: void 0
+        });
+        state.currentUrl = nextUrl;
+        state.currentParams = nextParams;
+        return 'boolean' == typeof result ? result : void 0;
+    };
+}
+function wrapModernLoader(modernRoute, modernLoader, revalidationState, options = {}) {
+    const route = modernRoute;
+    return async (ctx)=>{
+        try {
+            if (revalidationState) rememberRouteLocation(revalidationState, ctx);
+            if ('function' == typeof route.lazyImport) try {
+                await route.lazyImport();
+            } catch  {}
+            const signal = ctx?.abortController?.signal || ctx?.signal || new AbortController().signal;
+            const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
+            const href = 'string' == typeof ctx?.location ? ctx.location : ctx?.location?.publicHref || ctx?.location?.href || ctx?.location?.url?.href || '';
+            const request = baseRequest ? new Request(baseRequest, {
+                signal
+            }) : createModernRequest(href, signal);
+            const params = mapParamsForModernLoader({
+                modernRoute,
+                params: ctx.params || {}
+            });
+            const loadModernData = async ()=>{
+                const result = modernLoader ? await modernLoader({
+                    request,
+                    params,
+                    context: ctx?.context?.requestContext
+                }) : null;
+                return normalizeModernLoaderResponse(result);
+            };
+            if (options.rscPayloadRouter && isTanstackRscPayloadNavigationEnabled()) return loadTanstackRscRouteData({
+                hasClientLoader: route.hasClientLoader || void 0 !== route.clientData,
+                loadClientData: loadModernData,
+                request,
+                routeId: ctx.route?.id
+            });
+            return loadModernData();
+        } catch (err) {
+            if (isResponse(err)) {
+                if (isTanstackRedirect(err)) throw err;
+                if (isRedirectResponse(err)) {
+                    const location = err.headers.get('Location') || '/';
+                    throwTanstackRedirect(location);
+                }
+                if (404 === err.status) throw notFound();
+            }
+            throw err;
+        }
+    };
+}
+function isRouteObjectPathlessLayout(route) {
+    return !route.path && !route.index;
+}
+function isRouteObjectSplatRoute(route) {
+    return 'string' == typeof route.path && route.path.includes('*');
+}
+function mapParamsForRouteObjectLoader({ route, params }) {
+    if (isRouteObjectSplatRoute(route)) {
+        const { _splat, ...rest } = params;
+        if (void 0 !== _splat) return {
+            ...rest,
+            '*': _splat
+        };
+        return rest;
+    }
+    return params;
+}
+function wrapRouteObjectLoader(route, revalidationState, options = {}) {
+    const modernRoute = route;
+    const routeLoader = modernRoute.loader;
+    if ('function' != typeof routeLoader) return;
+    return async (ctx)=>{
+        try {
+            if (revalidationState) rememberRouteLocation(revalidationState, ctx);
+            if ('function' == typeof modernRoute.lazyImport) try {
+                await modernRoute.lazyImport();
+            } catch  {}
+            const signal = ctx?.abortController?.signal || ctx?.signal || new AbortController().signal;
+            const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
+            const href = 'string' == typeof ctx?.location ? ctx.location : ctx?.location?.publicHref || ctx?.location?.href || ctx?.location?.url?.href || '';
+            const request = baseRequest ? new Request(baseRequest, {
+                signal
+            }) : createModernRequest(href, signal);
+            const params = mapParamsForRouteObjectLoader({
+                route,
+                params: ctx.params || {}
+            });
+            const loadModernData = async ()=>{
+                const result = await routeLoader({
+                    request,
+                    params,
+                    context: ctx?.context?.requestContext
+                });
+                return normalizeModernLoaderResponse(result);
+            };
+            if (options.rscPayloadRouter && isTanstackRscPayloadNavigationEnabled()) return loadTanstackRscRouteData({
+                hasClientLoader: modernRoute.hasClientLoader || void 0 !== modernRoute.clientData,
+                loadClientData: loadModernData,
+                request,
+                routeId: ctx.route?.id
+            });
+            return loadModernData();
+        } catch (err) {
+            if (isResponse(err)) {
+                if (isTanstackRedirect(err)) throw err;
+                if (isRedirectResponse(err)) {
+                    const location = err.headers.get('Location') || '/';
+                    throwTanstackRedirect(location);
+                }
+                if (404 === err.status) throw notFound();
+            }
+            throw err;
+        }
+    };
+}
+function toRouteComponent(routeObject) {
+    const route = routeObject;
+    if (route.Component) return route.Component;
+    const element = route.element;
+    if (element) return ()=>element;
+}
+function toErrorComponent(routeObject) {
+    const route = routeObject;
+    if (route.ErrorBoundary) return route.ErrorBoundary;
+    if (route.errorElement) return ()=>route.errorElement;
+}
+function toPendingComponent(routeObject) {
+    const route = routeObject;
+    return route.HydrateFallback || route.pendingComponent || void 0;
+}
+function mergeModernRouteHandle(route) {
+    const config = route.config;
+    const handle = {
+        ...route.handle,
+        ...config && 'object' == typeof config ? config.handle : {}
+    };
+    return Object.keys(handle).length > 0 ? handle : void 0;
+}
+function createRouteStaticData(opts) {
+    const staticData = {};
+    if (opts.modernRouteId) staticData.modernRouteId = opts.modernRouteId;
+    if (opts.modernRouteAction) staticData.modernRouteAction = opts.modernRouteAction;
+    if (opts.modernRouteHandle) staticData.modernRouteHandle = opts.modernRouteHandle;
+    if (opts.modernRouteHasAction) staticData.modernRouteHasAction = true;
+    if (opts.modernRouteHasClientLoader) staticData.modernRouteHasClientLoader = true;
+    if (opts.modernRouteHasLoader) staticData.modernRouteHasLoader = true;
+    if (opts.modernRouteIsClientComponent) staticData.modernRouteIsClientComponent = true;
+    if (opts.modernRouteLoader) staticData.modernRouteLoader = opts.modernRouteLoader;
+    if (opts.modernRouteShouldRevalidate) staticData.modernRouteShouldRevalidate = opts.modernRouteShouldRevalidate;
+    return Object.keys(staticData).length > 0 ? staticData : void 0;
+}
+function createRouteFromRouteObject(opts) {
+    const { options = {}, parent, routeObject } = opts;
+    const modernRouteObject = routeObject;
+    const revalidationState = {};
+    const shouldRevalidate = modernRouteObject.shouldRevalidate;
+    const shouldReload = createModernShouldReload(shouldRevalidate, revalidationState);
+    const stableFallbackId = routeObject.id || modernRouteObject.file || routeObject.path || 'pathless';
+    const base = {
+        getParentRoute: ()=>parent,
+        component: toRouteComponent(routeObject),
+        pendingComponent: toPendingComponent(routeObject),
+        errorComponent: toErrorComponent(routeObject),
+        wrapInSuspense: true,
+        staticData: createRouteStaticData({
+            modernRouteId: routeObject.id,
+            modernRouteAction: modernRouteObject.action,
+            modernRouteHandle: mergeModernRouteHandle(modernRouteObject),
+            modernRouteHasAction: modernRouteObject.hasAction || Boolean(modernRouteObject.action),
+            modernRouteHasClientLoader: modernRouteObject.hasClientLoader || void 0 !== modernRouteObject.clientData,
+            modernRouteHasLoader: modernRouteObject.hasLoader || 'function' == typeof modernRouteObject.loader,
+            modernRouteIsClientComponent: modernRouteObject.isClientComponent,
+            modernRouteLoader: modernRouteObject.loader,
+            modernRouteShouldRevalidate: shouldRevalidate
+        }),
+        loader: wrapRouteObjectLoader(routeObject, revalidationState, options)
+    };
+    if (modernRouteObject.inValidSSRRoute) base.ssr = false;
+    if (shouldReload) base.shouldReload = shouldReload;
+    if (isRouteObjectPathlessLayout(routeObject)) base.id = stableFallbackId;
+    else base.path = routeObject.index ? '/' : toTanstackPath(routeObject.path || '');
+    const route = createTanstackRoute(base);
+    const children = routeObject.children;
+    if (children && children.length > 0) {
+        const childRoutes = children.map((child)=>createRouteFromRouteObject({
+                options,
+                parent: route,
+                routeObject: child
+            }));
+        route.addChildren(childRoutes);
+    }
+    return route;
+}
+function createRouteFromModernRoute(opts) {
+    const { options = {}, parent, modernRoute } = opts;
+    const route = modernRoute;
+    const revalidationState = {};
+    const modernId = route.id;
+    const stableFallbackId = modernId || route._component || route.filename || route.data || ('function' == typeof route.loader ? route.id : void 0);
+    const pendingComponent = route.loading || route.pendingComponent;
+    const errorComponent = route.error || route.errorComponent;
+    const component = route.component;
+    const modernLoader = route.loader;
+    const modernAction = route.action;
+    const modernShouldRevalidate = route.shouldRevalidate;
+    const shouldReload = createModernShouldReload(modernShouldRevalidate, revalidationState);
+    const isPathlessLayout = 'nested' === route.type && 'boolean' != typeof route.index && void 0 === route.path;
+    const isIndexRoute = 'nested' === route.type && Boolean(route.index);
+    const base = {
+        getParentRoute: ()=>parent,
+        component: component || void 0,
+        pendingComponent: pendingComponent || void 0,
+        errorComponent: errorComponent || void 0,
+        wrapInSuspense: true,
+        staticData: createRouteStaticData({
+            modernRouteId: modernId,
+            modernRouteAction: modernAction,
+            modernRouteHandle: mergeModernRouteHandle(route),
+            modernRouteHasAction: route.hasAction || Boolean(modernAction),
+            modernRouteHasClientLoader: route.hasClientLoader || void 0 !== route.clientData,
+            modernRouteHasLoader: route.hasLoader || 'function' == typeof modernLoader,
+            modernRouteIsClientComponent: route.isClientComponent,
+            modernRouteLoader: modernLoader,
+            modernRouteShouldRevalidate: modernShouldRevalidate
+        }),
+        loader: wrapModernLoader(modernRoute, modernLoader, revalidationState, options)
+    };
+    if (route.inValidSSRRoute) base.ssr = false;
+    if (shouldReload) base.shouldReload = shouldReload;
+    if (isPathlessLayout) base.id = stableFallbackId || 'pathless';
+    else {
+        const rawPath = route.path;
+        base.path = isIndexRoute ? '/' : toTanstackPath(rawPath || '');
+    }
+    const tanstackRoute = createTanstackRoute(base);
+    const children = route.children;
+    if (children && children.length > 0) {
+        const childRoutes = children.map((child)=>createRouteFromModernRoute({
+                options,
+                parent: tanstackRoute,
+                modernRoute: child
+            }));
+        tanstackRoute.addChildren(childRoutes);
+    }
+    return tanstackRoute;
+}
+function createRouteTreeFromModernRoutes(routes, options = {}) {
+    const rootModern = routes.find((r)=>r && 'nested' === r.type && r.isRoot);
+    const rootComponent = rootModern?.component;
+    const pendingComponent = rootModern?.loading;
+    const errorComponent = rootModern?.error;
+    const rootLoader = rootModern?.loader;
+    const rootAction = rootModern?.action;
+    const rootModernId = rootModern?.id;
+    const rootShouldRevalidate = rootModern?.shouldRevalidate;
+    const rootRevalidationState = {};
+    const rootShouldReload = createModernShouldReload(rootShouldRevalidate, rootRevalidationState);
+    const rootRouteOptions = {
+        component: rootComponent || void 0,
+        pendingComponent: pendingComponent || void 0,
+        errorComponent: errorComponent || void 0,
+        wrapInSuspense: true,
+        notFoundComponent: DefaultNotFound,
+        staticData: createRouteStaticData({
+            modernRouteId: rootModernId,
+            modernRouteAction: rootAction,
+            modernRouteHandle: rootModern ? mergeModernRouteHandle(rootModern) : void 0,
+            modernRouteHasAction: rootModern?.hasAction || Boolean(rootAction),
+            modernRouteHasClientLoader: rootModern?.hasClientLoader || void 0 !== rootModern?.clientData,
+            modernRouteHasLoader: rootModern?.hasLoader || 'function' == typeof rootLoader,
+            modernRouteIsClientComponent: rootModern?.isClientComponent,
+            modernRouteLoader: rootLoader,
+            modernRouteShouldRevalidate: rootShouldRevalidate
+        }),
+        loader: rootModern ? wrapModernLoader(rootModern, rootLoader, rootRevalidationState, options) : void 0
+    };
+    if (rootShouldReload) rootRouteOptions.shouldReload = rootShouldReload;
+    if (rootModern?.inValidSSRRoute) rootRouteOptions.ssr = false;
+    const rootRoute = createTanstackRootRoute(rootRouteOptions);
+    const topLevel = rootModern ? rootModern.children || [] : routes;
+    const childRoutes = topLevel.map((child)=>createRouteFromModernRoute({
+            options,
+            parent: rootRoute,
+            modernRoute: child
+        }));
+    rootRoute.addChildren(childRoutes);
+    return rootRoute;
+}
+function getRootLikeRouteObject(routes) {
+    return routes.find((route)=>'/' === route.path && !route.index);
+}
+function createRouteTreeFromRouteObjects(routes, options = {}) {
+    const rootLikeRoute = getRootLikeRouteObject(routes);
+    const rootRevalidationState = {};
+    const rootShouldRevalidate = rootLikeRoute?.shouldRevalidate;
+    const rootShouldReload = createModernShouldReload(rootShouldRevalidate, rootRevalidationState);
+    const rootRouteOptions = {
+        component: rootLikeRoute ? toRouteComponent(rootLikeRoute) : void 0,
+        pendingComponent: rootLikeRoute ? toPendingComponent(rootLikeRoute) : void 0,
+        errorComponent: rootLikeRoute ? toErrorComponent(rootLikeRoute) : void 0,
+        wrapInSuspense: true,
+        notFoundComponent: DefaultNotFound,
+        staticData: createRouteStaticData({
+            modernRouteId: rootLikeRoute?.id,
+            modernRouteAction: rootLikeRoute?.action,
+            modernRouteHandle: rootLikeRoute ? mergeModernRouteHandle(rootLikeRoute) : void 0,
+            modernRouteHasAction: rootLikeRoute?.hasAction || Boolean(rootLikeRoute?.action),
+            modernRouteHasClientLoader: rootLikeRoute?.hasClientLoader || void 0 !== rootLikeRoute?.clientData,
+            modernRouteHasLoader: rootLikeRoute?.hasLoader || 'function' == typeof rootLikeRoute?.loader,
+            modernRouteIsClientComponent: rootLikeRoute?.isClientComponent,
+            modernRouteLoader: rootLikeRoute?.loader,
+            modernRouteShouldRevalidate: rootShouldRevalidate
+        }),
+        loader: rootLikeRoute ? wrapRouteObjectLoader(rootLikeRoute, rootRevalidationState, options) : void 0
+    };
+    if (rootShouldReload) rootRouteOptions.shouldReload = rootShouldReload;
+    if (rootLikeRoute?.inValidSSRRoute) rootRouteOptions.ssr = false;
+    const rootRoute = createTanstackRootRoute(rootRouteOptions);
+    const topLevel = rootLikeRoute ? [
+        ...rootLikeRoute.children || [],
+        ...routes.filter((route)=>route !== rootLikeRoute)
+    ] : routes;
+    const childRoutes = topLevel.map((routeObject)=>createRouteFromRouteObject({
+            options,
+            parent: rootRoute,
+            routeObject
+        }));
+    rootRoute.addChildren(childRoutes);
+    return rootRoute;
+}
+function getModernRouteIdsFromMatches(router) {
+    const matches = router.state.matches || [];
+    const ids = matches.map((match)=>{
+        const route = match.route;
+        return route?.options?.staticData?.modernRouteId;
+    }).filter((id)=>'string' == typeof id);
+    return Array.from(new Set(ids));
+}
+export { createRouteTreeFromModernRoutes, createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches };

package/dist/esm-node/runtime/rsc/ClientSlot.mjs

@@ -0,0 +1,20 @@
+import "node:module";
+"use client";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { useSlotContext } from "./SlotContext.mjs";
+function ClientSlot({ args, slot }) {
+    const context = useSlotContext();
+    if (!context) throw new Error('ClientSlot must be rendered inside CompositeComponent.');
+    const implementation = context.implementations[slot];
+    if (void 0 === implementation) {
+        if (context.strict) throw new Error(`Missing RSC slot implementation for "${slot}".`);
+        return null;
+    }
+    if ('function' == typeof implementation) return /*#__PURE__*/ jsx(Fragment, {
+        children: implementation(...args)
+    });
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: implementation
+    });
+}
+export { ClientSlot };

package/dist/esm-node/runtime/rsc/CompositeComponent.mjs

@@ -0,0 +1,42 @@
+import "node:module";
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { Suspense } from "react";
+import { SlotProvider } from "./SlotContext.mjs";
+import { RSC_PROXY_GET_TREE, RSC_PROXY_PATH } from "./symbols.mjs";
+function EmptyFallback() {
+    return null;
+}
+function selectTreePath(tree, path) {
+    let current = tree;
+    for (const key of path){
+        if (null === current || 'object' != typeof current) return null;
+        current = current[key];
+    }
+    return current;
+}
+function CompositeInner({ slotProps, src, strict }) {
+    const getTree = src[RSC_PROXY_GET_TREE];
+    if (!getTree) throw new Error('CompositeComponent src must come from createCompositeComponent().');
+    const tree = selectTreePath(getTree(), src[RSC_PROXY_PATH] || []);
+    return /*#__PURE__*/ jsx(SlotProvider, {
+        implementations: slotProps,
+        strict: strict,
+        children: tree
+    });
+}
+function CompositeComponent(props) {
+    const { children, src, strict, ...slotProps } = props;
+    return /*#__PURE__*/ jsx(Suspense, {
+        fallback: /*#__PURE__*/ jsx(EmptyFallback, {}),
+        children: /*#__PURE__*/ jsx(CompositeInner, {
+            slotProps: {
+                ...slotProps,
+                children
+            },
+            src: src,
+            strict: strict
+        })
+    });
+}
+export { CompositeComponent };

package/dist/esm-node/runtime/rsc/ReplayableStream.mjs

@@ -0,0 +1,105 @@
+import "node:module";
+const REPLAYABLE_STREAM_MARKER = Symbol.for('modern.tanstack.rsc.ReplayableStream');
+class ReplayableStream {
+    start() {
+        const signal = this.options.signal;
+        if (signal?.aborted) return void this.release();
+        this.abortListener = ()=>this.release();
+        signal?.addEventListener('abort', this.abortListener, {
+            once: true
+        });
+        const reader = this.source.getReader();
+        this.reader = reader;
+        const pump = async ()=>{
+            try {
+                while(!this.released){
+                    const { done, value } = await reader.read();
+                    if (done) break;
+                    this.chunks.push(value);
+                    this.notify();
+                }
+            } catch (err) {
+                if (!this.released) this.error = err;
+            } finally{
+                this.done = true;
+                this.detachAbortListener();
+                try {
+                    reader.releaseLock();
+                } catch  {}
+                if (this.reader === reader) this.reader = null;
+                this.notify();
+            }
+        };
+        pump();
+    }
+    detachAbortListener() {
+        const signal = this.options.signal;
+        if (signal && this.abortListener) signal.removeEventListener('abort', this.abortListener);
+        this.abortListener = null;
+    }
+    notify() {
+        this.waiter?.resolve();
+        this.waiter = null;
+    }
+    wait() {
+        if (this.done || this.released) return Promise.resolve();
+        if (!this.waiter) {
+            let resolve;
+            const promise = new Promise((res)=>{
+                resolve = res;
+            });
+            this.waiter = {
+                promise,
+                resolve
+            };
+        }
+        return this.waiter.promise;
+    }
+    release() {
+        if (this.released) return;
+        this.released = true;
+        this.chunks = [];
+        this.detachAbortListener();
+        try {
+            this.reader?.cancel(new Error('ReplayableStream released'));
+        } catch  {}
+        this.notify();
+    }
+    isReleased() {
+        return this.released;
+    }
+    createReplayStream() {
+        if (this.released) return new ReadableStream({
+            start (controller) {
+                controller.close();
+            }
+        });
+        let index = 0;
+        return new ReadableStream({
+            pull: async (controller)=>{
+                while(true){
+                    if (index < this.chunks.length) return void controller.enqueue(this.chunks[index++]);
+                    if (this.error) return void controller.error(this.error);
+                    if (this.done || this.released) return void controller.close();
+                    await this.wait();
+                }
+            },
+            cancel: ()=>{}
+        });
+    }
+    constructor(source, options = {}){
+        this.source = source;
+        this.options = options;
+        this[_REPLAYABLE_STREAM_MARKER] = true;
+        this.chunks = [];
+        this.done = false;
+        this.waiter = null;
+        this.released = false;
+        this.reader = null;
+        this.abortListener = null;
+        this.start();
+    }
+}
+_REPLAYABLE_STREAM_MARKER = REPLAYABLE_STREAM_MARKER;
+var _REPLAYABLE_STREAM_MARKER;
+export { REPLAYABLE_STREAM_MARKER, ReplayableStream };

package/dist/esm-node/runtime/rsc/RscNodeRenderer.mjs

@@ -0,0 +1,32 @@
+import "node:module";
+"use client";
+import { Fragment, jsx } from "react/jsx-runtime";
+import { Suspense } from "react";
+import { RSC_PROXY_GET_TREE, RSC_PROXY_PATH } from "./symbols.mjs";
+function EmptyFallback() {
+    return null;
+}
+function selectTreePath(tree, path) {
+    let current = tree;
+    for (const key of path){
+        if (null === current || 'object' != typeof current) return null;
+        current = current[key];
+    }
+    return current;
+}
+function RscNodeRenderInner({ data }) {
+    const getTree = data[RSC_PROXY_GET_TREE];
+    if (!getTree) throw new Error('Renderable RSC is missing its decoded tree getter.');
+    return /*#__PURE__*/ jsx(Fragment, {
+        children: selectTreePath(getTree(), data[RSC_PROXY_PATH] || [])
+    });
+}
+function RscNodeRenderer({ data }) {
+    return /*#__PURE__*/ jsx(Suspense, {
+        fallback: /*#__PURE__*/ jsx(EmptyFallback, {}),
+        children: /*#__PURE__*/ jsx(RscNodeRenderInner, {
+            data: data
+        })
+    });
+}
+export { RscNodeRenderer };

package/dist/esm-node/runtime/rsc/SlotContext.mjs

@@ -0,0 +1,18 @@
+import "node:module";
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { createContext, use } from "react";
+const SlotContext = /*#__PURE__*/ createContext(null);
+function useSlotContext() {
+    return use(SlotContext);
+}
+function SlotProvider({ children, implementations, strict }) {
+    return /*#__PURE__*/ jsx(SlotContext, {
+        value: {
+            implementations,
+            strict: true === strict
+        },
+        children: children
+    });
+}
+export { SlotProvider, useSlotContext };