@bleedingdev/modern-js-render 3.2.0-ultramodern.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+<p align="center">
+  <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
+</p>
+
+<h1 align="center">Modern.js</h1>
+
+<p align="center">
+  A Progressive React Framework for modern web development.
+</p>
+
+## Getting Started
+
+Please follow [Quick Start](https://modernjs.dev/en/guides/get-started/quick-start) to get started with Modern.js.
+
+## Documentation
+
+- [English Documentation](https://modernjs.dev/en/)
+- [中文文档](https://modernjs.dev)
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/modern.js/blob/main/CONTRIBUTING.md).
+
+## License
+
+Modern.js is [MIT licensed](https://github.com/web-infra-dev/modern.js/blob/main/LICENSE).

package/dist/esm/130.mjs

@@ -0,0 +1,95 @@
+import { decodeReply, loadServerAction, registerClientReference, registerServerReference, renderToReadableStream } from "react-server-dom-rspack/server.node";
+import { __webpack_require__ } from "./rslib-runtime.mjs";
+import { createFromReadableStream as createFromReadableStream_0 } from "react-server-dom-rspack/client.node";
+import { injectCSS, injectRSCPayload } from "./940.mjs";
+var rsc_namespaceObject = {};
+__webpack_require__.r(rsc_namespaceObject);
+__webpack_require__.d(rsc_namespaceObject, {
+    createFromReadableStream: ()=>createFromReadableStream_0,
+    handleAction: ()=>handleAction,
+    registerClientReference: ()=>registerClientReference,
+    registerServerReference: ()=>registerServerReference,
+    renderCSRWithRSC: ()=>renderCSRWithRSC,
+    renderRsc: ()=>renderRsc,
+    renderToReadableStream: ()=>renderToReadableStream
+});
+const renderRsc = (options)=>{
+    const readable = renderToReadableStream(options.element);
+    return readable;
+};
+const handleAction = async (req)=>{
+    try {
+        const serverReference = req.headers.get('x-rsc-action');
+        if (!serverReference) return new Response('Cannot find server reference', {
+            status: 404
+        });
+        const action = loadServerAction(serverReference);
+        if ('function' != typeof action) {
+            console.error('[RSC] Invalid action: server reference is not a function, serverReference:', serverReference);
+            return new Response('Invalid action', {
+                status: 400
+            });
+        }
+        const contentType = req.headers.get('content-type');
+        let args;
+        try {
+            if (contentType?.includes('multipart/form-data')) {
+                const formData = await req.formData();
+                args = await decodeReply(formData);
+            } else {
+                const text = await req.text();
+                args = await decodeReply(text);
+            }
+        } catch (error) {
+            console.error('[RSC] Failed to decode request arguments, error:', error instanceof Error ? error.message : String(error), 'contentType:', contentType || 'unknown');
+            return new Response('Failed to decode request arguments', {
+                status: 400
+            });
+        }
+        const result = await Promise.resolve(action.apply(null, args));
+        const stream = renderRsc({
+            element: result
+        });
+        const response = new Response(stream, {
+            status: 200,
+            headers: {
+                'Content-Type': 'text/html'
+            }
+        });
+        return response;
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorStack = error instanceof Error ? error.stack : void 0;
+        console.error('[RSC] Error handling server action, error:', errorMessage, errorStack ? `\n${errorStack}` : '');
+        return new Response('Internal server error', {
+            status: 500
+        });
+    }
+};
+async function renderCSRWithRSC(options) {
+    const entryCssFiles = __webpack_require__.rscM?.entryCssFiles;
+    const cssFiles = entryCssFiles ? Object.values(entryCssFiles).flat() : [];
+    const rscPayloadStream = renderRsc({
+        element: options.rscRoot
+    });
+    const htmlStream = new ReadableStream({
+        start (controller) {
+            const encoder = new TextEncoder();
+            controller.enqueue(encoder.encode(options.html));
+            controller.close();
+        }
+    });
+    const stream = htmlStream.pipeThrough(injectCSS(cssFiles, {
+        injectClosingTags: false
+    })).pipeThrough(injectRSCPayload(rscPayloadStream, {
+        injectClosingTags: true
+    }));
+    return new Response(stream, {
+        status: 200,
+        headers: new Headers({
+            'content-type': 'text/html; charset=UTF-8'
+        })
+    });
+}
+export { createFromReadableStream } from "react-server-dom-rspack/client.node";
+export { handleAction, registerClientReference, registerServerReference, renderCSRWithRSC, renderRsc, renderToReadableStream, rsc_namespaceObject };

package/dist/esm/647.mjs

@@ -0,0 +1,143 @@
+import react, { createContext, useState } from "react";
+import { createFromFetch, createFromReadableStream, createServerReference, encodeReply, setServerCallback } from "react-server-dom-rspack/client.browser";
+const encoder = new TextEncoder();
+let streamController;
+const rscStream = new ReadableStream({
+    start (controller) {
+        if ("u" < typeof window) return;
+        const handleChunk = (chunk)=>{
+            if ('string' == typeof chunk) controller.enqueue(encoder.encode(chunk));
+            else controller.enqueue(chunk);
+        };
+        window.__FLIGHT_DATA = window.__FLIGHT_DATA || [];
+        window.__FLIGHT_DATA.forEach(handleChunk);
+        window.__FLIGHT_DATA.push = (chunk)=>{
+            handleChunk(chunk);
+        };
+        streamController = controller;
+    }
+});
+if ("u" > typeof document && 'loading' === document.readyState) document.addEventListener('DOMContentLoaded', ()=>{
+    streamController?.close();
+});
+else streamController?.close();
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+var _statusCode = /*#__PURE__*/ new WeakMap(), _url = /*#__PURE__*/ new WeakMap(), _details = /*#__PURE__*/ new WeakMap();
+class CallServerError extends Error {
+    get statusCode() {
+        return _class_private_field_get(this, _statusCode);
+    }
+    get url() {
+        return _class_private_field_get(this, _url);
+    }
+    get details() {
+        return {
+            ..._class_private_field_get(this, _details)
+        };
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            statusCode: _class_private_field_get(this, _statusCode),
+            url: _class_private_field_get(this, _url),
+            details: _class_private_field_get(this, _details)
+        };
+    }
+    constructor(message, statusCode, url = '', details = {}){
+        const formattedMessage = `Call Server Action failed (${statusCode}): ${message}\nURL: ${url}`;
+        super(formattedMessage), _class_private_field_init(this, _statusCode, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _url, {
+            writable: true,
+            value: void 0
+        }), _class_private_field_init(this, _details, {
+            writable: true,
+            value: void 0
+        });
+        this.name = 'CallServerError';
+        _class_private_field_set(this, _statusCode, statusCode);
+        _class_private_field_set(this, _url, url);
+        _class_private_field_set(this, _details, details);
+    }
+}
+async function requestCallServer(id, args) {
+    const entryName = window.__MODERN_JS_ENTRY_NAME;
+    const url = 'main' === entryName || 'index' === entryName ? '/' : `/${entryName}`;
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Accept: 'text/x-component',
+                'x-rsc-action': id
+            },
+            body: await encodeReply(args)
+        });
+        if (!response.ok) throw new CallServerError(response.statusText, response.status, url, {
+            id,
+            args
+        });
+        return response;
+    } catch (error) {
+        if (error instanceof CallServerError) throw error;
+        throw new CallServerError(error instanceof Error ? error.message : 'Unknown error', 1, url, {
+            id,
+            args
+        });
+    }
+}
+async function callServer(id, args) {
+    const response = requestCallServer(id, args);
+    const res = createFromFetch(response);
+    return res;
+}
+const ResetRootContext = /*#__PURE__*/ createContext(void 0);
+function RscClientRoot({ rscPayload }) {
+    const elements = react.use(rscPayload);
+    const [root, setRoot] = useState(elements);
+    return /*#__PURE__*/ react.createElement(ResetRootContext.Provider, {
+        value: {
+            setRoot
+        }
+    }, root);
+}
+const ElementsContext = /*#__PURE__*/ createContext(null);
+const ServerElementsProvider = ({ elements, children })=>/*#__PURE__*/ react.createElement(react.Fragment, null, /*#__PURE__*/ react.createElement(ElementsContext.Provider, {
+        value: elements
+    }, children));
+const RSCServerSlot = ()=>{
+    const elements = react.use(ElementsContext);
+    return elements;
+};
+export { ElementsContext, RSCServerSlot, ResetRootContext, RscClientRoot, ServerElementsProvider, callServer, createFromFetch, createFromReadableStream, createServerReference, rscStream, setServerCallback };

package/dist/esm/940.mjs

@@ -0,0 +1,107 @@
+const encoder = new TextEncoder();
+const closingTagsPattern = /<\/body>\s*<\/html>\s*$/i;
+function injectRSCPayload(rscStream, { injectClosingTags = true }) {
+    const decoder = new TextDecoder();
+    let resolveFlightDataPromise;
+    const flightDataPromise = new Promise((resolve)=>resolveFlightDataPromise = resolve);
+    let startedRSC = false;
+    const buffered = [];
+    let timeout = null;
+    function flushBufferedChunks(controller) {
+        for (const chunk of buffered){
+            let buf = decoder.decode(chunk);
+            if (closingTagsPattern.test(buf)) buf = buf.replace(closingTagsPattern, '');
+            controller.enqueue(encoder.encode(buf));
+        }
+        buffered.length = 0;
+        timeout = null;
+    }
+    return new TransformStream({
+        transform (chunk, controller) {
+            buffered.push(chunk);
+            if (timeout) return;
+            timeout = setTimeout(async ()=>{
+                flushBufferedChunks(controller);
+                if (!startedRSC) {
+                    startedRSC = true;
+                    writeRSCStream(rscStream, controller).catch((err)=>controller.error(err)).then(()=>resolveFlightDataPromise());
+                }
+            }, 0);
+        },
+        async flush (controller) {
+            await flightDataPromise;
+            if (timeout) {
+                clearTimeout(timeout);
+                flushBufferedChunks(controller);
+            }
+            if (injectClosingTags) controller.enqueue(encoder.encode('</body></html>'));
+        }
+    });
+}
+async function writeRSCStream(rscStream, controller) {
+    const decoder = new TextDecoder('utf-8', {
+        fatal: true
+    });
+    for await (const chunk of rscStream)try {
+        writeChunk(JSON.stringify(decoder.decode(chunk, {
+            stream: true
+        })), controller);
+    } catch (err) {
+        const base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
+        writeChunk(`Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`, controller);
+    }
+    const remaining = decoder.decode();
+    if (remaining.length) writeChunk(JSON.stringify(remaining), controller);
+}
+function writeChunk(chunk, controller) {
+    controller.enqueue(encoder.encode(`<script>${escapeScript(`(self.__FLIGHT_DATA||=[]).push(${chunk})`)}</script>`));
+}
+function escapeScript(script) {
+    return script.replace(/<!--/g, '<\\!--').replace(/<\/(script)/gi, '</\\$1');
+}
+function injectCSS(cssFiles, { injectClosingTags = true } = {}) {
+    if (0 === cssFiles.length) return new TransformStream({
+        transform (chunk, controller) {
+            controller.enqueue(chunk);
+        },
+        flush (controller) {
+            if (injectClosingTags) controller.enqueue(encoder.encode('</body></html>'));
+        }
+    });
+    const decoder = new TextDecoder();
+    const headTrailer = '</head>';
+    const buffered = [];
+    let timeout = null;
+    let cssInjected = false;
+    const cssLinks = cssFiles.map((css)=>`<link href="${css}" rel="stylesheet" />`).join('');
+    function flushBufferedChunks(controller) {
+        for (const chunk of buffered){
+            let buf = decoder.decode(chunk);
+            if (!cssInjected && buf.includes(headTrailer)) {
+                buf = buf.replace(headTrailer, `${cssLinks}${headTrailer}`);
+                cssInjected = true;
+            }
+            controller.enqueue(encoder.encode(buf));
+        }
+        buffered.length = 0;
+        timeout = null;
+    }
+    return new TransformStream({
+        transform (chunk, controller) {
+            buffered.push(chunk);
+            if (timeout) return;
+            timeout = setTimeout(()=>{
+                flushBufferedChunks(controller);
+            }, 0);
+        },
+        async flush (controller) {
+            if (timeout) {
+                clearTimeout(timeout);
+                flushBufferedChunks(controller);
+            }
+            if (!cssInjected) controller.enqueue(encoder.encode(cssLinks));
+            if (injectClosingTags) controller.enqueue(encoder.encode('</body></html>'));
+        }
+    });
+}
+export { injectCSS, injectRSCPayload };

package/dist/esm/client.mjs

@@ -0,0 +1 @@
+export { ElementsContext, RSCServerSlot, ResetRootContext, RscClientRoot, ServerElementsProvider, callServer, createFromFetch, createFromReadableStream, createServerReference, rscStream, setServerCallback } from "./647.mjs";

package/dist/esm/rsc.mjs

@@ -0,0 +1 @@
+export { createFromReadableStream, handleAction, registerClientReference, registerServerReference, renderCSRWithRSC, renderRsc, renderToReadableStream } from "./130.mjs";

package/dist/esm/rslib-runtime.mjs

@@ -0,0 +1,23 @@
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+export { __webpack_require__ };

package/dist/esm/ssr.mjs

@@ -0,0 +1,58 @@
+import { SSR_HYDRATION_ID_PREFIX } from "@modern-js/utils/universal/constants";
+import { renderToReadableStream } from "react-dom/server.edge";
+import { __webpack_require__ } from "./rslib-runtime.mjs";
+import { ServerElementsProvider } from "./647.mjs";
+function CSSLinks({ cssFiles }) {
+    if (0 === cssFiles.length) return null;
+    return /*#__PURE__*/ React.createElement(React.Fragment, null, cssFiles.map((css)=>/*#__PURE__*/ React.createElement("link", {
+            key: css,
+            href: css,
+            rel: "stylesheet"
+        })));
+}
+function wrapStream(stream, originalStream) {
+    const wrappedStream = Object.create(stream);
+    for (const prop of Object.keys(originalStream))if (!(prop in wrappedStream)) wrappedStream[prop] = originalStream[prop];
+    return wrappedStream;
+}
+const renderSSRStream = async (children, options)=>{
+    const { rscRoot, routes } = options;
+    const clientManifest = __webpack_require__.rscM?.clientManifest;
+    const serverConsumerModuleMap = __webpack_require__.rscM?.serverConsumerModuleMap;
+    const entryCssFiles = __webpack_require__.rscM?.entryCssFiles;
+    const hasRoutes = Boolean(routes && routes.length > 0);
+    if (!clientManifest || !serverConsumerModuleMap) return renderToReadableStream(children, {
+        ...options,
+        identifierPrefix: SSR_HYDRATION_ID_PREFIX
+    });
+    try {
+        const [{ renderRsc }, { createFromReadableStream }, { injectRSCPayload }] = await Promise.all([
+            import("./130.mjs").then((m)=>m.rsc_namespaceObject),
+            import("react-server-dom-rspack/client.edge"),
+            import("./940.mjs")
+        ]);
+        const rscStream = await renderRsc({
+            element: rscRoot || children
+        });
+        const [rscElementStream, rscPayloadStream] = rscStream.tee();
+        const elements = createFromReadableStream(rscElementStream);
+        let cssFiles = [];
+        if (!hasRoutes && entryCssFiles) cssFiles = Object.values(entryCssFiles).flat();
+        const htmlStream = await renderToReadableStream(/*#__PURE__*/ React.createElement(ServerElementsProvider, {
+            elements: elements
+        }, /*#__PURE__*/ React.createElement(CSSLinks, {
+            cssFiles: cssFiles
+        }), children), {
+            ...options,
+            identifierPrefix: SSR_HYDRATION_ID_PREFIX
+        });
+        const stream = htmlStream.pipeThrough(injectRSCPayload(rscPayloadStream, {
+            injectClosingTags: true
+        }));
+        return wrapStream(stream, htmlStream);
+    } catch (error) {
+        console.error(error);
+        throw error;
+    }
+};
+export { renderSSRStream };

package/dist/types/client/callServer.d.ts

@@ -0,0 +1,4 @@
+type ReactServerValue = unknown;
+export declare function requestCallServer(id: string, args: ReactServerValue): Promise<Response>;
+export declare function callServer(id: string, args: ReactServerValue): Promise<any>;
+export {};

package/dist/types/client/index.d.ts

@@ -0,0 +1,24 @@
+import React, { type ReactNode } from 'react';
+import { createFromFetch, createFromReadableStream, createServerReference, setServerCallback } from 'react-server-dom-rspack/client.browser';
+export { rscStream } from '../rsc-html-stream/client';
+export { callServer } from './callServer';
+export { createFromFetch, createFromReadableStream, createServerReference };
+declare global {
+    interface Window {
+        __MODERN_JS_ENTRY_NAME?: string;
+    }
+}
+export declare const ResetRootContext: React.Context<{
+    setRoot: (root: React.ReactNode) => void;
+} | undefined>;
+export { setServerCallback };
+export declare function RscClientRoot({ rscPayload, }: {
+    rscPayload: Promise<React.ReactNode>;
+}): React.JSX.Element;
+type Elements = Promise<ReactNode[]>;
+export declare const ElementsContext: React.Context<Elements | null>;
+export declare const ServerElementsProvider: ({ elements, children, }: {
+    elements: Elements;
+    children: ReactNode;
+}) => React.JSX.Element;
+export declare const RSCServerSlot: () => Elements | null;

package/dist/types/client.d.ts

@@ -0,0 +1 @@
+export * from './client/index';

package/dist/types/rsc-html-stream/client.d.ts

@@ -0,0 +1,5 @@
+/**
+ * forked and modified from https://github.com/devongovett/rsc-html-stream/blob/main/client.js
+ * license at https://github.com/devongovett/rsc-html-stream/blob/main/LICENSE
+ */
+export declare const rscStream: ReadableStream<Uint8Array<ArrayBufferLike>>;

package/dist/types/rsc-html-stream/server.d.ts

@@ -0,0 +1,9 @@
+export declare function injectRSCPayload(rscStream: ReadableStream, { injectClosingTags, }: {
+    injectClosingTags?: boolean;
+}): TransformStream;
+/**
+ * Inject CSS link tags into HTML stream before closing head tag
+ */
+export declare function injectCSS(cssFiles: string[], { injectClosingTags, }?: {
+    injectClosingTags?: boolean;
+}): TransformStream;

package/dist/types/rsc.d.ts

@@ -0,0 +1 @@
+export * from './server/rsc';

package/dist/types/server/rsc/csr.d.ts

@@ -0,0 +1,5 @@
+import type { ReactElement } from 'react';
+export declare function renderCSRWithRSC(options: {
+    html: string;
+    rscRoot: ReactElement;
+}): Promise<Response>;

package/dist/types/server/rsc/index.d.ts

@@ -0,0 +1,2 @@
+export * from './csr';
+export * from './rsc';

package/dist/types/server/rsc/rsc.d.ts

@@ -0,0 +1,8 @@
+export { renderToReadableStream } from 'react-server-dom-rspack/server.node';
+export { createFromReadableStream } from 'react-server-dom-rspack/client.node';
+export { registerClientReference, registerServerReference, } from 'react-server-dom-rspack/server.node';
+type RenderRscOptions = {
+    element: React.ReactElement;
+};
+export declare const renderRsc: (options: RenderRscOptions) => ReadableStream<Uint8Array<ArrayBufferLike>>;
+export declare const handleAction: (req: Request) => Promise<Response>;

package/dist/types/server/ssr/index.d.ts

@@ -0,0 +1 @@
+export * from './ssr';

package/dist/types/server/ssr/ssr.d.ts

@@ -0,0 +1,9 @@
+import { renderToReadableStream } from 'react-dom/server.edge';
+type Options = {
+    request: Request;
+    routes?: unknown[];
+} & Parameters<typeof renderToReadableStream>[1];
+export declare const renderSSRStream: (children: React.ReactNode, options: Options & {
+    rscRoot: React.ReactElement;
+}) => Promise<ReturnType<typeof renderToReadableStream>>;
+export {};

package/dist/types/ssr.d.ts

@@ -0,0 +1 @@
+export * from './server/ssr';

package/package.json

@@ -0,0 +1,84 @@
+{
+  "name": "@bleedingdev/modern-js-render",
+  "description": "A Progressive React Framework for modern web development.",
+  "homepage": "https://github.com/BleedingDev/ultramodern.js#readme",
+  "bugs": {
+    "url": "https://github.com/BleedingDev/ultramodern.js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BleedingDev/ultramodern.js.git",
+    "directory": "packages/runtime/render"
+  },
+  "license": "MIT",
+  "keywords": [
+    "react",
+    "framework",
+    "modern",
+    "modern.js"
+  ],
+  "version": "3.2.0-ultramodern.0",
+  "files": [
+    "dist",
+    "hook.d.ts"
+  ],
+  "dependencies": {
+    "@swc/helpers": "^0.5.21",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.0",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.0"
+  },
+  "devDependencies": {
+    "@rslib/core": "0.21.5",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@typescript/native-preview": "7.0.0-dev.20260516.1",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
+    "react-server-dom-rspack": "0.0.2",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.2.0-ultramodern.0",
+    "@scripts/rstest-config": "2.66.0"
+  },
+  "peerDependencies": {
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
+    "react-server-dom-rspack": "0.0.2"
+  },
+  "exports": {
+    "./ssr": {
+      "types": "./dist/types/server/ssr/index.d.ts",
+      "default": "./dist/esm/ssr.mjs"
+    },
+    "./rsc": {
+      "types": "./dist/types/server/rsc/index.d.ts",
+      "default": "./dist/esm/rsc.mjs"
+    },
+    "./client": {
+      "types": "./dist/types/client/index.d.ts",
+      "default": "./dist/esm/client.mjs"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "ssr": [
+        "./dist/types/server/ssr/index.d.ts"
+      ],
+      "rsc": [
+        "./dist/types/server/rsc/index.d.ts"
+      ],
+      "client": [
+        "./dist/types/client/index.d.ts"
+      ]
+    }
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "dev": "rslib build --watch",
+    "build": "rslib build && pnpm -w tsgo:dts \"$PWD\"",
+    "test": "rstest --passWithNoTests"
+  },
+  "types": "./dist/types/browser.d.ts"
+}