flux-md 0.17.0 → 0.18.0

package/README.md

@@ -25,8 +25,10 @@ constructs Web Workers). For **server-side / static rendering of finished
 content** — SSR, React Server Components, build steps — use the worker-free,
 synchronous [`flux-md/server`](#server-side-rendering) entry. The framework packages — `react`,
 `vue`, `svelte`, `solid-js` — are all **optional** peer dependencies; you only
-need the one whose binding you import. The core (`flux-md`, `flux-md/client`,
-`flux-md/dom`, `flux-md/element`) needs none.
+need the one whose binding you import. The framework-free entries
+(`flux-md/client`, `flux-md/dom`, `flux-md/element`, and `flux-md/server`) need
+none. (The bare `flux-md` entry re-exports the React component surface, so it
+pulls `react` — import from `flux-md/client` if you want a framework-free core.)
 
 > **Vite — one-line config.** Vite's dependency pre-bundling (esbuild) hoists
 > the wasm-bindgen glue into `.vite/deps/`, which breaks the relative
@@ -44,43 +46,35 @@ need the one whose binding you import. The core (`flux-md`, `flux-md/client`,
 
 <a id="nextjs"></a>
 
-> **Next.js (App Router) — two requirements.** Verified on **Next.js 16** with
-> **Turbopack** (the default for both `next dev` and `next build`). The same two
-> requirements apply under webpack. Because flux-md ships TypeScript source:
+> **Next.js (App Router) — one requirement.** Works on **Next.js** with
+> **Turbopack** (the default for both `next dev` and `next build`) or webpack.
+> Since 0.17.0 flux-md ships **compiled ESM**, so **no `transpilePackages` or
+> other build config is needed** — earlier versions required it only because the
+> package shipped raw TypeScript, which Next does not compile inside
+> `node_modules`. That no longer applies.
 >
-> 1. **Transpile the package.** Next does not compile `node_modules` TypeScript
->    by default — without this, Turbopack errors with *"Unknown module type"* on
->    `react.tsx`. Add flux-md to `transpilePackages`:
+> **Use it from a Client Component.** `<FluxMarkdown>` uses React hooks (and
+> spawns a Web Worker on mount), so it must carry `"use client"` — it can't be
+> a Server Component. (It is still SSR-safe: on the server it renders an empty
+> shell and only starts streaming after hydration, so there's no SSR crash —
+> the constraint is hooks, not the worker.)
 >
->    ```ts
->    // next.config.ts
->    import type { NextConfig } from "next";
->    const nextConfig: NextConfig = { transpilePackages: ["flux-md"] };
->    export default nextConfig;
->    ```
+> ```tsx
+> "use client";
+> import { FluxMarkdown } from "flux-md/react";
 >
-> 2. **Use it from a Client Component.** `<FluxMarkdown>` uses React hooks (and
->    spawns a Web Worker on mount), so it must carry `"use client"` — it can't be
->    a Server Component. (It is still SSR-safe: on the server it renders an empty
->    shell and only starts streaming after hydration, so there's no SSR crash —
->    the constraint is hooks, not the worker.)
->
->    ```tsx
->    "use client";
->    import { FluxMarkdown } from "flux-md/react";
->
->    export default function Answer({ stream }: { stream: AsyncIterable<string> }) {
->      return <FluxMarkdown stream={stream} />;
->    }
->    ```
+> export default function Answer({ stream }: { stream: AsyncIterable<string> }) {
+>   return <FluxMarkdown stream={stream} />;
+> }
+> ```
 >
->    **Create the `stream` in Client Component code, not in a Server Component.**
->    A `Response` / `ReadableStream` / `AsyncIterable` isn't serializable, so it
->    can't be passed as a prop from a Server Component (e.g. `page.tsx`) — that
->    throws *"Only plain objects can be passed to Client Components."* Pass a
->    serializable prop (a URL, the chat messages) from the server and open the
->    stream on the client — e.g. `stream={await fetch("/api/chat")}` from a client
->    effect, or the `useFluxStream` hook (see [Quick start](#quick-start)).
+> **Create the `stream` in Client Component code, not in a Server Component.**
+> A `Response` / `ReadableStream` / `AsyncIterable` isn't serializable, so it
+> can't be passed as a prop from a Server Component (e.g. `page.tsx`) — that
+> throws *"Only plain objects can be passed to Client Components."* Pass a
+> serializable prop (a URL, the chat messages) from the server and open the
+> stream on the client — e.g. `stream={await fetch("/api/chat")}` from a client
+> effect, or the `useFluxStream` hook (see [Quick start](#quick-start)).
 >
 > That's it — Turbopack bundles the worker and emits the `.wasm` to
 > `_next/static/media` itself, so no extra asset/loader config is needed (and the
@@ -427,12 +421,15 @@ const html = renderToString("# Hello\n\n**world**");   // sync HTML string, no w
 ```
 
 For React server rendering (RSC, static generation, or SSR), use
-`<FluxMarkdownStatic>` — a hookless, RSC-safe component that renders finished
-content with the same `components` overrides (inline/block component tags
-dispatch on the server too):
+`<FluxMarkdownStatic>` from **`flux-md/server/react`** — a hookless, RSC-safe
+component that renders finished content with the same `components` overrides
+(inline/block component tags dispatch on the server too). It lives in its own
+subpath so the core `flux-md/server` above stays importable with no `react`
+installed:
 
 ```tsx
-import { initFlux, FluxMarkdownStatic } from "flux-md/server";
+import { initFlux } from "flux-md/server";
+import { FluxMarkdownStatic } from "flux-md/server/react";
 
 await initFlux();
 export default function Doc({ md }: { md: string }) {
@@ -451,10 +448,11 @@ export default function Doc({ md }: { md: string }) {
   bundler-resolved asset. On edge runtimes pass bytes yourself:
   `initFluxSync(wasmBytes)`.
 - **`renderToString(md, { config })`** — synchronous HTML string, **zero React
-  dependency**.
+  dependency** (imports cleanly with no `react` installed).
 - **`parseToBlocks(md, { config })`** — the block array, for custom rendering.
-- **`<FluxMarkdownStatic content config components />`** — synchronous React tree
-  for **render-once** contexts; render it with your framework's server renderer
+- **`<FluxMarkdownStatic content config components />`** (from
+  `flux-md/server/react`) — synchronous React tree for **render-once** contexts;
+  render it with your framework's server renderer
   (`renderToStaticMarkup`, RSC, …). For live streaming, client-side code
   highlighting, or Mermaid, render `<FluxMarkdown>` on the client instead — it's a
   separate component. (If you SSR-then-hydrate, use the *same* component on both
@@ -1161,7 +1159,7 @@ re-snapping during streaming, so treat smooth following there as best-effort.
 │              microtask, calls WASM   │
 └──┬──── ffi ───────────────────────────┘
    ▼
-┌── Rust → WASM (~150 KB after opt) ────┐
+┌── Rust → WASM (~170 KB after opt) ────┐
 │  StreamParser:                        │
 │    buffer: append-only                │
 │    committed_offset                   │

package/dist/client.d.ts

@@ -132,6 +132,7 @@ export declare class FluxClient {
     private coalesce;
     private rafHandle;
     private finalizePending;
+    private epoch;
     private appendedBytes;
     private patchCount;
     private totalParseMicros;

package/dist/client.js

@@ -141,6 +141,12 @@ class FluxPool {
         }
       }
       for (const sid of pw.streamIds) this.dispatch(sid, msg);
+      try {
+        pw.worker.terminate();
+      } catch {
+      }
+      const idx = this.workers.indexOf(pw);
+      if (idx !== -1) this.workers.splice(idx, 1);
       return;
     }
     this.dispatch(msg.streamId, msg);
@@ -200,8 +206,13 @@ class FluxClient {
   coalesce = false;
   rafHandle = null;
   // Set by finalize(); the next patch's emit flushes synchronously (a 'done'
-  // notification must not be deferred a frame) and clears it.
+  // notification must not be deferred a frame) and clears it. Belt-and-suspenders
+  // alongside the per-patch `final` flag, which is the authoritative signal.
   finalizePending = false;
+  // Stream generation, bumped on reset(). Stamped on every worker message and
+  // echoed back on each patch; a patch whose epoch is older than this is a
+  // pre-reset straggler and is dropped before it can repopulate the cleared store.
+  epoch = 0;
   // Perf
   appendedBytes = 0;
   patchCount = 0;
@@ -259,7 +270,8 @@ class FluxClient {
    * multiplexing (pick() is unchanged and remains the only path to create()).
    */
   ensureAcquired() {
-    if (this.pw) return this.pw;
+    if (this.pw && !this.pw.failed) return this.pw;
+    this.pw = null;
     const { streamId, pw } = this.pool.acquire((msg) => this.onMessage(msg));
     this.streamId = streamId;
     this.pw = pw;
@@ -283,12 +295,12 @@ class FluxClient {
   append(chunk) {
     const pw = this.ensureAcquired();
     if (this.firstAppendMs === 0) this.firstAppendMs = performance.now();
-    this.pool.send(pw, { type: "append", streamId: this.streamId, chunk, config: this.firstConfig() });
+    this.pool.send(pw, { type: "append", streamId: this.streamId, chunk, config: this.firstConfig(), epoch: this.epoch });
   }
   finalize() {
     const pw = this.ensureAcquired();
     this.finalizePending = true;
-    this.pool.send(pw, { type: "finalize", streamId: this.streamId, config: this.firstConfig() });
+    this.pool.send(pw, { type: "finalize", streamId: this.streamId, config: this.firstConfig(), epoch: this.epoch });
   }
   /**
    * Pipe a source straight in: read it to completion, `append()` each chunk,
@@ -402,8 +414,9 @@ class FluxClient {
     this.contentDone = false;
     this.cancelFrame();
     this.finalizePending = false;
+    this.epoch += 1;
     const pw = this.ensureAcquired();
-    this.pool.send(pw, { type: "reset", streamId: this.streamId });
+    this.pool.send(pw, { type: "reset", streamId: this.streamId, epoch: this.epoch });
     if (hadContent) this.emit(true);
   }
   destroy() {
@@ -511,6 +524,7 @@ class FluxClient {
   onMessage(msg) {
     switch (msg.type) {
       case "patch": {
+        if (msg.epoch !== void 0 && msg.epoch < this.epoch) break;
         let patch;
         try {
           patch = JSON.parse(msg.patch);
@@ -527,7 +541,7 @@ class FluxClient {
         this.wasmMemoryBytes = msg.wasmMemoryBytes;
         this.patchCount += 1;
         this.lastPatchMs = performance.now();
-        const sync = this.finalizePending;
+        const sync = this.finalizePending || msg.final === true;
         this.finalizePending = false;
         this.emit(sync);
         if (this.onBlock) {

package/dist/server-react.d.ts

@@ -0,0 +1,32 @@
+import { type ReactNode } from "react";
+import type { Components, ParserConfig } from "./types.js";
+interface FluxMarkdownStaticProps {
+    /** The complete markdown to render (server/static use is for finished content). */
+    content: string;
+    /** Parser config (same shape as the streaming client's). */
+    config?: ParserConfig;
+    /** Tag-level / block-kind / component-tag overrides (see {@link Components}). */
+    components?: Components;
+    /** Appended to the root's `className` (the `flux-md` class is always present). */
+    className?: string;
+    /** Set on the root element. */
+    id?: string;
+    /** Set on the root element (e.g. `"article"`). */
+    role?: string;
+    /** Make the root a live region (parity with `<FluxMarkdown>` if you hydrate). */
+    "aria-live"?: "off" | "polite" | "assertive";
+    /** Live-region atomicity; pair with `aria-live`. */
+    "aria-atomic"?: boolean;
+}
+/**
+ * Synchronous, worker-free React rendering of finished markdown — a React Server
+ * Component, or any one-shot SSR / static render. Emits the `flux-md` root +
+ * per-block structure with the same `components` overrides (inline/block
+ * component tags dispatch here too). Requires `initFlux` (or `initFluxSync`)
+ * from `flux-md/server` to have run. Uses no hooks (RSC-safe). A **render-once**
+ * component: for live streaming, client-side code highlighting, or Mermaid use
+ * the client `<FluxMarkdown>` instead (and if you SSR-then-hydrate, render the
+ * *same* component on both sides).
+ */
+export declare function FluxMarkdownStatic({ content, config, components, className, id, role, "aria-live": ariaLive, "aria-atomic": ariaAtomic, }: FluxMarkdownStaticProps): ReactNode;
+export {};

package/dist/server-react.js

@@ -0,0 +1,48 @@
+import { createElement } from "react";
+import { htmlToReact } from "./html-to-react.js";
+import { blockKindProps } from "./react.js";
+import { parseToBlocks } from "./server.js";
+function renderStaticBlock(block, components) {
+  const kind = block.kind.type;
+  if (components) {
+    if (kind === "Component") {
+      const tag = block.kind.data?.tag;
+      const override = tag && components[tag] || components.Component;
+      if (override) return createElement(override, { key: block.id, ...blockKindProps(block, components) });
+    }
+    const blockOverride = components[kind];
+    if (blockOverride) return createElement(blockOverride, { key: block.id, ...blockKindProps(block, components) });
+  }
+  const className = "flux-block flux-block-" + kind.toLowerCase() + (block.open ? " flux-open" : "") + (block.speculative ? " flux-speculative" : "");
+  if (components) {
+    return createElement("div", { key: block.id, className }, htmlToReact(block.html, components));
+  }
+  return createElement("div", { key: block.id, className, dangerouslySetInnerHTML: { __html: block.html } });
+}
+function FluxMarkdownStatic({
+  content,
+  config,
+  components,
+  className,
+  id,
+  role,
+  "aria-live": ariaLive,
+  "aria-atomic": ariaAtomic
+}) {
+  const blocks = parseToBlocks(content, { config });
+  const comps = components && Object.keys(components).length > 0 ? components : void 0;
+  return createElement(
+    "div",
+    {
+      className: className ? `flux-md ${className}` : "flux-md",
+      id,
+      role,
+      "aria-live": ariaLive,
+      "aria-atomic": ariaAtomic
+    },
+    blocks.map((b) => renderStaticBlock(b, comps))
+  );
+}
+export {
+  FluxMarkdownStatic
+};

package/dist/server.d.ts

@@ -1,5 +1,4 @@
-import { type ReactNode } from "react";
-import type { Block, Components, ParserConfig } from "./types.js";
+import type { Block, ParserConfig } from "./types.js";
 /** Has the sync WASM core been initialized in this process? */
 export declare function isFluxReady(): boolean;
 /** Initialize the sync core from compiled WASM bytes (or a `WebAssembly.Module`).
@@ -24,38 +23,9 @@ export declare function parseToBlocks(markdown: string, opts?: {
  * Render a complete markdown string to an HTML string synchronously — no worker,
  * no React. The concatenated per-block HTML (XSS-safe with `unsafeHtml` off).
  * For component dispatch / a `<FluxMarkdown>`-matching React tree, use
- * {@link FluxMarkdownStatic} with your framework's server renderer instead.
+ * `FluxMarkdownStatic` from `flux-md/server/react` with your framework's server
+ * renderer instead.
  */
 export declare function renderToString(markdown: string, opts?: {
     config?: ParserConfig;
 }): string;
-interface FluxMarkdownStaticProps {
-    /** The complete markdown to render (server/static use is for finished content). */
-    content: string;
-    /** Parser config (same shape as the streaming client's). */
-    config?: ParserConfig;
-    /** Tag-level / block-kind / component-tag overrides (see {@link Components}). */
-    components?: Components;
-    /** Appended to the root's `className` (the `flux-md` class is always present). */
-    className?: string;
-    /** Set on the root element. */
-    id?: string;
-    /** Set on the root element (e.g. `"article"`). */
-    role?: string;
-    /** Make the root a live region (parity with `<FluxMarkdown>` if you hydrate). */
-    "aria-live"?: "off" | "polite" | "assertive";
-    /** Live-region atomicity; pair with `aria-live`. */
-    "aria-atomic"?: boolean;
-}
-/**
- * Synchronous, worker-free React rendering of finished markdown — a React Server
- * Component, or any one-shot SSR / static render. Emits the `flux-md` root +
- * per-block structure with the same `components` overrides (inline/block
- * component tags dispatch here too). Requires {@link initFlux} (or
- * {@link initFluxSync}) to have run. Uses no hooks (RSC-safe). A **render-once**
- * component: for live streaming, client-side code highlighting, or Mermaid use
- * the client `<FluxMarkdown>` instead (and if you SSR-then-hydrate, render the
- * *same* component on both sides).
- */
-export declare function FluxMarkdownStatic({ content, config, components, className, id, role, "aria-live": ariaLive, "aria-atomic": ariaAtomic, }: FluxMarkdownStaticProps): ReactNode;
-export {};

package/dist/server.js

@@ -1,7 +1,4 @@
-import { createElement } from "react";
 import initWasmAsync, { FluxParser, initSync } from "./wasm/flux_md_core.js";
-import { htmlToReact } from "./html-to-react.js";
-import { blockKindProps } from "./react.js";
 let ready = false;
 function isFluxReady() {
   return ready;
@@ -75,49 +72,7 @@ function parseToBlocks(markdown, opts) {
 function renderToString(markdown, opts) {
   return parseToBlocks(markdown, opts).map((b) => b.html).join("");
 }
-function renderStaticBlock(block, components) {
-  const kind = block.kind.type;
-  if (components) {
-    if (kind === "Component") {
-      const tag = block.kind.data?.tag;
-      const override = tag && components[tag] || components.Component;
-      if (override) return createElement(override, { key: block.id, ...blockKindProps(block, components) });
-    }
-    const blockOverride = components[kind];
-    if (blockOverride) return createElement(blockOverride, { key: block.id, ...blockKindProps(block, components) });
-  }
-  const className = "flux-block flux-block-" + kind.toLowerCase() + (block.open ? " flux-open" : "") + (block.speculative ? " flux-speculative" : "");
-  if (components) {
-    return createElement("div", { key: block.id, className }, htmlToReact(block.html, components));
-  }
-  return createElement("div", { key: block.id, className, dangerouslySetInnerHTML: { __html: block.html } });
-}
-function FluxMarkdownStatic({
-  content,
-  config,
-  components,
-  className,
-  id,
-  role,
-  "aria-live": ariaLive,
-  "aria-atomic": ariaAtomic
-}) {
-  const blocks = parseToBlocks(content, { config });
-  const comps = components && Object.keys(components).length > 0 ? components : void 0;
-  return createElement(
-    "div",
-    {
-      className: className ? `flux-md ${className}` : "flux-md",
-      id,
-      role,
-      "aria-live": ariaLive,
-      "aria-atomic": ariaAtomic
-    },
-    blocks.map((b) => renderStaticBlock(b, comps))
-  );
-}
 export {
-  FluxMarkdownStatic,
   initFlux,
   initFluxSync,
   isFluxReady,

package/dist/types-core.d.ts

@@ -336,13 +336,16 @@ export type ToWorker = {
     streamId: number;
     chunk: string;
     config?: ParserConfig;
+    epoch?: number;
 } | {
     type: "finalize";
     streamId: number;
     config?: ParserConfig;
+    epoch?: number;
 } | {
     type: "reset";
     streamId: number;
+    epoch?: number;
 } | {
     type: "dispose";
     streamId: number;
@@ -357,6 +360,8 @@ export type FromWorker = {
     parseMicros: number;
     retainedBytes: number;
     wasmMemoryBytes: number;
+    final?: boolean;
+    epoch?: number;
 } | {
     type: "error";
     streamId: number;

package/dist/worker-core.d.ts

@@ -44,6 +44,7 @@ export declare class WorkerCore {
     private pending;
     private totalAppended;
     private finalizePending;
+    private epochs;
     private flushScheduled;
     private ready;
     constructor(deps: WorkerCoreDeps);
@@ -53,8 +54,12 @@ export declare class WorkerCore {
     markReady(): void;
     private getOrCreate;
     private dispose;
+    /** free() a stream's parser, swallowing a throw from a poisoned WASM instance
+     *  so teardown can never escape the message loop. */
+    private safeFree;
     private emitPatch;
     private scheduleFlush;
     private flush;
     private doFinalize;
+    private postParseError;
 }

package/dist/worker-core.js

@@ -9,6 +9,11 @@ class WorkerCore {
   pending = /* @__PURE__ */ new Map();
   totalAppended = /* @__PURE__ */ new Map();
   finalizePending = /* @__PURE__ */ new Set();
+  // Per-stream generation, echoed on emitted patches so the client can drop a
+  // patch produced before a reset (see FromWorker.epoch). A microtask flush
+  // drains `pending` between messages, so the epoch at emit time is always the
+  // epoch the buffered input was appended under.
+  epochs = /* @__PURE__ */ new Map();
   flushScheduled = false;
   ready = false;
   /** Handle one message from the main thread (append/finalize/reset/dispose). */
@@ -17,6 +22,9 @@ class WorkerCore {
     if ((msg.type === "append" || msg.type === "finalize") && msg.config) {
       this.config.set(id, msg.config);
     }
+    if (msg.type !== "dispose" && msg.epoch !== void 0) {
+      this.epochs.set(id, msg.epoch);
+    }
     switch (msg.type) {
       case "append":
         this.pending.set(id, (this.pending.get(id) ?? "") + msg.chunk);
@@ -27,7 +35,7 @@ class WorkerCore {
         else this.doFinalize(id);
         break;
       case "reset":
-        this.parsers.get(id)?.free();
+        this.safeFree(id);
         this.parsers.delete(id);
         this.pending.delete(id);
         this.finalizePending.delete(id);
@@ -57,14 +65,23 @@ class WorkerCore {
     return p;
   }
   dispose(streamId) {
-    this.parsers.get(streamId)?.free();
+    this.safeFree(streamId);
     this.parsers.delete(streamId);
     this.config.delete(streamId);
     this.pending.delete(streamId);
     this.finalizePending.delete(streamId);
     this.totalAppended.delete(streamId);
+    this.epochs.delete(streamId);
+  }
+  /** free() a stream's parser, swallowing a throw from a poisoned WASM instance
+   *  so teardown can never escape the message loop. */
+  safeFree(streamId) {
+    try {
+      this.parsers.get(streamId)?.free();
+    } catch {
+    }
   }
-  emitPatch(streamId, patch, parser, parseMicros) {
+  emitPatch(streamId, patch, parser, parseMicros, final) {
     this.deps.post({
       type: "patch",
       streamId,
@@ -72,7 +89,9 @@ class WorkerCore {
       appendedBytes: this.totalAppended.get(streamId) ?? 0,
       parseMicros,
       retainedBytes: parser.retainedBytes(),
-      wasmMemoryBytes: this.deps.memBytes()
+      wasmMemoryBytes: this.deps.memBytes(),
+      final,
+      epoch: this.epochs.get(streamId)
     });
   }
   scheduleFlush() {
@@ -92,9 +111,9 @@ class WorkerCore {
         const patch = parser.append(chunk);
         const dt = (performance.now() - t0) * 1e3;
         this.totalAppended.set(streamId, (this.totalAppended.get(streamId) ?? 0) + chunk.length);
-        this.emitPatch(streamId, patch, parser, dt);
+        this.emitPatch(streamId, patch, parser, dt, false);
       } catch (e) {
-        this.deps.post({ type: "error", streamId, message: e instanceof Error ? e.message : String(e) });
+        this.postParseError(streamId, e);
       }
     }
   }
@@ -110,11 +129,25 @@ class WorkerCore {
         this.totalAppended.set(streamId, (this.totalAppended.get(streamId) ?? 0) + buffered.length);
       }
       const patch = parser.finalize();
-      this.emitPatch(streamId, patch, parser, 0);
+      this.emitPatch(streamId, patch, parser, 0, true);
     } catch (e) {
-      this.deps.post({ type: "error", streamId, message: e instanceof Error ? e.message : String(e) });
+      this.postParseError(streamId, e);
     }
   }
+  // A WASM trap (stack overflow / unreachable / OOM) throws a
+  // WebAssembly.RuntimeError and POISONS the singleton instance shared by every
+  // stream on this worker — so it is escalated to `fatal`, which the pool treats
+  // as a worker-level failure (eviction + terminate). A plain Error (e.g. a
+  // parser-construction failure) stays a recoverable per-stream error.
+  postParseError(streamId, e) {
+    const fatal = typeof WebAssembly !== "undefined" && typeof WebAssembly.RuntimeError === "function" && e instanceof WebAssembly.RuntimeError;
+    this.deps.post({
+      type: "error",
+      streamId,
+      message: e instanceof Error ? e.message : String(e),
+      fatal
+    });
+  }
 }
 export {
   WorkerCore

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flux-md",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Zero-dep streaming markdown for the browser. Rust→WASM core, Web Worker per stream, incremental parse with speculative closure.",
   "type": "module",
   "sideEffects": ["./dist/worker.js", "./dist/styles.css"],
@@ -11,6 +11,7 @@
     "./client": { "types": "./dist/client.d.ts", "import": "./dist/client.js" },
     "./react": { "types": "./dist/react.d.ts", "import": "./dist/react.js" },
     "./server": { "types": "./dist/server.d.ts", "import": "./dist/server.js" },
+    "./server/react": { "types": "./dist/server-react.d.ts", "import": "./dist/server-react.js" },
     "./dom": { "types": "./dist/dom.d.ts", "import": "./dist/dom.js" },
     "./element": { "types": "./dist/element.d.ts", "import": "./dist/element.js" },
     "./vue": { "types": "./dist/vue.d.ts", "import": "./dist/vue.js" },
@@ -23,7 +24,8 @@
   },
   "files": [
     "dist",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md"
   ],
   "peerDependencies": {
     "react": ">=18",