react-on-rails 16.6.0 → 16.7.0-rc.1

package/README.md

@@ -14,6 +14,14 @@ pnpm add react-on-rails
 
 **Using React on Rails Pro?** Install [`react-on-rails-pro`](https://www.npmjs.com/package/react-on-rails-pro) instead. The Pro package re-exports everything from this package plus Pro-exclusive features. The `react_on_rails_pro` gem requires the Pro npm package.
 
+## Need More Than OSS?
+
+If you want React Server Components, streaming SSR, fragment caching, or faster Node-based SSR, try [`react-on-rails-pro`](https://www.npmjs.com/package/react-on-rails-pro). It is free to evaluate in development, CI/CD, and staging; production licenses are required only for production deployments.
+
+- [Compare OSS vs Pro](https://reactonrails.com/docs/getting-started/oss-vs-pro/)
+- [Pro quick start](https://reactonrails.com/docs/getting-started/pro-quick-start/)
+- [React on Rails Pro overview](https://reactonrails.com/docs/pro/)
+
 ## Quick Start
 
 ### Register Components

package/lib/ReactDOMServer.d.cts

@@ -0,0 +1,2 @@
+export { renderToPipeableStream, renderToString, type PipeableStream } from 'react-dom/server';
+//# sourceMappingURL=ReactDOMServer.d.cts.map

package/lib/ReactOnRails.client.js

@@ -1,7 +1,19 @@
-import { createBaseClientObject } from "./base/client.js";
+import { createCoreCapability } from "./capabilities/core.js";
+import { createLifecycleCapability } from "./capabilities/lifecycle.js";
 import createReactOnRails from "./createReactOnRails.js";
+import ComponentRegistry from "./ComponentRegistry.js";
+import StoreRegistry from "./StoreRegistry.js";
+import { clientStartup } from "./clientStartup.js";
+const registries = { ComponentRegistry, StoreRegistry };
 const currentGlobal = globalThis.ReactOnRails || null;
-const ReactOnRails = createReactOnRails(createBaseClientObject, currentGlobal);
+const ReactOnRails = createReactOnRails([createCoreCapability(registries), createLifecycleCapability()], {
+    currentGlobal,
+    // Defer startup to the next tick so all synchronous <script> tags finish evaluating
+    // before we scan the DOM for components. Pro's proClientStartup runs synchronously
+    // because streaming hydration needs to attach listeners before the first paint.
+    startup: typeof window !== 'undefined' ? () => setTimeout(() => clientStartup(), 0) : null,
+    registries,
+});
 export * from "./types/index.js";
 export default ReactOnRails;
 //# sourceMappingURL=ReactOnRails.client.js.map

package/lib/ReactOnRails.full.js

@@ -1,7 +1,17 @@
-import { createBaseFullObject } from "./base/full.js";
+import { createCoreCapability } from "./capabilities/core.js";
+import { createLifecycleCapability } from "./capabilities/lifecycle.js";
+import { createSSRCapability } from "./capabilities/ssr.js";
 import createReactOnRails from "./createReactOnRails.js";
+import ComponentRegistry from "./ComponentRegistry.js";
+import StoreRegistry from "./StoreRegistry.js";
+import { clientStartup } from "./clientStartup.js";
+const registries = { ComponentRegistry, StoreRegistry };
 const currentGlobal = globalThis.ReactOnRails || null;
-const ReactOnRails = createReactOnRails(createBaseFullObject, currentGlobal);
+const ReactOnRails = createReactOnRails([createCoreCapability(registries), createLifecycleCapability(), createSSRCapability()], {
+    currentGlobal,
+    startup: typeof window !== 'undefined' ? () => setTimeout(() => clientStartup(), 0) : null,
+    registries,
+});
 export * from "./types/index.js";
 export default ReactOnRails;
 //# sourceMappingURL=ReactOnRails.full.js.map

package/lib/RenderUtils.js

@@ -1,13 +1,10 @@
+import sanitizeNonce from "./sanitizeNonce.js";
 // eslint-disable-next-line import/prefer-default-export -- only one export for now, but others may be added later
 export function wrapInScriptTags(scriptId, scriptBody, nonce) {
     if (!scriptBody) {
         return '';
     }
-    // Sanitize nonce to prevent attribute injection attacks.
-    // CSP nonces should be base64/base64url-like strings with optional trailing padding.
-    // NOTE: keep this logic in sync with sanitizeNonce() in react-on-rails-pro/src/utils.ts
-    const nonceWithAllowedCharsOnly = nonce?.replace(/[^a-zA-Z0-9+/=_-]/g, '');
-    const sanitizedNonce = nonceWithAllowedCharsOnly?.match(/^[a-zA-Z0-9+/_-]+={0,2}$/)?.[0];
+    const sanitizedNonce = sanitizeNonce(nonce);
     const nonceAttr = sanitizedNonce ? ` nonce="${sanitizedNonce}"` : '';
     return `
 <script id="${scriptId}"${nonceAttr}>

package/lib/base/client.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @deprecated Use `capabilities/core.ts` instead. This file is kept for backward compatibility
+ * with older versions of react-on-rails-pro that import from `react-on-rails/@internal/base/client`.
+ */
 import type { RegisteredComponent, ReactComponentOrRenderFunction, Store, StoreGenerator, ReactOnRailsInternal } from '../types/index.ts';
 interface Registries {
     ComponentRegistry: {
@@ -19,7 +23,7 @@ interface Registries {
  * Base client object type that includes all core ReactOnRails methods except Pro-specific ones.
  * Derived from ReactOnRailsInternal by omitting Pro-only methods.
  */
-export type BaseClientObjectType = Omit<ReactOnRailsInternal, 'getOrWaitForComponent' | 'getOrWaitForStore' | 'getOrWaitForStoreGenerator' | 'reactOnRailsStoreLoaded' | 'streamServerRenderedReactComponent' | 'serverRenderRSCReactComponent'>;
+export type BaseClientObjectType = Omit<ReactOnRailsInternal, 'getOrWaitForComponent' | 'getOrWaitForStore' | 'getOrWaitForStoreGenerator' | 'reactOnRailsStoreLoaded' | 'streamServerRenderedReactComponent' | 'serverRenderRSCReactComponent' | 'addAsyncPropsCapabilityToComponentProps' | 'getOrCreateAsyncPropsManager'>;
 export declare function createBaseClientObject(registries: Registries, currentObject?: BaseClientObjectType | null): BaseClientObjectType;
 export {};
 //# sourceMappingURL=client.d.ts.map

package/lib/base/client.js

@@ -1,3 +1,7 @@
+/**
+ * @deprecated Use `capabilities/core.ts` instead. This file is kept for backward compatibility
+ * with older versions of react-on-rails-pro that import from `react-on-rails/@internal/base/client`.
+ */
 import * as Authenticity from "../Authenticity.js";
 import buildConsoleReplay, { consoleReplay } from "../buildConsoleReplay.js";
 import reactHydrateOrRender from "../reactHydrateOrRender.js";
@@ -201,6 +205,11 @@ Fix: Use only react-on-rails OR react-on-rails-pro, not both.`);
             void args; // Mark as used
             throw new Error('handleError is not available in "react-on-rails/client". Import "react-on-rails" server-side.');
         },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        prepareRenderResult(...args) {
+            void args; // Mark as used
+            throw new Error('prepareRenderResult is not available in "react-on-rails/client". Import "react-on-rails" server-side.');
+        },
     };
     // Cache the object and registries
     cachedObject = obj;

package/lib/base/full.d.ts

@@ -1,10 +1,14 @@
+/**
+ * @deprecated Use `capabilities/ssr.ts` instead. This file is kept for backward compatibility
+ * with older versions of react-on-rails-pro that import from `react-on-rails/@internal/base/full`.
+ */
 import { createBaseClientObject, type BaseClientObjectType } from './client.ts';
 import type { ReactOnRailsInternal } from '../types/index.ts';
 /**
  * SSR-specific functions that extend the base client object to create a full object.
  * Typed explicitly to ensure type safety when mutating the base object.
  */
-export type ReactOnRailsFullSpecificFunctions = Pick<ReactOnRailsInternal, 'handleError' | 'serverRenderReactComponent'>;
+export type ReactOnRailsFullSpecificFunctions = Pick<ReactOnRailsInternal, 'handleError' | 'serverRenderReactComponent' | 'prepareRenderResult'>;
 /**
  * Full object type that includes all base methods plus real SSR implementations.
  * Derived from ReactOnRailsInternal by picking base methods and SSR methods.

package/lib/base/full.js

@@ -1,6 +1,11 @@
+/**
+ * @deprecated Use `capabilities/ssr.ts` instead. This file is kept for backward compatibility
+ * with older versions of react-on-rails-pro that import from `react-on-rails/@internal/base/full`.
+ */
 import { createBaseClientObject } from "./client.js";
 import handleError from "../handleError.js";
 import serverRenderReactComponent from "../serverRenderReactComponent.js";
+import { buildLengthPrefixedResult } from "../serverRenderUtils.js";
 // Warn about bundle size when included in browser bundles
 if (typeof window !== 'undefined') {
     console.warn('Optimization opportunity: "react-on-rails" includes ~14KB of server-rendering code. ' +
@@ -19,6 +24,12 @@ export function createBaseFullObject(registries, currentObject = null) {
         serverRenderReactComponent(options) {
             return serverRenderReactComponent(options);
         },
+        prepareRenderResult(html, consoleReplayScript, hasErrors, renderingError) {
+            return buildLengthPrefixedResult(html, consoleReplayScript, {
+                hasErrors,
+                error: renderingError ?? undefined,
+            });
+        },
     };
     // Type assertion is safe here because:
     // 1. We start with BaseClientObjectType (from createBaseClientObject)

package/lib/base/full.rsc.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @deprecated Use `capabilities/ssr.rsc.ts` instead. This file is kept for backward compatibility
+ * with older versions of react-on-rails-pro that import from `react-on-rails/@internal/base/full`.
+ */
 import { createBaseClientObject, type BaseClientObjectType } from './client.ts';
 import type { BaseFullObjectType } from './full.ts';
 export type * from './full.ts';

package/lib/base/full.rsc.js

@@ -1,3 +1,7 @@
+/**
+ * @deprecated Use `capabilities/ssr.rsc.ts` instead. This file is kept for backward compatibility
+ * with older versions of react-on-rails-pro that import from `react-on-rails/@internal/base/full`.
+ */
 import { createBaseClientObject } from "./client.js";
 export function createBaseFullObject(registries, currentObject = null) {
     // Get or create client object (with caching logic)
@@ -11,6 +15,9 @@ export function createBaseFullObject(registries, currentObject = null) {
         serverRenderReactComponent() {
             throw new Error('"serverRenderReactComponent" function is not supported in RSC bundle');
         },
+        prepareRenderResult() {
+            throw new Error('"prepareRenderResult" function is not supported in RSC bundle');
+        },
     };
     // Type assertion is safe here because:
     // 1. We start with BaseClientObjectType (from createBaseClientObject)

package/lib/capabilities/core.d.ts

@@ -0,0 +1,58 @@
+import type { ReactElement } from 'react';
+import type { RegisteredComponent, RenderReturnType, ReactComponentOrRenderFunction, AuthenticityHeaders, Store, StoreGenerator, ReactOnRailsOptions } from '../types/index.ts';
+export interface Registries {
+    ComponentRegistry: {
+        register: (components: Record<string, ReactComponentOrRenderFunction>) => void;
+        get: (name: string) => RegisteredComponent;
+        components: () => Map<string, RegisteredComponent>;
+    };
+    StoreRegistry: {
+        register: (storeGenerators: Record<string, StoreGenerator>) => void;
+        getStore: (name: string, throwIfMissing?: boolean) => Store | undefined;
+        getStoreGenerator: (name: string) => StoreGenerator;
+        setStore: (name: string, store: Store) => void;
+        clearHydratedStores: () => void;
+        storeGenerators: () => Map<string, StoreGenerator>;
+        stores: () => Map<string, Store>;
+    };
+}
+/**
+ * Creates the core capability containing all base ReactOnRails methods.
+ * These are the methods that exist in every bundle variant (client, full, node, RSC).
+ */
+export declare function createCoreCapability(registries: Registries): {
+    options: Partial<ReactOnRailsOptions>;
+    isRSCBundle: boolean;
+    authenticityToken(): string | null;
+    authenticityHeaders(otherHeaders?: Record<string, string>): AuthenticityHeaders;
+    reactHydrateOrRender(domNode: Element, reactElement: ReactElement, hydrate: boolean): RenderReturnType;
+    setOptions(newOptions: Partial<ReactOnRailsOptions>): void;
+    option<K extends keyof ReactOnRailsOptions>(key: K): ReactOnRailsOptions[K];
+    buildConsoleReplay(): string;
+    getConsoleReplayScript(): string;
+    resetOptions(): void;
+    register(components: Record<string, ReactComponentOrRenderFunction>): void;
+    registerStore(stores: Record<string, StoreGenerator>): void;
+    registerStoreGenerators(storeGenerators: Record<string, StoreGenerator>): void;
+    getStore(name: string, throwIfMissing?: boolean): Store | undefined;
+    getStoreGenerator(name: string): StoreGenerator;
+    setStore(name: string, store: Store): void;
+    clearHydratedStores(): void;
+    getComponent(name: string): RegisteredComponent;
+    registeredComponents(): Map<string, RegisteredComponent>;
+    storeGenerators(): Map<string, StoreGenerator>;
+    stores(): Map<string, Store>;
+    render(name: string, props: Record<string, string>, domNodeId: string, hydrate: boolean): RenderReturnType;
+    serverRenderReactComponent(...args: any[]): any;
+    handleError(...args: any[]): any;
+    prepareRenderResult(...args: any[]): any;
+    getOrWaitForComponent(): Promise<RegisteredComponent>;
+    getOrWaitForStore(): Promise<Store>;
+    getOrWaitForStoreGenerator(): Promise<StoreGenerator>;
+    reactOnRailsStoreLoaded(): Promise<void>;
+    streamServerRenderedReactComponent(...args: any[]): any;
+    serverRenderRSCReactComponent(...args: any[]): any;
+    addAsyncPropsCapabilityToComponentProps(...args: any[]): any;
+    getOrCreateAsyncPropsManager(...args: any[]): any;
+};
+//# sourceMappingURL=core.d.ts.map

package/lib/capabilities/core.js

@@ -0,0 +1,188 @@
+import * as Authenticity from "../Authenticity.js";
+import buildConsoleReplay, { consoleReplay } from "../buildConsoleReplay.js";
+import reactHydrateOrRender from "../reactHydrateOrRender.js";
+import createReactOutput from "../createReactOutput.js";
+const DEFAULT_OPTIONS = {
+    traceTurbolinks: false,
+    turbo: false,
+    debugMode: false,
+    logComponentRegistration: false,
+};
+/**
+ * Creates the core capability containing all base ReactOnRails methods.
+ * These are the methods that exist in every bundle variant (client, full, node, RSC).
+ */
+export function createCoreCapability(registries) {
+    const { ComponentRegistry, StoreRegistry } = registries;
+    return {
+        options: {},
+        isRSCBundle: false,
+        // ===================================================================
+        // STABLE METHOD IMPLEMENTATIONS - Core package implementations
+        // ===================================================================
+        authenticityToken() {
+            return Authenticity.authenticityToken();
+        },
+        authenticityHeaders(otherHeaders = {}) {
+            return Authenticity.authenticityHeaders(otherHeaders);
+        },
+        reactHydrateOrRender(domNode, reactElement, hydrate) {
+            return reactHydrateOrRender(domNode, reactElement, hydrate);
+        },
+        setOptions(newOptions) {
+            const { traceTurbolinks, turbo, debugMode, logComponentRegistration, ...rest } = newOptions;
+            if (typeof traceTurbolinks !== 'undefined') {
+                this.options.traceTurbolinks = traceTurbolinks;
+            }
+            if (typeof turbo !== 'undefined') {
+                this.options.turbo = turbo;
+            }
+            if (typeof debugMode !== 'undefined') {
+                this.options.debugMode = debugMode;
+                if (debugMode) {
+                    console.log('[ReactOnRails] Debug mode enabled');
+                }
+            }
+            if (typeof logComponentRegistration !== 'undefined') {
+                this.options.logComponentRegistration = logComponentRegistration;
+                if (logComponentRegistration) {
+                    console.log('[ReactOnRails] Component registration logging enabled');
+                }
+            }
+            if (Object.keys(rest).length > 0) {
+                throw new Error(`Invalid options passed to ReactOnRails.options: ${JSON.stringify(rest)}`);
+            }
+        },
+        option(key) {
+            return this.options[key];
+        },
+        buildConsoleReplay() {
+            return buildConsoleReplay();
+        },
+        getConsoleReplayScript() {
+            return consoleReplay();
+        },
+        resetOptions() {
+            this.options = { ...DEFAULT_OPTIONS };
+        },
+        // ===================================================================
+        // REGISTRY METHOD IMPLEMENTATIONS - Using provided registries
+        // ===================================================================
+        register(components) {
+            if (this.options.debugMode || this.options.logComponentRegistration) {
+                // Use performance.now() if available, otherwise fallback to Date.now()
+                const perf = typeof performance !== 'undefined' ? performance : { now: () => Date.now() };
+                const startTime = perf.now();
+                const componentNames = Object.keys(components);
+                console.log(`[ReactOnRails] Registering ${componentNames.length} component(s): ${componentNames.join(', ')}`);
+                ComponentRegistry.register(components);
+                const endTime = perf.now();
+                console.log(`[ReactOnRails] Component registration completed in ${(endTime - startTime).toFixed(2)}ms`);
+                // Log individual component details if in full debug mode
+                if (this.options.debugMode) {
+                    componentNames.forEach((name) => {
+                        const component = components[name];
+                        const size = component.toString().length;
+                        console.log(`[ReactOnRails] ✅ Registered: ${name} (${size} chars)`);
+                    });
+                }
+            }
+            else {
+                ComponentRegistry.register(components);
+            }
+        },
+        registerStore(stores) {
+            this.registerStoreGenerators(stores);
+        },
+        registerStoreGenerators(storeGenerators) {
+            if (!storeGenerators) {
+                throw new Error('Called ReactOnRails.registerStoreGenerators with a null or undefined, rather than ' +
+                    'an Object with keys being the store names and the values are the store generators.');
+            }
+            StoreRegistry.register(storeGenerators);
+        },
+        getStore(name, throwIfMissing = true) {
+            return StoreRegistry.getStore(name, throwIfMissing);
+        },
+        getStoreGenerator(name) {
+            return StoreRegistry.getStoreGenerator(name);
+        },
+        setStore(name, store) {
+            StoreRegistry.setStore(name, store);
+        },
+        clearHydratedStores() {
+            StoreRegistry.clearHydratedStores();
+        },
+        getComponent(name) {
+            return ComponentRegistry.get(name);
+        },
+        registeredComponents() {
+            return ComponentRegistry.components();
+        },
+        storeGenerators() {
+            return StoreRegistry.storeGenerators();
+        },
+        stores() {
+            return StoreRegistry.stores();
+        },
+        render(name, props, domNodeId, hydrate) {
+            const componentObj = ComponentRegistry.get(name);
+            const reactElement = createReactOutput({ componentObj, props, domNodeId });
+            return this.reactHydrateOrRender(document.getElementById(domNodeId), reactElement, hydrate);
+        },
+        // ===================================================================
+        // SSR STUBS — overridden by createSSRCapability() in full/node bundles
+        // ===================================================================
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        serverRenderReactComponent(...args) {
+            void args;
+            throw new Error('serverRenderReactComponent is not available in the client bundle. Import "react-on-rails" server-side.');
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        handleError(...args) {
+            void args;
+            throw new Error('handleError is not available in the client bundle. Import "react-on-rails" server-side.');
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        prepareRenderResult(...args) {
+            void args;
+            throw new Error('prepareRenderResult is not available in the client bundle. Import "react-on-rails" server-side.');
+        },
+        // ===================================================================
+        // PRO STUBS — overridden by Pro capabilities in react-on-rails-pro
+        // ===================================================================
+        getOrWaitForComponent() {
+            throw new Error('getOrWaitForComponent requires the react-on-rails-pro package.');
+        },
+        getOrWaitForStore() {
+            throw new Error('getOrWaitForStore requires the react-on-rails-pro package.');
+        },
+        getOrWaitForStoreGenerator() {
+            throw new Error('getOrWaitForStoreGenerator requires the react-on-rails-pro package.');
+        },
+        reactOnRailsStoreLoaded() {
+            throw new Error('reactOnRailsStoreLoaded requires the react-on-rails-pro package.');
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        streamServerRenderedReactComponent(...args) {
+            void args;
+            throw new Error('streamServerRenderedReactComponent requires the react-on-rails-pro package.');
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        serverRenderRSCReactComponent(...args) {
+            void args;
+            throw new Error('serverRenderRSCReactComponent requires the react-on-rails-pro package.');
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        addAsyncPropsCapabilityToComponentProps(...args) {
+            void args;
+            throw new Error('addAsyncPropsCapabilityToComponentProps requires the react-on-rails-pro package.');
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        getOrCreateAsyncPropsManager(...args) {
+            void args;
+            throw new Error('getOrCreateAsyncPropsManager requires the react-on-rails-pro package.');
+        },
+    };
+}
+//# sourceMappingURL=core.js.map

package/lib/capabilities/lifecycle.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Core lifecycle capability.
+ * Provides the core (non-Pro) implementations for page/component loaded callbacks.
+ */
+export declare function createLifecycleCapability(): {
+    reactOnRailsPageLoaded(): Promise<void>;
+    reactOnRailsComponentLoaded(domId: string): Promise<void>;
+};
+//# sourceMappingURL=lifecycle.d.ts.map

package/lib/capabilities/lifecycle.js

@@ -0,0 +1,19 @@
+/* eslint-disable import/prefer-default-export -- named export for consistency with capability API */
+import { reactOnRailsPageLoaded } from "../clientStartup.js";
+import { reactOnRailsComponentLoaded } from "../ClientRenderer.js";
+/**
+ * Core lifecycle capability.
+ * Provides the core (non-Pro) implementations for page/component loaded callbacks.
+ */
+export function createLifecycleCapability() {
+    return {
+        reactOnRailsPageLoaded() {
+            reactOnRailsPageLoaded();
+            return Promise.resolve();
+        },
+        reactOnRailsComponentLoaded(domId) {
+            return reactOnRailsComponentLoaded(domId);
+        },
+    };
+}
+//# sourceMappingURL=lifecycle.js.map

package/lib/capabilities/ssr.d.ts

@@ -0,0 +1,11 @@
+import type { RenderParams, ErrorOptions, RenderingError } from '../types/index.ts';
+/**
+ * SSR capability.
+ * Provides server-side rendering methods (serverRenderReactComponent, handleError).
+ */
+export declare function createSSRCapability(): {
+    handleError(options: ErrorOptions): string | undefined;
+    serverRenderReactComponent(options: RenderParams): null | string | Promise<string>;
+    prepareRenderResult(html: string, consoleReplayScript: string, hasErrors: boolean, renderingError: RenderingError | null): string;
+};
+//# sourceMappingURL=ssr.d.ts.map

package/lib/capabilities/ssr.js

@@ -0,0 +1,31 @@
+/* eslint-disable import/prefer-default-export -- named export for consistency with capability API */
+import handleError from "../handleError.js";
+import serverRenderReactComponent from "../serverRenderReactComponent.js";
+import { buildLengthPrefixedResult } from "../serverRenderUtils.js";
+// Warn about bundle size when included in browser bundles
+if (typeof window !== 'undefined') {
+    console.warn('Optimization opportunity: this bundle includes ~14KB of server-rendering code that browsers may not need. ' +
+        'See https://forum.shakacode.com/t/how-to-use-different-versions-of-a-file-for-client-and-server-rendering/1352 ' +
+        '(Requires creating a free account). Click this for the stack trace.');
+}
+/**
+ * SSR capability.
+ * Provides server-side rendering methods (serverRenderReactComponent, handleError).
+ */
+export function createSSRCapability() {
+    return {
+        handleError(options) {
+            return handleError(options);
+        },
+        serverRenderReactComponent(options) {
+            return serverRenderReactComponent(options);
+        },
+        prepareRenderResult(html, consoleReplayScript, hasErrors, renderingError) {
+            return buildLengthPrefixedResult(html, consoleReplayScript, {
+                hasErrors,
+                error: renderingError ?? undefined,
+            });
+        },
+    };
+}
+//# sourceMappingURL=ssr.js.map

package/lib/capabilities/ssr.rsc.d.ts

@@ -0,0 +1,10 @@
+/**
+ * SSR capability for RSC bundles.
+ * SSR methods throw because they are not supported in the RSC bundle.
+ */
+export declare function createSSRCapability(): {
+    handleError(): never;
+    serverRenderReactComponent(): never;
+    prepareRenderResult(): never;
+};
+//# sourceMappingURL=ssr.rsc.d.ts.map

package/lib/capabilities/ssr.rsc.js

@@ -0,0 +1,19 @@
+/* eslint-disable import/prefer-default-export -- named export for consistency with capability API */
+/**
+ * SSR capability for RSC bundles.
+ * SSR methods throw because they are not supported in the RSC bundle.
+ */
+export function createSSRCapability() {
+    return {
+        handleError() {
+            throw new Error('"handleError" function is not supported in RSC bundle');
+        },
+        serverRenderReactComponent() {
+            throw new Error('"serverRenderReactComponent" function is not supported in RSC bundle');
+        },
+        prepareRenderResult() {
+            throw new Error('"prepareRenderResult" function is not supported in RSC bundle');
+        },
+    };
+}
+//# sourceMappingURL=ssr.rsc.js.map

package/lib/createReactOnRails.d.ts

@@ -1,7 +1,20 @@
-import { createBaseClientObject, type BaseClientObjectType } from './base/client.ts';
-import { createBaseFullObject } from './base/full.ts';
+import type { Registries } from './capabilities/core.ts';
 import type { ReactOnRailsInternal } from './types/index.ts';
-type BaseObjectCreator = typeof createBaseClientObject | typeof createBaseFullObject;
-export default function createReactOnRails(baseObjectCreator: BaseObjectCreator, currentGlobal?: BaseClientObjectType | null): ReactOnRailsInternal;
-export {};
+export type { Registries };
+/**
+ * Assembles the ReactOnRails global object from an array of capabilities.
+ *
+ * Each capability is a partial implementation of ReactOnRailsInternal.
+ * Capabilities are merged in array order (last wins for overlapping keys).
+ *
+ * @param capabilities - Array of capability objects to merge.
+ * @param options.currentGlobal - Current globalThis.ReactOnRails value (for misconfiguration detection).
+ * @param options.startup - Callback invoked once on first initialization, after the global is set.
+ * @param options.registries - The registries used by the core capability (for mixing detection).
+ */
+export default function createReactOnRails(capabilities: Partial<ReactOnRailsInternal>[], options: {
+    currentGlobal: ReactOnRailsInternal | null;
+    startup: (() => void) | null;
+    registries: Registries;
+}): ReactOnRailsInternal;
 //# sourceMappingURL=createReactOnRails.d.ts.map