one 1.9.3 → 1.9.5

package/src/server/oneServe.ts

@@ -72,6 +72,20 @@ export async function oneServe(
 
   const { routeToBuildInfo, routeMap } = buildInfo as One.BuildInfo
 
+  // find nearest +not-found path by walking up from a url path
+  function findNearestNotFoundPath(urlPath: string): string {
+    let cur = urlPath
+    while (cur) {
+      const parent = cur.lastIndexOf('/') > 0 ? cur.slice(0, cur.lastIndexOf('/')) : ''
+      if (routeMap[`${parent}/+not-found`]) {
+        return `${parent}/+not-found`
+      }
+      if (!parent) break
+      cur = parent
+    }
+    return '/+not-found'
+  }
+
   const serverOptions = {
     ...oneOptions,
     root: '.',
@@ -450,46 +464,36 @@ url: ${url}`)
         // dynamic route matched but no static HTML exists for this path
         // (slug wasn't in generateStaticParams) - return 404
         if (isDynamicRoute) {
-          // find nearest +not-found.html by walking up the path
-          let currentPath = url.pathname
-          while (currentPath) {
-            const parentDir =
-              currentPath.lastIndexOf('/') > 0
-                ? currentPath.slice(0, currentPath.lastIndexOf('/'))
-                : ''
-            const notFoundPath = routeMap[`${parentDir}/+not-found`]
-
-            if (notFoundPath) {
-              const fetchStaticHtml = getFetchStaticHtml()
-              let notFoundHtml: string | null = null
-
-              if (fetchStaticHtml) {
-                notFoundHtml = await fetchStaticHtml(notFoundPath)
-              }
+          const notFoundRoute = findNearestNotFoundPath(url.pathname)
+          const notFoundHtmlPath = routeMap[notFoundRoute]
 
-              if (!notFoundHtml) {
-                try {
-                  notFoundHtml = await readFile(
-                    join('dist/client', notFoundPath),
-                    'utf-8'
-                  )
-                } catch {
-                  // File not found
-                }
-              }
+          if (notFoundHtmlPath) {
+            const fetchStaticHtml = getFetchStaticHtml()
+            let notFoundHtml: string | null = null
+
+            if (fetchStaticHtml) {
+              notFoundHtml = await fetchStaticHtml(notFoundHtmlPath)
+            }
 
-              if (notFoundHtml) {
-                const headers = new Headers()
-                headers.set('content-type', 'text/html')
-                return new Response(notFoundHtml, {
-                  headers,
-                  status: 404,
-                })
+            if (!notFoundHtml) {
+              try {
+                notFoundHtml = await readFile(
+                  join('dist/client', notFoundHtmlPath),
+                  'utf-8'
+                )
+              } catch {
+                // File not found
               }
             }
 
-            if (!parentDir) break
-            currentPath = parentDir
+            if (notFoundHtml) {
+              const headers = new Headers()
+              headers.set('content-type', 'text/html')
+              return new Response(notFoundHtml, {
+                headers,
+                status: 404,
+              })
+            }
           }
 
           // no +not-found.html found, return basic 404
@@ -542,6 +546,19 @@ url: ${url}`)
           // this handles all loader refetches or fetches due to navigation
           if (url.pathname.endsWith(LOADER_JS_POSTFIX_UNCACHED)) {
             const originalUrl = getPathFromLoaderPath(url.pathname)
+
+            // for ssg routes with dynamic params, check if this path was statically generated
+            // if not in routeMap, the slug wasn't in generateStaticParams - return 404
+            if (route.type === 'ssg' && Object.keys(route.routeKeys).length > 0) {
+              if (!routeMap[originalUrl]) {
+                const nfPath = findNearestNotFoundPath(originalUrl)
+                return new Response(
+                  `export function loader(){return{__oneError:404,__oneErrorMessage:'Not Found',__oneNotFoundPath:${JSON.stringify(nfPath)}}}`,
+                  { headers: { 'Content-Type': 'text/javascript' } }
+                )
+              }
+            }
+
             const finalUrl = new URL(originalUrl, url.origin)
             const cleanedRequest = new Request(finalUrl, request)
             return resolveLoaderRoute(requestHandlers, cleanedRequest, finalUrl, route)
@@ -687,6 +704,20 @@ url: ${url}`)
           continue
         }
 
+        // for ssg routes with dynamic params, check if this path was statically generated
+        if (
+          route.type === 'ssg' &&
+          Object.keys(route.routeKeys).length > 0 &&
+          !routeMap[originalUrl]
+        ) {
+          const nfPath = findNearestNotFoundPath(originalUrl)
+          c.header('Content-Type', 'text/javascript')
+          c.status(200)
+          return c.body(
+            `export function loader(){return{__oneError:404,__oneErrorMessage:'Not Found',__oneNotFoundPath:${JSON.stringify(nfPath)}}}`
+          )
+        }
+
         // for now just change this
         const loaderRoute = {
           ...route,

package/src/useLoader.ts

@@ -32,37 +32,38 @@ export type LoaderTimingEntry = {
 const loaderTimingHistory: LoaderTimingEntry[] = []
 const MAX_TIMING_HISTORY = 50
 
-function recordLoaderTiming(entry: LoaderTimingEntry) {
-  if (process.env.NODE_ENV !== 'development') return
-
-  loaderTimingHistory.unshift(entry)
-  if (loaderTimingHistory.length > MAX_TIMING_HISTORY) {
-    loaderTimingHistory.pop()
-  }
-  // Dispatch event for devtools (web only - CustomEvent doesn't exist on native)
-  if (typeof window !== 'undefined' && typeof CustomEvent !== 'undefined') {
-    window.dispatchEvent(new CustomEvent('one-loader-timing', { detail: entry }))
-
-    // Also dispatch error event if there was an error
-    if (entry.error) {
-      window.dispatchEvent(
-        new CustomEvent('one-error', {
-          detail: {
-            error: {
-              message: entry.error,
-              name: 'LoaderError',
-            },
-            route: {
-              pathname: entry.path,
-            },
-            timestamp: Date.now(),
-            type: 'loader',
-          },
-        })
-      )
-    }
-  }
-}
+const recordLoaderTiming =
+  process.env.NODE_ENV === 'development'
+    ? (entry: LoaderTimingEntry) => {
+        loaderTimingHistory.unshift(entry)
+        if (loaderTimingHistory.length > MAX_TIMING_HISTORY) {
+          loaderTimingHistory.pop()
+        }
+        // Dispatch event for devtools (web only - CustomEvent doesn't exist on native)
+        if (typeof window !== 'undefined' && typeof CustomEvent !== 'undefined') {
+          window.dispatchEvent(new CustomEvent('one-loader-timing', { detail: entry }))
+
+          // Also dispatch error event if there was an error
+          if (entry.error) {
+            window.dispatchEvent(
+              new CustomEvent('one-error', {
+                detail: {
+                  error: {
+                    message: entry.error,
+                    name: 'LoaderError',
+                  },
+                  route: {
+                    pathname: entry.path,
+                  },
+                  timestamp: Date.now(),
+                  type: 'loader',
+                },
+              })
+            )
+          }
+        }
+      }
+    : undefined
 
 export function getLoaderTimingHistory(): LoaderTimingEntry[] {
   return loaderTimingHistory
@@ -146,7 +147,7 @@ export async function refetchLoader(pathname: string): Promise<void> {
 
     // detect server redirect signal during refetch
     if (result?.__oneRedirect) {
-      recordLoaderTiming({
+      recordLoaderTiming?.({
         path: pathname,
         startTime,
         moduleLoadTime,
@@ -163,6 +164,21 @@ export async function refetchLoader(pathname: string): Promise<void> {
       return
     }
 
+    // detect 404 error signal during refetch
+    // don't clear data - keep existing data while navigating to not-found
+    if (result?.__oneError === 404) {
+      recordLoaderTiming?.({
+        path: pathname,
+        startTime,
+        moduleLoadTime,
+        executionTime,
+        totalTime,
+        source: 'refetch',
+      })
+      router.replace(result.__oneNotFoundPath || '/+not-found')
+      return
+    }
+
     updateState(pathname, {
       data: result,
       state: 'idle',
@@ -170,7 +186,7 @@ export async function refetchLoader(pathname: string): Promise<void> {
       hasLoadedOnce: true,
     })
 
-    recordLoaderTiming({
+    recordLoaderTiming?.({
       path: pathname,
       startTime,
       moduleLoadTime,
@@ -186,7 +202,7 @@ export async function refetchLoader(pathname: string): Promise<void> {
       state: 'idle',
     })
 
-    recordLoaderTiming({
+    recordLoaderTiming?.({
       path: pathname,
       startTime,
       totalTime,
@@ -360,7 +376,7 @@ export function useLoaderState<
 
               // detect server redirect signal on native
               if (data?.__oneRedirect) {
-                recordLoaderTiming({
+                recordLoaderTiming?.({
                   path: currentPath,
                   startTime,
                   moduleLoadTime,
@@ -377,13 +393,29 @@ export function useLoaderState<
                 return
               }
 
+              // detect 404 error signal on native
+              // don't update state so the component stays suspended while navigating
+              if (data?.__oneError === 404) {
+                recordLoaderTiming?.({
+                  path: currentPath,
+                  startTime,
+                  moduleLoadTime,
+                  executionTime,
+                  totalTime,
+                  source: 'initial',
+                })
+                router.replace(data.__oneNotFoundPath || '/+not-found')
+                // keep component suspended until navigation unmounts it
+                await new Promise(() => {})
+              }
+
               updateState(currentPath, {
                 data,
                 hasLoadedOnce: true,
                 promise: undefined,
               })
 
-              recordLoaderTiming({
+              recordLoaderTiming?.({
                 path: currentPath,
                 startTime,
                 moduleLoadTime,
@@ -398,7 +430,7 @@ export function useLoaderState<
                 data: {},
                 promise: undefined,
               })
-              recordLoaderTiming({
+              recordLoaderTiming?.({
                 path: currentPath,
                 startTime,
                 totalTime,
@@ -434,7 +466,7 @@ export function useLoaderState<
 
           // detect server redirect signal (fallback if preload didn't catch it)
           if (result?.__oneRedirect) {
-            recordLoaderTiming({
+            recordLoaderTiming?.({
               path: currentPath,
               startTime,
               moduleLoadTime,
@@ -451,13 +483,29 @@ export function useLoaderState<
             return
           }
 
+          // detect 404 error signal - navigate to not-found page
+          // don't update state so the component stays suspended while navigating
+          if (result?.__oneError === 404) {
+            recordLoaderTiming?.({
+              path: currentPath,
+              startTime,
+              moduleLoadTime,
+              executionTime,
+              totalTime,
+              source: 'initial',
+            })
+            router.replace(result.__oneNotFoundPath || '/+not-found')
+            // keep component suspended until navigation unmounts it
+            await new Promise(() => {})
+          }
+
           updateState(currentPath, {
             data: result,
             hasLoadedOnce: true,
             promise: undefined,
           })
 
-          recordLoaderTiming({
+          recordLoaderTiming?.({
             path: currentPath,
             startTime,
             moduleLoadTime,
@@ -473,7 +521,7 @@ export function useLoaderState<
             promise: undefined,
           })
 
-          recordLoaderTiming({
+          recordLoaderTiming?.({
             path: currentPath,
             startTime,
             totalTime,

package/src/vite/plugins/clientTreeShakePlugin.ts

@@ -179,7 +179,7 @@ export async function transformTreeShakeClient(code: string, id: string) {
       // Restore any type imports that were incorrectly removed
       restoreTypeImports(ast, typeImports)
 
-      const out = generate(ast)
+      const out = generate(ast, { retainLines: true })
 
       // add back in empty or filled loader and genparams
       const codeOut =

package/src/vite/plugins/fileSystemRouterPlugin.tsx

@@ -50,6 +50,34 @@ export function createFileSystemRouterPlugin(options: One.PluginOptions): Plugin
 
   function createRequestHandler() {
     const routerRoot = getRouterRootFromOneOptions(options)
+
+    // find the nearest +not-found route by walking up from a route's directory
+    async function findNearestNotFoundPath(routeFile: string): Promise<string> {
+      const routeDir = routeFile.replace(/\/[^/]+$/, '')
+      let searchDir = routeDir
+      while (true) {
+        for (const ext of ['.tsx', '.ts', '.jsx', '.js']) {
+          const candidate = path.join(routerRoot, searchDir, `+not-found${ext}`)
+          try {
+            const mod = await runner.import(candidate)
+            if (mod?.default) {
+              return searchDir ? `/${searchDir}/+not-found` : '/+not-found'
+            }
+          } catch {
+            // not found at this level
+          }
+        }
+        if (!searchDir) break
+        const parent = searchDir.replace(/\/[^/]+$/, '')
+        if (parent === searchDir) {
+          searchDir = ''
+        } else {
+          searchDir = parent
+        }
+      }
+      return '/+not-found'
+    }
+
     return createHandleRequest(
       {
         async handlePage({ route, url, loaderProps }) {
@@ -214,7 +242,90 @@ export function createFileSystemRouterPlugin(options: One.PluginOptions): Plugin
 
             LoaderDataCache[route.file] = loaderData
 
-            const is404 = route.isNotFound || !getPageExport(exported)
+            // detect 404: not-found routes, missing page exports, or ssg dynamic routes with invalid slugs
+            const isDynamicRoute = Object.keys(route.routeKeys || {}).length > 0
+
+            // for ssg dynamic routes, check generateStaticParams to validate the slug
+            let isMissingSsgSlug = false
+            if (route.type === 'ssg' && isDynamicRoute && exported.generateStaticParams) {
+              const staticParams = await exported.generateStaticParams({
+                params: loaderProps?.params,
+              })
+              const currentParams = loaderProps?.params || {}
+              isMissingSsgSlug = !staticParams.some((sp: Record<string, string>) =>
+                Object.keys(sp).every((key) => sp[key] === currentParams[key])
+              )
+            }
+
+            const is404 =
+              route.isNotFound ||
+              !getPageExport(exported) ||
+              isMissingSsgSlug ||
+              (route.type === 'ssg' && isDynamicRoute && loaderData === undefined)
+
+            // for ssg dynamic routes with invalid slug, render the not-found page instead
+            if (
+              isMissingSsgSlug ||
+              (route.type === 'ssg' && isDynamicRoute && loaderData === undefined)
+            ) {
+              // find nearest +not-found by walking up the route's directory
+              let notFoundExported: any = {}
+              let notFoundRoutePath = '/+not-found'
+              const routeDir = route.file.replace(/\/[^/]+$/, '')
+              let searchDir = routeDir
+              while (true) {
+                for (const ext of ['.tsx', '.ts', '.jsx', '.js']) {
+                  const candidate = path.join(routerRoot, searchDir, `+not-found${ext}`)
+                  try {
+                    notFoundExported = await runner.import(candidate)
+                    if (notFoundExported?.default) {
+                      notFoundRoutePath = searchDir
+                        ? `/${searchDir}/+not-found`
+                        : '/+not-found'
+                      break
+                    }
+                  } catch {
+                    // not found at this level
+                  }
+                }
+                if (notFoundExported?.default || !searchDir) break
+                const parent = searchDir.replace(/\/[^/]+$/, '')
+                if (parent === searchDir) {
+                  searchDir = ''
+                } else {
+                  searchDir = parent
+                }
+              }
+
+              if (notFoundExported.default) {
+                // override the route to render the not-found page
+                setServerContext({
+                  loaderData: undefined,
+                  loaderProps,
+                  matches: [],
+                })
+
+                const notFoundHtml = await render({
+                  mode: 'ssg',
+                  loaderData: undefined,
+                  loaderProps,
+                  path: notFoundRoutePath,
+                  preloads,
+                  matches: [],
+                })
+
+                return new Response(notFoundHtml, {
+                  status: 404,
+                  headers: { 'Content-Type': 'text/html' },
+                })
+              }
+
+              // fallback if no +not-found page exists
+              return new Response('<html><body><h1>404 - Not Found</h1></body></html>', {
+                status: 404,
+                headers: { 'Content-Type': 'text/html' },
+              })
+            }
 
             const html = await render({
               mode: isSpaShell
@@ -298,34 +409,64 @@ export function createFileSystemRouterPlugin(options: One.PluginOptions): Plugin
 
           const exported = await runner.import(routeFile)
 
+          // for ssg dynamic routes, check generateStaticParams to validate the slug
+          const isDynamicRoute = Object.keys(route.routeKeys || {}).length > 0
+          if (route.type === 'ssg' && isDynamicRoute && exported.generateStaticParams) {
+            const staticParams = await exported.generateStaticParams({
+              params: loaderProps?.params,
+            })
+            const currentParams = loaderProps?.params || {}
+            const isValidSlug = staticParams.some((sp: Record<string, string>) =>
+              Object.keys(sp).every((key) => sp[key] === currentParams[key])
+            )
+            if (!isValidSlug) {
+              const nfPath = await findNearestNotFoundPath(route.file)
+              return `export function loader(){return{__oneError:404,__oneErrorMessage:'Not Found',__oneNotFoundPath:${JSON.stringify(nfPath)}}}`
+            }
+          }
+
           // Track file dependencies from loader for hot reload
           let loaderData: any
           if (exported.loader) {
-            const tracked = await trackLoaderDependencies(() =>
-              exported.loader(loaderProps)
-            )
-            loaderData = tracked.result
+            try {
+              const tracked = await trackLoaderDependencies(() =>
+                exported.loader(loaderProps)
+              )
+              loaderData = tracked.result
 
-            // if the loader returned a Response (e.g. redirect()), throw it
-            // so it bubbles up through resolveResponse and can be transformed
-            // into a JS redirect module for client-side navigation
-            if (isResponse(loaderData)) {
-              throw loaderData
-            }
+              // if the loader returned a Response (e.g. redirect()), throw it
+              // so it bubbles up through resolveResponse and can be transformed
+              // into a JS redirect module for client-side navigation
+              if (isResponse(loaderData)) {
+                throw loaderData
+              }
 
-            // Register dependencies: map file path -> route paths that depend on it
-            const routePath = loaderProps?.path || '/'
-            for (const dep of tracked.dependencies) {
-              // Resolve to absolute path for consistent lookup when file changes
-              const absoluteDep = path.resolve(dep)
-              if (!loaderFileDependencies.has(absoluteDep)) {
-                loaderFileDependencies.set(absoluteDep, new Set())
-                server?.watcher.add(absoluteDep)
-                if (debugLoaderDeps) {
-                  console.info(` ⓵  [loader-dep] watching: ${absoluteDep}`)
+              // Register dependencies: map file path -> route paths that depend on it
+              const routePath = loaderProps?.path || '/'
+              for (const dep of tracked.dependencies) {
+                // Resolve to absolute path for consistent lookup when file changes
+                const absoluteDep = path.resolve(dep)
+                if (!loaderFileDependencies.has(absoluteDep)) {
+                  loaderFileDependencies.set(absoluteDep, new Set())
+                  server?.watcher.add(absoluteDep)
+                  if (debugLoaderDeps) {
+                    console.info(` ⓵  [loader-dep] watching: ${absoluteDep}`)
+                  }
                 }
+                loaderFileDependencies.get(absoluteDep)!.add(routePath)
+              }
+            } catch (err) {
+              // re-throw Response errors (redirects)
+              if (isResponse(err)) {
+                throw err
+              }
+              // for file-not-found errors (e.g., missing MDX for non-existent slug),
+              // return a 404 signal so the client navigates to +not-found
+              if ((err as any)?.code === 'ENOENT') {
+                const nfPath = await findNearestNotFoundPath(route.file)
+                return `export function loader(){return{__oneError:404,__oneErrorMessage:'Not Found',__oneNotFoundPath:${JSON.stringify(nfPath)}}}`
               }
-              loaderFileDependencies.get(absoluteDep)!.add(routePath)
+              throw err
             }
           }
 

package/src/vite/plugins/sourceInspectorPlugin.ts

@@ -15,7 +15,6 @@ interface JsxLocation {
 
 /**
  * Parse code with oxc and find all JSX opening elements.
- * Returns insertion points sorted by offset (descending for safe insertion).
  */
 async function findJsxElements(code: string, filename: string): Promise<JsxLocation[]> {
   const result = await parse(filename, code)
@@ -53,14 +52,12 @@ async function findJsxElements(code: string, filename: string): Promise<JsxLocat
 
       // skip Fragment and already-tagged elements
       if (tagName && tagName !== 'Fragment' && !tagName.endsWith('.Fragment')) {
-        // Check if already has data-one-source
         const hasSourceAttr = node.attributes?.some(
           (attr: any) =>
             attr.type === 'JSXAttribute' && attr.name?.name === 'data-one-source'
         )
 
         if (!hasSourceAttr) {
-          // Insert position is right after the tag name
           const nameEnd = node.name.end
           const loc = getLocation(node.start)
 
@@ -73,7 +70,6 @@ async function findJsxElements(code: string, filename: string): Promise<JsxLocat
       }
     }
 
-    // Walk all child nodes in consistent order
     for (const key of Object.keys(node)) {
       if (key === 'parent') continue
       const value = node[key]
@@ -89,19 +85,15 @@ async function findJsxElements(code: string, filename: string): Promise<JsxLocat
 
   walk(result.program)
 
-  // Sort by offset descending so we can insert from end to start without shifting positions
   return locations.sort((a, b) => b.insertOffset - a.insertOffset)
 }
 
+type TransformOut = { code: string; map?: null } | undefined
+
 /**
  * Transforms JSX to inject data-one-source attributes using oxc-parser.
- * Embeds line:column directly in the attribute - safe because both SSR and client
- * run this same transform with enforce:'pre' on the same source.
  */
-async function injectSourceToJsx(
-  code: string,
-  id: string
-): Promise<{ code: string; map?: null } | undefined> {
+async function injectSourceToJsx(code: string, id: string): Promise<TransformOut> {
   const [filePath] = id.split('?')
   if (!filePath) return
 
@@ -155,9 +147,10 @@ async function openInEditor(
 
 // track connected vscode clients and browser clients
 const vscodeClients = new Set<WebSocket>()
-let viteServer: ViteDevServer | null = null
 
 export function sourceInspectorPlugin(): Plugin[] {
+  const cache = new Map<string, TransformOut>()
+
   return [
     // Transform plugin - injects data-one-source attributes
     {
@@ -165,7 +158,7 @@ export function sourceInspectorPlugin(): Plugin[] {
       enforce: 'pre',
       apply: 'serve',
 
-      transform(code, id) {
+      async transform(code, id) {
         const envName = this.environment?.name
         // Skip native environments only - transform both client and SSR for consistency
         if (envName === 'ios' || envName === 'android') return
@@ -181,7 +174,18 @@ export function sourceInspectorPlugin(): Plugin[] {
 
         if (!id.endsWith('.jsx') && !id.endsWith('.tsx')) return
 
-        return injectSourceToJsx(code, id)
+        if (cache.has(code)) {
+          return cache.get(code)
+        }
+
+        const out = await injectSourceToJsx(code, id)
+        cache.set(code, out)
+
+        if (cache.size > 100) {
+          cache.clear()
+        }
+
+        return out
       },
     },
 
@@ -193,8 +197,6 @@ export function sourceInspectorPlugin(): Plugin[] {
       apply: 'serve',
 
       configureServer(server: ViteDevServer) {
-        viteServer = server
-
         // set up websocket server for vscode cursor position
         let wss: InstanceType<typeof import('ws').WebSocketServer> | null = null
 

package/types/cli/build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/cli/build.ts"],"names":[],"mappings":"AAwDA,wBAAsB,KAAK,CAAC,IAAI,EAAE;IAChC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,SAAS,CAAA;IACpC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,iBAmgCA"}
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/cli/build.ts"],"names":[],"mappings":"AAwDA,wBAAsB,KAAK,CAAC,IAAI,EAAE;IAChC,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,SAAS,CAAA;IACpC,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,iBAygCA"}