one 1.25.6 → 1.25.8

package/dist/esm/views/ScrollBehavior.test.native.js

@@ -0,0 +1,158 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import TestRenderer, { act } from "react-test-renderer";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { registerScrollGroup, ScrollBehavior } from "./ScrollBehavior.native.js";
+var subscriptions = vi.hoisted(function () {
+  return {
+    loading: void 0,
+    root: void 0
+  };
+});
+vi.mock("../router/lastAction", function () {
+  return {
+    setLastAction: vi.fn()
+  };
+});
+vi.mock("../router/router", function () {
+  return {
+    subscribeToLoadingState: function (subscriber) {
+      subscriptions.loading = subscriber;
+      return function () {
+        subscriptions.loading = void 0;
+      };
+    },
+    subscribeToRootState: function (subscriber) {
+      subscriptions.root = subscriber;
+      return function () {
+        subscriptions.root = void 0;
+      };
+    }
+  };
+});
+globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+var renderer;
+var location;
+var scrollTo;
+beforeEach(function () {
+  process.env.VITE_ENVIRONMENT = "client";
+  location = {
+    pathname: "/",
+    search: "",
+    hash: ""
+  };
+  scrollTo = vi.fn();
+  var windowMock = Object.assign(new EventTarget(), {
+    location,
+    scrollTo,
+    scrollY: 500
+  });
+  var storage = /* @__PURE__ */new Map();
+  vi.stubGlobal("window", windowMock);
+  vi.stubGlobal("document", {
+    getElementById: vi.fn()
+  });
+  vi.stubGlobal("sessionStorage", {
+    getItem: function (key) {
+      var _storage_get;
+      return (_storage_get = storage.get(key)) !== null && _storage_get !== void 0 ? _storage_get : null;
+    },
+    setItem: function (key, value) {
+      return storage.set(key, value);
+    },
+    removeItem: function (key) {
+      return storage.delete(key);
+    }
+  });
+  act(function () {
+    renderer = TestRenderer.create(/* @__PURE__ */_jsx(ScrollBehavior, {}));
+  });
+});
+afterEach(function () {
+  act(function () {
+    return renderer === null || renderer === void 0 ? void 0 : renderer.unmount();
+  });
+  renderer = void 0;
+  vi.useRealTimers();
+  vi.unstubAllGlobals();
+  delete process.env.VITE_ENVIRONMENT;
+});
+describe("ScrollBehavior initial navigation", function () {
+  it("does not scroll when the navigator publishes its initial state after mount", function () {
+    act(function () {
+      var _subscriptions_root;
+      return (_subscriptions_root = subscriptions.root) === null || _subscriptions_root === void 0 ? void 0 : _subscriptions_root.call(subscriptions, {});
+    });
+    expect(scrollTo).not.toHaveBeenCalled();
+  });
+  it("scrolls to the top when the first state notification is a real navigation", function () {
+    location.pathname = "/compat/react-native-gesture-handler";
+    act(function () {
+      var _subscriptions_root;
+      return (_subscriptions_root = subscriptions.root) === null || _subscriptions_root === void 0 ? void 0 : _subscriptions_root.call(subscriptions, {});
+    });
+    expect(scrollTo).toHaveBeenCalledWith(0, 0);
+  });
+  it("handles a query change as a first navigation", function () {
+    location.search = "?platform=ios";
+    act(function () {
+      var _subscriptions_root;
+      return (_subscriptions_root = subscriptions.root) === null || _subscriptions_root === void 0 ? void 0 : _subscriptions_root.call(subscriptions, {});
+    });
+    expect(scrollTo).toHaveBeenCalledWith(0, 0);
+  });
+});
+describe("ScrollBehavior groups", function () {
+  it("preserves position between routes in the same group", function () {
+    vi.useFakeTimers();
+    var unregister = registerScrollGroup("/compat/react-native-gesture-handler");
+    act(function () {
+      var _subscriptions_root;
+      return (_subscriptions_root = subscriptions.root) === null || _subscriptions_root === void 0 ? void 0 : _subscriptions_root.call(subscriptions, {});
+    });
+    location.pathname = "/compat/react-native-gesture-handler";
+    act(function () {
+      var _subscriptions_root;
+      return (_subscriptions_root = subscriptions.root) === null || _subscriptions_root === void 0 ? void 0 : _subscriptions_root.call(subscriptions, {});
+    });
+    scrollTo.mockClear();
+    act(function () {
+      var _subscriptions_loading;
+      return (_subscriptions_loading = subscriptions.loading) === null || _subscriptions_loading === void 0 ? void 0 : _subscriptions_loading.call(subscriptions, "loading");
+    });
+    location.pathname = "/compat/react-native-gesture-handler/pan-gesture";
+    act(function () {
+      var _subscriptions_root;
+      return (_subscriptions_root = subscriptions.root) === null || _subscriptions_root === void 0 ? void 0 : _subscriptions_root.call(subscriptions, {});
+    });
+    vi.runAllTimers();
+    expect(scrollTo).toHaveBeenCalledWith(0, 500);
+    unregister();
+    vi.useRealTimers();
+  });
+  it("does not match a different route whose slug has the same prefix", function () {
+    var unregister = registerScrollGroup("/compat/react-native");
+    act(function () {
+      var _subscriptions_root;
+      return (_subscriptions_root = subscriptions.root) === null || _subscriptions_root === void 0 ? void 0 : _subscriptions_root.call(subscriptions, {});
+    });
+    location.pathname = "/compat/react-native/core";
+    act(function () {
+      var _subscriptions_root;
+      return (_subscriptions_root = subscriptions.root) === null || _subscriptions_root === void 0 ? void 0 : _subscriptions_root.call(subscriptions, {});
+    });
+    scrollTo.mockClear();
+    act(function () {
+      var _subscriptions_loading;
+      return (_subscriptions_loading = subscriptions.loading) === null || _subscriptions_loading === void 0 ? void 0 : _subscriptions_loading.call(subscriptions, "loading");
+    });
+    location.pathname = "/compat/react-native-gesture-handler";
+    act(function () {
+      var _subscriptions_root;
+      return (_subscriptions_root = subscriptions.root) === null || _subscriptions_root === void 0 ? void 0 : _subscriptions_root.call(subscriptions, {});
+    });
+    expect(scrollTo).toHaveBeenCalledWith(0, 0);
+    unregister();
+  });
+});
+//# sourceMappingURL=ScrollBehavior.test.native.js.map

package/dist/esm/views/ScrollBehavior.test.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["jsx","_jsx","React","TestRenderer","act","afterEach","beforeEach","describe","expect","it","vi","registerScrollGroup","ScrollBehavior","subscriptions","hoisted","loading","root","mock","setLastAction","fn","subscribeToLoadingState","subscriber","subscribeToRootState","globalThis","IS_REACT_ACT_ENVIRONMENT","renderer","location","scrollTo","process","env","VITE_ENVIRONMENT","pathname","search","hash","windowMock","Object","assign","EventTarget","scrollY","storage","Map","stubGlobal","getElementById","getItem","key","_storage_get","get","setItem","value","set","removeItem","delete","create","unmount","useRealTimers","unstubAllGlobals","_subscriptions_root","call","not","toHaveBeenCalled","toHaveBeenCalledWith"],"sources":["../../../src/views/ScrollBehavior.test.tsx"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "one",
-  "version": "1.25.6",
+  "version": "1.25.8",
   "license": "BSD-3-Clause",
   "sideEffects": [
     "setup.mjs",
@@ -193,18 +193,18 @@
     "@cloudflare/vite-plugin": "^1.33.1",
     "@swc/core": "^1.14.0",
     "@ungap/structured-clone": "^1.2.0",
-    "@vxrn/color-scheme": "1.25.6",
-    "@vxrn/compiler": "1.25.6",
-    "@vxrn/resolve": "1.25.6",
-    "@vxrn/tslib-lite": "1.25.6",
-    "@vxrn/use-isomorphic-layout-effect": "1.25.6",
-    "@vxrn/vite-plugin-metro": "1.25.6",
+    "@vxrn/color-scheme": "1.25.8",
+    "@vxrn/compiler": "1.25.8",
+    "@vxrn/resolve": "1.25.8",
+    "@vxrn/tslib-lite": "1.25.8",
+    "@vxrn/use-isomorphic-layout-effect": "1.25.8",
+    "@vxrn/vite-plugin-metro": "1.25.8",
     "babel-dead-code-elimination": "1.0.10",
     "babel-plugin-module-resolver": "^5.0.2",
     "babel-preset-expo": "~57.0.5",
     "citty": "^0.1.6",
     "core-js": "^3.38.1",
-    "create-vxrn": "1.25.6",
+    "create-vxrn": "1.25.8",
     "escape-string-regexp": "^5.0.0",
     "expo-linking": "~57.0.5",
     "expo-modules-core": "~57.0.10",
@@ -224,7 +224,7 @@
     "tsconfig-paths": "^4",
     "use-latest-callback": "^0.2.3",
     "vite": "^8.2.2",
-    "vxrn": "1.25.6",
+    "vxrn": "1.25.8",
     "web-streams-polyfill": "^4.3.0",
     "ws": "^8.21.0",
     "xxhashjs": "^0.2.2"

package/src/cli/prebuild.test.ts

@@ -0,0 +1,48 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { run } from './prebuild'
+
+const { loadUserOneOptionsMock, prebuildMock } = vi.hoisted(() => ({
+  loadUserOneOptionsMock: vi.fn(),
+  prebuildMock: vi.fn(),
+}))
+
+vi.mock('../vite/loadConfig', () => ({
+  loadUserOneOptions: loadUserOneOptionsMock,
+}))
+
+vi.mock('vxrn', () => ({
+  prebuild: prebuildMock,
+}))
+
+describe('one prebuild', () => {
+  beforeEach(() => {
+    loadUserOneOptionsMock.mockReset()
+    prebuildMock.mockReset()
+  })
+
+  it('loads the app bundler configuration before native prebuild', async () => {
+    loadUserOneOptionsMock.mockResolvedValueOnce({})
+
+    await run({ platform: 'ios', expo: true, 'no-install': true })
+
+    expect(loadUserOneOptionsMock).toHaveBeenCalledWith('build', true)
+    expect(loadUserOneOptionsMock.mock.invocationCallOrder[0]).toBeLessThan(
+      prebuildMock.mock.invocationCallOrder[0]
+    )
+    expect(prebuildMock).toHaveBeenCalledWith({
+      root: process.cwd(),
+      platform: 'ios',
+      expo: true,
+      'no-install': true,
+    })
+  })
+
+  it('does not prebuild when the app configuration fails to load', async () => {
+    loadUserOneOptionsMock.mockRejectedValueOnce(new Error('invalid vite config'))
+
+    await expect(run({ platform: 'ios', expo: true })).rejects.toThrow(
+      'invalid vite config'
+    )
+    expect(prebuildMock).not.toHaveBeenCalled()
+  })
+})

package/src/cli/prebuild.ts

@@ -1,8 +1,11 @@
+import { loadUserOneOptions } from '../vite/loadConfig'
+
 export async function run(args: {
   platform?: string
   expo: boolean
   'no-install'?: boolean
 }) {
+  await loadUserOneOptions('build', true)
   const { prebuild } = await import('vxrn')
 
   await prebuild({

package/src/createHandleRequest.test.ts

@@ -62,8 +62,9 @@ vi.mock('./vite/getManifest', () => ({
   }),
 }))
 
-function createRequest(path: string) {
+function createRequest(path: string, method = 'GET') {
   return new Request(`http://localhost:3000${path}`, {
+    method,
     headers: {
       host: 'localhost:3000',
     },
@@ -262,6 +263,59 @@ describe('createHandleRequest', () => {
     })
   })
 
+  describe('request method dispatch', () => {
+    it('answers HEAD page requests exactly like GET', async () => {
+      const handlePage = vi.fn(
+        async () =>
+          new Response('<html></html>', { headers: { 'content-type': 'text/html' } })
+      )
+      const { handler } = createHandleRequest({ handlePage }, { routerRoot: '/app' })
+
+      const get = await handler(createRequest('/my-page', 'GET'))
+      const head = await handler(createRequest('/my-page', 'HEAD'))
+
+      if (!(get instanceof Response) || !(head instanceof Response)) {
+        throw new Error('expected both GET and HEAD to return a Response')
+      }
+      // the transport drops the body for HEAD, so the handler layer must agree
+      // with GET on everything else: status and content type.
+      expect(head.status).toBe(get.status)
+      expect(head.headers.get('content-type')).toBe(get.headers.get('content-type'))
+      expect(handlePage).toHaveBeenCalledTimes(2)
+    })
+
+    it('continues routing HEAD requests to API handlers', async () => {
+      const mockHandlersWithAPI = {
+        handlePage: vi.fn().mockResolvedValue('<html></html>'),
+        handleAPI: vi.fn().mockResolvedValue({
+          HEAD: () => new Response(null, { status: 204 }),
+        }),
+      }
+      const { handler } = createHandleRequest(mockHandlersWithAPI, {
+        routerRoot: '/app',
+      })
+
+      const result = await handler(createRequest('/api/github/agent/run.sh', 'HEAD'))
+
+      expect(result).toBeInstanceOf(Response)
+      if (!(result instanceof Response)) {
+        throw new Error('expected HEAD API request to return a Response')
+      }
+      expect(result.status).toBe(204)
+      expect(mockHandlersWithAPI.handleAPI).toHaveBeenCalledOnce()
+      expect(mockHandlersWithAPI.handlePage).not.toHaveBeenCalled()
+    })
+
+    it('does not route POST requests to page handlers', async () => {
+      const { handler } = createHandleRequest(mockHandlers, { routerRoot: '/app' })
+
+      const result = await handler(createRequest('/my-page', 'POST'))
+
+      expect(result).toBeNull()
+      expect(mockHandlers.handlePage).not.toHaveBeenCalled()
+    })
+  })
+
   describe('special paths', () => {
     it('should skip __vxrnhmr path', async () => {
       const { handler } = createHandleRequest(mockHandlers, { routerRoot: '/app' })

package/src/createHandleRequest.ts

@@ -35,6 +35,13 @@ function isStaticAssetRequestPath(pathname: string): boolean {
   )
 }
 
+// page (document) routes answer HEAD exactly like GET. the transport drops the
+// body: node's ServerResponse suppresses it for HEAD and workerd does the same.
+// without this a HEAD document request falls through to a bare 404 while GET is 200.
+export function isPageRequestMethod(method: string) {
+  return method === 'GET' || method === 'HEAD'
+}
+
 // ensure handler results are always a proper Response so middleware
 // can safely use response.body / response.headers / new Response(response.body, ...)
 function ensureResponse(value: any): Response {
@@ -425,7 +432,7 @@ export function createHandleRequest(
         }
       }
 
-      if (request.method !== 'GET') {
+      if (!isPageRequestMethod(request.method)) {
         return null
       }
 

package/src/router/diagnoseRouteLoadFailure.ts

@@ -0,0 +1,108 @@
+// a browser content blocker (safari's built-in blockers, ublock, adguard,
+// brave shields) matches filter rules against the request url. in dev the
+// vite module url mirrors the source path, so an ordinary app file can match
+// a tracking rule purely by where it lives — easylist, easyprivacy and
+// adguard all ship the plain substring rule `/analytics/pageview`, which is
+// enough to refuse `src/features/site/analytics/PageviewTracker.tsx`.
+//
+// one blocked module fails the whole dynamic import, and the browser reports
+// only `TypeError: Importing a module script failed` pointing at one's own
+// route loader. nothing in that names the file, the app, or the blocker, so
+// it reads as a framework or vite bug and sends people restarting dev servers
+// and clearing caches.
+//
+// a blocked request also fails `fetch()`, so walking the route's module graph
+// from the browser finds the exact module the blocker refused. dev only, and
+// only after a route has already failed to load.
+
+const MAX_MODULES = 500
+const TIMEOUT_MS = 5000
+
+// vite rewrites bare specifiers to absolute paths, so most of these are
+// already root-relative; the rest resolve against the importing module.
+function collectImports(source: string, base: string): string[] {
+  const out: string[] = []
+  const add = (spec: string) => {
+    if (!/^[./]|^https?:/.test(spec)) return
+    try {
+      out.push(new URL(spec, base).href)
+    } catch {}
+  }
+  for (const m of source.matchAll(/(?:^|[\s;}])(?:import|export)[^'"]{0,300}?from\s*["']([^"']+)["']/g))
+    add(m[1])
+  for (const m of source.matchAll(/\bimport\s*\(\s*["']([^"']+)["']\s*\)/g)) add(m[1])
+  for (const m of source.matchAll(/(?:^|[\s;}])import\s*["']([^"']+)["']/g)) add(m[1])
+  return out
+}
+
+/**
+ * Walks the module graph under `entryUrl` looking for a module the browser
+ * refuses to fetch. Returns the blocked module's url, or null when every
+ * module in the graph is reachable (which means the import failed for some
+ * other reason, such as a syntax error inside one of them).
+ */
+export async function findBlockedModule(entryUrl: string): Promise<string | null> {
+  const deadline = Date.now() + TIMEOUT_MS
+  const seen = new Set<string>()
+  let frontier = [new URL(entryUrl, window.location.href).href]
+
+  while (frontier.length && seen.size < MAX_MODULES && Date.now() < deadline) {
+    const batch = frontier.filter((url) => !seen.has(url)).slice(0, 32)
+    if (!batch.length) break
+    frontier = frontier.slice(batch.length)
+
+    const results = await Promise.all(
+      batch.map(async (url) => {
+        seen.add(url)
+        let res: Response
+        try {
+          res = await fetch(url)
+        } catch {
+          // the request never reached the server. in dev the server is
+          // demonstrably up (the page and one's own runtime loaded from it),
+          // so this is the browser refusing to make the request.
+          return { url, blocked: true, imports: [] as string[] }
+        }
+        if (!res.ok) return { url, blocked: false, imports: [] }
+        const type = res.headers.get('content-type') ?? ''
+        if (!type.includes('javascript')) return { url, blocked: false, imports: [] }
+        return { url, blocked: false, imports: collectImports(await res.text(), url) }
+      })
+    )
+
+    for (const result of results) {
+      if (result.blocked) return result.url
+      for (const next of result.imports) {
+        if (!seen.has(next)) frontier.push(next)
+      }
+    }
+  }
+
+  return null
+}
+
+/**
+ * Turns a failed route import into a message that names the responsible file.
+ * Returns null when the graph is fully reachable, leaving the original error
+ * as the only report.
+ */
+export async function diagnoseRouteLoadFailure(
+  routeId: string,
+  routeUrl: string
+): Promise<string | null> {
+  const blocked = await findBlockedModule(routeUrl)
+  if (!blocked) return null
+
+  const path = blocked.replace(window.location.origin, '')
+  return [
+    `Route "${routeId}" failed to load because this browser refused to fetch ${path}`,
+    ``,
+    `That request never reached the dev server, so a content blocker or privacy`,
+    `extension is blocking it. In dev the module URL is the source path, and a`,
+    `path containing a word like "analytics", "pageview" or "track" matches the`,
+    `tracking rules those blockers ship.`,
+    ``,
+    `Rename the file or the directory so its path no longer matches, or allow`,
+    `${window.location.origin} in the blocker.`,
+  ].join('\n')
+}

package/src/router/useViteRoutes.tsx

@@ -1,5 +1,6 @@
 import type { GlobbedRouteImports } from '../types'
 import type { One } from '../vite/types'
+import { diagnoseRouteLoadFailure } from './diagnoseRouteLoadFailure'
 import { hmrImport } from './hmrImport'
 
 // essentially a development helper
@@ -303,6 +304,15 @@ export function globbedRoutesToRouteContext(
               message: err instanceof Error ? err.message : String(err),
               stack: err instanceof Error ? err.stack : undefined,
             })
+
+            // `Importing a module script failed` names neither the module nor
+            // the reason. when a browser content blocker refused one of the
+            // route's imports, walking the graph finds the exact file.
+            if (process.env.NODE_ENV === 'development' && routePaths[id]) {
+              diagnoseRouteLoadFailure(id, routePaths[id]).then((message) => {
+                if (message) console.error(message)
+              })
+            }
           }
           loadedRoutes[id] = {
             default: () => null,

package/src/server/oneServe.ts

@@ -924,7 +924,6 @@ url: ${url}`)
 
   for (const route of compiledManifest.apiRoutes) {
     app.get(route.urlPath, createHonoHandler(route))
-    app.on('HEAD', route.urlPath, createHonoHandler(route))
     app.put(route.urlPath, createHonoHandler(route))
     app.post(route.urlPath, createHonoHandler(route))
     app.delete(route.urlPath, createHonoHandler(route))
@@ -933,7 +932,6 @@ url: ${url}`)
 
     if (route.urlPath !== route.urlCleanPath) {
       app.get(route.urlCleanPath, createHonoHandler(route))
-      app.on('HEAD', route.urlCleanPath, createHonoHandler(route))
       app.put(route.urlCleanPath, createHonoHandler(route))
       app.post(route.urlCleanPath, createHonoHandler(route))
       app.delete(route.urlCleanPath, createHonoHandler(route))

package/src/server/workerHandler.test.ts

@@ -0,0 +1,125 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import type { One } from '../vite/types'
+import { createWorkerHandler, type LazyRoutes } from './workerHandler'
+
+const pageRoute = {
+  file: 'app/some-page.tsx',
+  page: '/some-page',
+  namedRegex: '^/some-page(?:/)?$',
+  urlPath: '/some-page',
+  urlCleanPath: '/some-page',
+  routeKeys: {},
+  type: 'ssr',
+  middlewares: [],
+} satisfies One.BuildInfo['manifest']['pageRoutes'][number]
+
+const apiRoute = {
+  file: 'app/api/status+api.ts',
+  page: '/api/status',
+  namedRegex: '^/api/status(?:/)?$',
+  urlPath: '/api/status',
+  urlCleanPath: '/api/status',
+  routeKeys: {},
+  type: 'api',
+  middlewares: [],
+} satisfies One.BuildInfo['manifest']['apiRoutes'][number]
+
+const buildInfo = {
+  constants: { CACHE_KEY: 'test' },
+  routeToBuildInfo: {
+    [pageRoute.file]: {
+      type: 'ssr',
+      path: pageRoute.page,
+      routeFile: pageRoute.file,
+      middlewares: [],
+      preloadPath: '',
+      cssPreloadPath: '',
+      loaderPath: '',
+      cleanPath: pageRoute.page,
+      htmlPath: '',
+      clientJsPath: '',
+      serverJsPath: '',
+      params: {},
+      preloads: [],
+      css: [],
+      layoutCSS: [],
+    },
+  },
+  pathToRoute: {},
+  routeMap: {},
+  manifest: {
+    pageRoutes: [pageRoute],
+    apiRoutes: [apiRoute],
+    allRoutes: [pageRoute, apiRoute],
+  },
+  preloads: {},
+  cssPreloads: {},
+  loaders: {},
+} satisfies One.BuildInfo
+
+const lazyRoutes = {
+  serverEntry: async () => ({
+    default: {
+      render: () => '<html></html>',
+    },
+  }),
+  pages: {
+    [pageRoute.file]: async () => ({}),
+  },
+  api: {
+    [apiRoute.page]: async () => ({
+      HEAD: () => new Response(null, { status: 204 }),
+    }),
+  },
+  middlewares: {},
+} satisfies LazyRoutes
+
+function createHandler() {
+  vi.stubEnv('ONE_BUFFERED_SSR', '1')
+  return createWorkerHandler({
+    oneOptions: { web: { defaultRenderMode: 'ssr' } },
+    buildInfo,
+    lazyRoutes,
+  }).handleRequest
+}
+
+afterEach(() => {
+  vi.unstubAllEnvs()
+})
+
+describe('createWorkerHandler', () => {
+  it('answers HEAD page requests exactly like GET', async () => {
+    const handleRequest = createHandler()
+    const get = await handleRequest(new Request('https://example.com/some-page'))
+    const head = await handleRequest(
+      new Request('https://example.com/some-page', { method: 'HEAD' })
+    )
+
+    if (!(get instanceof Response) || !(head instanceof Response)) {
+      throw new Error('expected both GET and HEAD to return a Response')
+    }
+    // workerd drops the body for HEAD, so the handler must agree with GET on
+    // status and content type. asserting an empty body here would only be
+    // asserting the transport's job.
+    expect(get.status).toBe(200)
+    expect(head.status).toBe(get.status)
+    expect(head.headers.get('content-type')).toBe(get.headers.get('content-type'))
+  })
+
+  it('does not route POST requests to page handlers', async () => {
+    const response = await createHandler()(
+      new Request('https://example.com/some-page', { method: 'POST' })
+    )
+
+    expect(response).toBeNull()
+  })
+
+  it('continues routing HEAD requests to API handlers', async () => {
+    const response = await createHandler()(
+      new Request('https://example.com/api/status', { method: 'HEAD' })
+    )
+
+    expect(response).toBeInstanceOf(Response)
+    expect(response?.status).toBe(204)
+  })
+})

package/src/server/workerHandler.ts

@@ -7,6 +7,7 @@ import {
   compileManifest,
   getSubdomain,
   getURLfromRequestURL,
+  isPageRequestMethod,
   type RequestHandlers,
   resolveAPIRoute,
   resolveLoaderRoute,
@@ -706,8 +707,8 @@ export function createWorkerHandler(options: WorkerHandlerOptions) {
       }
     }
 
-    // 6. page routes (GET only)
-    if (method === 'GET') {
+    // 6. page routes
+    if (isPageRequestMethod(method)) {
       for (const route of compiledManifest.pageRoutes) {
         if (!route.compiledRegex.test(pathname)) continue