@reactra/language-tools 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Akhil Shastri and the Reactra contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,109 @@
+# @reactra/language-tools
+
+TypeScript / IDE tooling for the Reactra DSL. It gives the terse Reactra `.tsx` DSL
+**full, precise type-checking** — in your editor and in CI — without changing how the
+DSL feels to write.
+
+## The problem it solves
+
+A Reactra `.tsx` file is not plain TypeScript. The moment a tool sees `state count = 0`,
+`inject store cartStore`, or `await(user) { … } pending { … }`, stock `tsc` and your
+editor's TypeScript language service give up — they can't parse it, so you lose
+type-checking, hover, autocomplete, and go-to-definition on the parts that matter most.
+
+`@reactra/language-tools` fixes this with a **shadow file**: for each DSL file it
+synthesizes a parallel, fully-typed TypeScript projection (the "shadow"), runs the *real*
+TypeScript type system over the shadow, and maps every diagnostic back to your DSL source
+line. You write terse DSL; you get the type safety of hand-written React.
+
+> **No suppression.** Earlier approaches hid the DSL from TypeScript (suppressing the
+> errors it couldn't understand). This package does the opposite — it *synthesizes* a
+> file TypeScript fully understands, so the types are real, not silenced.
+
+## Does my editor work?
+
+| Where | What you install | What you get |
+|---|---|---|
+| **VS Code · Cursor** | the Reactra editor extension (bundles the Volar language plugin) | live red squiggles, hover types, autocomplete, go-to-def on DSL bindings |
+| **Zed · neovim · any LSP editor** | the standalone LSP — `reactra-lsp-server` (stdio) | the same, via your editor's generic LSP client |
+| **CI · terminal · any editor or none** | `reactra-tsc` | headless, whole-project type-checking that fails the build on type errors |
+
+All three are **one engine** — the same shadow emitter and the same Volar `LanguagePlugin`.
+So your editor and your CI can't disagree: if the editor is green, `reactra-tsc` is green.
+
+## `reactra-tsc` — the CLI
+
+`reactra-tsc` is to Reactra what `vue-tsc` is to Vue: a drop-in `tsc` that understands the
+DSL. Use it in CI or a pre-commit hook so type errors fail the build regardless of which
+editor (if any) a developer uses.
+
+```jsonc
+// package.json
+{
+  "scripts": {
+    "type-check": "reactra-tsc --noEmit -p tsconfig.json"
+  }
+}
+```
+
+```sh
+$ reactra-tsc --noEmit -p tsconfig.json
+src/pages/cart.tsx(14,7): error TS2322: Type 'string' is not assignable to type 'number'.
+```
+
+The error points at your **DSL** line — the shadow is generated fresh at check time and
+never committed, so there's no stale artifact to drift.
+
+> Today this is a clean gate for apps built from the fully-typed constructs. If your app
+> uses one of the known-gap constructs below (`uses`, `query T[]`, store `input` types),
+> `reactra-tsc` will also report advisory false positives on correct code — see **Current
+> coverage**, and prefer an allow-listed gate until those gaps close.
+
+## How it works (the anti-drift guarantee)
+
+The shadow emitter consumes the **same `FileGraph`** the Reactra compiler's code-generation
+pass consumes (`compile(source).graph`). Editor tooling and the build run off one parsed
+model of your file, so a *grammar* change propagates to both through a single edit — the
+shadow can never disagree with the build about how your file **parses**.
+
+The two emitters still make *lowering* decisions independently off that shared graph (the
+shadow emits typed TS; Pass 9 emits React), so lowering parity — e.g. that a store is
+exported in the shadow exactly when the compiler exports it — is held construct-by-construct
+by the `F`-gate suite, not for free by graph-sharing alone.
+
+```
+DSL source ──> compile() ──> FileGraph ──┬──> Pass 9 codegen ──> React 19 .tsx  (what ships)
+                                         └──> reactra2tsx ─────> shadow .tsx     (what tsc checks)
+```
+
+## Package surface
+
+- `createReactraLanguagePlugin()` — the Volar `LanguagePlugin` (consumed by the editor
+  extension and `reactra-tsc`).
+- `emitShadow(graph, source, rewrites?)` — the shadow emitter (`reactra2tsx`).
+- `reactra-tsc` — the CLI binary.
+- `reactra-lsp-server` — the standalone, editor-agnostic LSP binary.
+
+## Current coverage
+
+Type fidelity is proven construct-by-construct against the real emitter output (the
+`F`-gate suite): components (page + plain), `state` (+ the kept `setX` escape hatch),
+`derived` (expression + block-IIFE), `action`, `resource`, all eight `inject store` forms,
+`inject service`, `param` and store `input` annotations, `query` (incl. `T[]`/union casts),
+`meta`, `errorBoundary`, the `view` body, and `await/pending/error`.
+
+Known gaps still being closed:
+
+- a `resource` fetcher that isn't a plain entity-name call (e.g. a `.then()` chain) lowers as
+  `Resource<unknown>` — name it with an intermediate `const` to recover the type.
+
+Recently closed: `param X: T` and store `input X: T` annotations (now threaded through the
+preprocessor and AST, so a route param and every route-store `input` field projects at its
+declared type — the central route-store data-flow is fully typed); `uses <behaviour>` injected
+names (`undo`/`redo`/… typed from the behaviour registry); and `query T[]` (cast to the declared
+type). With those closed, the repo's example type-check gate (`scripts/typecheck-examples.mjs`)
+is **blocking on DSL source** — any example `.tsx` type error fails it.
+
+> **Honest status:** the typed constructs — now including `param`/`input` — are sound today.
+> The one remaining gap is the non-entity-name `resource` fetcher above, which degrades to
+> `Resource<unknown>` (a soundness-preserving widening, not a false positive).

package/dist/cli/reactra-tsc.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=reactra-tsc.d.ts.map

package/dist/cli/reactra-tsc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactra-tsc.d.ts","sourceRoot":"","sources":["../../src/cli/reactra-tsc.ts"],"names":[],"mappings":""}

package/dist/cli/reactra-tsc.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+// reactra-tsc — headless type-checker for Reactra DSL files in CI.
+// Per plan/phase-4-language-tools-spec.md §7 (reactra-tsc CLI / M3 gate).
+//
+// Equivalent to vue-tsc: runTsc() + the Reactra language plugin.
+// Usage: reactra-tsc --noEmit --project tsconfig.json
+//
+// runTsc patches fs.readFileSync to intercept the TypeScript source and inject
+// Volar's proxyCreateProgram. It must be pointed at `typescript/lib/tsc.js`
+// (not `typescript/bin/tsc`) because the bin shim (`require('../lib/tsc.js')`)
+// uses a path pattern that runTsc's shim-detection regex cannot handle on TS 5.9+;
+// `lib/tsc.js` uses the `module.exports = require("./_tsc.js")` pattern that
+// the regex expects.
+import { runTsc } from "@volar/typescript/lib/quickstart/runTsc.js";
+import { createReactraLanguagePlugin } from "../language-plugin.js";
+import { createRequire } from "node:module";
+// Surface the R026 missing-`;` advisory by default in the headless gate — this is
+// the deliberate "strict check" context (a migrated v2 codebase has `;` everywhere,
+// so it stays quiet; un-migrated code gets the migration nudge). Opt out with
+// `REACTRA_R026=0`. `??=` respects an explicit value the caller already set.
+process.env.REACTRA_R026 ??= "1";
+// Node.js CJS interop — require.resolve for the tsc library path.
+const require = createRequire(import.meta.url);
+runTsc(require.resolve("typescript/lib/tsc.js"), { extraSupportedExtensions: [".tsx"], extraExtensionsToRemove: [] }, (_ts, _options) => [createReactraLanguagePlugin()]);
+//# sourceMappingURL=reactra-tsc.js.map

package/dist/cli/reactra-tsc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactra-tsc.js","sourceRoot":"","sources":["../../src/cli/reactra-tsc.ts"],"names":[],"mappings":";AACA,mEAAmE;AACnE,0EAA0E;AAC1E,EAAE;AACF,iEAAiE;AACjE,sDAAsD;AACtD,EAAE;AACF,+EAA+E;AAC/E,4EAA4E;AAC5E,+EAA+E;AAC/E,mFAAmF;AACnF,6EAA6E;AAC7E,qBAAqB;AAErB,OAAO,EAAE,MAAM,EAAE,MAAM,4CAA4C,CAAA;AACnE,OAAO,EAAE,2BAA2B,EAAE,MAAM,uBAAuB,CAAA;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,kFAAkF;AAClF,oFAAoF;AACpF,8EAA8E;AAC9E,6EAA6E;AAC7E,OAAO,CAAC,GAAG,CAAC,YAAY,KAAK,GAAG,CAAA;AAEhC,kEAAkE;AAClE,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AAE9C,MAAM,CACJ,OAAO,CAAC,OAAO,CAAC,uBAAuB,CAAC,EACxC,EAAE,wBAAwB,EAAE,CAAC,MAAM,CAAC,EAAE,uBAAuB,EAAE,EAAE,EAAE,EACnE,CAAC,GAAG,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC,2BAA2B,EAAE,CAAC,CACnD,CAAA"}

package/dist/diagnostic-plugin.d.ts

@@ -0,0 +1,12 @@
+import type { LanguageServicePlugin } from "@volar/language-server";
+/**
+ * Service plugin that surfaces a Reactra DSL parse failure (annotated on the
+ * shadow VirtualCode by the language plugin) as a single LSP011 diagnostic.
+ *
+ * Register it in the standalone server's service-plugin array
+ * (`lsp/server.ts`). It is a no-op for any document without a
+ * `reactraParseError` annotation (clean DSL, non-DSL, or a transient
+ * dangling-dot edit that recovered).
+ */
+export declare const createReactraDiagnosticPlugin: () => LanguageServicePlugin;
+//# sourceMappingURL=diagnostic-plugin.d.ts.map

package/dist/diagnostic-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostic-plugin.d.ts","sourceRoot":"","sources":["../src/diagnostic-plugin.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAA;AAoEnE;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,QAAO,qBA4B/C,CAAA"}

package/dist/diagnostic-plugin.js

@@ -0,0 +1,112 @@
+// Reactra standalone-LSP diagnostic service plugin (framework-review §B2).
+// Per plan/phase-4-language-tools-spec.md §6 (standalone LSP) + the VS Code
+// Extension spec §9 (LSP011 — Reactra DSL syntax error).
+//
+// THE Zed/neovim gap closer. The standalone Volar language server
+// (`lsp/server.ts`) previously returned a bare empty shadow on a DSL parse
+// error, so a malformed file showed NOTHING in those editors. The language
+// plugin now annotates that empty shadow with `reactraParseError` (C2); this
+// service plugin reads it off the document's root VirtualCode and surfaces it as
+// a single LSP011 diagnostic at the mapped DSL position (C1/C4/C5).
+//
+// The VirtualCode IS the channel (C1) — no URI-keyed side-channel map.
+//
+// Scope (C6): this is a `provideDiagnostics` service-plugin hook, which the
+// hybrid tsserver path (`ts-plugin.ts`, `getSemanticDiagnostics`) does NOT see.
+// VS Code is covered by the legacy `vscode-extension/server` (its own LSP011),
+// so there is no VS Code gap; B2 closes only the standalone-server editors.
+//
+// LSP011 (C5) is already allocated (VS Code Extension spec §9) — same semantic,
+// different surface. We reuse it; no new code. Message format + range rule
+// mirror the legacy `computeLSP011` provider exactly.
+import { URI } from "vscode-uri";
+// vscode-languageserver-protocol's DiagnosticSeverity.Error === 1. Written as a
+// literal so the protocol package stays a type-only import (matches the rest of
+// this stack — no runtime value import of the protocol enums).
+const SEVERITY_ERROR = 1;
+/**
+ * Build the LSP011 diagnostic range from the mapped DSL offset (C4):
+ *   - offset present → start = offset, end = end of that DSL line; if the offset
+ *     is at/after the line end (EOF / line-end), fall back to a visible span
+ *     from the first non-whitespace char (zero-width is invisible).
+ *   - offset null → file-level: line 0, start → end of line 0.
+ * Mirrors the legacy `computeLSP011` rule so the two surfaces agree.
+ */
+const rangeFor = (text, dslOffset) => {
+    const lines = text.split("\n");
+    if (dslOffset === null) {
+        const line0 = lines[0] ?? "";
+        return {
+            start: { line: 0, character: 0 },
+            end: { line: 0, character: Math.max(1, line0.length) },
+        };
+    }
+    // Convert the absolute DSL offset → { line, character }.
+    let line = 0;
+    let lineStart = 0;
+    for (let i = 0; i < dslOffset && i < text.length; i++) {
+        if (text[i] === "\n") {
+            line++;
+            lineStart = i + 1;
+        }
+    }
+    const lineText = lines[line] ?? "";
+    let startChar = dslOffset - lineStart;
+    let endChar = lineText.length;
+    if (startChar >= endChar) {
+        const firstNonWs = lineText.search(/\S/);
+        startChar = firstNonWs < 0 ? 0 : firstNonWs;
+        endChar = Math.max(lineText.length, startChar + 1);
+    }
+    return {
+        start: { line, character: startChar },
+        end: { line, character: endChar },
+    };
+};
+/**
+ * Read the parse-error annotation off the document's root VirtualCode.
+ * `context.language.scripts.get(uri).generated.root` is the same object the
+ * language plugin returned from `buildVirtualCode`/`updateVirtualCode`.
+ */
+const readParseError = (context, documentUri) => {
+    const script = context.language.scripts.get(URI.parse(documentUri));
+    const root = script?.generated?.root;
+    return root?.reactraParseError;
+};
+/**
+ * Service plugin that surfaces a Reactra DSL parse failure (annotated on the
+ * shadow VirtualCode by the language plugin) as a single LSP011 diagnostic.
+ *
+ * Register it in the standalone server's service-plugin array
+ * (`lsp/server.ts`). It is a no-op for any document without a
+ * `reactraParseError` annotation (clean DSL, non-DSL, or a transient
+ * dangling-dot edit that recovered).
+ */
+export const createReactraDiagnosticPlugin = () => ({
+    name: "reactra-diagnostics",
+    capabilities: {
+        diagnosticProvider: {
+            interFileDependencies: false,
+            workspaceDiagnostics: false,
+        },
+    },
+    create(context) {
+        return {
+            provideDiagnostics(document) {
+                const parseError = readParseError(context, document.uri);
+                if (!parseError)
+                    return [];
+                return [
+                    {
+                        severity: SEVERITY_ERROR,
+                        code: "LSP011",
+                        source: "reactra",
+                        message: `Reactra DSL syntax error: ${parseError.message}`,
+                        range: rangeFor(document.getText(), parseError.dslOffset),
+                    },
+                ];
+            },
+        };
+    },
+});
+//# sourceMappingURL=diagnostic-plugin.js.map

package/dist/diagnostic-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostic-plugin.js","sourceRoot":"","sources":["../src/diagnostic-plugin.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { emitShadow } from "./shadow/index.ts";
+export type { ShadowResult, ShadowMapping } from "./shadow/index.ts";
+export { createReactraLanguagePlugin } from "./language-plugin.ts";
+export type { ReactraVirtualCode } from "./language-plugin.ts";
+export { createReactraDiagnosticPlugin } from "./diagnostic-plugin.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAC9C,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACpE,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAA;AAClE,YAAY,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAE9D,OAAO,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAA"}

package/dist/index.js

@@ -0,0 +1,7 @@
+// @reactra/language-tools — public entry.
+// Per plan/phase-4-language-tools-spec.md §1 (Package layout).
+export { emitShadow } from "./shadow/index.js";
+export { createReactraLanguagePlugin } from "./language-plugin.js";
+// B2: the standalone-LSP parse-error diagnostic service plugin (LSP011).
+export { createReactraDiagnosticPlugin } from "./diagnostic-plugin.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,0CAA0C;AAC1C,+DAA+D;AAE/D,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAE9C,OAAO,EAAE,2BAA2B,EAAE,MAAM,sBAAsB,CAAA;AAElE,yEAAyE;AACzE,OAAO,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAA"}

package/dist/language-plugin.d.ts

@@ -0,0 +1,44 @@
+import type { LanguagePlugin, VirtualCode } from "@volar/language-core";
+/**
+ * A Reactra shadow VirtualCode that can carry a DSL parse error (B2 / C2).
+ *
+ * When `buildVirtualCode` cannot produce a usable shadow (a genuine DSL syntax
+ * error, after dangling-dot recovery has failed), it returns an empty-but-
+ * ANNOTATED VirtualCode: the `export {}` placeholder snapshot keeps downstream
+ * TypeScript happy (no spurious TS noise), while `reactraParseError` carries the
+ * mapped DSL position + cleaned message. The standalone LSP's diagnostic service
+ * plugin (`createReactraDiagnosticPlugin`) reads this field off
+ * `scripts.get(uri).generated.root` and surfaces it as LSP011 (Zed/neovim).
+ *
+ * The VirtualCode IS the channel — no URI-keyed side-channel map (C1).
+ */
+export interface ReactraVirtualCode extends VirtualCode {
+    /**
+     * Set only on a genuine parse failure. `dslOffset` is the error position in
+     * DSL-source coordinates (null when the babel error carried no usable
+     * position → file-level diagnostic). `message` is the babel message with the
+     * trailing `(line:col)` stripped (the range conveys position).
+     */
+    reactraParseError?: {
+        dslOffset: number | null;
+        message: string;
+    };
+}
+/**
+ * Create the Reactra Volar language plugin.
+ *
+ * Register this plugin with a Volar language service to enable type-checking,
+ * completions, hover, and goto-definition for Reactra DSL `.tsx` files.
+ *
+ * The `typescript.getServiceScript` property is required by `@volar/typescript`'s
+ * `createProxyLanguageService` to route TypeScript diagnostics from the shadow
+ * back to DSL positions. Without it, `getSemanticDiagnostics` returns nothing.
+ *
+ * @example
+ * ```ts
+ * import { createReactraLanguagePlugin } from "@reactra/language-tools/language-plugin"
+ * const plugin = createReactraLanguagePlugin()
+ * ```
+ */
+export declare const createReactraLanguagePlugin: () => LanguagePlugin<string>;
+//# sourceMappingURL=language-plugin.d.ts.map

package/dist/language-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-plugin.d.ts","sourceRoot":"","sources":["../src/language-plugin.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EACV,cAAc,EACd,WAAW,EAGZ,MAAM,sBAAsB,CAAA;AAsC7B;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,kBAAmB,SAAQ,WAAW;IACrD;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE;QAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CAClE;AAsOD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,2BAA2B,QAAO,cAAc,CAAC,MAAM,CAqElE,CAAA"}