@web-widget/react 3.0.0-beta.2 → 3.0.0-beta.5

package/dist/chunk-CSPKK7RR.js

@@ -0,0 +1,195 @@
+// src/server/context.ts
+import { createContext } from "react";
+var ReactServerRenderModeContext = createContext(null);
+
+// src/widget/fallback.ts
+import { isValidElement } from "react";
+function resolveFallback(fallback) {
+  var _a;
+  if (fallback !== null && typeof fallback === "object" && !isValidElement(fallback) && !Array.isArray(fallback) && ("pending" in fallback || "error" in fallback)) {
+    const value = fallback;
+    return {
+      pendingFallback: value.pending,
+      errorFallback: (_a = value.error) != null ? _a : value.pending
+    };
+  }
+  return {
+    pendingFallback: fallback,
+    errorFallback: fallback
+  };
+}
+
+// src/widget/factory.ts
+import {
+  Suspense,
+  createElement as createElement2,
+  memo,
+  useContext
+} from "react";
+
+// src/widget/task.ts
+import {
+  WebWidgetRenderer
+} from "@web-widget/web-widget";
+async function renderWidgetResult(renderer, children, renderChildren) {
+  try {
+    if (!renderChildren) {
+      const html2 = children ? "" : await renderer.renderInnerHTMLToString();
+      return { status: "success", html: html2 };
+    }
+    if (!children) {
+      const html2 = await renderer.renderInnerHTMLToString();
+      return { status: "success", html: html2 };
+    }
+    const lightChildrenHTML = await renderChildren(children);
+    const html = await renderer.renderInnerHTMLToString({
+      children: lightChildrenHTML
+    });
+    return { status: "success", html };
+  } catch (error) {
+    return {
+      status: "error",
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+function createWidgetRenderTask({
+  children,
+  loader,
+  renderChildren,
+  ...options
+}) {
+  if (!loader) {
+    throw new TypeError("Missing loader.");
+  }
+  const renderer = new WebWidgetRenderer(loader, options);
+  const { attributes, localName, opaqueInnerHTML } = renderer;
+  const result = opaqueInnerHTML !== void 0 ? Promise.resolve({ status: "success", html: opaqueInnerHTML }) : renderWidgetResult(renderer, children, renderChildren);
+  return {
+    attributes,
+    children,
+    hasChildrenRenderer: renderChildren !== void 0,
+    localName,
+    opaqueInnerHTML,
+    pendingBoundary: renderer.pendingBoundary,
+    result
+  };
+}
+
+// src/widget/views.ts
+import { createElement, use } from "react";
+function renderDirectChildren(task) {
+  if (task.hasChildrenRenderer || !task.children) return void 0;
+  return createElement(
+    task.localName,
+    { ...task.attributes, suppressHydrationWarning: true },
+    task.children
+  );
+}
+function renderPending(task, pendingFallback) {
+  return createElement(
+    task.localName,
+    { ...task.attributes, suppressHydrationWarning: true },
+    createElement(
+      task.pendingBoundary.localName,
+      {
+        "aria-busy": task.pendingBoundary.ariaBusy,
+        slot: task.pendingBoundary.slot,
+        style: { display: task.pendingBoundary.display }
+      },
+      pendingFallback
+    )
+  );
+}
+function renderResult(task, result, errorFallback) {
+  if (result.status === "error") {
+    console.error("[ReactWidget] Rendering error:", result.error);
+    return errorFallback;
+  }
+  return createElement(task.localName, {
+    ...task.attributes,
+    dangerouslySetInnerHTML: { __html: result.html },
+    suppressHydrationWarning: true
+  });
+}
+function StreamingWidgetView({
+  task,
+  clientOnly,
+  errorFallback,
+  pendingFallback
+}) {
+  const directChildren = renderDirectChildren(task);
+  if (directChildren) return directChildren;
+  if (task.opaqueInnerHTML !== void 0) {
+    return renderResult(
+      task,
+      { status: "success", html: task.opaqueInnerHTML },
+      errorFallback
+    );
+  }
+  if (clientOnly && typeof window === "undefined" && pendingFallback != null) {
+    return renderPending(task, pendingFallback);
+  }
+  return renderResult(task, use(task.result), errorFallback);
+}
+async function BufferedWidgetView({
+  task,
+  clientOnly,
+  errorFallback,
+  pendingFallback
+}) {
+  const directChildren = renderDirectChildren(task);
+  if (directChildren) return directChildren;
+  if (clientOnly && pendingFallback != null) {
+    return renderPending(task, pendingFallback);
+  }
+  return renderResult(task, await task.result, errorFallback);
+}
+
+// src/widget/factory.ts
+function createWidgetAdapter(renderChildren) {
+  return function widget(loader, options = {}) {
+    return memo(function ReactWidget({
+      children,
+      slot,
+      widget: widget2 = {},
+      ...data
+    }) {
+      const { fallback, id, loading, clientOnly } = widget2;
+      const serverRenderMode = useContext(ReactServerRenderModeContext);
+      const { pendingFallback, errorFallback } = resolveFallback(fallback);
+      const buffered = serverRenderMode === "buffered";
+      const task = createWidgetRenderTask({
+        ...options,
+        clientOnly: widget2.clientOnly,
+        children,
+        data,
+        id,
+        loader,
+        loading: loading != null ? loading : options.loading,
+        renderChildren,
+        serverOnly: widget2.serverOnly,
+        slot
+      });
+      const view = createElement2(
+        buffered ? BufferedWidgetView : StreamingWidgetView,
+        {
+          clientOnly,
+          errorFallback,
+          pendingFallback,
+          task
+        }
+      );
+      return buffered || task.opaqueInnerHTML !== void 0 ? view : createElement2(Suspense, {
+        fallback: pendingFallback,
+        children: view
+      });
+    });
+  };
+}
+
+export {
+  ReactServerRenderModeContext,
+  resolveFallback,
+  createWidgetAdapter
+};

package/dist/react.adapter.client.d.ts

@@ -1,9 +1,13 @@
 import * as _web_widget_schema from '@web-widget/schema';
+export { WidgetContainerOptions } from '@web-widget/schema';
+import { ReactWidgetFactory } from './react.adapter.server.js';
+export { ReactWidgetComponent, ReactWidgetContainerProps, ReactWidgetProps, WebWidgetProps, resolveFallback } from './react.adapter.server.js';
 import { FunctionComponent } from 'react';
-export * from '@web-widget/helpers';
-export { D as DefineWebWidgetOptions, R as ReactWidgetComponent, a as ReactWidgetProps, W as WebWidgetProps, b as WidgetContainerConfig, c as WidgetFallback, d as container, r as resolveFallback } from './components-BdC3VZlV.js';
+import 'react-dom/static';
 import '@web-widget/web-widget';
+import 'react-dom/server';
 
+declare const widget: ReactWidgetFactory;
 declare const render: _web_widget_schema.ClientRender<FunctionComponent<{}>, unknown, _web_widget_schema.ClientRenderOptions, void | _web_widget_schema.ClientRenderResult<unknown>>;
 
-export { render };
+export { ReactWidgetFactory, render, widget };

package/dist/react.adapter.client.js

@@ -1,32 +1,62 @@
 import {
-  container,
+  createWidgetAdapter,
   resolveFallback
-} from "./chunk-VQFEYZQS.js";
+} from "./chunk-CSPKK7RR.js";
 
 // src/adapter.client.ts
 import { defineClientRender } from "@web-widget/helpers";
 import { createElement, StrictMode } from "react";
 import { createRoot, hydrateRoot } from "react-dom/client";
-export * from "@web-widget/helpers";
+
+// src/client/hydration-error.ts
+var HYDRATION_ERROR_EVENT = "web-widget:hydration-error";
+function hydrationHost(container) {
+  var _a, _b;
+  if (container instanceof Element) return container.closest("web-widget");
+  const root = container;
+  return (_b = (_a = root.host) == null ? void 0 : _a.closest("web-widget")) != null ? _b : null;
+}
+function reportRecoverableError(container, error) {
+  var _a;
+  const host = hydrationHost(container);
+  (host != null ? host : container).dispatchEvent(
+    new CustomEvent(HYDRATION_ERROR_EVENT, {
+      bubbles: true,
+      composed: true,
+      detail: {
+        moduleURL: (_a = host == null ? void 0 : host.getAttribute("import")) != null ? _a : "",
+        adapter: "react",
+        phase: "mismatch",
+        error
+      }
+    })
+  );
+}
+
+// src/adapter.client.ts
+var widget = createWidgetAdapter();
 var render = defineClientRender(
-  async (component, data, { recovering, container: container2 }) => {
-    data = data != null ? data : {};
+  async (component, data, { id, recovering, container }) => {
     if (!component) {
       throw new TypeError(`Missing component.`);
     }
-    if (!container2) {
+    if (!container) {
       throw new Error(`Missing container.`);
     }
+    const props = data != null ? data : {};
     let root;
     return {
       async mount() {
         const isAsyncFunction = Object.prototype.toString.call(component) === "[object AsyncFunction]";
-        let vNode = isAsyncFunction ? await component(data) : createElement(component, data);
+        let vNode = isAsyncFunction ? await component(props) : createElement(component, props);
         vNode = createElement(StrictMode, null, vNode);
         if (recovering) {
-          root = hydrateRoot(container2, vNode);
+          root = hydrateRoot(container, vNode, {
+            identifierPrefix: id,
+            onRecoverableError: (error) => reportRecoverableError(container, error)
+          });
         } else {
-          root = createRoot(container2);
+          root = createRoot(container, { identifierPrefix: id });
           root.render(vNode);
         }
       },
@@ -38,7 +68,7 @@ var render = defineClientRender(
   }
 );
 export {
-  container,
   render,
-  resolveFallback
+  resolveFallback,
+  widget
 };

package/dist/react.adapter.server.d.ts

@@ -1,17 +1,39 @@
 import * as _web_widget_schema from '@web-widget/schema';
-import { FunctionComponent } from 'react';
+import { WidgetHostProps, WidgetContainerProps, WidgetContainerOptions, ExtractWidgetProps, WidgetModuleLoader } from '@web-widget/schema';
+export { WidgetContainerOptions } from '@web-widget/schema';
+import { FunctionComponent, ReactNode } from 'react';
 import { PrerenderOptions } from 'react-dom/static';
-export * from '@web-widget/helpers';
-export { D as DefineWebWidgetOptions, R as ReactWidgetComponent, a as ReactWidgetProps, W as WebWidgetProps, b as WidgetContainerConfig, c as WidgetFallback, d as container, r as resolveFallback } from './components-BdC3VZlV.js';
+import { WebWidgetRendererOptions } from '@web-widget/web-widget';
 import { RenderToReadableStreamOptions } from 'react-dom/server';
-import '@web-widget/web-widget';
 
 declare global {
     interface ReadableStream {
         [Symbol.asyncIterator](): AsyncIterator<ArrayBuffer | Uint8Array>;
     }
 }
-type RenderToStringOptions = PrerenderOptions;
+type PrerenderToStringOptions = PrerenderOptions;
+
+type ReactWidgetContainerProps = WidgetContainerProps<ReactNode>;
+interface ReactWidgetProps extends WidgetHostProps {
+    children?: ReactNode;
+    /** Container configuration, isolated from widget's own props. */
+    widget?: ReactWidgetContainerProps;
+}
+interface ReactWidgetComponent<T> extends FunctionComponent<T & ReactWidgetProps> {
+}
+interface ReactWidgetFactory {
+    <M>(loader: () => Promise<M>, options?: WidgetContainerOptions): ReactWidgetComponent<ExtractWidgetProps<M>>;
+    <Props>(loader: WidgetModuleLoader, options?: WidgetContainerOptions): ReactWidgetComponent<Props>;
+}
+type WebWidgetProps = WebWidgetRendererOptions & {
+    loader: WidgetModuleLoader;
+    children?: ReactNode;
+};
+
+declare function resolveFallback(fallback: ReactWidgetContainerProps['fallback']): {
+    pendingFallback: ReactNode;
+    errorFallback: ReactNode;
+};
 
 declare module '@web-widget/schema' {
     interface ServerRenderOptions {
@@ -19,12 +41,14 @@ declare module '@web-widget/schema' {
     }
 }
 
+declare const widget: ReactWidgetFactory;
 type StreamOptions = {
+    /** @deprecated */
     awaitAllReady?: boolean;
-} & RenderToReadableStreamOptions & RenderToStringOptions;
+} & RenderToReadableStreamOptions & PrerenderToStringOptions;
 interface ReactRenderOptions {
     react?: StreamOptions;
 }
 declare const render: _web_widget_schema.ServerRender<FunctionComponent<{}>, unknown, _web_widget_schema.ServerRenderOptions, _web_widget_schema.ServerRenderResult>;
 
-export { type ReactRenderOptions, render };
+export { type ReactRenderOptions, type ReactWidgetComponent, type ReactWidgetContainerProps, type ReactWidgetFactory, type ReactWidgetProps, type WebWidgetProps, render, resolveFallback, widget };

package/dist/react.adapter.server.js

@@ -1,18 +1,19 @@
 import {
-  container,
+  ReactServerRenderModeContext,
+  createWidgetAdapter,
   resolveFallback
-} from "./chunk-VQFEYZQS.js";
+} from "./chunk-CSPKK7RR.js";
 
 // src/adapter.server.ts
 import { defineServerRender } from "@web-widget/helpers";
 import { createElement, StrictMode } from "react";
 
-// src/edge.ts
+// src/server/react-dom.ts
 import { renderToReadableStream as _renderToReadableStream } from "react-dom/server.edge";
 import { prerender as _prerender } from "react-dom/static.edge";
 var prerender = _prerender;
 var renderToReadableStream = _renderToReadableStream;
-async function renderToString(vNode, options) {
+async function prerenderToString(vNode, options) {
   return readableStreamToString(
     (await prerender(vNode, options)).prelude
   );
@@ -28,31 +29,49 @@ async function readableStreamToString(readableStream) {
 }
 
 // src/adapter.server.ts
-export * from "@web-widget/helpers";
+var widget = createWidgetAdapter(
+  (children) => prerenderToString(
+    createElement(
+      ReactServerRenderModeContext.Provider,
+      { value: "buffered" },
+      children
+    ),
+    {}
+  )
+);
 var DEFAULT_TIMEOUT_MS = 1e3 * 10;
 var render = defineServerRender(
-  async (component, data, { progressive, react }) => {
-    data = data != null ? data : {};
+  async (component, data, { id, progressive, react }) => {
     if (!component) {
       throw new TypeError(`Missing component.`);
     }
-    const reactRenderOptions = Object.create(react != null ? react : null);
-    const { onError, awaitAllReady, signal } = reactRenderOptions;
-    reactRenderOptions.signal = signal != null ? signal : AbortSignal.timeout(DEFAULT_TIMEOUT_MS);
+    const props = data != null ? data : {};
+    const { awaitAllReady, onError, signal, ...configuredOptions } = react != null ? react : {};
     const preShellErrors = [];
     let shellRendered = false;
-    reactRenderOptions.onError = (e, i) => {
-      if (shellRendered) {
-        console.error(e);
-      } else {
-        preShellErrors.push(e);
+    const reactRenderOptions = {
+      ...configuredOptions,
+      // React uses this namespace for useId(). It must match hydrateRoot and
+      // be unique across independently rendered widget roots in one document.
+      identifierPrefix: id,
+      signal: signal != null ? signal : AbortSignal.timeout(DEFAULT_TIMEOUT_MS),
+      onError(e, i) {
+        if (shellRendered) {
+          console.error(e);
+        } else {
+          preShellErrors.push(e);
+        }
+        onError == null ? void 0 : onError(e instanceof Error ? e : new Error(String(e)), i);
       }
-      onError == null ? void 0 : onError(e instanceof Error ? e : new Error(String(e)), i);
     };
     const isAsyncFunction = Object.prototype.toString.call(component) === "[object AsyncFunction]";
-    let vNode = isAsyncFunction ? await component(data) : createElement(component, data);
-    vNode = createElement(StrictMode, null, vNode);
-    const renderMethod = progressive ? renderToReadableStream : renderToString;
+    let vNode = isAsyncFunction ? await component(props) : createElement(component, props);
+    vNode = createElement(
+      ReactServerRenderModeContext.Provider,
+      { value: progressive ? "progressive" : "buffered" },
+      createElement(StrictMode, null, vNode)
+    );
+    const renderMethod = progressive ? renderToReadableStream : prerenderToString;
     const result = await renderMethod(vNode, reactRenderOptions);
     shellRendered = true;
     for (const e of preShellErrors) {
@@ -65,7 +84,7 @@ var render = defineServerRender(
   }
 );
 export {
-  container,
   render,
-  resolveFallback
+  resolveFallback,
+  widget
 };

package/dist/react.transform.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    name: string;
+    extensions: string[];
+    adapter: string;
+};
+
+export { _default as default };

package/dist/react.transform.js

@@ -0,0 +1,9 @@
+// src/transform.ts
+var transform_default = {
+  name: "react",
+  extensions: [".tsx", ".jsx"],
+  adapter: "@web-widget/react/adapter"
+};
+export {
+  transform_default as default
+};

package/globals.d.ts

@@ -18,8 +18,8 @@ type WidgetContainerConfig = {
    * - `{ pending?, error? }` — specify independently; `error` defaults to `pending`.
    */
   fallback?: WebWidgetFallback;
-  /** Client-side module loading strategy: `'lazy'` loads on first render, `'eager'` on module parse, `'idle'` on browser idle. */
-  loading?: 'lazy' | 'eager' | 'idle';
+  /** Client-side module loading strategy. `'auto'` prioritizes visible widgets and eventually loads all widgets. */
+  loading?: 'auto' | 'lazy' | 'eager' | 'idle';
   /** Widget renders only on the server (SSR), producing static HTML with no client-side mount. Mutually exclusive with `clientOnly`. */
   serverOnly?: true;
   /** Widget renders only on the client, producing no server HTML (empty placeholder until client mount). Mutually exclusive with `serverOnly`. */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@web-widget/react",
   "description": "React adapter",
-  "version": "3.0.0-beta.2",
+  "version": "3.0.0-beta.5",
   "homepage": "https://github.com/web-widget/web-widget#readme",
   "repository": {
     "type": "git",
@@ -13,38 +13,45 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@web-widget/helpers": "3.0.0-beta.2",
-    "@web-widget/schema": "3.0.0-beta.2",
-    "@web-widget/web-widget": "3.0.0-beta.2"
+    "@web-widget/helpers": "workspace:*",
+    "@web-widget/schema": "workspace:*",
+    "@web-widget/web-widget": "workspace:*"
   },
   "devDependencies": {
-    "@types/jest": "^29.5.12",
-    "@types/react": "^19.2.14",
-    "@types/react-dom": "^19.2.3",
-    "jest": "^29.7.0",
-    "react": "^19.2.6",
-    "react-dom": "^19.2.6",
-    "ts-jest": "29.2.1",
-    "tsup": "^8.3.4",
-    "typescript": "^5.9.3",
-    "vite": "^8.0.12"
+    "@types/react": "catalog:",
+    "@types/react-dom": "catalog:",
+    "react": "catalog:",
+    "react-dom": "catalog:",
+    "tsup": "catalog:",
+    "typescript": "catalog:",
+    "vite": "catalog:",
+    "vitest": "catalog:"
   },
   "exports": {
     ".": {
       "types": "./dist/react.d.ts",
+      "development": "./src/index.ts",
       "default": "./dist/react.js"
     },
+    "./transform": {
+      "types": "./dist/react.transform.d.ts",
+      "development": "./src/transform.ts",
+      "default": "./dist/react.transform.js"
+    },
     "./adapter": {
       "worker": {
         "types": "./dist/react.adapter.server.d.ts",
+        "development": "./src/adapter.server.ts",
         "default": "./dist/react.adapter.server.js"
       },
       "browser": {
         "types": "./dist/react.adapter.client.d.ts",
+        "development": "./src/adapter.client.ts",
         "default": "./dist/react.adapter.client.js"
       },
       "default": {
         "types": "./dist/react.adapter.server.d.ts",
+        "development": "./src/adapter.server.ts",
         "default": "./dist/react.adapter.server.js"
       }
     },
@@ -52,15 +59,6 @@
       "types": "./globals.d.ts"
     }
   },
-  "webWidgetAdapter": {
-    "version": "1.0.0",
-    "name": "react",
-    "extensions": [
-      ".tsx",
-      ".jsx"
-    ],
-    "adapter": "./adapter"
-  },
   "files": [
     "dist",
     "globals.d.ts"
@@ -70,10 +68,35 @@
     "react-dom": "^19.0.0"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/react.d.ts",
+        "default": "./dist/react.js"
+      },
+      "./transform": {
+        "types": "./dist/react.transform.d.ts",
+        "default": "./dist/react.transform.js"
+      },
+      "./adapter": {
+        "worker": {
+          "types": "./dist/react.adapter.server.d.ts",
+          "default": "./dist/react.adapter.server.js"
+        },
+        "browser": {
+          "types": "./dist/react.adapter.client.d.ts",
+          "default": "./dist/react.adapter.client.js"
+        },
+        "default": {
+          "types": "./dist/react.adapter.server.d.ts",
+          "default": "./dist/react.adapter.server.js"
+        }
+      },
+      "./globals": {
+        "types": "./globals.d.ts"
+      }
+    }
   },
-  "sideEffects": false,
-  "type": "module",
   "scripts": {
     "build": "pnpm exec tsup",
     "clean:build": "rm -rf dist",
@@ -81,6 +104,8 @@
     "dev": "pnpm exec tsup --watch",
     "lint": "eslint src",
     "prebuild": "pnpm run clean:build",
-    "test": "jest"
-  }
-}
+    "test": "vitest run"
+  },
+  "sideEffects": false,
+  "type": "module"
+}

package/dist/chunk-VQFEYZQS.js

@@ -1,131 +0,0 @@
-// src/components.ts
-import { WebWidgetRenderer } from "@web-widget/web-widget";
-import {
-  Component,
-  Fragment,
-  Suspense,
-  createElement,
-  isValidElement,
-  use,
-  memo
-} from "react";
-var renderWebWidget = function({
-  children,
-  loader,
-  ...props
-}) {
-  if (!loader) {
-    throw new TypeError(`Missing loader.`);
-  }
-  if (children) {
-    throw new TypeError(`Children not supported.`);
-  }
-  const widget = new WebWidgetRenderer(loader, {
-    ...props,
-    // TODO children
-    children: ""
-  });
-  const localName = widget.localName;
-  const attributes = widget.attributes;
-  const innerHTML = widget.renderInnerHTMLToString().catch(
-    (err) => err instanceof Error ? err : new Error(String(err))
-  );
-  return {
-    localName,
-    attributes,
-    innerHTML
-  };
-};
-function WebWidget({
-  localName,
-  attributes,
-  innerHTML,
-  errorFallback
-}) {
-  const html = use(innerHTML);
-  if (html instanceof Error) {
-    console.error("[ReactWidget] Rendering error:", html);
-    return createElement(Fragment, null, errorFallback);
-  }
-  return createElement(localName, {
-    ...attributes,
-    dangerouslySetInnerHTML: { __html: html },
-    // NOTE: Since the innerHTML property of a widget
-    // will inevitably differ between the server and the client,
-    // this turns off hydration mismatch warnings.
-    suppressHydrationWarning: true
-  });
-}
-function resolveFallback(fallback) {
-  var _a;
-  if (fallback !== null && typeof fallback === "object" && !isValidElement(fallback) && !Array.isArray(fallback) && ("pending" in fallback || "error" in fallback)) {
-    const obj = fallback;
-    return {
-      pendingFallback: obj.pending,
-      errorFallback: (_a = obj.error) != null ? _a : obj.pending
-    };
-  }
-  return {
-    pendingFallback: fallback,
-    errorFallback: fallback
-  };
-}
-var WidgetErrorBoundary = class extends Component {
-  constructor() {
-    super(...arguments);
-    this.state = { hasError: false };
-  }
-  static getDerivedStateFromError() {
-    return { hasError: true };
-  }
-  componentDidCatch(error) {
-    console.error("[ReactWidget] Rendering error:", error);
-  }
-  render() {
-    var _a;
-    if (this.state.hasError) {
-      return (_a = this.props.fallback) != null ? _a : null;
-    }
-    return this.props.children;
-  }
-};
-function container(loader, options = {}) {
-  return memo(function ReactWidget({
-    children,
-    widget: {
-      fallback,
-      loading = ((_a) => (_a = options.loading) != null ? _a : "lazy")(),
-      serverOnly,
-      clientOnly
-    } = {},
-    ...data
-  }) {
-    var _a2;
-    const renderStage = serverOnly ? "server" : clientOnly ? "client" : options.renderStage;
-    const { pendingFallback, errorFallback } = resolveFallback(fallback);
-    return createElement(
-      WidgetErrorBoundary,
-      { fallback: errorFallback },
-      createElement(Suspense, {
-        fallback: pendingFallback,
-        children: createElement(WebWidget, {
-          errorFallback,
-          ...renderWebWidget({
-            ...options,
-            children,
-            data,
-            loader,
-            loading,
-            renderStage,
-            renderTarget: (_a2 = options.renderTarget) != null ? _a2 : "light"
-          })
-        })
-      })
-    );
-  });
-}
-
-export {
-  resolveFallback,
-  container
-};

package/dist/components-BdC3VZlV.d.ts

@@ -1,104 +0,0 @@
-import { WebWidgetRendererOptions, Loader } from '@web-widget/web-widget';
-import { ExtractWidgetProps } from '@web-widget/schema';
-import { FunctionComponent, ReactNode } from 'react';
-
-interface ReactWidgetComponent<T> extends FunctionComponent<T & ReactWidgetProps> {
-}
-/**
- * Extract the props type `P` from a widget module's default export.
- *
- * Handles multiple component paradigms so that cross-framework widgets
- * (e.g. Vue imported into React) retain their props types:
- *
- * - React: `ComponentType<P>`, `FunctionComponent<P>`, etc.
- * - Vue: components expose `$props` via a constructor signature.
- * - Fallback: `unknown` when no pattern matches.
- */
-interface WebWidgetProps {
-    base?: WebWidgetRendererOptions['base'];
-    children?: ReactNode;
-    data?: WebWidgetRendererOptions['data'];
-    import?: WebWidgetRendererOptions['import'];
-    inactive?: WebWidgetRendererOptions['inactive'];
-    loader: Loader;
-    meta?: WebWidgetRendererOptions['meta'];
-    loading?: WebWidgetRendererOptions['loading'];
-    name?: WebWidgetRendererOptions['name'];
-    renderStage?: WebWidgetRendererOptions['renderStage'];
-    renderTarget?: WebWidgetRendererOptions['renderTarget'];
-}
-type DefineWebWidgetOptions = Partial<Pick<WebWidgetRendererOptions, 'base' | 'import' | 'loading' | 'name' | 'renderStage' | 'renderTarget'>>;
-type WidgetFallback = ReactNode | {
-    pending?: ReactNode;
-    error?: ReactNode;
-};
-/**
- * Resolve a WidgetFallback into separate pending and error UI.
- * - `ReactNode`: used for both pending and error.
- * - `{ pending?, error? }`: error defaults to pending if omitted.
- */
-declare function resolveFallback(fallback: WidgetFallback | undefined): {
-    pendingFallback: ReactNode;
-    errorFallback: ReactNode;
-};
-type WidgetContainerConfig = {
-    /**
-     * Fallback UI for loading and error states.
-     *
-     * Only effective during server-side rendering: loading UI shows while the
-     * widget module renders; error UI shows if rendering fails. Both are
-     * serialized into the HTML stream — no client-side retry exists in the
-     * islands architecture.
-     *
-     * - `ReactNode` — used for both pending (Suspense) and error (ErrorBoundary).
-     * - `{ pending?, error? }` — specify independently; `error` defaults to `pending`.
-     *
-     * @example
-     * // Simple: same UI for both states
-     * <Widget widget={{ fallback: <Spinner /> }} />
-     *
-     * // Differentiated: separate pending and error UI
-     * <Widget widget={{ fallback: { pending: <Spinner />, error: <ErrorUI /> } }} />
-     */
-    fallback?: WidgetFallback;
-    /** Client-side module loading strategy: `'lazy'` loads on first render, `'eager'` on module parse, `'idle'` on browser idle. */
-    loading?: WebWidgetRendererOptions['loading'];
-    /** Widget renders only on the server (SSR), producing static HTML with no client-side mount. Mutually exclusive with `clientOnly`. */
-    serverOnly?: true;
-    /** Widget renders only on the client, producing no server HTML (empty placeholder until client mount). Mutually exclusive with `serverOnly`. */
-    clientOnly?: true;
-};
-interface ReactWidgetProps {
-    children?: ReactNode;
-    /** Container configuration, isolated from widget's own props */
-    widget?: WidgetContainerConfig;
-}
-/**
- * Container function (WebWidgetAdapter protocol).
- *
- * Wraps a widget module loader into a React component with full props
- * type inference from the source module's default export.
- *
- * For same-framework imports (React → React), props types are inferred
- * automatically. Cross-framework imports use explicit `container()` calls;
- * sources without a structural props contract can use `container<Props>()`.
- *
- * @example
- * ```tsx
- * import { container } from '@web-widget/react/adapter';
- *
- * // Same-framework: full type inference
- * const Counter = container(() => import('./Counter@widget.tsx'));
- * //    ^? ReactWidgetComponent<{ count: number }>
- *
- * <Counter count={42} />  // type-checked: ✓
- *
- * // Cross-framework: explicit container() recommended
- * const VueCounter = container(() => import('./Counter@widget.vue'));
- * <VueCounter count={42} />  // type-checked: ✓
- * ```
- */
-declare function container<M>(loader: () => Promise<M>, options?: DefineWebWidgetOptions): ReactWidgetComponent<ExtractWidgetProps<M>>;
-declare function container<Props>(loader: Loader, options?: DefineWebWidgetOptions): ReactWidgetComponent<Props>;
-
-export { type DefineWebWidgetOptions as D, type ReactWidgetComponent as R, type WebWidgetProps as W, type ReactWidgetProps as a, type WidgetContainerConfig as b, type WidgetFallback as c, container as d, resolveFallback as r };