@nifrajs/web 2.14.1 → 3.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nifrajs/web",
-  "version": "2.14.1",
+  "version": "3.1.0",
   "description": "Framework-agnostic SSR core for nifra - the render seam + HTML document orchestration.",
   "keywords": [
     "bun",
@@ -159,6 +159,16 @@
       "bun": "./src/internal/parity.ts",
       "types": "./dist/internal/parity.d.ts",
       "default": "./dist/internal/parity.js"
+    },
+    "./internal/query-runtime": {
+      "bun": "./src/internal/query-runtime.ts",
+      "types": "./dist/internal/query-runtime.d.ts",
+      "default": "./dist/internal/query-runtime.js"
+    },
+    "./internal/fetcher-runtime": {
+      "bun": "./src/internal/fetcher-runtime.ts",
+      "types": "./dist/internal/fetcher-runtime.d.ts",
+      "default": "./dist/internal/fetcher-runtime.js"
     }
   },
   "files": [
@@ -176,7 +186,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@nifrajs/core": "2.14.1"
+    "@nifrajs/core": "3.1.0",
+    "@nifrajs/island-trigger": "3.1.0"
   },
   "peerDependencies": {
     "sass": "^1.0.0",

package/src/boundary.ts

@@ -0,0 +1,407 @@
+/**
+ * Framework-neutral async boundaries. A boundary owns one named piece of UI data; the web core owns
+ * lifecycle, concurrency, and isolation while each adapter decides how its `render` result is mounted.
+ * The contract deliberately contains no React/Svelte/Vue/Preact types.
+ */
+
+/** Request-scoped inputs available to dynamic and intercepting boundaries. */
+export interface BoundaryRequestCtx {
+  readonly request: Request
+  readonly params: Readonly<Record<string, string>>
+  readonly api: unknown
+  readonly env: unknown
+  readonly draft: boolean
+  readonly search: Readonly<Record<string, unknown>>
+  readonly signal: AbortSignal
+}
+
+/** Build-safe inputs available to a static boundary. It intentionally has no request/session/params API. */
+export interface StaticCtx {
+  readonly phase: "build"
+  readonly origin?: string
+}
+
+export type BoundaryMode = "static" | "dynamic" | { readonly intercept: string }
+
+interface BoundaryBase<Data, UI> {
+  readonly name: string
+  readonly render: (data: Data) => UI
+  readonly fallback?: UI
+  /** Adapter-provided error slot name. The neutral core never imports a UI component. */
+  readonly errorId?: string
+}
+
+export type StaticBoundary<Data, UI> = BoundaryBase<Data, UI> & {
+  readonly mode: "static"
+  readonly load?: (ctx: StaticCtx) => Data | Promise<Data>
+}
+
+export type DynamicBoundary<Data, UI> = BoundaryBase<Data, UI> & {
+  readonly mode: "dynamic"
+  readonly load?: (ctx: BoundaryRequestCtx) => Data | Promise<Data>
+}
+
+export type InterceptBoundary<Data, UI> = BoundaryBase<Data, UI> & {
+  readonly mode: { readonly intercept: string }
+  readonly load?: (ctx: BoundaryRequestCtx) => Data | Promise<Data>
+}
+
+/** A discriminated union: the `mode` selects the context type accepted by `load`. */
+export type Boundary<Data, UI> =
+  | StaticBoundary<Data, UI>
+  | DynamicBoundary<Data, UI>
+  | InterceptBoundary<Data, UI>
+
+/**
+ * Erased runtime registration shape used by a route/layout manifest. This is intentionally a
+ * structural union rather than `Boundary<never, unknown>`: a registration keeps its loader's
+ * concrete data type at the declaration site, and function-parameter variance must not turn that
+ * loader into `Promise<never>` when the manifest erases it.
+ */
+type ErasedBoundaryBase = {
+  readonly name: string
+  readonly render: (data: never) => unknown
+  readonly fallback?: unknown
+  readonly errorId?: string
+}
+
+export type BoundaryRegistration =
+  | (ErasedBoundaryBase & {
+      readonly mode: "static"
+      readonly load?: (ctx: StaticCtx) => unknown | Promise<unknown>
+    })
+  | (ErasedBoundaryBase & {
+      readonly mode: "dynamic"
+      readonly load?: (ctx: BoundaryRequestCtx) => unknown | Promise<unknown>
+    })
+  | (ErasedBoundaryBase & {
+      readonly mode: { readonly intercept: string }
+      readonly load?: (ctx: BoundaryRequestCtx) => unknown | Promise<unknown>
+    })
+
+/** Neutral manifest descriptor: no framework component crosses the web core boundary. */
+export interface BoundaryDescriptor {
+  readonly name: string
+  readonly mode: BoundaryMode
+  readonly hasLoad: boolean
+  readonly errorId?: string
+}
+
+export type BoundaryStatus = "unresolved" | "pending" | "ready" | "error"
+
+export interface BoundaryError {
+  readonly name: string
+  readonly message: string
+}
+
+/** Serializable boundary state passed to the adapter's render seam. */
+export interface BoundaryState {
+  readonly name: string
+  readonly mode: BoundaryMode
+  readonly status: BoundaryStatus
+  readonly data?: unknown
+  readonly error?: BoundaryError
+  readonly errorId?: string
+}
+
+export type BoundaryStates = Readonly<Record<string, BoundaryState>>
+
+/** A dynamic load that has started but is not part of the initial render barrier. */
+export interface PendingBoundary {
+  readonly name: string
+  readonly mode: BoundaryMode
+  readonly errorId?: string
+  readonly promise: Promise<unknown>
+}
+
+/** Runtime handles for a concurrent boundary batch. `initial` is renderable immediately. */
+export interface DynamicBoundaryBatch {
+  readonly initial: BoundaryStates
+  readonly pending: ReadonlyArray<PendingBoundary>
+  /** Resolves to final per-boundary states for non-streaming consumers and tests. */
+  readonly complete: Promise<BoundaryStates>
+}
+
+/** Public in-memory reference cache for build-safe static boundary values. It holds no payload outside
+ * the process and is intentionally not a durable or tenant-aware cache implementation. */
+export interface StaticBoundaryCache {
+  get(boundary: BoundaryRegistration): Promise<unknown> | undefined
+  set(boundary: BoundaryRegistration, value: Promise<unknown>): void
+}
+
+export class MemoryStaticBoundaryCache implements StaticBoundaryCache {
+  readonly #values = new WeakMap<object, Promise<unknown>>()
+
+  get(boundary: BoundaryRegistration): Promise<unknown> | undefined {
+    return this.#values.get(boundary as object)
+  }
+
+  set(boundary: BoundaryRegistration, value: Promise<unknown>): void {
+    this.#values.set(boundary as object, value)
+  }
+}
+
+export interface StaticBoundaryImportEdge {
+  readonly from: string
+  readonly to: string
+}
+
+export interface StaticBoundaryRoot {
+  readonly name: string
+  readonly module: string
+}
+
+/**
+ * Enforce the second half of the static-boundary safety boundary. A build adapter supplies the
+ * transitive module graph and the modules it has classified as request-scoped; a static root that
+ * reaches one fails before any shared shell is emitted. Keeping this check graph-shaped makes it
+ * usable by Bun/Vite without making the neutral web runtime depend on either bundler.
+ */
+export function assertStaticBoundaryImports(
+  roots: readonly StaticBoundaryRoot[],
+  edges: readonly StaticBoundaryImportEdge[],
+  requestScopedModules: ReadonlySet<string>,
+): void {
+  const next = new Map<string, string[]>()
+  for (const edge of edges) {
+    const children = next.get(edge.from)
+    if (children === undefined) next.set(edge.from, [edge.to])
+    else children.push(edge.to)
+  }
+  for (const root of roots) {
+    const seen = new Set<string>([root.module])
+    const queue = [root.module]
+    for (let cursor = 0; cursor < queue.length; cursor++) {
+      const module = queue[cursor]
+      if (module === undefined) continue
+      if (requestScopedModules.has(module)) {
+        throw new TypeError(
+          `[nifra/web] static boundary "${root.name}" reaches request-scoped module "${module}"`,
+        )
+      }
+      for (const child of next.get(module) ?? []) {
+        if (!seen.has(child)) {
+          seen.add(child)
+          queue.push(child)
+        }
+      }
+    }
+  }
+}
+
+const BOUNDARY_NAME = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/
+const MAX_INTERCEPT_PATH = 2048
+
+const modeKey = (mode: BoundaryMode): string =>
+  typeof mode === "string" ? mode : `intercept:${mode.intercept}`
+
+const assertMode = (mode: BoundaryMode): void => {
+  if (mode === "static" || mode === "dynamic") return
+  if (
+    typeof mode !== "object" ||
+    mode === null ||
+    typeof mode.intercept !== "string" ||
+    mode.intercept.length === 0 ||
+    mode.intercept.length > MAX_INTERCEPT_PATH ||
+    !mode.intercept.startsWith("/") ||
+    mode.intercept.startsWith("//")
+  ) {
+    throw new TypeError("[nifra/web] boundary intercept must be a same-origin path")
+  }
+}
+
+/** Validate and serialize the neutral boundary manifest. Duplicate names fail closed at startup. */
+export function boundaryDescriptors(
+  boundaries: readonly BoundaryRegistration[],
+): ReadonlyArray<BoundaryDescriptor> {
+  const seen = new Set<string>()
+  return boundaries.map((boundary) => {
+    if (!BOUNDARY_NAME.test(boundary.name) || seen.has(boundary.name)) {
+      throw new TypeError(`[nifra/web] invalid or duplicate boundary name "${boundary.name}"`)
+    }
+    assertMode(boundary.mode)
+    seen.add(boundary.name)
+    return {
+      name: boundary.name,
+      mode: boundary.mode,
+      hasLoad: boundary.load !== undefined,
+      ...(boundary.errorId !== undefined ? { errorId: boundary.errorId } : {}),
+    }
+  })
+}
+
+const scopedContext = (context: BoundaryRequestCtx): BoundaryRequestCtx =>
+  Object.freeze({
+    request: context.request,
+    params: Object.freeze({ ...context.params }),
+    api: context.api,
+    env: context.env,
+    draft: context.draft,
+    search: Object.freeze({ ...context.search }),
+    signal: context.signal,
+  })
+
+/**
+ * Redact a failed load into the client-visible slot. Boundary states are serialized into the document
+ * (`window.__NIFRA_BOUNDARIES__`), so the thrown error's own message never crosses: a driver or fetch
+ * failure carries hosts, credentials, and query text that a page is not allowed to publish. An `Error`
+ * subclass name is withheld for the same reason - it names the internal library. The real error goes to
+ * a generic server-console event, the same split `deferred.ts` uses for a rejected deferred value. The
+ * log deliberately carries only the failure kind: exception messages can contain credentials, query
+ * text, or user data and must not be copied into an operational sink by default.
+ *
+ * A boundary that wants to show the user something specific catches its own failure inside `load` and
+ * returns that as data; the framework never guesses which parts of an exception are publishable.
+ */
+const boundaryError = (error: unknown): BoundaryError => {
+  if (error !== undefined) {
+    console.error("[nifra/web] boundary load failed", {
+      kind: error instanceof Error ? "error" : typeof error,
+    })
+  }
+  return { name: "Error", message: "Boundary failed" }
+}
+
+/**
+ * Resolve all dynamic boundaries concurrently. Each receives a fresh frozen context object; one
+ * failure becomes that boundary's error state and never rejects a sibling or exposes sibling data.
+ * Static/intercepting modes remain `unresolved` until their phase-specific runtime owns them.
+ */
+export async function resolveDynamicBoundaries(
+  boundaries: readonly BoundaryRegistration[],
+  context: BoundaryRequestCtx,
+): Promise<BoundaryStates> {
+  return startDynamicBoundaries(boundaries, context).complete
+}
+
+/**
+ * Start all dynamic boundary loads at once without making the page wait for the slowest sibling.
+ * The initial states contain `status: "pending"`; callers that support deferred values can attach
+ * each `pending.promise` to its own slot. `complete` still provides settled, isolated states to
+ * non-streaming callers, preserving the simple reference API.
+ */
+export function startDynamicBoundaries(
+  boundaries: readonly BoundaryRegistration[],
+  context: BoundaryRequestCtx,
+): DynamicBoundaryBatch {
+  // Validation only: a bad name, a duplicate, or a malformed intercept path throws here rather than
+  // producing a half-registered batch. It cannot return holes, so no slot below tests for one.
+  boundaryDescriptors(boundaries)
+  const initial: Record<string, BoundaryState> = {}
+  const pending: PendingBoundary[] = []
+
+  for (const boundary of boundaries) {
+    const base = {
+      name: boundary.name,
+      mode: boundary.mode,
+      ...(boundary.errorId !== undefined ? { errorId: boundary.errorId } : {}),
+    }
+    if (boundary.mode !== "dynamic") {
+      initial[boundary.name] = { ...base, status: "unresolved" }
+      continue
+    }
+    if (boundary.load === undefined) {
+      initial[boundary.name] = { ...base, status: "ready" }
+      continue
+    }
+    // Promise.resolve().then() converts a synchronous throw into this boundary's rejection, so it
+    // cannot abort siblings or escape before the caller attaches the deferred consumer.
+    const promise = Promise.resolve().then(() => boundary.load?.(scopedContext(context)))
+    pending.push({
+      name: boundary.name,
+      mode: boundary.mode,
+      ...(boundary.errorId !== undefined ? { errorId: boundary.errorId } : {}),
+      promise,
+    })
+    initial[boundary.name] = { ...base, status: "pending" }
+  }
+
+  const complete = Promise.all(
+    boundaries.map(async (boundary) => {
+      const base = {
+        name: boundary.name,
+        mode: boundary.mode,
+        ...(boundary.errorId !== undefined ? { errorId: boundary.errorId } : {}),
+      }
+      if (boundary.mode !== "dynamic") return { ...base, status: "unresolved" as const }
+      if (boundary.load === undefined) return { ...base, status: "ready" as const }
+      const load = pending.find((entry) => entry.name === boundary.name)
+      if (load === undefined)
+        return { ...base, status: "error" as const, error: boundaryError(undefined) }
+      try {
+        const data = await load.promise
+        return { ...base, status: "ready" as const, ...(data !== undefined ? { data } : {}) }
+      } catch (error) {
+        return { ...base, status: "error" as const, error: boundaryError(error) }
+      }
+    }),
+  ).then((states) => Object.fromEntries(states.map((state) => [state.name, state])))
+
+  return { initial, pending, complete }
+}
+
+/**
+ * Resolve only explicitly annotated static boundaries with a request-free build context. Dynamic
+ * and intercepting boundaries remain unresolved. Values are cached by boundary object identity in
+ * the supplied in-memory cache, so a worker instance does not repeat a build-safe computation per
+ * request. A rejected static load becomes that slot's error state; it never fabricates shared data.
+ */
+export async function resolveStaticBoundaries(
+  boundaries: readonly BoundaryRegistration[],
+  context: StaticCtx,
+  cache: StaticBoundaryCache = DEFAULT_STATIC_CACHE,
+): Promise<BoundaryStates> {
+  // Validation only - see `startDynamicBoundaries`; the descriptor list has no holes to test for.
+  boundaryDescriptors(boundaries)
+  const states = await Promise.all(
+    boundaries.map(async (boundary) => {
+      if (boundary.mode !== "static") {
+        return {
+          name: boundary.name,
+          mode: boundary.mode,
+          status: "unresolved" as const,
+          ...(boundary.errorId !== undefined ? { errorId: boundary.errorId } : {}),
+        }
+      }
+      if (boundary.load === undefined) {
+        return {
+          name: boundary.name,
+          mode: boundary.mode,
+          status: "ready" as const,
+          ...(boundary.errorId !== undefined ? { errorId: boundary.errorId } : {}),
+        }
+      }
+      let value = cache.get(boundary)
+      if (value === undefined) {
+        value = Promise.resolve().then(() => boundary.load?.(context))
+        cache.set(boundary, value)
+      }
+      try {
+        const data = await value
+        return {
+          name: boundary.name,
+          mode: boundary.mode,
+          status: "ready" as const,
+          ...(data !== undefined ? { data } : {}),
+          ...(boundary.errorId !== undefined ? { errorId: boundary.errorId } : {}),
+        }
+      } catch (error) {
+        return {
+          name: boundary.name,
+          mode: boundary.mode,
+          status: "error" as const,
+          error: boundaryError(error),
+          ...(boundary.errorId !== undefined ? { errorId: boundary.errorId } : {}),
+        }
+      }
+    }),
+  )
+  return Object.fromEntries(states.map((state) => [state.name, state]))
+}
+
+const DEFAULT_STATIC_CACHE = new MemoryStaticBoundaryCache()
+
+/** Stable mode label for adapter registries and diagnostics. */
+export function boundaryModeKey(mode: BoundaryMode): string {
+  return modeKey(mode)
+}

package/src/build-vite.ts

@@ -33,6 +33,7 @@ import {
 } from "./build.ts"
 import { discoverRoutes } from "./fs.ts"
 import { generateClientEntry, generateServerManifest } from "./index.ts"
+import { viteDedupePackages } from "./internal/identity-policy.ts"
 import {
   assertDevelopmentProductionParity,
   assertIdentityParity,
@@ -201,9 +202,10 @@ export async function buildClientVite(options: BuildClientViteOptions): Promise<
           ...(options.define ?? {}),
         },
         resolve: {
-          // Mirror the Bun build's reactDedupePlugin: one physical react/react-dom, or a hook-using route
-          // gets a second dispatcher. No-op when the app isn't React.
-          dedupe: ["react", "react-dom"],
+          // Same framework coverage as the Bun build's dedupe plugins, from the one policy table: one
+          // physical copy of react/react-dom, preact, and svelte, or a hook-using route gets a second
+          // dispatcher/options global. No-op per framework the app does not use.
+          dedupe: [...viteDedupePackages()],
           ...(options.conditions ? { conditions: [...options.conditions] } : {}),
         },
         css: {

package/src/build.ts

@@ -8,10 +8,15 @@
 import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"
 import { cp, lstat, mkdir, realpath } from "node:fs/promises"
 import { dirname, join, relative, resolve as resolvePath, sep } from "node:path"
+import {
+  singleCopyPlugin as declaredSingleCopyPlugin,
+  readSingleCopyDeclaration,
+} from "@nifrajs/core/single-copy"
 import { type BunPlugin, Glob } from "bun"
 import { sanitizeOutputNames } from "./chunk-names.ts"
 import { discoverRoutes } from "./fs.ts"
 import { generateClientEntry, generateServerManifest } from "./index.ts"
+import { dedupePolicyFor } from "./internal/identity-policy.ts"
 import {
   assertDevelopmentProductionParity,
   assertIdentityParity,
@@ -1015,6 +1020,7 @@ export async function buildClient(options: BuildClientOptions): Promise<BuildMan
         ...buildExtras,
         minify: options.minify ?? true,
         plugins: [
+          ...declaredSingleCopyPlugins(root),
           reactDedupePlugin(routesDir),
           preactDedupePlugin(routesDir),
           svelteDedupePlugin(routesDir),
@@ -1105,12 +1111,17 @@ export async function buildClient(options: BuildClientOptions): Promise<BuildMan
     const base = basename(path)
     return base.slice(0, base.lastIndexOf("-")) // strip `-${hash}.css`
   }
+  // `css` is the union of every emitted stylesheet, matching the Vite pipeline (build-vite.ts) so the
+  // field means the same thing on both bundlers. The bootstrap aggregate lists first, preserving the
+  // fallback link order `createWebApp` uses (whole-app stylesheet before any route-scoped one); the
+  // per-route `cssBundle` outputs follow. Dropping those per-route outputs (the old `aggregate`-only
+  // shape) left them in `manifest.assets` but not `css`, so a route-scoped stylesheet normalized to
+  // `asset:css` and tripped the module-graph parity contract - a bundler-dependent divergence.
   const cssAssets = result.outputs.filter((o) => o.kind === "asset" && o.path.endsWith(".css"))
-  const aggregate = cssAssets
-    .filter((o) => cssNameOf(o.path) === bootstrapName)
-    .map((o) => toUrl(o.path))
-  const css: readonly string[] =
-    aggregate.length > 0 ? aggregate : cssAssets.map((o) => toUrl(o.path))
+  const css: readonly string[] = [
+    ...cssAssets.filter((o) => cssNameOf(o.path) === bootstrapName),
+    ...cssAssets.filter((o) => cssNameOf(o.path) !== bootstrapName),
+  ].map((o) => toUrl(o.path))
 
   // CSS - per-route: each route/layout file is its own entrypoint, so the build metafile records its
   // `cssBundle` - exactly the CSS that file's subtree uses (shared-component CSS is inlined into each
@@ -1244,7 +1255,7 @@ const reactDomEdgePlugin = (from: string): BunPlugin => ({
  * condition-agnostic, so pinning it doesn't disturb the edge/browser/server conditions that select
  * react-dom's build.
  */
-const REACT_DEDUPE_SPECS = ["react", "react/jsx-runtime", "react/jsx-dev-runtime"] as const
+const REACT_DEDUPE_SPECS = dedupePolicyFor("react").bunSpecs ?? []
 export const reactDedupePlugin = (from: string): BunPlugin => ({
   name: "nifra-react-dedupe",
   setup(build) {
@@ -1272,13 +1283,7 @@ export const reactDedupePlugin = (from: string): BunPlugin => ({
  * skipped). Preact core is condition-agnostic, so pinning it doesn't disturb any condition selection - and
  * unlike react-dom there is no edge-vs-server build to preserve, so pinning the subpaths is safe.
  */
-const PREACT_DEDUPE_SPECS = [
-  "preact",
-  "preact/hooks",
-  "preact/compat",
-  "preact/jsx-runtime",
-  "preact/jsx-dev-runtime",
-] as const
+const PREACT_DEDUPE_SPECS = dedupePolicyFor("preact").bunSpecs ?? []
 export const preactDedupePlugin = (from: string): BunPlugin => ({
   name: "nifra-preact-dedupe",
   setup(build) {
@@ -1295,6 +1300,7 @@ export const preactDedupePlugin = (from: string): BunPlugin => ({
   },
 })
 
+const SVELTE_DEDUPE_PATTERN = dedupePolicyFor("svelte").bunPattern ?? /^svelte($|\/internal\/)/
 /**
  * Dedupe Svelte to a single copy - the Svelte analogue of `reactDedupePlugin`/`preactDedupePlugin`, closing
  * the same class of bug for Svelte (which had NO build-time dedup before). A workspace- or file-linked
@@ -1313,7 +1319,7 @@ export const preactDedupePlugin = (from: string): BunPlugin => ({
 export const svelteDedupePlugin = (from: string): BunPlugin => ({
   name: "nifra-svelte-dedupe",
   setup(build) {
-    build.onResolve({ filter: /^svelte($|\/internal\/)/ }, (args) => {
+    build.onResolve({ filter: SVELTE_DEDUPE_PATTERN }, (args) => {
       try {
         return { path: Bun.resolveSync(args.path, from) }
       } catch {
@@ -1323,6 +1329,21 @@ export const svelteDedupePlugin = (from: string): BunPlugin => ({
   },
 })
 
+/**
+ * The app's declared single-copy rule, applied to the bundle.
+ *
+ * The three plugins above cover the framework runtimes by name, which is the case that bites hardest
+ * and needs no configuration. This one covers what a name list cannot know: `@nifrajs/*` (two copies
+ * of `@nifrajs/core` are two `Server` classes, and `Server` has private members, so `.merge()` stops
+ * accepting the other's app) and whatever else the app named in
+ * `"nifra": { "singleCopy": [...] }`.
+ *
+ * Nothing declared means no plugin at all - the plan does filesystem work, so it is not built for the
+ * majority of apps that have a single copy of everything and never think about this.
+ */
+const declaredSingleCopyPlugins = (root: string): readonly BunPlugin[] =>
+  readSingleCopyDeclaration(root) === undefined ? [] : [declaredSingleCopyPlugin({ cwd: root })]
+
 /**
  * Remix-style `.server` convention for the CLIENT build. A module named `*.server.ts(x)` (`db.server.ts`,
  * `auth.server.ts`, …) is server-only - empty it in the browser bundle so its (possibly `node:` / native /
@@ -1439,6 +1460,7 @@ export async function buildServer(options: BuildServerOptions): Promise<ServerBu
     // Lazy → one chunk per route (loaded on first request); eager → a single self-contained file.
     splitting: lazy,
     plugins: [
+      ...declaredSingleCopyPlugins(resolvePath(dirname(routesDir))),
       ...(edge ? [reactDomEdgePlugin(entryDir), solidWebServerPlugin(entryDir)] : []),
       reactDedupePlugin(entryDir),
       preactDedupePlugin(entryDir),