@pitlane/dev 0.5.1 → 0.6.1

package/CHANGELOG.md

@@ -1,5 +1,54 @@
 # @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`.
+
+- Raised the `remix` peer dependency to `^3.0.0-rc.1` (from
+  `^3.0.0-beta.10`). The plugin itself is unchanged: `remix()`, its
+  `prerender` option, and `@pitlane/dev/runtime` all behave as they did in
+  0.5.1.
+- Now depends on `@pitlane/crawler@^0.2.0`, its Remix rc.1 release. The
+  manifest carries `workspace:^` and the release workflow packs with pnpm,
+  which rewrites it to the version the monorepo resolved. 0.5.1 shipped
+  `^0.1.0`, which `0.2.0` does not satisfy, so the crawler release only reaches
+  `remix({ prerender })` users through this bump.
+- Two rc.1 breaking changes land in the app code this plugin's guides
+  document, not in the plugin. The documented `app/entry.browser.ts` reads the
+  frame-targeting attributes off a submit button, and rc.1 renamed all of them
+  into the `data-rmx-*` namespace, so `rmx-target`, `rmx-src`, and
+  `rmx-reset-scroll` become `data-rmx-target`, `data-rmx-src`, and
+  `data-rmx-reset-scroll`. Nothing raises an error when they are missed: rc.1's
+  runtime matches only the prefixed names, so a stale attribute is inert and
+  frame navigation silently falls back to a document load. `createAssetServer`
+  also replaced `fileMap` with directory-based `mounts`, which affects an app
+  that configures its own asset server rather than letting this plugin do it.
+- Tested against Vite 8.1 (Rolldown), Vite+ 0.2 (`vp`), and
+  `remix@3.0.0-rc.1`, across the node, cloudflare, hmr, and prerender fixtures.
+
 ## 0.5.1
 
 Fixes an unusable 0.5.0 on npm.

package/README.md

@@ -12,7 +12,7 @@ npm install --save-dev @pitlane/dev
 vp add -D @pitlane/dev
 ```
 
-Requires `remix@^3.0.0-beta.10` and `vite@>=7` as peers. Tested against **Vite 8.1** (Rolldown), **Vite+ 0.2** (`vp`), and `remix@3.0.0-beta.10` — 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
 
@@ -123,14 +123,14 @@ remix({
 });
 ```
 
-| Option               | Type                               | Default               | Purpose                                                                                                                                                           |
-| -------------------- | ---------------------------------- | --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `server`             | `boolean`                          | `true`                | Whether the app has a server. Pass `false` for [SPA mode](#spa-mode), which ignores every option below.                                                           |
-| `prerender`          | `boolean \| string[] \| fn \| obj` | none                  | Render paths to static HTML at build time. See [Prerendering](#prerendering).                                                                                     |
-| `clientEntry`        | `string \| false`                  | `"app/entry.browser"` | Client entry module. Pass `false` for fully server-rendered apps with no hydration.                                                                               |
-| `serverEntry`        | `string`                           | `"app/entry.server"`  | Server entry module, built as `dist/ssr/index.js`.                                                                                                                |
-| `serverEnvironments` | `string[]`                         | `["ssr"]`             | Environment names the `clientEntry()` transform treats as "server".                                                                                               |
-| `serverHandler`      | `boolean`                          | `true`                | Serve dev requests through your server entry. Set `false` when `@cloudflare/vite-plugin`, `@netlify/vite-plugin`, or `nitro/vite` owns dev-time request handling. |
+| Option               | Type                               | Default               | Purpose                                                                                                                                                                                                  |
+| -------------------- | ---------------------------------- | --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `server`             | `boolean`                          | `true`                | Whether the app has a server. Pass `false` for [SPA mode](#spa-mode), which ignores every option below.                                                                                                  |
+| `prerender`          | `boolean \| string[] \| fn \| obj` | none                  | Render paths to static HTML at build time. See [Prerendering](#prerendering).                                                                                                                            |
+| `clientEntry`        | `string \| false`                  | `"app/entry.browser"` | Client entry module. Pass `false` for fully server-rendered apps with no hydration.                                                                                                                      |
+| `serverEntry`        | `string`                           | `"app/entry.server"`  | Server entry module, built as `dist/ssr/index.js`.                                                                                                                                                       |
+| `serverEnvironments` | `string[]`                         | `["ssr"]`             | Environment names the `clientEntry()` transform treats as "server".                                                                                                                                      |
+| `serverHandler`      | `boolean`                          | `true`                | Serve dev requests through your server entry. Set `false` when `@cloudflare/vite-plugin` or `nitro/vite` owns dev-time request handling. Netlify's plugin does not serve SSR, so keep the default there. |
 
 ## Prerendering
 
@@ -429,10 +429,10 @@ dist/
 | ----------- | -------------- |
 | `vite`      | 8.1.5          |
 | `vite-plus` | 0.2.6          |
-| `remix`     | 3.0.0-beta.10  |
-| Node        | 24 LTS, 25     |
+| `remix`     | 3.0.0-rc.2     |
+| Node        | 24 LTS, 26     |
 
-Remix 3 is in beta; each `@pitlane/dev` release records the exact beta it was verified against. Rolldown is not required — the transform runs identically on generic Vite and Vite+.
+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+.
 
 ### Troubleshooting
 

package/dist/index.d.mts

@@ -94,7 +94,9 @@ interface RemixPluginOptions {
   /**
    * Serve dev-server requests through the server entry's fetch handler.
    * Set to `false` when another plugin owns dev-time request handling —
-   * e.g. `@cloudflare/vite-plugin`, `@netlify/vite-plugin`, or `nitro/vite`.
+   * `@cloudflare/vite-plugin` (workerd) or `nitro/vite`. Keep the default
+   * with `@netlify/vite-plugin`, which emulates platform primitives around
+   * the dev server but leaves SSR to the app's fetch handler.
    *
    * Ignored when `server` is `false`, which has no fetch handler.
    *

package/dist/index.mjs

@@ -635,12 +635,18 @@ const SERVER_UPDATE_SETTLE_MS = 50;
 * preserving live component state.
 *
 * `ui-hmr` only recognizes named-function component forms, so arrow-form
-* exports (`export const Name = clientEntry(url, (handle) => …)` and
-* `export const Name = (handle) => …`) are first normalized to named function
+* exports (`export let Name = clientEntry(url, (handle) => …)` and
+* `export let Name = (handle) => …`) are first normalized to named function
 * expressions — the idiomatic Remix authoring style then hot-swaps without any
 * 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,
@@ -724,11 +735,11 @@ function serverDataHmr(serverEnvironments) {
 *
 * Handles the two idiomatic Remix arrow forms:
 *
-* - `export const Name = clientEntry(url, (handle) => …)`
-* - `export const Name = (handle) => () => <jsx/>`
+* - `export let Name = clientEntry(url, (handle) => …)`
+* - `export let Name = (handle) => () => <jsx/>`
 *
-* Both become `export const Name = clientEntry(url, function Name(handle) { … })`
-* / `export const Name = function Name(handle) { … }`, which is behavior-
+* Both become `export let Name = clientEntry(url, function Name(handle) { … })`
+* / `export let Name = function Name(handle) { … }`, which is behavior-
 * identical for component setup functions (they never rely on a lexical `this`
 * or `arguments`).
 */
@@ -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) {
@@ -825,7 +937,7 @@ function preview$1() {
 //#region src/transform.ts
 const CLIENT_ENTRY_PATTERN = /\bclientEntry\b/;
 /**
-* Rewrites `export const Name = clientEntry(import.meta.url, …)` so the first
+* Rewrites `export let Name = clientEntry(import.meta.url, …)` so the first
 * argument resolves to a production asset URL carrying an `#ExportName`
 * fragment.
 *
@@ -866,10 +978,11 @@ function clientEntryTransform(serverEnvironments) {
 	};
 }
 /**
-* Matches exactly `export const Name = clientEntry(import.meta.url, …)` at the
-* top level, with at least two arguments. Default exports, aliased callees,
-* and non-exported calls are intentionally ignored — the `#Name` fragment
-* requires a named export.
+* Matches exactly `export let Name = clientEntry(import.meta.url, …)` at the
+* top level, with at least two arguments. Any declaration kind (`let`, `const`,
+* `var`) qualifies; the export name is what matters. Default exports, aliased
+* callees, and non-exported calls are intentionally ignored — the `#Name`
+* fragment requires a named export.
 */
 function findClientEntryCalls(program) {
 	let results = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pitlane/dev",
-  "version": "0.5.1",
+  "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,20 +42,20 @@
     "@hiogawa/vite-plugin-fullstack": "0.0.11",
     "magic-string": "^0.30.21",
     "oxc-parser": "^0.141.0",
-    "@pitlane/crawler": "^0.1.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-beta.10",
+    "remix": "3.0.0-rc.2",
     "typescript": "^7.0.2",
     "vite": "^8.1.5",
     "vite-plus": "^0.2.6",
     "wrangler": "^4.114.0"
   },
   "peerDependencies": {
-    "remix": "^3.0.0-beta.10",
+    "remix": "^3.0.0-rc.1",
     "vite": ">=7.0.0"
   },
   "engines": {