@pitlane/dev 0.6.0 → 0.6.1

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @pitlane/dev
 
+## 0.6.1
+
+Target Remix `3.0.0-rc.2`.
+
+- Component HMR no longer instruments a PascalCase export that is not a
+  Remix component setup. `remix/ui-hmr` matches any exported PascalCase
+  function whose body returns something, so an `export async function` had
+  its body moved into a plain arrow, where the `await` no longer parsed and
+  the browser failed the module and every importer with
+  `SyntaxError: Unexpected reserved word`. A generator broke the same way on
+  `yield`, a helper returning an element was rewritten to return a function,
+  and a `clientEntry()` setup with no render function threw inside the
+  transform. The plugin now checks the shape itself and leaves the module
+  alone when one of them is present, warning when a real component in that
+  file loses its hot swap as a result.
+- The `remix` peer stays at `^3.0.0-rc.1`, which already admits rc.2. Tested
+  against Vite 8.1 (Rolldown), Vite+ 0.2 (`vp`), and `remix@3.0.0-rc.2`,
+  across the node, cloudflare, hmr, spa, and prerender fixtures.
+- Now depends on `@pitlane/crawler@^0.2.1`, its rc.2 release. The manifest
+  carries `workspace:^` and the release workflow packs with pnpm, which
+  rewrites it to the version the monorepo resolved, so crawler publishes
+  first.
+
 ## 0.6.0
 
 Target Remix `3.0.0-rc.1`.

package/README.md

@@ -12,7 +12,7 @@ npm install --save-dev @pitlane/dev
 vp add -D @pitlane/dev
 ```
 
-Requires `remix@^3.0.0-rc.1` and `vite@>=7` as peers. Tested against **Vite 8.1** (Rolldown), **Vite+ 0.2** (`vp`), and `remix@3.0.0-rc.1` — the [templates](https://github.com/pitlane-tools/templates) are the continuously tested reference.
+Requires `remix@^3.0.0-rc.1` and `vite@>=7` as peers. Tested against **Vite 8.1** (Rolldown), **Vite+ 0.2** (`vp`), and `remix@3.0.0-rc.2` — the [templates](https://github.com/pitlane-tools/templates) are the continuously tested reference.
 
 ## Quick start
 
@@ -429,7 +429,7 @@ dist/
 | ----------- | -------------- |
 | `vite`      | 8.1.5          |
 | `vite-plus` | 0.2.6          |
-| `remix`     | 3.0.0-rc.1     |
+| `remix`     | 3.0.0-rc.2     |
 | Node        | 24 LTS, 26     |
 
 Remix 3 is in prerelease; each `@pitlane/dev` release records the exact prerelease it was verified against. Rolldown is not required — the transform runs identically on generic Vite and Vite+.

package/dist/index.mjs

@@ -641,6 +641,12 @@ const SERVER_UPDATE_SETTLE_MS = 50;
 * source changes. The normalization is discarded when `ui-hmr` does not
 * instrument the module, so non-component arrows are never rewritten.
 *
+* `ui-hmr` instruments any exported PascalCase function whose body returns
+* something, which is a wider net than a Remix component: an `async` function,
+* a generator, or a plain JSX helper all match, and all three are miscompiled
+* by it. Modules holding one are left alone entirely. See
+* {@link findComponentExports}.
+*
 * The browser transform runs in the client environment and the server transform
 * in the server environment(s); both emit the standard `import.meta.hot.accept()`
 * protocol that Vite's own HMR runtime drives.
@@ -659,6 +665,11 @@ function componentHmr(serverEnvironments) {
 			} },
 			handler(code, id) {
 				let source = normalizeArrowComponents(code, id) ?? code;
+				let { supported, unsupported } = findComponentExports(source, id);
+				if (unsupported.length > 0) {
+					if (supported.length > 0) this.warn(`Component HMR is off for this module. These exports are PascalCase but are not Remix component setups, which are synchronous and return a render function: ${unsupported.join(", ")}. Moving or renaming them lets ${supported.join(", ")} hot-swap again.`);
+					return;
+				}
 				let result = serverEnvironments.has(this.environment.name) ? transformComponentsForServer(source, {
 					importSource: "remix",
 					moduleUrl: id,
@@ -770,9 +781,110 @@ function getNormalizableArrow(init) {
 /** A Remix component setup returns a render function; that is the HMR signal. */
 function returnsRenderFunction(arrow) {
 	let body = arrow.body;
-	if (body.type === "ArrowFunctionExpression" || body.type === "FunctionExpression") return true;
-	if (body.type === "BlockStatement") return body.body.some((statement) => statement.type === "ReturnStatement" && (statement.argument?.type === "ArrowFunctionExpression" || statement.argument?.type === "FunctionExpression"));
-	return false;
+	if (body.type !== "BlockStatement") return isRenderFunction(body);
+	return isRenderFunction(getRenderArgument(body));
+}
+/**
+* The expression `ui-hmr` hoists out of a setup body and re-registers on every
+* update: the argument of the first top-level `return`. Mirrors its own
+* `getRenderArgument`, so this module agrees with it about what it will match.
+*/
+function getRenderArgument(body) {
+	return body.body.find((node) => node.type === "ReturnStatement")?.argument ?? void 0;
+}
+function isRenderFunction(node) {
+	return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+}
+/**
+* Splits a module's PascalCase exports into the ones `remix/ui-hmr` can
+* instrument and the ones it would instrument but miscompile.
+*
+* All `ui-hmr` asks is whether an exported PascalCase function returns
+* something, which catches three shapes it cannot handle. An `async` setup or
+* a generator has its body moved into a plain arrow, so the `await` or `yield`
+* stops parsing and the module — along with everything importing it — fails to
+* load. A function returning an element rather than a render function is
+* rewritten to return a function, so anything calling it directly gets the
+* wrong value back. A `clientEntry()` setup with no `return` at all throws
+* inside the transform.
+*
+* Instrumentation is per module, so a single one of those turns component HMR
+* off for the whole file. Losing the hot swap beats emitting a module that
+* does not run.
+*/
+function findComponentExports(code, id) {
+	let program = parseSync(id, code).program;
+	let exportedNames = getExportedNames(program);
+	let supported = [];
+	let unsupported = [];
+	for (let item of program.body) {
+		let statement = item.type === "ExportNamedDeclaration" && item.declaration ? item.declaration : item;
+		let directExport = statement !== item;
+		if (statement.type === "FunctionDeclaration") {
+			let name = statement.id?.name;
+			if (!name || !isPascalCase(name)) continue;
+			if (!directExport && !exportedNames.has(name)) continue;
+			if (!statement.body || !getRenderArgument(statement.body)) continue;
+			if (isComponentSetup(statement)) supported.push(name);
+			else unsupported.push(name);
+			continue;
+		}
+		if (statement.type !== "VariableDeclaration") continue;
+		for (let declarator of statement.declarations) {
+			if (declarator.id.type !== "Identifier") continue;
+			let name = declarator.id.name;
+			if (!isPascalCase(name)) continue;
+			if (!directExport && !exportedNames.has(name)) continue;
+			let init = declarator.init;
+			if (!init) continue;
+			let setup = getClientEntrySetup(init);
+			if (!setup) {
+				if (init.type !== "FunctionExpression") continue;
+				if (!init.body || !getRenderArgument(init.body)) continue;
+				setup = init;
+			}
+			if (isComponentSetup(setup)) supported.push(name);
+			else unsupported.push(name);
+		}
+	}
+	return {
+		supported,
+		unsupported
+	};
+}
+/** The documented shape: a synchronous setup that returns a render function. */
+function isComponentSetup(setup) {
+	if (setup.async || setup.generator || !setup.body) return false;
+	return isRenderFunction(getRenderArgument(setup.body));
+}
+/**
+* The setup inside `clientEntry(url, setup)`, including the
+* `clientEntry(url, wrap(setup))` form `ui-hmr` also unwraps.
+*/
+function getClientEntrySetup(init) {
+	if (init.type !== "CallExpression") return void 0;
+	if (init.callee.type !== "Identifier" || init.callee.name !== "clientEntry") return void 0;
+	let candidate = init.arguments[1];
+	if (candidate?.type === "FunctionExpression") return candidate;
+	if (candidate?.type !== "CallExpression") return void 0;
+	let inner = candidate.arguments[0];
+	return inner?.type === "FunctionExpression" ? inner : void 0;
+}
+/**
+* PascalCase names re-exported under their own name (`export { Card }`), which
+* `ui-hmr` instruments alongside `export function`. An alias
+* (`export { CardImpl as Card }`) is not one of them.
+*/
+function getExportedNames(program) {
+	let names = /* @__PURE__ */ new Set();
+	for (let item of program.body) {
+		if (item.type !== "ExportNamedDeclaration") continue;
+		for (let { exported, local } of item.specifiers) {
+			if (local.type !== "Identifier" || exported.type !== "Identifier") continue;
+			if (local.name === exported.name && isPascalCase(local.name)) names.add(local.name);
+		}
+	}
+	return names;
 }
 /** Source of the arrow's parameter list, always parenthesized. */
 function getParamsSource(code, arrow) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pitlane/dev",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "remix() — the Remix 3 Vite plugin: build orchestration, clientEntry() hydration transform, dev server with component and server-data HMR, SPA mode, build-time prerendering, and preview for any Vite or Vite+ project.",
   "keywords": [
     "pitlane",
@@ -42,13 +42,13 @@
     "@hiogawa/vite-plugin-fullstack": "0.0.11",
     "magic-string": "^0.30.21",
     "oxc-parser": "^0.141.0",
-    "@pitlane/crawler": "^0.2.0"
+    "@pitlane/crawler": "^0.2.1"
   },
   "devDependencies": {
     "@cloudflare/vite-plugin": "^1.31.0",
     "@types/node": "^25.5.0",
     "playwright": "1.61.1",
-    "remix": "3.0.0-rc.1",
+    "remix": "3.0.0-rc.2",
     "typescript": "^7.0.2",
     "vite": "^8.1.5",
     "vite-plus": "^0.2.6",