@thomaflette/eslint-plugin-solid-2 0.2.0 → 0.2.1

package/README.md

@@ -63,7 +63,9 @@ The `flat/recommended` and `flat/recommended-type-checked` names are aliases for
 | `prefer-show`                       | Uses `<Show>` for idiomatic reactive JSX conditionals.                                                   |
 | `self-closing-comp`                 | Keeps empty JSX elements consistently self-closing.                                                      |
 
-Every rule has focused documentation in [docs](./docs).
+Every rule has focused documentation in [docs](./docs). The
+[dev-diagnostic coverage matrix](./docs/dev-diagnostic-coverage.md) records which Solid runtime
+diagnostics are covered statically and which remain intentionally runtime-only.
 
 ## Design principles
 

package/docs/adr/0001-only-false-positive-free-rules.md

@@ -58,3 +58,8 @@ props are valid code that static analysis cannot prove safe or unsafe.
   proven from bindings or nominal Solid accessor types, and recognizes JSX, nested closures,
   reactive callbacks, and `untrack` as safe execution contexts. It does not restore the deleted
   heuristic's guesses about arbitrary helper calls.
+- Runtime-state mirrors for `PENDING_ASYNC_FORBIDDEN_SCOPE`, `SETTLED_CLEANUP_UNOWNED`, and the
+  `NO_OWNER_*` diagnostics were prototyped and rejected. Whether they fire depends on the source's
+  pending state or the active owner at execution; an owner-backed scheduler and an already-settled
+  async memo are valid counterexamples to static callback/source heuristics. Solid's exact runtime
+  diagnostics own these cases.

package/docs/dev-diagnostic-coverage.md

@@ -0,0 +1,29 @@
+# Solid 2 dev-diagnostic coverage
+
+The plugin complements Solid's
+[dev-mode diagnostics](https://github.com/solidjs/solid/blob/next/documentation/solid-2.0/08-dev-diagnostics.md).
+It reports a diagnostic statically only when the source proves the invalid runtime context. Dynamic
+ownership, pending state, disposal state, and scheduler behavior remain with the runtime.
+
+| Solid diagnostic                 | Static coverage                                                                                  | Rule or owner                                                                 |
+| -------------------------------- | ------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------- |
+| `REACTIVE_WRITE_IN_OWNED_SCOPE`  | Strong, sound subset                                                                             | `no-owned-scope-writes`                                                       |
+| `PENDING_ASYNC_UNTRACKED_READ`   | Partial; catches provable untracked reads, regardless of pending state                           | `no-stale-props-alias`, `no-destructure`, `no-untracked-read-in-effect-apply` |
+| `ASYNC_OUTSIDE_LOADING_BOUNDARY` | Runtime only; loading ancestry and render timing are dynamic                                     | Solid runtime                                                                 |
+| `CLEANUP_IN_FORBIDDEN_SCOPE`     | Strong                                                                                           | `no-leaf-owner-operations`                                                    |
+| `SETTLED_CLEANUP_UNOWNED`        | Runtime only; ownership at execution determines whether cleanup is honored                       | Solid runtime                                                                 |
+| `PRIMITIVE_IN_FORBIDDEN_SCOPE`   | Strong for owner-creating primitives; plain value signals/stores follow current runtime behavior | `no-leaf-owner-operations`                                                    |
+| Invalid cleanup return           | Type-level cases are intentionally delegated                                                     | TypeScript and Solid runtime                                                  |
+| `flush()` in forbidden scope     | Strong                                                                                           | `no-leaf-owner-operations`                                                    |
+| Potential infinite loop          | Runtime only; depends on executed graph behavior                                                 | Solid runtime                                                                 |
+| `STRICT_READ_UNTRACKED`          | Strong, sound subset of binding-proven reads                                                     | `no-stale-props-alias`, `no-destructure`, `no-untracked-read-in-effect-apply` |
+| `PENDING_ASYNC_FORBIDDEN_SCOPE`  | Runtime only; the source must actually be pending when read                                      | Solid runtime                                                                 |
+| `NO_OWNER_EFFECT`                | Runtime only; the active owner is execution-context state                                        | Solid runtime                                                                 |
+| `NO_OWNER_CLEANUP`               | Runtime only; the active owner is execution-context state                                        | Solid runtime                                                                 |
+| `NO_OWNER_BOUNDARY`              | Runtime only; the active owner is execution-context state                                        | Solid runtime                                                                 |
+| `RUN_WITH_DISPOSED_OWNER`        | Runtime only; disposal is dynamic                                                                | Solid runtime                                                                 |
+
+Some plugin rules have no corresponding runtime diagnostic. For example,
+`no-reactive-read-after-await` catches dependency loss that native async continuation semantics make
+indistinguishable from an intentional untracked read at runtime. The control-flow and JSX rules
+likewise protect static structure or style rather than mirroring a dev diagnostic.

package/docs/no-leaf-owner-operations.md

@@ -34,11 +34,15 @@ onSettled(() => {
 
 ## Good
 
-```ts
-onSettled(() => {
-  const id = setInterval(tick, 1000);
-  return () => clearInterval(id);
-});
+```tsx
+function Ticker() {
+  onSettled(() => {
+    const id = setInterval(tick, 1000);
+    return () => clearInterval(id);
+  });
+
+  return <output>{time()}</output>;
+}
 ```
 
 ```ts
@@ -49,17 +53,21 @@ createTrackedEffect(() => {
 ```
 
 ```ts
-createEffect(
-  () => count(),
-  () => {
-    queueMicrotask(() => flush());
-  },
-);
+onSettled(() => {
+  queueMicrotask(() => {
+    setOpen(true);
+    flush(); // Commit the update before reading the resulting DOM.
+    dialog.focus();
+  });
+});
 ```
 
 ## Notes
 
 - Only **direct** calls inside the forbidden callback body are checked; nested helper function definitions are allowed.
+- `flush()` is normally unnecessary because Solid flushes updates automatically. Use it only at an
+  imperative boundary that must observe the updated DOM synchronously; a microtask scheduled from a
+  leaf-owner callback is outside that callback's non-reentrant flush cycle.
 - Calls are matched by binding (a direct, aliased, or namespace `solid-js` import, or an unresolved
   global) — a same-named function from another package is not flagged. Type-aware mode also follows
   re-export chains.

package/docs/no-owned-scope-writes.md

@@ -3,9 +3,9 @@
 Disallow writing to signals/stores or calling actions inside component bodies and reactive compute
 scopes.
 
-This matches Solid 2's `SIGNAL_WRITE_IN_OWNED_SCOPE` behavior. In these places, derive values instead of writing state back into the graph.
-It also matches beta.17's `ACTION_CALLED_IN_OWNED_SCOPE` error: actions belong at imperative
-boundaries such as event handlers.
+This matches Solid 2's `REACTIVE_WRITE_IN_OWNED_SCOPE` behavior. In these places, derive values
+instead of writing state back into the graph. It also matches the runtime's
+`ACTION_CALLED_IN_OWNED_SCOPE` error: actions belong at imperative boundaries such as event handlers.
 
 ## Bad
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thomaflette/eslint-plugin-solid-2",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Sound ESLint rules for Solid 2 reactivity and idiomatic control flow.",
   "keywords": [
     "eslint",