@tanstack/start-plugin-core 1.167.35 → 1.168.0

package/src/vite/prerender.ts

@@ -1,50 +1,16 @@
-import { promises as fsp } from 'node:fs'
-import os from 'node:os'
-import path from 'pathe'
-import { joinURL, withBase, withTrailingSlash, withoutBase } from 'ufo'
 import { VITE_ENVIRONMENT_NAMES } from '../constants'
-import { createLogger } from '../utils'
-import { Queue } from '../queue'
+import { prerender } from '../prerender'
+import type { PrerenderHandler } from '../prerender'
+import type { TanStackStartOutputConfig } from '../schema'
 import type { PreviewServer, ResolvedConfig, ViteBuilder } from 'vite'
-import type { Page, TanStackStartOutputConfig } from '../schema'
 
-export async function prerender({
+export async function prerenderWithVite({
   startConfig,
   builder,
 }: {
   startConfig: TanStackStartOutputConfig
   builder: ViteBuilder
 }) {
-  const logger = createLogger('prerender')
-  logger.info('Prerendering pages...')
-
-  if (startConfig.prerender?.enabled) {
-    let pages = startConfig.pages.length ? startConfig.pages : [{ path: '/' }]
-
-    if (startConfig.prerender.autoStaticPathsDiscovery ?? true) {
-      const pagesMap = new Map(pages.map((item) => [item.path, item]))
-      const discoveredPages = globalThis.TSS_PRERENDABLE_PATHS || []
-
-      for (const page of discoveredPages) {
-        if (!pagesMap.has(page.path)) {
-          pagesMap.set(page.path, page)
-        }
-      }
-
-      pages = Array.from(pagesMap.values())
-    }
-
-    startConfig.pages = pages
-  }
-
-  const routerBasePath = joinURL('/', startConfig.router.basepath ?? '')
-  const routerBaseUrl = new URL(routerBasePath, 'http://localhost')
-
-  startConfig.pages = validateAndNormalizePrerenderPages(
-    startConfig.pages,
-    routerBaseUrl,
-  )
-
   const serverEnv = builder.environments[VITE_ENVIRONMENT_NAMES.server]
 
   if (!serverEnv) {
@@ -68,203 +34,23 @@ export async function prerender({
   const previewServer = await startPreviewServer(serverEnv.config)
   const baseUrl = getResolvedUrl(previewServer)
 
-  const isRedirectResponse = (res: Response) => {
-    return res.status >= 300 && res.status < 400 && res.headers.get('location')
-  }
-
-  async function localFetch(
-    path: string,
-    options?: RequestInit,
-    maxRedirects: number = 5,
-  ): Promise<Response> {
-    const url = new URL(path, baseUrl)
-    const request = new Request(url, options)
-    const response = await fetch(request)
-
-    if (isRedirectResponse(response) && maxRedirects > 0) {
-      const location = response.headers.get('location')!
-      if (location.startsWith('http://localhost') || location.startsWith('/')) {
-        const newUrl = location.replace('http://localhost', '')
-        return localFetch(newUrl, options, maxRedirects - 1)
-      }
-
-      logger.warn(`Skipping redirect to external location: ${location}`)
-    }
-
-    return response
-  }
-
-  try {
-    const pages = await prerenderPages({ outputDir })
-
-    logger.info(`Prerendered ${pages.length} pages:`)
-    pages.forEach((page) => {
-      logger.info(`- ${page}`)
-    })
-  } catch (error) {
-    logger.error(error)
-  } finally {
-    await previewServer.close()
+  const handler: PrerenderHandler = {
+    getClientOutputDirectory() {
+      return outputDir
+    },
+    request(path, options) {
+      const url = new URL(path, baseUrl)
+      return fetch(new Request(url, options))
+    },
+    close() {
+      return previewServer.close()
+    },
   }
 
-  function extractLinks(html: string): Array<string> {
-    const linkRegex = /<a[^>]+href=["']([^"']+)["'][^>]*>/g
-    const links: Array<string> = []
-    let match: RegExpExecArray | null
-
-    while ((match = linkRegex.exec(html)) !== null) {
-      const href = match[1]
-      if (href && (href.startsWith('/') || href.startsWith('./'))) {
-        links.push(href)
-      }
-    }
-
-    return links
-  }
-
-  async function prerenderPages({ outputDir }: { outputDir: string }) {
-    const seen = new Set<string>()
-    const prerendered = new Set<string>()
-    const retriesByPath = new Map<string, number>()
-    const concurrency = startConfig.prerender?.concurrency ?? os.cpus().length
-    logger.info(`Concurrency: ${concurrency}`)
-    const queue = new Queue({ concurrency })
-    const routerBasePath = joinURL('/', startConfig.router.basepath ?? '')
-
-    const routerBaseUrl = new URL(routerBasePath, 'http://localhost')
-    startConfig.pages = validateAndNormalizePrerenderPages(
-      startConfig.pages,
-      routerBaseUrl,
-    )
-
-    startConfig.pages.forEach((page) => addCrawlPageTask(page))
-
-    if (queue.isSettled()) {
-      logger.info('No pages matched prerender filter; skipping.')
-      return Array.from(prerendered)
-    }
-
-    await queue.start()
-
-    return Array.from(prerendered)
-
-    function addCrawlPageTask(page: Page) {
-      if (seen.has(page.path)) return
-
-      seen.add(page.path)
-
-      if (page.fromCrawl) {
-        startConfig.pages.push(page)
-      }
-
-      if (!(page.prerender?.enabled ?? true)) return
-
-      if (
-        startConfig.prerender?.filter &&
-        !startConfig.prerender.filter(page)
-      ) {
-        return
-      }
-
-      const prerenderOptions = {
-        ...startConfig.prerender,
-        ...page.prerender,
-      }
-
-      queue.add(async () => {
-        logger.info(`Crawling: ${page.path}`)
-        const retries = retriesByPath.get(page.path) || 0
-        try {
-          const res = await localFetch(
-            withTrailingSlash(withBase(page.path, routerBasePath)),
-            {
-              headers: {
-                ...(prerenderOptions.headers ?? {}),
-              },
-            },
-            prerenderOptions.maxRedirects,
-          )
-
-          if (!res.ok) {
-            if (isRedirectResponse(res)) {
-              logger.warn(`Max redirects reached for ${page.path}`)
-            }
-            throw new Error(`Failed to fetch ${page.path}: ${res.statusText}`, {
-              cause: res,
-            })
-          }
-
-          const cleanPagePath = (
-            prerenderOptions.outputPath || page.path
-          ).split(/[?#]/)[0]!
-
-          const contentType = res.headers.get('content-type') || ''
-          const isImplicitHTML =
-            !cleanPagePath.endsWith('.html') && contentType.includes('html')
-
-          const routeWithIndex = cleanPagePath.endsWith('/')
-            ? cleanPagePath + 'index'
-            : cleanPagePath
-
-          const isSpaShell =
-            startConfig.spa?.prerender.outputPath === cleanPagePath
-
-          let htmlPath: string
-          if (isSpaShell) {
-            htmlPath = cleanPagePath + '.html'
-          } else if (
-            cleanPagePath.endsWith('/') ||
-            (prerenderOptions.autoSubfolderIndex ?? true)
-          ) {
-            htmlPath = joinURL(cleanPagePath, 'index.html')
-          } else {
-            htmlPath = cleanPagePath + '.html'
-          }
-
-          const filename = withoutBase(
-            isImplicitHTML ? htmlPath : routeWithIndex,
-            routerBasePath,
-          )
-
-          const html = await res.text()
-
-          const filepath = path.join(outputDir, filename)
-
-          await fsp.mkdir(path.dirname(filepath), {
-            recursive: true,
-          })
-
-          await fsp.writeFile(filepath, html)
-
-          prerendered.add(page.path)
-
-          const newPage = await prerenderOptions.onSuccess?.({ page, html })
-
-          if (newPage) {
-            Object.assign(page, newPage)
-          }
-
-          if (prerenderOptions.crawlLinks ?? true) {
-            const links = extractLinks(html)
-            for (const link of links) {
-              addCrawlPageTask({ path: link, fromCrawl: true })
-            }
-          }
-        } catch (error) {
-          if (retries < (prerenderOptions.retryCount ?? 0)) {
-            logger.warn(`Encountered error, retrying: ${page.path} in 500ms`)
-            await new Promise((resolve) =>
-              setTimeout(resolve, prerenderOptions.retryDelay),
-            )
-            retriesByPath.set(page.path, retries + 1)
-            addCrawlPageTask(page)
-          } else if (prerenderOptions.failOnError ?? true) {
-            throw error
-          }
-        }
-      })
-    }
-  }
+  return prerender({
+    startConfig,
+    handler,
+  })
 }
 
 async function startPreviewServer(
@@ -299,30 +85,3 @@ function getResolvedUrl(previewServer: PreviewServer): URL {
 
   return new URL(baseUrl)
 }
-
-function validateAndNormalizePrerenderPages(
-  pages: Array<Page>,
-  routerBaseUrl: URL,
-): Array<Page> {
-  return pages.map((page) => {
-    let url: URL
-    try {
-      url = new URL(page.path, routerBaseUrl)
-    } catch (err) {
-      throw new Error(`prerender page path must be relative: ${page.path}`, {
-        cause: err,
-      })
-    }
-
-    if (url.origin !== 'http://localhost') {
-      throw new Error(`prerender page path must be relative: ${page.path}`)
-    }
-
-    const decodedPathname = decodeURIComponent(url.pathname)
-
-    return {
-      ...page,
-      path: decodedPathname + url.search + url.hash,
-    }
-  })
-}

package/src/vite/start-compiler-plugin/hot-update.ts

@@ -0,0 +1,24 @@
+import type { EnvironmentModuleNode } from 'vite'
+
+export function mergeHotUpdateModules(
+  currentModules: Array<EnvironmentModuleNode>,
+  additionalModules: Array<EnvironmentModuleNode>,
+): Array<EnvironmentModuleNode> | undefined {
+  if (additionalModules.length === 0) {
+    return undefined
+  }
+
+  const mergedModules = currentModules.slice()
+  const seenModules = new Set(currentModules)
+
+  for (const mod of additionalModules) {
+    if (seenModules.has(mod)) {
+      continue
+    }
+
+    seenModules.add(mod)
+    mergedModules.push(mod)
+  }
+
+  return mergedModules
+}

package/src/vite/start-compiler-plugin/module-specifier.ts

@@ -3,16 +3,21 @@ import type { DevServerFnModuleSpecifierEncoder } from '../../start-compiler/typ
 export function createViteDevServerFnModuleSpecifierEncoder(
   root: string,
 ): DevServerFnModuleSpecifierEncoder {
-  const rootWithTrailingSlash = root.endsWith('/') ? root : `${root}/`
+  const normalizedRoot = root.replace(/\\/g, '/')
+  const rootWithTrailingSlash = normalizedRoot.endsWith('/')
+    ? normalizedRoot
+    : `${normalizedRoot}/`
 
   return ({ extractedFilename }) => {
-    let file = extractedFilename
+    const normalizedFile = extractedFilename.replace(/\\/g, '/')
 
-    if (file.startsWith(rootWithTrailingSlash)) {
-      file = file.slice(rootWithTrailingSlash.length)
+    if (normalizedFile.startsWith(rootWithTrailingSlash)) {
+      return `/${normalizedFile.slice(rootWithTrailingSlash.length)}`
     }
 
-    return `/@id/${file}`
+    return normalizedFile.startsWith('/')
+      ? `/@fs${normalizedFile}`
+      : `/@fs/${normalizedFile}`
   }
 }
 
@@ -23,6 +28,11 @@ export function decodeViteDevServerModuleSpecifier(
 
   if (sourceFile.startsWith('/@id/')) {
     sourceFile = sourceFile.slice('/@id/'.length)
+  } else if (sourceFile.startsWith('/@fs/')) {
+    sourceFile = sourceFile.slice('/@fs'.length)
+    sourceFile = sourceFile.replace(/^\/([A-Za-z]:\/)/, '$1')
+  } else if (sourceFile.startsWith('/')) {
+    sourceFile = sourceFile.slice(1)
   }
 
   const queryIndex = sourceFile.indexOf('?')

package/src/vite/start-compiler-plugin/plugin.ts

@@ -1,4 +1,3 @@
-import assert from 'node:assert'
 import { VIRTUAL_MODULES } from '@tanstack/start-server-core'
 import { resolve as resolvePath } from 'pathe'
 import {
@@ -12,7 +11,6 @@ import {
   createStartCompiler,
   mergeServerFnsById,
 } from '../../start-compiler/host'
-import { loadModuleForViteCompiler } from '../../start-compiler/load-module'
 import { generateServerFnResolverModule } from '../../start-compiler/server-fn-resolver-module'
 import { cleanId } from '../../start-compiler/utils'
 import { createVirtualModule } from '../createVirtualModule'
@@ -21,17 +19,116 @@ import {
   createViteDevServerFnModuleSpecifierEncoder,
   decodeViteDevServerModuleSpecifier,
 } from './module-specifier'
+import { mergeHotUpdateModules } from './hot-update'
 import type { CompileStartFrameworkOptions } from '../../types'
 import type {
   GenerateFunctionIdFnOptional,
   ServerFn,
 } from '../../start-compiler/types'
-import type { PluginOption } from 'vite'
+import type { EnvironmentModuleNode, PluginOption } from 'vite'
 
 // Re-export from shared constants for backwards compatibility
 export { SERVER_FN_LOOKUP }
 
 const validateServerFnIdVirtualModule = `virtual:tanstack-start-validate-server-fn-id`
+const TSS_SERVERFN_SPLIT_PARAM = 'tss-serverfn-split'
+
+type ModuleInvalidationEnvironment = {
+  moduleGraph: {
+    getModulesByFile: (file: string) => Set<EnvironmentModuleNode> | undefined
+    invalidateModule: (
+      mod: EnvironmentModuleNode,
+      seen?: Set<EnvironmentModuleNode>,
+    ) => void
+  }
+}
+
+function invalidateMatchingFileModules(
+  environment: ModuleInvalidationEnvironment,
+  ids: Iterable<string>,
+  shouldInvalidate: (mod: EnvironmentModuleNode) => boolean,
+) {
+  const seen = new Set<EnvironmentModuleNode>()
+  const invalidatedModules: Array<EnvironmentModuleNode> = []
+
+  for (const id of ids) {
+    const fileModules = environment.moduleGraph.getModulesByFile(cleanId(id))
+
+    if (!fileModules) {
+      continue
+    }
+
+    for (const fileModule of fileModules) {
+      if (!shouldInvalidate(fileModule)) {
+        continue
+      }
+
+      environment.moduleGraph.invalidateModule(fileModule, seen)
+      invalidatedModules.push(fileModule)
+    }
+  }
+
+  return invalidatedModules
+}
+
+function invalidateServerFnProviderModules(
+  environment: {
+    moduleGraph: {
+      getModulesByFile: (file: string) => Set<EnvironmentModuleNode> | undefined
+      invalidateModule: (
+        mod: EnvironmentModuleNode,
+        seen?: Set<EnvironmentModuleNode>,
+      ) => void
+    }
+  },
+  ids: Iterable<string>,
+) {
+  return invalidateMatchingFileModules(
+    environment,
+    ids,
+    (fileModule) => fileModule.id?.includes(TSS_SERVERFN_SPLIT_PARAM) ?? false,
+  )
+}
+
+function invalidateServerFnLookupModules(
+  environment: ModuleInvalidationEnvironment,
+  ids: Iterable<string>,
+) {
+  invalidateMatchingFileModules(
+    environment,
+    ids,
+    (fileModule) => fileModule.id?.includes(SERVER_FN_LOOKUP) ?? false,
+  )
+}
+
+function getServerFnProviderIds(ids: Iterable<string>) {
+  const providerIds = new Set<string>()
+
+  for (const id of ids) {
+    const cleanedId = cleanId(id)
+    providerIds.add(`${cleanedId}?${TSS_SERVERFN_SPLIT_PARAM}`)
+  }
+
+  return providerIds
+}
+
+function invalidateModuleNodes(
+  environment: {
+    moduleGraph: {
+      invalidateModule: (
+        mod: EnvironmentModuleNode,
+        seen?: Set<EnvironmentModuleNode>,
+      ) => void
+    }
+  },
+  modules: Iterable<EnvironmentModuleNode>,
+) {
+  const seen = new Set<EnvironmentModuleNode>()
+
+  for (const mod of modules) {
+    environment.moduleGraph.invalidateModule(mod, seen)
+  }
+}
 
 function getDevServerFnValidatorModule(): string {
   return `
@@ -148,16 +245,23 @@ export function startCompilerPlugin(
                   ? createViteDevServerFnModuleSpecifierEncoder(root)
                   : undefined,
               loadModule: async (id: string) => {
-                await loadModuleForViteCompiler({
-                  compiler: compiler!,
-                  mode: this.environment.mode,
-                  fetchModule:
-                    this.environment.mode === 'dev'
-                      ? this.environment.fetchModule.bind(this.environment)
-                      : undefined,
-                  loadModule: this.load.bind(this),
-                  id,
-                })
+                if (mode === 'build') {
+                  const loaded = await this.load({ id })
+                  const code = loaded.code ?? ''
+
+                  compiler!.ingestModule({ code, id })
+                  return
+                }
+
+                if (this.environment.mode !== 'dev') {
+                  this.error(
+                    `could not load module ${id}: unknown environment mode ${this.environment.mode}`,
+                  )
+                }
+
+                await this.environment.transformRequest(
+                  `${id}?${SERVER_FN_LOOKUP}`,
+                )
               },
 
               resolveId: async (source: string, importer?: string) => {
@@ -190,19 +294,85 @@ export function startCompilerPlugin(
 
       hotUpdate(ctx) {
         const compiler = compilers.get(this.environment.name)
+        const idsToInvalidate = new Set<string>()
+        const transitiveCompilerImportersToInvalidate = new Set<string>()
+        const importerModulesToInvalidate = new Set<EnvironmentModuleNode>()
 
         ctx.modules.forEach((m) => {
           if (m.id) {
+            idsToInvalidate.add(m.id)
             const deleted = compiler?.invalidateModule(m.id)
+
+            if (deleted) {
+              transitiveCompilerImportersToInvalidate.add(cleanId(m.id))
+            }
+
             if (deleted) {
               m.importers.forEach((importer) => {
                 if (importer.id) {
-                  compiler?.invalidateModule(importer.id)
+                  idsToInvalidate.add(importer.id)
+                  importerModulesToInvalidate.add(importer)
+                  transitiveCompilerImportersToInvalidate.add(
+                    cleanId(importer.id),
+                  )
                 }
               })
             }
           }
         })
+
+        const finishHotUpdate = async () => {
+          if (environment.type === 'server' && compiler) {
+            const pendingImporters = [
+              ...transitiveCompilerImportersToInvalidate,
+            ]
+            const seenImporters = new Set(pendingImporters)
+
+            while (pendingImporters.length > 0) {
+              const importerId = pendingImporters.pop()!
+              const nestedImporters =
+                await compiler.getTransitiveImporters(importerId)
+
+              for (const nestedImporterId of nestedImporters) {
+                if (seenImporters.has(nestedImporterId)) {
+                  continue
+                }
+
+                seenImporters.add(nestedImporterId)
+                pendingImporters.push(nestedImporterId)
+              }
+            }
+
+            for (const importerId of seenImporters) {
+              idsToInvalidate.add(importerId)
+              compiler.invalidateModule(importerId)
+            }
+          }
+
+          invalidateModuleNodes(this.environment, importerModulesToInvalidate)
+          invalidateServerFnLookupModules(this.environment, idsToInvalidate)
+
+          if (environment.type !== 'server') {
+            return
+          }
+
+          invalidateModuleNodes(this.environment, ctx.modules)
+
+          const providerIdsToInvalidate =
+            getServerFnProviderIds(idsToInvalidate)
+          for (const providerId of providerIdsToInvalidate) {
+            compiler?.invalidateModule(providerId)
+          }
+
+          const providerModules = invalidateServerFnProviderModules(
+            this.environment,
+            [...idsToInvalidate, ...providerIdsToInvalidate],
+          )
+
+          return mergeHotUpdateModules(ctx.modules, providerModules)
+        }
+
+        return finishHotUpdate()
       },
     }
   }
@@ -267,10 +437,15 @@ export function startCompilerPlugin(
                   // Trigger transform of the source file in this environment,
                   // which will compile createServerFn calls and populate
                   // serverFnsById as a side effect.
-                  // This plugin only runs in dev (apply: 'serve'), so mode
-                  // must be 'dev' — assert to narrow to DevEnvironment.
-                  assert(this.environment.mode === 'dev')
-                  await this.environment.fetchModule(absPath)
+                  if (this.environment.mode !== 'dev') {
+                    this.error(
+                      `could not validate server function ID ${fnId}: unknown environment mode ${this.environment.mode}`,
+                    )
+                  }
+
+                  await this.environment.transformRequest(
+                    `${absPath}?${SERVER_FN_LOOKUP}`,
+                  )
 
                   // Re-check after lazy compilation
                   if (serverFnsById[fnId]) {

package/dist/esm/import-protection-plugin/ast.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ast.js","names":[],"sources":["../../../src/import-protection-plugin/ast.ts"],"sourcesContent":["import { parseAst } from '@tanstack/router-utils'\n\nexport type ParsedAst = ReturnType<typeof parseAst>\n\nexport function parseImportProtectionAst(code: string): ParsedAst {\n  return parseAst({ code })\n}\n"],"mappings":";;AAIA,SAAgB,yBAAyB,MAAyB;AAChE,QAAO,SAAS,EAAE,MAAM,CAAC"}

package/dist/esm/import-protection-plugin/constants.d.ts

@@ -1,6 +0,0 @@
-export declare const SERVER_FN_LOOKUP_QUERY = "?server-fn-module-lookup";
-export declare const IMPORT_PROTECTION_DEBUG: boolean;
-export declare const IMPORT_PROTECTION_DEBUG_FILTER: string | undefined;
-export declare const KNOWN_SOURCE_EXTENSIONS: Set<string>;
-/** Vite's browser-visible prefix for virtual modules (replaces `\0`). */
-export declare const VITE_BROWSER_VIRTUAL_PREFIX = "/@id/__x00__";

package/dist/esm/import-protection-plugin/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.js","names":[],"sources":["../../../src/import-protection-plugin/constants.ts"],"sourcesContent":["import { SERVER_FN_LOOKUP } from '../constants'\n\nexport const SERVER_FN_LOOKUP_QUERY = `?${SERVER_FN_LOOKUP}`\n\nexport const IMPORT_PROTECTION_DEBUG =\n  process.env.TSR_IMPORT_PROTECTION_DEBUG === '1' ||\n  process.env.TSR_IMPORT_PROTECTION_DEBUG === 'true'\n\nexport const IMPORT_PROTECTION_DEBUG_FILTER =\n  process.env.TSR_IMPORT_PROTECTION_DEBUG_FILTER\n\nexport const KNOWN_SOURCE_EXTENSIONS = new Set([\n  '.ts',\n  '.tsx',\n  '.mts',\n  '.cts',\n  '.js',\n  '.jsx',\n  '.mjs',\n  '.cjs',\n  '.json',\n])\n\n/** Vite's browser-visible prefix for virtual modules (replaces `\\0`). */\nexport const VITE_BROWSER_VIRTUAL_PREFIX = '/@id/__x00__'\n"],"mappings":";;AAEA,IAAa,yBAAyB,IAAI;AAE1C,IAAa,0BACX,QAAQ,IAAI,gCAAgC,OAC5C,QAAQ,IAAI,gCAAgC;AAE9C,IAAa,iCACX,QAAQ,IAAI;AAEd,IAAa,0BAA0B,IAAI,IAAI;CAC7C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;AAGF,IAAa,8BAA8B"}

package/dist/esm/import-protection-plugin/defaults.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"defaults.js","names":[],"sources":["../../../src/import-protection-plugin/defaults.ts"],"sourcesContent":["import type { ImportProtectionEnvRules } from '../schema'\nimport type { Pattern } from './utils'\n\nexport interface DefaultImportProtectionRules {\n  client: Required<ImportProtectionEnvRules>\n  server: Required<ImportProtectionEnvRules>\n}\n\nconst frameworks = ['react', 'solid', 'vue'] as const\n\n/**\n * Returns the default import protection rules.\n *\n * All three framework variants are always included so that, e.g., a React\n * project also denies `@tanstack/solid-start/server` imports.\n */\nexport function getDefaultImportProtectionRules(): DefaultImportProtectionRules {\n  const clientSpecifiers: Array<Pattern> = frameworks.map(\n    (fw) => `@tanstack/${fw}-start/server`,\n  )\n\n  return {\n    client: {\n      specifiers: clientSpecifiers,\n      files: ['**/*.server.*'],\n      excludeFiles: ['**/node_modules/**'],\n    },\n    server: {\n      specifiers: [],\n      files: ['**/*.client.*'],\n      excludeFiles: ['**/node_modules/**'],\n    },\n  }\n}\n\n/**\n * Marker module specifiers that restrict a file to a specific environment.\n */\nexport function getMarkerSpecifiers(): {\n  serverOnly: Array<string>\n  clientOnly: Array<string>\n} {\n  return {\n    serverOnly: frameworks.map((fw) => `@tanstack/${fw}-start/server-only`),\n    clientOnly: frameworks.map((fw) => `@tanstack/${fw}-start/client-only`),\n  }\n}\n"],"mappings":";AAQA,IAAM,aAAa;CAAC;CAAS;CAAS;CAAM;;;;;;;AAQ5C,SAAgB,kCAAgE;AAK9E,QAAO;EACL,QAAQ;GACN,YANqC,WAAW,KACjD,OAAO,aAAa,GAAG,eACzB;GAKG,OAAO,CAAC,gBAAgB;GACxB,cAAc,CAAC,qBAAqB;GACrC;EACD,QAAQ;GACN,YAAY,EAAE;GACd,OAAO,CAAC,gBAAgB;GACxB,cAAc,CAAC,qBAAqB;GACrC;EACF;;;;;AAMH,SAAgB,sBAGd;AACA,QAAO;EACL,YAAY,WAAW,KAAK,OAAO,aAAa,GAAG,oBAAoB;EACvE,YAAY,WAAW,KAAK,OAAO,aAAa,GAAG,oBAAoB;EACxE"}

package/dist/esm/import-protection-plugin/extensionlessAbsoluteIdResolver.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"extensionlessAbsoluteIdResolver.js","names":[],"sources":["../../../src/import-protection-plugin/extensionlessAbsoluteIdResolver.ts"],"sourcesContent":["import { basename, dirname, extname, isAbsolute } from 'node:path'\nimport { resolveModulePath } from 'exsolve'\n\nimport { KNOWN_SOURCE_EXTENSIONS } from './constants'\nimport { normalizeFilePath } from './utils'\n\nconst FILE_RESOLUTION_EXTENSIONS = [...KNOWN_SOURCE_EXTENSIONS]\n\ntype DepKey = `file:${string}` | `dir:${string}`\n\n/**\n * Canonicalize extensionless absolute IDs like `/src/foo.server` to the\n * physical file when possible.\n *\n * Keeps a small cache plus a reverse index so we can invalidate on HMR\n * updates without clearing the whole map.\n */\nexport class ExtensionlessAbsoluteIdResolver {\n  private entries = new Map<string, { value: string; deps: Set<DepKey> }>()\n  private keysByDep = new Map<DepKey, Set<string>>()\n\n  clear(): void {\n    this.entries.clear()\n    this.keysByDep.clear()\n  }\n\n  /**\n   * Invalidate any cached entries that might be affected by changes to `id`.\n   * We invalidate both the file and its containing directory.\n   */\n  invalidateByFile(id: string): void {\n    const file = normalizeFilePath(id)\n    this.invalidateDep(`file:${file}`)\n    if (isAbsolute(file)) {\n      this.invalidateDep(`dir:${dirname(file)}`)\n    }\n  }\n\n  resolve(id: string): string {\n    const key = normalizeFilePath(id)\n    const cached = this.entries.get(key)\n    if (cached) return cached.value\n\n    let result = key\n    let resolvedPhysical: string | undefined\n\n    if (isAbsolute(key)) {\n      const ext = extname(key)\n      if (!FILE_RESOLUTION_EXTENSIONS.includes(ext)) {\n        const resolved = resolveModulePath(`./${basename(key)}`, {\n          from: dirname(key),\n          extensions: FILE_RESOLUTION_EXTENSIONS,\n          try: true,\n        })\n        if (resolved) {\n          resolvedPhysical = resolved\n          result = normalizeFilePath(resolved)\n        }\n      }\n    }\n\n    const resolvedFile = resolvedPhysical\n      ? normalizeFilePath(resolvedPhysical)\n      : undefined\n\n    const deps = this.buildDepsForKey(key, resolvedFile)\n    this.entries.set(key, { value: result, deps })\n    this.indexDeps(key, deps)\n    return result\n  }\n\n  private invalidateDep(dep: DepKey): void {\n    const keys = this.keysByDep.get(dep)\n    if (!keys) return\n\n    // Copy because deleting keys mutates indexes.\n    for (const key of Array.from(keys)) {\n      this.deleteKey(key)\n    }\n  }\n\n  private buildDepsForKey(key: string, resolvedFile: string | undefined) {\n    const deps = new Set<DepKey>()\n    deps.add(`file:${key}`)\n\n    if (isAbsolute(key)) {\n      deps.add(`dir:${dirname(key)}`)\n    }\n    if (resolvedFile) {\n      deps.add(`file:${resolvedFile}`)\n    }\n\n    return deps\n  }\n\n  private indexDeps(key: string, deps: Set<DepKey>): void {\n    for (const dep of deps) {\n      let keys = this.keysByDep.get(dep)\n      if (!keys) {\n        keys = new Set<string>()\n        this.keysByDep.set(dep, keys)\n      }\n      keys.add(key)\n    }\n  }\n\n  private deleteKey(key: string): void {\n    const entry = this.entries.get(key)\n    this.entries.delete(key)\n    if (!entry) return\n\n    for (const dep of entry.deps) {\n      const keys = this.keysByDep.get(dep)\n      if (!keys) continue\n      keys.delete(key)\n      if (keys.size === 0) {\n        this.keysByDep.delete(dep)\n      }\n    }\n  }\n}\n"],"mappings":";;;;;AAMA,IAAM,6BAA6B,CAAC,GAAG,wBAAwB;;;;;;;;AAW/D,IAAa,kCAAb,MAA6C;CAC3C,0BAAkB,IAAI,KAAmD;CACzE,4BAAoB,IAAI,KAA0B;CAElD,QAAc;AACZ,OAAK,QAAQ,OAAO;AACpB,OAAK,UAAU,OAAO;;;;;;CAOxB,iBAAiB,IAAkB;EACjC,MAAM,OAAO,kBAAkB,GAAG;AAClC,OAAK,cAAc,QAAQ,OAAO;AAClC,MAAI,WAAW,KAAK,CAClB,MAAK,cAAc,OAAO,QAAQ,KAAK,GAAG;;CAI9C,QAAQ,IAAoB;EAC1B,MAAM,MAAM,kBAAkB,GAAG;EACjC,MAAM,SAAS,KAAK,QAAQ,IAAI,IAAI;AACpC,MAAI,OAAQ,QAAO,OAAO;EAE1B,IAAI,SAAS;EACb,IAAI;AAEJ,MAAI,WAAW,IAAI,EAAE;GACnB,MAAM,MAAM,QAAQ,IAAI;AACxB,OAAI,CAAC,2BAA2B,SAAS,IAAI,EAAE;IAC7C,MAAM,WAAW,kBAAkB,KAAK,SAAS,IAAI,IAAI;KACvD,MAAM,QAAQ,IAAI;KAClB,YAAY;KACZ,KAAK;KACN,CAAC;AACF,QAAI,UAAU;AACZ,wBAAmB;AACnB,cAAS,kBAAkB,SAAS;;;;EAK1C,MAAM,eAAe,mBACjB,kBAAkB,iBAAiB,GACnC,KAAA;EAEJ,MAAM,OAAO,KAAK,gBAAgB,KAAK,aAAa;AACpD,OAAK,QAAQ,IAAI,KAAK;GAAE,OAAO;GAAQ;GAAM,CAAC;AAC9C,OAAK,UAAU,KAAK,KAAK;AACzB,SAAO;;CAGT,cAAsB,KAAmB;EACvC,MAAM,OAAO,KAAK,UAAU,IAAI,IAAI;AACpC,MAAI,CAAC,KAAM;AAGX,OAAK,MAAM,OAAO,MAAM,KAAK,KAAK,CAChC,MAAK,UAAU,IAAI;;CAIvB,gBAAwB,KAAa,cAAkC;EACrE,MAAM,uBAAO,IAAI,KAAa;AAC9B,OAAK,IAAI,QAAQ,MAAM;AAEvB,MAAI,WAAW,IAAI,CACjB,MAAK,IAAI,OAAO,QAAQ,IAAI,GAAG;AAEjC,MAAI,aACF,MAAK,IAAI,QAAQ,eAAe;AAGlC,SAAO;;CAGT,UAAkB,KAAa,MAAyB;AACtD,OAAK,MAAM,OAAO,MAAM;GACtB,IAAI,OAAO,KAAK,UAAU,IAAI,IAAI;AAClC,OAAI,CAAC,MAAM;AACT,2BAAO,IAAI,KAAa;AACxB,SAAK,UAAU,IAAI,KAAK,KAAK;;AAE/B,QAAK,IAAI,IAAI;;;CAIjB,UAAkB,KAAmB;EACnC,MAAM,QAAQ,KAAK,QAAQ,IAAI,IAAI;AACnC,OAAK,QAAQ,OAAO,IAAI;AACxB,MAAI,CAAC,MAAO;AAEZ,OAAK,MAAM,OAAO,MAAM,MAAM;GAC5B,MAAM,OAAO,KAAK,UAAU,IAAI,IAAI;AACpC,OAAI,CAAC,KAAM;AACX,QAAK,OAAO,IAAI;AAChB,OAAI,KAAK,SAAS,EAChB,MAAK,UAAU,OAAO,IAAI"}

package/dist/esm/import-protection-plugin/matchers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"matchers.js","names":[],"sources":["../../../src/import-protection-plugin/matchers.ts"],"sourcesContent":["import picomatch from 'picomatch'\n\nimport type { Pattern } from './utils'\n\nexport interface CompiledMatcher {\n  pattern: Pattern\n  test: (value: string) => boolean\n}\n\n/**\n * Compile a Pattern (string glob or RegExp) into a fast test function.\n * String patterns use picomatch for full glob support (**, *, ?, braces, etc.).\n * RegExp patterns are used as-is.\n */\nexport function compileMatcher(pattern: Pattern): CompiledMatcher {\n  if (pattern instanceof RegExp) {\n    // RegExp with `g` or `y` flags are stateful because `.test()` mutates\n    // `lastIndex`. Reset it to keep matcher evaluation deterministic.\n    return {\n      pattern,\n      test: (value: string) => {\n        pattern.lastIndex = 0\n        return pattern.test(value)\n      },\n    }\n  }\n\n  const isMatch = picomatch(pattern, { dot: true })\n  return { pattern, test: isMatch }\n}\n\nexport function compileMatchers(\n  patterns: Array<Pattern>,\n): Array<CompiledMatcher> {\n  return patterns.map(compileMatcher)\n}\n\nexport function matchesAny(\n  value: string,\n  matchers: Array<CompiledMatcher>,\n): CompiledMatcher | undefined {\n  for (const matcher of matchers) {\n    if (matcher.test(value)) {\n      return matcher\n    }\n  }\n  return undefined\n}\n"],"mappings":";;;;;;;AAcA,SAAgB,eAAe,SAAmC;AAChE,KAAI,mBAAmB,OAGrB,QAAO;EACL;EACA,OAAO,UAAkB;AACvB,WAAQ,YAAY;AACpB,UAAO,QAAQ,KAAK,MAAM;;EAE7B;AAIH,QAAO;EAAE;EAAS,MADF,UAAU,SAAS,EAAE,KAAK,MAAM,CAAC;EAChB;;AAGnC,SAAgB,gBACd,UACwB;AACxB,QAAO,SAAS,IAAI,eAAe;;AAGrC,SAAgB,WACd,OACA,UAC6B;AAC7B,MAAK,MAAM,WAAW,SACpB,KAAI,QAAQ,KAAK,MAAM,CACrB,QAAO"}