@nifrajs/web 4.0.2 → 5.1.0

package/src/llms-txt.ts

@@ -3,9 +3,12 @@ import {
   reflectedRoutesFromEvidence,
   snapshotProjectEvidence,
 } from "@nifrajs/core/evidence"
+import { type BackendEvidenceProvider, NIFRA_BACKEND_EVIDENCE } from "@nifrajs/core/mount"
 import { compileRoutePattern, type RoutePatternSegment } from "@nifrajs/core/pattern"
 
 const IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/
+const RESERVED_CLIENT_SEGMENT = /^(?:get|post|put|patch|delete|head|options)$/i
+const RESERVED_EXACT_SEGMENTS = new Set(["subscribe", "ws", "index", "then"])
 
 /** The subset of JSON Schema fields {@link tsTypeOf} reads to render a TypeScript type string. */
 interface JsonSchemaNode {
@@ -93,7 +96,13 @@ function clientCall(method: string, path: string, schema: unknown): string {
   if (segs.length === 0) chain += ".index"
   else
     for (const seg of segs) {
-      chain += paramCall(seg) ?? (IDENT.test(seg) ? `.${seg}` : `[${JSON.stringify(seg)}]`)
+      chain +=
+        paramCall(seg) ??
+        (RESERVED_CLIENT_SEGMENT.test(seg) || RESERVED_EXACT_SEGMENTS.has(seg)
+          ? `(${JSON.stringify(seg)})`
+          : IDENT.test(seg)
+            ? `.${seg}`
+            : `[${JSON.stringify(seg)}]`)
     }
   const isBodyVerb = verb === "post" || verb === "put" || verb === "patch"
   let call: string
@@ -101,12 +110,27 @@ function clientCall(method: string, path: string, schema: unknown): string {
     const bodyArg = s?.body ? "body" : s?.query ? "undefined" : ""
     const opts = s?.query ? (bodyArg ? ", { query }" : "{ query }") : ""
     call = `.${verb}(${bodyArg}${opts})`
+  } else if (verb === "delete") {
+    const fields = [...(s?.body ? ["body"] : []), ...(s?.query ? ["query"] : [])]
+    call = `.delete(${fields.length === 0 ? "" : `{ ${fields.join(", ")} }`})`
   } else {
     call = `.${verb}(${s?.query ? "{ query }" : ""})`
   }
   return `await ${chain}${call}`
 }
 
+async function backendEvidence(backend: unknown): Promise<ProjectEvidenceSnapshot> {
+  if (backend !== null && (typeof backend === "object" || typeof backend === "function")) {
+    // biome-ignore lint/plugin/requireSafetyCommentForTypeAssertion: Object/function check allows reading the optional symbol-keyed provider without touching the client path proxy.
+    const provider = (backend as { readonly [NIFRA_BACKEND_EVIDENCE]?: unknown })[
+      NIFRA_BACKEND_EVIDENCE
+    ]
+    // biome-ignore lint/plugin/requireSafetyCommentForTypeAssertion: A callable at NIFRA_BACKEND_EVIDENCE implements the framework's trusted evidence-provider seam.
+    if (typeof provider === "function") return (provider as BackendEvidenceProvider).call(backend)
+  }
+  return snapshotProjectEvidence(backend)
+}
+
 /** Read the project's `AGENTS.md`, or `""` if there isn't one (or we're on an edge runtime with no
  * filesystem). Never throws - a missing file just means no guidelines section. */
 async function readAgentsMd(): Promise<string> {
@@ -134,6 +158,8 @@ export async function generateLlmsTxt(
     readonly includeLocalGuidelines?: boolean
     /** Reuse the project's canonical route-evidence pass when one is already available. */
     readonly evidence?: ProjectEvidenceSnapshot
+    /** The mount prefix a visitor's URL carries but the backend's own routes do not (`apiStrip`). */
+    readonly apiPathPrefix?: string
   } = {},
 ): Promise<string> {
   let output = ""
@@ -160,14 +186,17 @@ export async function generateLlmsTxt(
   // 3. API Routes
   output += `## API Routes\n\n`
   const apiRoutes = reflectedRoutesFromEvidence(
-    options.evidence ?? snapshotProjectEvidence(backend),
+    options.evidence ?? (await backendEvidence(backend)),
   )
 
   if (apiRoutes.length === 0) {
     output += `No API routes registered.\n`
   } else {
+    const prefix = options.apiPathPrefix ?? ""
     for (const route of apiRoutes) {
-      output += `- **${route.method}** \`${route.path}\`\n`
+      // The stripped backend's root is the bare prefix, as the mount matches it.
+      const path = prefix !== "" && route.path === "/" ? prefix : prefix + route.path
+      output += `- **${route.method}** \`${path}\`\n`
       if (full) {
         output += `  - Client Call: \`${clientCall(route.method, route.path, route.schema)}\`\n`
         const s = route.schema

package/src/manifest.ts

@@ -271,13 +271,24 @@ export interface Meta {
 }
 
 /**
- * Args for a route's `meta` function: the loader's `data` + the route `params` + the request `origin`.
- * `meta()` runs in BOTH SSR and client navigation, so it has **no `request`/`process.env`/server access** -
- * `origin` is the only server-resolved fact it gets (so you needn't thread `siteUrl` through loader data
- * for absolute `og:url`/`canonical`/`og:image` URLs). See {@link origin}.
+ * Args for a route's or layout's `meta` function: its own loader's `data` + the page's `pageData` + the
+ * route `params` + the request `origin`. `meta()` runs in BOTH SSR and client navigation, so it has
+ * **no `request`/`process.env`/server access** - `origin` is the only server-resolved fact it gets (so you
+ * needn't thread `siteUrl` through loader data for absolute `og:url`/`canonical`/`og:image` URLs). See
+ * {@link origin}.
  */
 export interface MetaArgs<Data = unknown> {
+  /**
+   * The loader data of the module that exports this `meta`: the page's for a page, the layout's own for a
+   * layout (`null` when the layout has no loader), the same value its component receives. A layout that
+   * loads the locale sets `lang` from here, so a soft navigation keeps it.
+   */
   readonly data: Data
+  /**
+   * The page's loader data, for a layout's `meta` that builds on the page (a title template). In a page's
+   * own `meta` it is the same value as {@link data}. Always set by the framework.
+   */
+  readonly pageData?: unknown
   readonly params: Record<string, string>
   /** The resolved document CSP nonce, when this render uses per-request nonce protection. */
   readonly nonce?: string
@@ -323,7 +334,18 @@ export type GetStaticPaths = () => StaticPaths | Promise<StaticPaths>
 export interface RouteModule {
   readonly default: unknown
   readonly loader?: Loader
+  /** Layout loader that must run before actions and is not retained across the action's render. */
+  readonly gate?: boolean
   readonly action?: Action
+  /**
+   * Backend half only: which browser origins may POST to {@link action}. When omitted, a request
+   * whose `Origin` is another site's is refused with 403 before middleware, gates or the action run;
+   * requests without an `Origin` (non-browser clients) pass. An array allows exactly those origins
+   * (and refuses a request without one); a function decides, receiving `null` when there is none.
+   * Use it for a callback a third party posts to, such as an identity provider's `form_post`.
+   * `Origin` is browser-enforced, not authentication: keep the action's own auth checks.
+   */
+  readonly allowedOrigins?: ReadonlyArray<string> | ((origin: string | null) => boolean)
   /**
    * Backend half only: the schema of what {@link loader} sends to the browser. Required whenever the
    * loader returns data. Keys it does not declare are dropped before the page renders; a declared
@@ -384,6 +406,14 @@ export interface RouteModule {
    * the module on the server and in the browser, so it must be the same value on both.
    */
   readonly handle?: unknown
+  /**
+   * On a root status page (`_404.tsx`, `_<status>.tsx`) or an `_error.tsx`. By default (`true`) the
+   * page renders inside the layouts above it with their loader data and `meta`, as a nested `_404`
+   * renders. When those layouts cannot render it - a loader throws, a gate or the middleware refuses -
+   * a root status page renders alone and an `_error` inside its layouts without their data, with the
+   * same status. `false` always renders them that way, and runs no layout loader for them.
+   */
+  readonly inLayouts?: boolean
   /**
    * Opt a **static** route (no `:param`/`*`) into build-time prerendering (SSG): `prerenderRoutes`
    * (from `@nifrajs/web/build`) renders it to a static `index.html` at build. The loader runs at build
@@ -621,6 +651,7 @@ export const BACKEND_ROUTE_EXPORTS: ReadonlySet<string> = new Set([
   "middleware",
   "gate",
   "shouldRevalidate",
+  "allowedOrigins",
 ])
 
 const routeError = (message: string): Error => new Error(`[nifra/web] ${message}`)
@@ -998,6 +1029,9 @@ const ancestorDirs = (file: string): string[] => {
  * turns a path into a lazy module loader. Pure - no fs. Throws at boot (the loud-and-early
  * RouteConfigError ethos) on duplicate patterns. `_layout`/`_404`/`_error`/`_loading`/`_middleware`
  * files are special; other `_`-prefixed files are ignored (private/colocated, never routed).
+ * A page pairs with its `.backend.*` half only when both are in `files`, so a hand-written list that
+ * omits the half serves the page without its loader and guards; `discoverRoutes` from
+ * `@nifrajs/web/fs` scans a routes dir and never does.
  */
 export function buildManifest(
   files: readonly string[],

package/src/open-resolved.ts

@@ -0,0 +1,64 @@
+import { constants as FS } from "node:fs"
+import { type FileHandle, open, readlink, realpath, stat } from "node:fs/promises"
+
+// Darwin's open(2) flag refusing a symlink in ANY component; `O_NOFOLLOW` covers only the last one.
+const O_NOFOLLOW_ANY = 0x20000000
+// Deno's node:fs rejects flags it does not know with EINVAL; the first refusal turns the flag off.
+let noFollowAny: boolean | undefined
+
+/**
+ * Open a name `realpath` already resolved, refusing it when any component became a symlink since.
+ * A local writer inside the served tree can swap an intermediate directory for a link after the
+ * containment check; `O_NOFOLLOW` alone would follow it. Darwin refuses such a path in the kernel;
+ * Linux reads back the name the descriptor holds. Elsewhere, Windows included, no file API can open
+ * without following a middle link or name an open descriptor's path, so the check in
+ * {@link opensAt} is a platform limit: it narrows the race to repeated swaps but cannot close it.
+ */
+export async function openResolved(realFile: string): Promise<FileHandle> {
+  // Read per open, not at load: this module can sit in a client bundle graph, where `process` is
+  // undefined.
+  if (noFollowAny ?? process.platform === "darwin") {
+    try {
+      return await open(realFile, FS.O_RDONLY | O_NOFOLLOW_ANY)
+    } catch (error) {
+      if (!(error instanceof Error && "code" in error && error.code === "EINVAL")) throw error
+      noFollowAny = false
+    }
+  }
+  const handle = await open(realFile, FS.O_RDONLY | FS.O_NOFOLLOW)
+  try {
+    if (await opensAt(handle, realFile)) return handle
+  } catch {}
+  await handle.close()
+  throw Object.assign(new Error(`${realFile} moved while it was opened`), { code: "ELOOP" })
+}
+
+/** Whether `handle` is the file at `realFile` with no symlink in its path. */
+export async function opensAt(
+  handle: Pick<FileHandle, "fd" | "stat">,
+  realFile: string,
+): Promise<boolean> {
+  try {
+    return (await readlink(`/proc/self/fd/${handle.fd}`)) === realFile
+  } catch {
+    return sameFileAt(handle, realFile)
+  }
+}
+
+/**
+ * {@link opensAt} where no descriptor's path can be read. Exported for its test, which runs it on
+ * every host.
+ */
+export async function sameFileAt(
+  handle: Pick<FileHandle, "stat">,
+  realFile: string,
+): Promise<boolean> {
+  // One step after another, so passing takes a swap back and a swap again between steps: the name
+  // resolves to itself, then to the opened file, then to itself again. Identities are compared as
+  // bigints because a Windows file index can exceed 2^53.
+  if ((await realpath(realFile)) !== realFile) return false
+  const opened = await handle.stat({ bigint: true })
+  const named = await stat(realFile, { bigint: true })
+  if (opened.dev !== named.dev || opened.ino !== named.ino) return false
+  return (await realpath(realFile)) === realFile
+}

package/src/plugins/kit.ts

@@ -4,7 +4,7 @@
  * CSS→client-bundle wiring, the deterministic hash, or the optional-peer guard. Internal to
  * `@nifrajs/web` (imported by the sibling plugin modules); not a public subpath.
  */
-import { existsSync } from "node:fs"
+import { existsSync, readFileSync } from "node:fs"
 import { dirname, join, relative } from "node:path"
 import { fileURLToPath, pathToFileURL } from "node:url"
 import type { BunPlugin } from "bun"
@@ -23,7 +23,7 @@ export type PluginBuilder = Parameters<BunPlugin["setup"]>[0]
  */
 export { rewriteSsrImports } from "../dev-ssr-graph.ts"
 
-const packageRootCache = new Map<string, string>()
+const packageCache = new Map<string, PackageOf>()
 
 /**
  * Convert a plugin/runtime path into a path the host filesystem can open.
@@ -57,14 +57,31 @@ export function portablePath(path: string): string {
   return normalizeFilePath(path).replaceAll("\\", "/")
 }
 
-/** The nearest ancestor directory of `startDir` that holds a `package.json` (the file's package root),
- * cached. Falls back to `startDir` if none is found, so it never throws. */
-function packageRootOf(startDir: string): string {
-  const cached = packageRootCache.get(startDir)
+interface PackageOf {
+  readonly root: string
+  readonly name: string
+}
+
+/** The nearest ancestor directory of `startDir` that holds a `package.json` (the file's package root)
+ * and that package's `name` (`""` when it has none), cached. Falls back to `startDir` if none is found,
+ * so it never throws. */
+function packageOf(startDir: string): PackageOf {
+  const cached = packageCache.get(startDir)
   if (cached !== undefined) return cached
   let dir = startDir
+  let name = ""
   for (;;) {
-    if (existsSync(join(dir, "package.json"))) break
+    const manifest = join(dir, "package.json")
+    if (existsSync(manifest)) {
+      try {
+        const parsed: unknown = JSON.parse(readFileSync(manifest, "utf8"))
+        if (typeof parsed === "object" && parsed !== null && "name" in parsed)
+          name = typeof parsed.name === "string" ? parsed.name : ""
+      } catch {
+        // An unreadable manifest still marks the package root; the name is only a disambiguator.
+      }
+      break
+    }
     const parent = dirname(dir)
     if (parent === dir) {
       dir = startDir // reached the filesystem root with no package.json - anchor on the file's own dir
@@ -72,8 +89,9 @@ function packageRootOf(startDir: string): string {
     }
     dir = parent
   }
-  packageRootCache.set(startDir, dir)
-  return dir
+  const found = { root: dir, name }
+  packageCache.set(startDir, found)
+  return found
 }
 
 /**
@@ -84,11 +102,13 @@ function packageRootOf(startDir: string): string {
  * different machines or from different cwds - derive the SAME relative path for a given file, so their
  * scoped class maps always agree. (Hashing the absolute path would differ across CI/host; a
  * cwd-relative path would silently desync if the SSR server started from a non-project-root cwd.)
+ * The package's `name` leads the path, so `src/Card.vue` in two workspace packages hashes apart.
  */
 export function reproduciblePath(absolutePath: string): string {
   const filePath = normalizeFilePath(absolutePath)
-  const root = packageRootOf(dirname(filePath))
-  return relative(root, filePath).replaceAll("\\", "/")
+  const { root, name } = packageOf(dirname(filePath))
+  const path = relative(root, filePath).replaceAll("\\", "/")
+  return name === "" ? path : `${name}/${path}`
 }
 
 /**

package/src/plugins/vite-leak-guard.ts

@@ -46,6 +46,7 @@ import {
   formatServerOnlyLeak,
 } from "../build-plan.ts"
 import { isBareNodeBuiltin } from "../internal/node-builtins.ts"
+import { installedManifest } from "../internal/package-entries.ts"
 import { privateEnvCheck } from "../internal/private-env.ts"
 import {
   emittedScanFiles,
@@ -58,6 +59,7 @@ import {
   scanForSecrets,
   textOf,
 } from "../internal/secret-scan.ts"
+import { withoutQuery } from "../internal/without-query.ts"
 import {
   accountEmittedFiles,
   assetDenial,
@@ -75,7 +77,7 @@ import {
   type GraphModule,
   type RollupBundleLike,
 } from "../module-graph.ts"
-import { createZoneClassifier, type ZoneClassifier } from "../zones.ts"
+import { createZoneClassifier, specifierPackage, type ZoneClassifier } from "../zones.ts"
 
 /**
  * The Rollup plugin-context slice this uses: `getModuleInfo` for a module's resolved imports, and `error`
@@ -160,9 +162,80 @@ export interface LeakGuardPlugin {
    * reached the browser.
    */
   leak?: string
+  buildStart(): void
+  /** Ordered first: the bundler's own resolver answers before a plugin listed after it is asked. */
+  readonly resolveId: {
+    readonly order: "pre"
+    handler(
+      this: ResolveContext,
+      source: string,
+      importer: string | undefined,
+      options?: Readonly<Record<string, unknown>>,
+    ): Promise<null>
+  }
   generateBundle(this: RollupPluginContext, options: unknown, bundle: RollupBundleLike): void
 }
 
+/**
+ * Rollup keeps no import's written specifier, yet a package that gives each entry its own side is judged
+ * by the entry an import names, since two entries may share one file. This records the specifier of
+ * each import of such a package by the edge it resolved to, and puts it back on the finished graph.
+ */
+function entrySpecifiers(appRoot: string, options: ServerZoneGuardOptions) {
+  // One edge may carry several specifiers: `pkg` and `pkg/react` can resolve to one shared file.
+  const written = new Map<string, Set<string>>()
+  let classifier: ZoneClassifier | undefined
+  const edge = (from: string, to: string): string =>
+    `${from.replaceAll("\\", "/")}\0${to.replaceAll("\\", "/")}`
+  return {
+    reset(): void {
+      written.clear()
+      classifier = undefined
+    },
+    async resolveId(
+      context: ResolveContext,
+      source: string,
+      importer: string | undefined,
+      resolveOptions: Readonly<Record<string, unknown>> | undefined,
+    ): Promise<null> {
+      const name = specifierPackage(source)
+      const from = importer === undefined ? undefined : withoutQuery(importer)
+      if (name === undefined || importer === undefined || from === undefined || !isAbsolute(from))
+        return null
+      const manifest = installedManifest(dirname(from), name)
+      if (manifest === undefined) return null
+      classifier ??= classifierFor(appRoot, options)
+      if (classifier.classify(manifest, source).entry === undefined) return null
+      const resolved = await context.resolve(source, importer, {
+        ...resolveOptions,
+        skipSelf: true,
+      })
+      if (resolved === null) return null
+      const key = edge(importer, resolved.id)
+      written.set(key, (written.get(key) ?? new Set<string>()).add(source))
+      return null
+    },
+    annotate(graph: ClientModuleGraph): ClientModuleGraph {
+      if (written.size === 0) return graph
+      const modules: Record<string, GraphModule> = {}
+      for (const [id, module] of Object.entries(graph.modules)) {
+        modules[id] = {
+          imports: module.imports.flatMap((im) => {
+            const originals =
+              im.original !== undefined || im.path === undefined
+                ? undefined
+                : written.get(edge(id, im.path))
+            return originals === undefined
+              ? [im]
+              : [...originals].map((original) => ({ ...im, original }))
+          }),
+        }
+      }
+      return { ...graph, modules }
+    },
+  }
+}
+
 const CSS_FILE = /\.(?:css|scss|sass|less|styl)(?:$|\?)/
 
 /**
@@ -175,8 +248,16 @@ export function viteLeakGuard(options: LeakGuardOptions = {}): LeakGuardPlugin {
   const appRoot = resolve(options.appRoot ?? process.cwd())
   const root = resolve(options.root ?? appRoot)
   const outDir = resolve(root, options.outDir ?? "dist")
+  const specifiers = entrySpecifiers(appRoot, options)
   const plugin: LeakGuardPlugin = {
     name: "nifra:leak-guard",
+    buildStart: () => specifiers.reset(),
+    resolveId: {
+      order: "pre",
+      handler(source, importer, resolveOptions) {
+        return specifiers.resolveId(this, source, importer, resolveOptions)
+      },
+    },
     generateBundle(_options, bundle) {
       const classifier = classifierFor(appRoot, options)
       // Resolved import edges per module, straight from Rollup's graph. Dynamic imports count too: a
@@ -186,7 +267,9 @@ export function viteLeakGuard(options: LeakGuardOptions = {}): LeakGuardPlugin {
         if (info === null) return []
         return [...(info.importedIds ?? []), ...(info.dynamicallyImportedIds ?? [])]
       }
-      const graph = completeGraph(fromRollupBundle(bundle, importsOf), this, importsOf)
+      const graph = specifiers.annotate(
+        completeGraph(fromRollupBundle(bundle, importsOf), this, importsOf),
+      )
       const sources = { classifier, sourceOf: rollupModuleSource }
       const privateEnv = privateEnvCheck(options.publicEnvPrefix ?? "PUBLIC_")
       const outputs = Object.values(bundle as Readonly<Record<string, RollupOutputLike>>)
@@ -251,6 +334,7 @@ function secretLeak(
       artifacts,
       env: options.secrets?.env ?? process.env,
       publicEnvPrefix: options.publicEnvPrefix ?? "PUBLIC_",
+      // biome-ignore lint/plugin/noConditionalEmptyObjectSpread: Explicitly configured secret-scan exemptions preserve their absence by default.
       ...(options.secrets?.exemptions ? { exemptions: options.secrets.exemptions } : {}),
     }),
   )
@@ -260,7 +344,7 @@ function secretLeak(
 export type ServerZoneGuardOptions = Pick<
   LeakGuardOptions,
   "appRoot" | "routesDir" | "generatedFiles" | "publicEnvPrefix"
->
+> & { readonly componentModules?: ReadonlySet<string> }
 
 /**
  * The server build's half of the zone rules, with the same checks and message as nifra's Bun server
@@ -270,8 +354,16 @@ export type ServerZoneGuardOptions = Pick<
  */
 export function viteServerZoneGuard(options: ServerZoneGuardOptions = {}): LeakGuardPlugin {
   const appRoot = resolve(options.appRoot ?? process.cwd())
+  const specifiers = entrySpecifiers(appRoot, options)
   const plugin: LeakGuardPlugin = {
     name: "nifra:server-zone-guard",
+    buildStart: () => specifiers.reset(),
+    resolveId: {
+      order: "pre",
+      handler(source, importer, resolveOptions) {
+        return specifiers.resolveId(this, source, importer, resolveOptions)
+      },
+    },
     generateBundle(_options, bundle) {
       const classifier = classifierFor(appRoot, options)
       const importsOf = (id: string): readonly string[] => {
@@ -279,12 +371,17 @@ export function viteServerZoneGuard(options: ServerZoneGuardOptions = {}): LeakG
         if (info === null) return []
         return [...(info.importedIds ?? []), ...(info.dynamicallyImportedIds ?? [])]
       }
-      const graph = completeGraph(fromRollupBundle(bundle, importsOf), this, importsOf)
+      const graph = specifiers.annotate(
+        completeGraph(fromRollupBundle(bundle, importsOf), this, importsOf),
+      )
       const leak = formatServerGraphVerdict(
         verifyServerGraph(graph, {
           classifier,
           sourceOf: rollupModuleSource,
           privateEnv: privateEnvCheck(options.publicEnvPrefix ?? "PUBLIC_"),
+          ...(options.componentModules === undefined
+            ? {}
+            : { componentModules: options.componentModules }),
         }),
       )
       if (leak === undefined) return
@@ -461,7 +558,6 @@ export interface AssetUrlGuardPlugin {
   ): Promise<null>
 }
 
-const POSTFIX = /[?#].*$/s
 const URL_SCHEME = /^(?:[a-z][a-z\d+.-]*:|\/\/)/i
 
 /**
@@ -503,7 +599,7 @@ export function viteAssetUrlGuard(options: ServerZoneGuardOptions = {}): AssetUr
     },
     async transform(code, id, transformOptions) {
       if (transformOptions?.ssr === true || !code.includes("import.meta.url")) return null
-      const importer = id.replace(POSTFIX, "")
+      const importer = withoutQuery(id)
       if (!isAbsolute(importer) || importer.includes("/node_modules/") || CSS_FILE.test(importer))
         return null
       let program: unknown
@@ -549,11 +645,11 @@ async function assetUrlFiles(
 ): Promise<string[]> {
   const files = new Set<string>()
   const add = (path: string | undefined): void => {
-    const file = path?.replace(POSTFIX, "")
+    const file = path === undefined ? undefined : withoutQuery(path)
     if (file === undefined || !isAbsolute(file) || file.includes("\0")) return
     if (statSync(file, { throwIfNoEntry: false })?.isFile() === true) files.add(file)
   }
-  if (!url.startsWith("/")) add(resolve(dirname(importer), url.replace(POSTFIX, "")))
+  if (!url.startsWith("/")) add(resolve(dirname(importer), withoutQuery(url)))
   const sources = url.startsWith(".") || url.startsWith("/") ? [url] : [url, `./${url}`]
   for (const source of sources) {
     try {

package/src/plugins/vite-zone-guard.ts

@@ -10,10 +10,12 @@
  *
  * The SSR environment loads the same files legitimately and is never checked here.
  */
-import { existsSync, readFileSync, statSync } from "node:fs"
+import { readFileSync, statSync } from "node:fs"
 import type { IncomingMessage, ServerResponse } from "node:http"
 import { dirname, isAbsolute, join, relative, resolve } from "node:path"
+import { installedManifest } from "../internal/package-entries.ts"
 import { privateEnvDenial } from "../internal/private-env.ts"
+import { withoutQuery } from "../internal/without-query.ts"
 import {
   browserDenial,
   type Classification,
@@ -78,7 +80,6 @@ export interface ViteZoneGuardPlugin {
   fileForUrl(url: string): string | undefined
 }
 
-const stripQuery = (id: string): string => id.replace(/[?#].*$/, "")
 /** Query forms that hand a module's source, or a URL to it, to the browser untransformed. */
 const RAW_QUERY = /(?:^|&)(?:raw|url|inline)(?:[&=]|$)/
 
@@ -136,7 +137,7 @@ export function viteZoneGuard(options: ViteZoneGuardOptions): ViteZoneGuardPlugi
   const fileForUrl = (url: string): string | undefined => {
     let path: string
     try {
-      path = decodeURIComponent(stripQuery(url))
+      path = decodeURIComponent(withoutQuery(url))
     } catch {
       return undefined
     }
@@ -187,16 +188,17 @@ export function viteZoneGuard(options: ViteZoneGuardOptions): ViteZoneGuardPlugi
     return context.error(new Error(message))
   }
 
-  /** A bare specifier's package, classified through its manifest so a workspace link is first-party. */
-  const packageClassification = (name: string, importer: string): Classification => {
-    let dir = dirname(importer)
-    for (;;) {
-      const manifest = join(dir, "node_modules", name, "package.json")
-      if (existsSync(manifest)) return classifier.classify(manifest)
-      const parent = dirname(dir)
-      if (parent === dir) return { zone: "library", packageName: name }
-      dir = parent
-    }
+  /** A bare import's package, classified through its manifest so a workspace link is first-party,
+   * and by the entry it names when the package declares a side per entry. */
+  const packageClassification = (
+    name: string,
+    importer: string,
+    specifier: string,
+  ): Classification => {
+    const manifest = installedManifest(dirname(importer), name)
+    return manifest === undefined
+      ? { zone: "library", packageName: name }
+      : classifier.classify(manifest, specifier)
   }
 
   return {
@@ -219,10 +221,10 @@ export function viteZoneGuard(options: ViteZoneGuardOptions): ViteZoneGuardPlugi
     async resolveId(source, importer, resolveOptions) {
       if (importer === undefined || resolveOptions?.scan === true) return null
       if (!isClient(this, resolveOptions?.ssr)) return null
-      const importerFile = stripQuery(importer)
+      const importerFile = withoutQuery(importer)
       if (!isAbsolute(importerFile)) return null
       if (source.startsWith(".")) {
-        const target = resolve(dirname(importerFile), stripQuery(source))
+        const target = resolve(dirname(importerFile), withoutQuery(source))
         if (isFile(target)) {
           const reason = browserDenial(classifier.classify(target))
           if (reason !== undefined) refuse(this, target, reason, importerFile)
@@ -231,21 +233,21 @@ export function viteZoneGuard(options: ViteZoneGuardOptions): ViteZoneGuardPlugi
       }
       const name = specifierPackage(source)
       if (name !== undefined) {
-        const reason = browserDenial(packageClassification(name, importerFile), source)
+        const reason = browserDenial(packageClassification(name, importerFile, source), source)
         if (reason !== undefined) refuse(this, source, reason, importerFile)
       }
       // An alias, a tsconfig path or a package export: what the specifier resolves to decides.
       const resolved = await this.resolve(source, importer, { ...resolveOptions, skipSelf: true })
-      const target = resolved === null || resolved.external ? undefined : stripQuery(resolved.id)
+      const target = resolved === null || resolved.external ? undefined : withoutQuery(resolved.id)
       if (target !== undefined && isAbsolute(target) && isFile(target)) {
-        const reason = browserDenial(classifier.classify(target), source)
+        const reason = browserDenial(classifier.classify(target, source), source)
         if (reason !== undefined) refuse(this, target, reason, importerFile)
       }
       return null
     },
     transform(code, id, transformOptions) {
       if (!isClient(this, transformOptions?.ssr)) return null
-      const file = stripQuery(id)
+      const file = withoutQuery(id)
       if (!isAbsolute(file) || !isFile(file)) return null
       // A fresh transform re-resolves every import, so an earlier refusal is stale until it recurs.
       refusals.delete(resolve(file))