unplugin-react-fine-grained-signals 0.1.1 → 0.2.0

package/README.md

@@ -2,7 +2,7 @@
 
 [English](README.md) | [日本語](README.ja.md)
 
-Universal bundler integration for automatic `useSignals()` insertion and the
+Universal bundler integration for automatic `useSignalTracking()` insertion and the
 optional managed render-scope transform in
 [`react-fine-grained-signals`](https://www.npmjs.com/package/react-fine-grained-signals).
 
@@ -16,8 +16,25 @@ supported bundlers.
 pnpm add -D unplugin-react-fine-grained-signals
 ```
 
-`react-fine-grained-signals` is a peer dependency. This package is ESM-only:
-use an ESM build configuration and `import`, not CommonJS `require()`.
+`react-fine-grained-signals` is a peer dependency. Node.js `^22.18.0 || >=24.11.0`
+is required — the range Babel 8, which the transform runs on, declares.
+
+Use the plugin and the runtime from the same release line (v0.2 with v0.2): the
+generated code imports runtime entry points that change between lines. When
+upgrading from v0.1, upgrade both packages together and rename the
+`@useSignals` / `@noUseSignals` comments — see the
+[v0.2 migration guide](https://github.com/sakzw/react-fine-grained-signals/blob/main/docs/migration/v0.2.md#transform-plugin).
+
+This package ships ESM only; there is no CommonJS build. An ESM build
+configuration that uses `import` is the primary setup, but a CommonJS
+configuration file (a `webpack.config.js` or `next.config.js` in a project
+without `"type": "module"`) can still load it with `require()`: every Node.js
+version in the range above loads the ESM entry points through its built-in
+`require(esm)` support. The plugin factory is the `default` export:
+
+```js
+const signals = require("unplugin-react-fine-grained-signals/webpack").default;
+```
 
 ## Vite
 
@@ -30,6 +47,65 @@ export default defineConfig({
 });
 ```
 
+### With React Compiler
+
+React Compiler must run *after* this transform: it would otherwise memoize away
+the `.value` reads before this plugin could mark the component `"use no memo"`,
+and the component would silently stop updating after its first render. List
+`signals()` before the plugin that runs the compiler:
+
+```ts
+import react from "@vitejs/plugin-react";
+import { defineConfig } from "vite";
+import signals from "unplugin-react-fine-grained-signals/vite";
+
+export default defineConfig({
+  plugins: [signals({ mode: "auto" }), react({ compiler: true })],
+});
+```
+
+In the setup this was tested with (Vite 8, `@vitejs/plugin-react` 6.1),
+`react({ compiler: true })` also needs plugin-react's optional
+`oxc-transform-react` package. Install it next to `babel-plugin-react-compiler`;
+without it the build stops with plugin-react's own "requires the optional
+`oxc-transform-react` package" error.
+
+Under Vite the order is also defended at the hook level. The plugin is
+`enforce: "pre"`, and its `transform` hook additionally declares
+`order: "pre"`, which Vite sorts on within the pre-enforced group. That makes it
+run ahead of `@vitejs/plugin-react` 6's compiler step (`react({ compiler: true })`,
+itself `enforce: "pre"` with no hook order) even when `react()` is listed first —
+before this, that order compiled the component first. This is Vite's ordering,
+not an absolute guarantee: a plugin whose transform also declares
+`order: "pre"` and is listed earlier still runs first. Keeping `signals()`
+first is therefore still the recommended configuration, and it is required
+wherever hook ordering does not apply: Rollup orders by array position alone,
+and the Babel route (`@rolldown/plugin-babel` with `reactCompilerPreset()`) has
+not been verified against this plugin.
+
+Two known limitations apply with React Compiler. Both were present in v0.1.1.
+
+- **Inline render helpers can be memoized by the compiler.** A function this
+  plugin treats as part of its caller's render gets no boundary and no
+  `"use no memo"` of its own. Examples are a PascalCase helper called as a
+  plain function (`Title()`) and a render callback such as `items.map(Row)`.
+  React Compiler can still compile that helper by itself. If the helper's JSX
+  has no dependency the compiler can see (a module-level signal read is not
+  one), the compiler caches the JSX, and the helper's output stays stale even
+  though the calling component re-renders. Put `"use no memo"` in the helper's
+  body, or render it as a component (`<Title />`) instead.
+- **An author-written `"use memo"` is kept.** The plugin does not add
+  `"use no memo"` to a function that already states a memoization directive.
+  Tested with `babel-plugin-react-compiler` 1.0:
+  - With the managed transform, the compiler does not compile the generated
+    `try` / `finally`. With the default `panicThreshold` it skips the function.
+    With `panicThreshold: "all_errors"` the build fails ("Handle TryStatement
+    without a catch clause").
+  - With `transform: "inject"`, the compiler compiles the function and can
+    memoize away its signal reads, so the component can stop updating.
+
+  Do not use `"use memo"` in functions that read signals.
+
 ## Other bundlers
 
 Use the matching entry point in the same way:
@@ -52,21 +128,22 @@ export default {
 ## Options
 
 - `mode`:
-  - `"manual"`: only an explicit first-statement imported `useSignals()` call
-    or a `@useSignals` comment on a named component/custom hook opts it in.
+  - `"manual"`: only an explicit first-statement imported `useSignalTracking()` call
+    or a `@signalTracking` comment on a named component/custom hook opts it in.
   - `"auto"` (default): additionally transforms named JSX components and
     named `useX` custom hooks that read `.value`.
   - `"all"`: additionally transforms every named JSX component. Nested
     callbacks are collected by their owning component but are never transform
     targets themselves.
 - `transform`:
-  - `"managed"` (default): adds an exact `try` / `finally` boundary, importing
+  - `"managed"` (default and recommended): adds an exact `try` / `finally` boundary, importing
     from the package's `/runtime` entry and closing the render-tracking
     window synchronously at the point the component function returns.
-  - `"inject"`: adds bare `useSignals()` for best-effort opt-in. It inserts a
-    normal `useSignals()` call without rewriting control flow, so it has the
-    same best-effort tracking boundary as a handwritten call — see
-    [the boundary design investigation](../../docs/design/use-signals-boundary-design.md)
+  - `"inject"` (supported advanced/compatibility mode): adds bare
+    `useSignalTracking()` for best-effort opt-in. It inserts a normal
+    `useSignalTracking()` call without rewriting control flow, so it has the same
+    best-effort tracking boundary as a handwritten call — see
+    [the boundary design investigation](../../development/design/use-signals-boundary-design.md)
     for the known sibling-misattribution limitation this mode can expose.
 - `reactCompiler`:
   - `"auto"` (default): marks every transformed function with `"use no memo"`,
@@ -75,8 +152,10 @@ export default {
     stops updating after the first signal write.
   - `"off"`: omits the directive. Choose it only when React Compiler is not in
     the build, or when the affected components were verified against
-    [the compatibility note](../../docs/design/react-compiler-compatibility.md).
+    [the compatibility note](../../development/design/react-compiler-compatibility.md).
 - `importSource`: overrides `react-fine-grained-signals` for a compatible wrapper.
+  The wrapper must re-export the runtime's root `useSignalTracking` and its
+  `/runtime` entry's `useManagedSignals`, which the generated code imports.
 - `reactImportSource`: an additional module specifier whose `memo` and
   `forwardRef` exports count as React's own when the plugin decides whether a
   wrapped function is a component. Recognition is additive, not a replacement:
@@ -93,7 +172,11 @@ of Hooks forbid. Recognition covers the inline definition site
 (`items.map((item) => …)`), a callback factored out and referenced by its own
 binding, whether that binding is a `const` (`const Row = …; items.map(Row)`) or
 a function declaration (`function Row() {…}` … `items.map(Row)`), and the
-optional-chained form of either (`items?.map(Row)`). Such a callback is left
+optional-chained form of either (`items?.map(Row)`). The `mapFn` of
+`Array.from(arrayLike, mapFn)` (`Array.from({ length: 5 }, Star)`) counts the
+same way, and so does a component held in an object that is destructured before
+being passed (`const { Row } = parts; items.map(Row)`, or `{ Row: Item }`).
+Such a callback is left
 alone, and its JSX and `.value` reads are collected by the component that
 invokes it — including when the callback is defined elsewhere in the same
 module, so that component is transformed even when its own body reads no
@@ -119,7 +202,7 @@ An anonymous or arrow function passed the same way —
 `observer((props) => …)` — carries no name for a boundary to attach to, and is
 left untransformed.
 
-This detection has four known limitations:
+This detection has five known limitations:
 
 - A re-assigned alias is not followed, so a PascalCase helper reached through
   `const RowAlias = Row; items.map(RowAlias)` is still treated as a component.
@@ -129,13 +212,24 @@ This detection has four known limitations:
   where hook injection is unsafe) or instantiates `Row` as its own component
   (where hook injection is what makes it update), and nothing in the file says
   which — so `Row` keeps its own hook whenever it is independently eligible.
-  Prefer inlining the callback at the call site
-  (`<Grid renderItem={(item) => <li>{item.value}</li>} />`), which the inline
-  detection above already attributes to the owning component, or state the
-  intent explicitly on the referenced function with a `@useSignals` /
-  `@noUseSignals` comment.
+  State the intent explicitly on the referenced function with a
+  `@signalTracking` / `@noSignalTracking` comment.
+
+  Writing the callback inline (`<Grid renderItem={(item) => <li>{item.value}</li>} />`)
+  is not a general fix. Its reads are attributed to the owning component, so
+  the owner is transformed, but `Grid` calls `renderItem` during its *own*
+  render, after the owner's function has returned. With the default managed
+  transform the owner's boundary is already closed by then, so the reads are
+  tracked only if `Grid` has a boundary of its own; otherwise the rendered items
+  stay stale. If `Grid` is your own component, opt it in with
+  `@signalTracking` (or have it read the signal itself).
 - A callback imported from another module is not followed, because the
   transform sees one file at a time.
+- A callback reached through an object key (`items.map(parts.Row)`, or
+  `const { Row } = parts` first) is kept off a boundary, but in `auto` mode its
+  `.value` reads are not credited to the caller. A caller that reads no signal
+  itself is then left untransformed and does not update; read the signal in the
+  caller, use `mode: "all"`, or add `@signalTracking` to the caller.
 - A function used in both roles keeps the exclusion. If `Row` is passed to
   `map` / `flatMap` / `forEach` anywhere in the module and is *also* rendered
   independently as a JSX tag (`<Row item={x} />`), the render-callback usage
@@ -144,12 +238,84 @@ This detection has four known limitations:
   independently rendered instance then has no subscription and goes stale on
   later signal writes. Split the two roles into two differently named
   functions, one per role, or opt the independently rendered function in
-  explicitly with a `@useSignals` comment.
+  explicitly with a `@signalTracking` comment.
 
 When in doubt, keep such helpers explicit: name them lowercase and without a
 `use` prefix, or opt them in manually only when they are genuinely rendered as
 components.
 
+## Components called as plain functions
+
+A PascalCase function that the module calls as a plain function — `Title()`,
+`Title?.()`, `Title!()`, or, for one held in an object, `ns.Home()`,
+`ns?.group?.Home()`, or `this.Home()` from a sibling member — is never
+mounted by React as a component of its own: its body simply runs inside the
+caller's render. It therefore never gets a boundary of its own, in any mode
+including `all`, and its JSX and `.value` reads are collected by the component
+or custom hook that makes the call:
+
+```jsx
+function Title() { return <h1>{count.value}</h1>; }
+// Outer is transformed and subscribes to `count`; Title is left as it is.
+function Outer({ show }) { return <div>{show && Title()}</div>; }
+```
+
+A boundary inside `Title` would add hooks to `Outer` that run only while `show`
+is true — a conditional hook call that React rejects ("Rendered more hooks than
+during the previous render"). A call made from an event handler, from the
+callback of `useEffect` / `useLayoutEffect` / `useInsertionEffect` /
+`useCallback` / `useMemo`, or from an async function runs outside the render,
+so its reads are not collected. Custom hooks (`useX`) are called as functions
+by design and keep their own boundary exactly as before.
+
+Known limitations:
+
+- The decision is module-wide: a single plain call anywhere in the module takes
+  away the function's own boundary. If it is *also* rendered as `<Title />`,
+  that instance has no subscription of its own and only refreshes when its
+  parent re-renders; the plugin prints a warning for this mix. Use one form
+  consistently.
+- Only calls through the function's own binding, or through the exact object
+  key path it is defined at, are recognized, and only within the module. Any
+  link of that path may be optional (`ns?.group.Home()`). Inside a member of
+  the same object literal, `this` counts as that path: `this.Home()` in a
+  method, an accessor, a `function` property value, or an arrow nested in one
+  of those. A nested `function` or class has a `this` of its own and is not
+  followed. An alias (`const T = Title; T()`), `Title.call(…)`, and calls from
+  other modules are not recognized.
+- A function held in an object can also be reached through a computed key:
+  `renderers[node.type](node)`, `renderers[key]?.(arg)`,
+  `items.map(renderers[key])`, or `this[key](arg)` from a sibling member.
+  Every slot that such an access can reach (the
+  same depth, under the same static prefix) gets no boundary of its own,
+  because a boundary there would run a variable number of times inside the
+  caller. Its reads are *not* collected by the caller, because the key is only
+  known at runtime. So a caller that reads no signal itself is not transformed
+  and does not update on the slot's signals. Read the signal in the caller, or
+  add `@signalTracking` to the caller. This also applies when the module
+  renders the same slot as `<renderers.User />`.
+- The reads are collected only when the caller is itself a component or a
+  `useX` hook. A call routed through a lowercase helper
+  (`function renderTitle() { return Title(); }`) is not followed, so nothing
+  subscribes to those reads; call the function directly from the component, or
+  render it as `<Title />`.
+- A keyed function (`ns.Home()`) is collected only when this module defines it
+  in an object literal bound to the root, or with exactly one member assignment
+  (`Card.Header = …`). A sibling's `this.Home()` is collected from the object
+  literal that member belongs to.
+- An object member the transform cannot see being called keeps its own
+  boundary. That covers a member reached through a parameter
+  (`function render(set, key) { return set[key](); }`), through an alias
+  (`const R = renderers[key]; R(arg)`), through computed destructuring
+  (`const { [key]: R } = renderers`), from an object inside an array
+  (`columns.map((c) => c.Cell(row))`), or from another module. Calling such a
+  member inline is then a hook call inside the caller, which crashes as soon
+  as the number of calls changes. Put `@noSignalTracking` on the member: it
+  then has no boundary of its own, and a transformed caller tracks its reads
+  because they run during the caller's render. Rendering that member as an
+  element (`<icons.Check />`) then gives the element no subscription of its
+  own.
+
 ## Higher-order components
 
 A component a higher-order component returns is recognized even though it has no
@@ -161,7 +327,7 @@ export const withCount = (Base) => (props) => <Base {...props} count={count.valu
 
 The inner function is the component here, and it inherits its identity from the
 factory's own binding — `withCount` — so `auto` mode subscribes it and a
-`@useSignals` (or `@noUseSignals`) comment on either the returned function or the
+`@signalTracking` (or `@noSignalTracking`) comment on either the returned function or the
 factory's declaration applies to it. Three conditions keep ordinary closures out:
 the function must be returned directly by the enclosing function (an explicit
 `return`, or an arrow's concise body); the returned function must render JSX
@@ -189,7 +355,7 @@ normally whenever it qualifies — reading a signal, rendering JSX — exactly l
 any other hook; only the returned closure inherits no name from it.
 
 The name is inherited from exactly one level out, so a factory returning a
-factory (`(a) => (b) => (props) => …`) resolves to nothing, and a `@useSignals`
+factory (`(a) => (b) => (props) => …`) resolves to nothing, and a `@signalTracking`
 comment there reports that rather than silently doing nothing. The one shape
 this cannot tell apart is a factory whose result is handed straight to an
 iteration method (`items.map(makeRow(prefix))`): that is syntactically a HOC
@@ -198,15 +364,24 @@ reference (`items.map(Row)`) or write it inline, so the owning component
 collects it.
 
 A component can also carry no binding of its own and still be named: one held
-as an object or class property — `Card.Header = () => <p>{count.value}</p>`, or
-a `class Holder { Row = () => <p>{count.value}</p> }` field — is named by its
-key, the same way `<Card.Header />` or `<ns.Row />` reaches it (a lowercase key
-stays excluded, exactly as a lowercase binding does), and a nameless default
+as an object property — `Card.Header = () => <p>{count.value}</p>` — or written as an
+object-literal method (`export const ns = { Home() { return <p>{count.value}</p>; } }`)
+is named by its key, the same way `<Card.Header />` or `<ns.Row />` reaches it
+(a lowercase key stays excluded, exactly as a lowercase binding does; getters,
+setters, async and generator methods are excluded, and so are class methods,
+which only an instance reaches), and a nameless default
 export (`export default (props) => <p>{count.value}</p>`) is named after the
 module's own file — the identity an `import App from "./App"` already gives it.
-A `this.Row = …` assignment inside a class is deliberately excluded, though —
-such a `this`-bound renderer still needs an explicit `useSignals()` call or
-`@useSignals` comment, as before this feature existed.
+Functions held by a class are deliberately excluded, though: a class field
+(`class Holder { Row = () => … }`, instance or `static`) and a `this.Row = …`
+assignment are never transformed, and a `@signalTracking` comment on one is
+reported and ignored. They are reached through `this.Row` or `Holder.Row`, which
+the transform cannot follow to tell a component from a function that
+`render()` calls directly (`this.Header()`) or passes per item
+(`items.map(this.Row)`) — and a hook boundary in either of those runs inside
+the class component's render, which React rejects. If such a function is only
+ever rendered as an element (`<this.Row />`), it may call `useSignalTracking()`
+itself; otherwise read signals in a function component instead.
 
 ## `memo` / `forwardRef` recognition
 
@@ -224,13 +399,13 @@ skipped, so signal writes stop re-rendering it. Three workarounds:
   way);
 - import `memo` / `forwardRef` directly from `"react"` at the affected call
   sites;
-- opt the component in explicitly with a `@useSignals` comment or a manual
-  `useSignals()` call.
+- opt the component in explicitly with a `@signalTracking` comment or a manual
+  `useSignalTracking()` call.
 
-## `useSignals()` opt-in and rewriting
+## `useSignalTracking()` opt-in and rewriting
 
-`@useSignals` and `@noUseSignals` apply only to their owning function; they do
-not affect nested functions. The plugin never adds a second `useSignals()`
+`@signalTracking` and `@noSignalTracking` apply only to their owning function; they do
+not affect nested functions. The plugin never adds a second `useSignalTracking()`
 call: a direct, namespace, or barrel-imported call it finds is treated as the
 function's existing opt-in. A call that is not the function's first statement,
 and any barrel-imported call, is left alone in both transform modes. A
@@ -240,21 +415,71 @@ absorbed into the generated boundary: the statement is removed and replaced by
 the managed store declaration plus the `try` / `finally` scope, so the function
 body is rewritten rather than left byte-for-byte untouched.
 
-A first-statement `useSignals()` call inside an `async` or generator function
+A first-statement `useSignalTracking()` call inside an `async` or generator function
 fails the build under the default `"managed"` transform, with
-`useSignals transform only supports synchronous, non-generator functions`. That
+`useSignalTracking transform only supports synchronous, non-generator functions`. That
 combination is already invalid React — hooks require a synchronous function
 component — so prefer fixing the function; `transform: "inject"` accepts it
 without rewriting the function, if the file must keep building unchanged.
 
+Parameter defaults are evaluated before the function body runs, so a signal
+read in one — `function Label({ v = count.value })` — would happen before the
+boundary opens and never be tracked. When a transformed function has such a
+parameter, that parameter and every parameter after it (to keep their
+evaluation order) are replaced by generated ones and bound again as the first
+statements inside the boundary, with the same `undefined`-only default rule.
+The parameter count is unchanged, so `forwardRef`'s `(props, ref)` shape is
+kept. If the body declares a name a moved default refers to, or re-declares a
+moved parameter, the move is skipped and that read stays untracked; read the
+signal in the body instead.
+
+The move keeps the default rule and the evaluation order. In TypeScript the
+generated parameter keeps the original's type and optionality, so the output
+stays valid TypeScript. The function's `length` can change, though. A
+parameter with a default does not count toward `length`, but the generated
+parameter that replaces it does. For example,
+`function useLabel(prefix?: string, value = count.value)` has a `length` of 1
+in the source and 2 after the transform. Do not rely on the `length` of a
+transformed function.
+
 ## Build integration
 
-Reapplying either transform mode is a no-op. The transform runs before other
-plugin transforms via `enforce: "pre"` on bundlers that support it (Vite,
-webpack, Rspack) — Rollup has no such concept, so list this plugin first there
-instead — and skips dependencies and non-JavaScript/TypeScript modules.
-Plain `.ts` files are parsed as TypeScript without JSX, while `.tsx`, `.jsx`,
-and JavaScript files may use JSX.
+Reapplying either transform mode is a no-op. The plugin is registered with
+`enforce: "pre"` on bundlers that support it (Vite, webpack, Rspack), and under
+Vite its transform hook also declares `order: "pre"` (see
+[With React Compiler](#with-react-compiler)). Rollup has neither concept, so
+list this plugin first there. Wherever the order of plugins or loaders is in
+your hands, put this plugin before anything that runs React Compiler or
+compiles JSX away. The transform skips dependencies and
+non-JavaScript/TypeScript modules, and never touches `.cjs` / `.cts` modules.
+The plugin matches extensions case-insensitively, so it transforms `App.TSX`
+exactly like `App.tsx`. Whether the bundler then compiles such a file the same
+way is up to the bundler, and is not guaranteed: Vite 8 does not compile
+`.JSX` / `.TSX` as JSX / TSX and fails to parse them, with or without this
+plugin. Plain `.ts` files are parsed as TypeScript without JSX, while `.tsx`,
+`.jsx`, and JavaScript files may use JSX.
+
+## Fast Refresh
+
+This limitation was present in v0.1.1. With the default managed transform and
+Vite's Oxc-based Fast Refresh, changing a transformed component's hooks
+(adding, removing, or reordering a hook) does not preserve Fast Refresh state.
+The refresh fails with "Rendered more hooks than during the previous render"
+(or "fewer"), and the page needs a full reload. The managed boundary puts the
+component's hooks inside a `try` block, where Fast Refresh does not include
+them in the component's hook signature. In the tested fixture,
+`transform: "inject"` did not have this limitation.
+
+## React Server Components
+
+The transform does not tell server modules from client modules: it reads
+neither `"use client"` / `"use server"` directives nor the bundler's
+environment or layer. A synchronous server component that reads `.value` would
+therefore receive the client-only render-tracking hook and fail when it renders
+on the server (async server components are never transformed, because async
+functions never are). In an RSC setup, keep server components out of the
+transform with `exclude` (for example by directory), opt individual ones out
+with a `@noSignalTracking` comment, or use `mode: "manual"`.
 
 ## License
 

package/dist/esbuild.d.ts

@@ -1,10 +1,10 @@
-import { a as createBundlerPlugin, c as resolveEsbuildLoader, d as ReactFineGrainedSignalsTransform, i as canTransform, l as ReactFineGrainedSignalsMode, n as EsbuildLoaderName, o as pluginName, r as ReactFineGrainedSignalsOptions, s as reactFineGrainedSignals, t as BundlerTransformOutput, u as ReactFineGrainedSignalsReactCompiler } from "./unplugin-CG9_mdcA.js";
+import { a as createBundlerPlugin, c as resolveEsbuildLoader, d as ReactFineGrainedSignalsTransform, i as canTransform, l as ReactFineGrainedSignalsMode, n as EsbuildLoaderName, o as pluginName, r as ReactFineGrainedSignalsOptions, s as reactFineGrainedSignals, t as BundlerTransformOutput, u as ReactFineGrainedSignalsReactCompiler } from "./unplugin-B9gaexDa.js";
 //#region src/esbuild.d.ts
 /** The plugin contract consumed by esbuild. */
-interface EsbuildPlugin {
+export interface EsbuildPlugin {
   name: string;
   setup(build: unknown): void | Promise<void>;
 }
 declare const _default: (options?: ReactFineGrainedSignalsOptions) => EsbuildPlugin;
 //#endregion
-export { BundlerTransformOutput, EsbuildLoaderName, EsbuildPlugin, type ReactFineGrainedSignalsMode, ReactFineGrainedSignalsOptions, type ReactFineGrainedSignalsReactCompiler, type ReactFineGrainedSignalsTransform, canTransform, createBundlerPlugin, _default as default, pluginName, reactFineGrainedSignals, resolveEsbuildLoader };
+export { BundlerTransformOutput, EsbuildLoaderName, type ReactFineGrainedSignalsMode, ReactFineGrainedSignalsOptions, type ReactFineGrainedSignalsReactCompiler, type ReactFineGrainedSignalsTransform, canTransform, createBundlerPlugin, _default as default, pluginName, reactFineGrainedSignals, resolveEsbuildLoader };

package/dist/esbuild.js

@@ -1,4 +1,4 @@
-import { a as resolveEsbuildLoader, i as reactFineGrainedSignals, n as createBundlerPlugin, r as pluginName, t as canTransform } from "./unplugin-B2_q8KNi.js";
+import { a as resolveEsbuildLoader, i as reactFineGrainedSignals, n as createBundlerPlugin, r as pluginName, t as canTransform } from "./unplugin-CPDTNSYq.js";
 //#region src/esbuild.ts
 var esbuild_default = createBundlerPlugin("esbuild");
 //#endregion

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { a as createBundlerPlugin, c as resolveEsbuildLoader, d as ReactFineGrainedSignalsTransform, i as canTransform, l as ReactFineGrainedSignalsMode, n as EsbuildLoaderName, o as pluginName, r as ReactFineGrainedSignalsOptions, s as reactFineGrainedSignals, t as BundlerTransformOutput, u as ReactFineGrainedSignalsReactCompiler } from "./unplugin-CG9_mdcA.js";
+import { a as createBundlerPlugin, c as resolveEsbuildLoader, d as ReactFineGrainedSignalsTransform, i as canTransform, l as ReactFineGrainedSignalsMode, n as EsbuildLoaderName, o as pluginName, r as ReactFineGrainedSignalsOptions, s as reactFineGrainedSignals, t as BundlerTransformOutput, u as ReactFineGrainedSignalsReactCompiler } from "./unplugin-B9gaexDa.js";
 export { BundlerTransformOutput, EsbuildLoaderName, type ReactFineGrainedSignalsMode, ReactFineGrainedSignalsOptions, type ReactFineGrainedSignalsReactCompiler, type ReactFineGrainedSignalsTransform, canTransform, createBundlerPlugin, reactFineGrainedSignals as default, reactFineGrainedSignals, pluginName, resolveEsbuildLoader };

package/dist/index.js

@@ -1,2 +1,2 @@
-import { a as resolveEsbuildLoader, i as reactFineGrainedSignals, n as createBundlerPlugin, r as pluginName, t as canTransform } from "./unplugin-B2_q8KNi.js";
+import { a as resolveEsbuildLoader, i as reactFineGrainedSignals, n as createBundlerPlugin, r as pluginName, t as canTransform } from "./unplugin-CPDTNSYq.js";
 export { canTransform, createBundlerPlugin, reactFineGrainedSignals as default, reactFineGrainedSignals, pluginName, resolveEsbuildLoader };

package/dist/loader.d.ts

@@ -10,6 +10,5 @@ interface LoaderContext {
   emitWarning?: ((warning: Error) => void) | undefined;
   emitError?: ((error: Error) => void) | undefined;
 }
-declare function reactFineGrainedSignalsLoader(this: LoaderContext, source: string, map?: unknown): void;
-//#endregion
-export { reactFineGrainedSignalsLoader as default };
+export default function reactFineGrainedSignalsLoader(this: LoaderContext, source: string, map?: unknown): void;
+//#endregion

package/dist/rollup.d.ts

@@ -1,11 +1,11 @@
-import { a as createBundlerPlugin, c as resolveEsbuildLoader, d as ReactFineGrainedSignalsTransform, i as canTransform, l as ReactFineGrainedSignalsMode, n as EsbuildLoaderName, o as pluginName, r as ReactFineGrainedSignalsOptions, s as reactFineGrainedSignals, t as BundlerTransformOutput, u as ReactFineGrainedSignalsReactCompiler } from "./unplugin-CG9_mdcA.js";
+import { a as createBundlerPlugin, c as resolveEsbuildLoader, d as ReactFineGrainedSignalsTransform, i as canTransform, l as ReactFineGrainedSignalsMode, n as EsbuildLoaderName, o as pluginName, r as ReactFineGrainedSignalsOptions, s as reactFineGrainedSignals, t as BundlerTransformOutput, u as ReactFineGrainedSignalsReactCompiler } from "./unplugin-B9gaexDa.js";
 //#region src/rollup.d.ts
 /** A minimal Rollup-compatible plugin shape. */
-interface RollupPlugin {
+export interface RollupPlugin {
   name: string;
   enforce?: "pre" | "post";
   transform?: (code: string, id: string) => BundlerTransformOutput;
 }
 declare const _default: (options?: ReactFineGrainedSignalsOptions) => RollupPlugin;
 //#endregion
-export { BundlerTransformOutput, EsbuildLoaderName, type ReactFineGrainedSignalsMode, ReactFineGrainedSignalsOptions, type ReactFineGrainedSignalsReactCompiler, type ReactFineGrainedSignalsTransform, RollupPlugin, canTransform, createBundlerPlugin, _default as default, pluginName, reactFineGrainedSignals, resolveEsbuildLoader };
+export { BundlerTransformOutput, EsbuildLoaderName, type ReactFineGrainedSignalsMode, ReactFineGrainedSignalsOptions, type ReactFineGrainedSignalsReactCompiler, type ReactFineGrainedSignalsTransform, canTransform, createBundlerPlugin, _default as default, pluginName, reactFineGrainedSignals, resolveEsbuildLoader };

package/dist/rollup.js

@@ -1,4 +1,4 @@
-import { a as resolveEsbuildLoader, i as reactFineGrainedSignals, n as createBundlerPlugin, r as pluginName, t as canTransform } from "./unplugin-B2_q8KNi.js";
+import { a as resolveEsbuildLoader, i as reactFineGrainedSignals, n as createBundlerPlugin, r as pluginName, t as canTransform } from "./unplugin-CPDTNSYq.js";
 //#region src/rollup.ts
 var rollup_default = createBundlerPlugin("rollup");
 //#endregion

package/dist/rspack.d.ts

@@ -1,9 +1,9 @@
-import { a as createBundlerPlugin, c as resolveEsbuildLoader, d as ReactFineGrainedSignalsTransform, i as canTransform, l as ReactFineGrainedSignalsMode, n as EsbuildLoaderName, o as pluginName, r as ReactFineGrainedSignalsOptions, s as reactFineGrainedSignals, t as BundlerTransformOutput, u as ReactFineGrainedSignalsReactCompiler } from "./unplugin-CG9_mdcA.js";
+import { a as createBundlerPlugin, c as resolveEsbuildLoader, d as ReactFineGrainedSignalsTransform, i as canTransform, l as ReactFineGrainedSignalsMode, n as EsbuildLoaderName, o as pluginName, r as ReactFineGrainedSignalsOptions, s as reactFineGrainedSignals, t as BundlerTransformOutput, u as ReactFineGrainedSignalsReactCompiler } from "./unplugin-B9gaexDa.js";
 //#region src/rspack.d.ts
 /** The compiler-plugin contract used by Rspack. */
-interface RspackPlugin {
+export interface RspackPlugin {
   apply(compiler: unknown): void;
 }
 declare const _default: (options?: ReactFineGrainedSignalsOptions) => RspackPlugin;
 //#endregion
-export { BundlerTransformOutput, EsbuildLoaderName, type ReactFineGrainedSignalsMode, ReactFineGrainedSignalsOptions, type ReactFineGrainedSignalsReactCompiler, type ReactFineGrainedSignalsTransform, RspackPlugin, canTransform, createBundlerPlugin, _default as default, pluginName, reactFineGrainedSignals, resolveEsbuildLoader };
+export { BundlerTransformOutput, EsbuildLoaderName, type ReactFineGrainedSignalsMode, ReactFineGrainedSignalsOptions, type ReactFineGrainedSignalsReactCompiler, type ReactFineGrainedSignalsTransform, canTransform, createBundlerPlugin, _default as default, pluginName, reactFineGrainedSignals, resolveEsbuildLoader };

package/dist/rspack.js

@@ -1,4 +1,4 @@
-import { a as resolveEsbuildLoader, i as reactFineGrainedSignals, n as createBundlerPlugin, r as pluginName, t as canTransform } from "./unplugin-B2_q8KNi.js";
+import { a as resolveEsbuildLoader, i as reactFineGrainedSignals, n as createBundlerPlugin, r as pluginName, t as canTransform } from "./unplugin-CPDTNSYq.js";
 //#region src/rspack.ts
 var rspack_default = createBundlerPlugin("rspack");
 //#endregion

package/dist/{unplugin-CG9_mdcA.d.ts → unplugin-B9gaexDa.d.ts}

@@ -7,12 +7,12 @@ type ReactFineGrainedSignalsReactCompiler = "auto" | "off";
 //#region src/unplugin.d.ts
 interface ReactFineGrainedSignalsOptions {
   /**
-   * `manual` preserves explicit useSignals() opt-in. `auto` detects signal
+   * `manual` preserves explicit useSignalTracking() opt-in. `auto` detects signal
    * reads in components and custom hooks; `all` also wraps JSX components that
    * do not statically expose a .value read.
    */
   mode?: ReactFineGrainedSignalsMode;
-  /** `managed` (default) adds an exact try/finally boundary; `inject` adds bare useSignals() for best-effort opt-in. */
+  /** `managed` (default) adds an exact try/finally boundary; `inject` adds bare useSignalTracking() for best-effort opt-in. */
   transform?: ReactFineGrainedSignalsTransform;
   /**
    * `auto` (default) marks every transformed function with `"use no memo"`, so
@@ -21,7 +21,7 @@ interface ReactFineGrainedSignalsOptions {
    * when its memoization has been verified against this library's tracking.
    */
   reactCompiler?: ReactFineGrainedSignalsReactCompiler;
-  /** Package that exports `useSignals` and its `/runtime` entry. */
+  /** Package whose root exports bare `useSignalTracking` and whose `/runtime` entry exports `useManagedSignals`. */
   importSource?: string;
   /**
    * Extra module specifier whose `memo`/`forwardRef` exports are treated as