docs: prepare Solid 2 RC docs for publication

Polish async and JSX guidance, curate generated references, and add staging safeguards so the rebuilt documentation can be reviewed safely before launch.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: ryansolid

.github/workflows/static_checks.yml

@@ -4,6 +4,7 @@ on:
   push:
     branches:
       - main
+      - v2-rebuild
   pull_request:
     branches:
       - main
@@ -40,3 +41,6 @@ jobs:
 
       - name: Check formatting
         run: pnpm exec prettier . --check
+
+      - name: Tone lint
+        run: pnpm lint:tone

.prettierignore

@@ -1,4 +1,5 @@
 .solid
+.pnpm-store
 dist
 *.min.*
 package-lock.json

WRITING.md

@@ -404,16 +404,17 @@ This is a list of Solid-specific words and what they mean. In the second column,
 
 These are technical; use them with the default assumption that the reader doesn't know what they mean.
 
-| Terms to use                      | Terms not to use                                                   | Definition                                                                                                                                                                               |
-| --------------------------------- | ------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Computation, reactive computation | _Not to be confused with_: computed                                | A scope that automatically reruns when its dependencies change (it doesn't necessarily _have_ dependencies).                                                                             |
-| Core primitive                    | API function                                                       | A primitive provided by the Solid core library; this typically provides reactive behaviors but not necessarily ( `createContext` does not).                                              |
-| Custom primitive                  | hook                                                               | A primitive created outside of the Solid core library; i.e., a function that provides a composable piece of functionality.                                                               |
-| Ownership, owns                   |                                                                    | A one-to-many relationship between computations; if a computation "owns" one or more other computations, all its owned computations are cleaned up when it is cleaned up.                |
-| Primitive                         | Hook                                                               | A function that serves as a building block of reactivity or behavior. usually begins with `create` or `use`.                                                                             |
-| Reactive value                    | Signal (don't use to describe a general reactive value)            | A value that can be tracked (includes signals, memos, properties of `props` and stores).                                                                                                 |
-| Reactivity                        |                                                                    | A system for writing expressions or behaviors that depend on certain values and execute when those values change.                                                                        |
-| Root                              |                                                                    | A computation that has no owner. created by `createRoot`.                                                                                                                                |
-| Scope                             | _Not to be confused with:_ root, effect (specific kinds of scopes) | A body of a function (a chunk of code).                                                                                                                                                  |
-| Solid                             | SolidJS (unless outside the community/internal writings)           | A JavaScript framework made up of a library (providing primitives and UI utilities) and a compiler (allowing you to write in JSX). Its differentiating feature is its reactivity system. |
-| Tracking scope                    | Tracking context, reactive context, reactive scope, reactive root  | A scope that, when run, Solid automatically tracks all read signals                                                                                                                      |
+| Terms to use                      | Terms not to use                                                    | Definition                                                                                                                                                                               |
+| --------------------------------- | ------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Computation, reactive computation | _Not to be confused with_: computed                                 | A scope that automatically reruns when its dependencies change (it doesn't necessarily _have_ dependencies).                                                                             |
+| Held update                       | Transition, except in an API name or internal implementation detail | An update whose commit waits for async work after a previous answer exists. The current committed view remains visible until the work settles.                                           |
+| Core primitive                    | API function                                                        | A primitive provided by the Solid core library; this typically provides reactive behaviors but not necessarily ( `createContext` does not).                                              |
+| Custom primitive                  | hook                                                                | A primitive created outside of the Solid core library; i.e., a function that provides a composable piece of functionality.                                                               |
+| Ownership, owns                   |                                                                     | A one-to-many relationship between computations; if a computation "owns" one or more other computations, all its owned computations are cleaned up when it is cleaned up.                |
+| Primitive                         | Hook                                                                | A function that serves as a building block of reactivity or behavior. usually begins with `create` or `use`.                                                                             |
+| Reactive value                    | Signal (don't use to describe a general reactive value)             | A value that can be tracked (includes signals, memos, properties of `props` and stores).                                                                                                 |
+| Reactivity                        |                                                                     | A system for writing expressions or behaviors that depend on certain values and execute when those values change.                                                                        |
+| Root                              |                                                                     | A computation that has no owner. created by `createRoot`.                                                                                                                                |
+| Scope                             | _Not to be confused with:_ root, effect (specific kinds of scopes)  | A body of a function (a chunk of code).                                                                                                                                                  |
+| Solid                             | SolidJS (unless outside the community/internal writings)            | A JavaScript framework made up of a library (providing primitives and UI utilities) and a compiler (allowing you to write in JSX). Its differentiating feature is its reactivity system. |
+| Tracking scope                    | Tracking context, reactive context, reactive scope, reactive root   | A scope that, when run, Solid automatically tracks all read signals                                                                                                                      |

env.d.ts

@@ -1,7 +1,6 @@
 interface ImportMetaEnv {
-	readonly VITE_ORAMA_ENDPOINT: string;
-	readonly VITE_ORAMA_API_KEY: string;
-	readonly VITE_ORAMA_SECURE_PROXY: string;
+	readonly VITE_ORAMA_PROJECT_ID?: string;
+	readonly VITE_ORAMA_PUBLIC_API_KEY?: string;
 }
 
 interface ImportMeta {
@@ -12,7 +11,8 @@ declare namespace NodeJS {
 	interface ProcessEnv {
 		readonly ORAMA_PROJECT_ID: string;
 		readonly ORAMA_DATASOURCE_ID: string;
-		readonly ORAMA_PUBLIC_API_KEY: string;
 		readonly ORAMA_PRIVATE_API_KEY: string;
+		readonly SITE_URL?: string;
+		readonly DEPLOY_PRIME_URL?: string;
 	}
 }

public/images/diagrams/async-update-timeline.svg

@@ -4,7 +4,11 @@ import { fileURLToPath } from "node:url";
 
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const OUTPUT_DIR = resolve(ROOT, process.argv[2] ?? "dist");
-const SITE_ORIGIN = new URL(process.env.SITE_URL ?? "https://docs.solidjs.com");
+const SITE_ORIGIN = new URL(
+	process.env.SITE_URL ??
+		process.env.DEPLOY_PRIME_URL ??
+		"https://docs.solidjs.com"
+);
 const INDEX_PATH = resolve(OUTPUT_DIR, "llms.txt");
 const FULL_PATH = resolve(OUTPUT_DIR, "llms-full.txt");