@ecopages/react 0.2.0-alpha.1

package/src/services/react-runtime-bundle.service.ts

@@ -0,0 +1,271 @@
+/**
+ * Runtime bundle service for React integration.
+ *
+ * Owns creation of the browser runtime assets for React and React DOM,
+ * including temporary entry generation, specifier mapping, and React DOM
+ * interop rewriting.
+ *
+ * @module
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import type { EcoBuildPlugin } from '@ecopages/core/build/build-types';
+import { type AssetDefinition, AssetFactory } from '@ecopages/core/services/asset-processing-service';
+import type { ReactRouterAdapter } from '../router-adapter.ts';
+
+type RuntimeModuleConfig = {
+	specifier: string;
+	defaultExport?: boolean;
+};
+
+export type ReactRuntimeImports = {
+	react: string;
+	reactDomClient: string;
+	reactJsxRuntime: string;
+	reactJsxDevRuntime: string;
+	reactDom: string;
+	router?: string;
+};
+
+export interface ReactRuntimeBundleServiceConfig {
+	routerAdapter?: ReactRouterAdapter;
+}
+
+export class ReactRuntimeBundleService {
+	constructor(private readonly config: ReactRuntimeBundleServiceConfig) {}
+
+	getRuntimeImports(): ReactRuntimeImports {
+		const runtimeImports: ReactRuntimeImports = {
+			react: this.buildImportMapSourceUrl('react.js'),
+			reactDomClient: this.buildImportMapSourceUrl('react-dom.js'),
+			reactJsxRuntime: this.buildImportMapSourceUrl('react.js'),
+			reactJsxDevRuntime: this.buildImportMapSourceUrl('react.js'),
+			reactDom: this.buildImportMapSourceUrl('react-dom.js'),
+		};
+
+		if (this.config.routerAdapter) {
+			runtimeImports.router = this.buildImportMapSourceUrl(`${this.config.routerAdapter.bundle.outputName}.js`);
+		}
+
+		return runtimeImports;
+	}
+
+	getSpecifierMap(): Record<string, string> {
+		const runtimeImports = this.getRuntimeImports();
+		const map: Record<string, string> = {
+			react: runtimeImports.react,
+			'react/jsx-runtime': runtimeImports.reactJsxRuntime,
+			'react/jsx-dev-runtime': runtimeImports.reactJsxDevRuntime,
+			'react-dom': runtimeImports.reactDom,
+			'react-dom/client': runtimeImports.reactDomClient,
+		};
+
+		if (this.config.routerAdapter && runtimeImports.router) {
+			map[this.config.routerAdapter.importMapKey] = runtimeImports.router;
+		}
+
+		return map;
+	}
+
+	getDependencies(): AssetDefinition[] {
+		const runtimeAttrs = { type: 'module', defer: '' } as const;
+		const runtimeImports = this.getRuntimeImports();
+		const reactRuntimeAliasPlugin = this.createRuntimeSpecifierAliasPlugin({
+			react: runtimeImports.react,
+		});
+		const reactDomRuntimeInteropPlugin = this.createReactDomRuntimeInteropPlugin();
+
+		const reactEntry = this.createRuntimeEntry(
+			[
+				{ specifier: 'react', defaultExport: true },
+				{ specifier: 'react/jsx-runtime' },
+				{ specifier: 'react/jsx-dev-runtime' },
+			],
+			'react-entry.mjs',
+		);
+		const reactDomEntry = this.createRuntimeEntry(
+			[{ specifier: 'react-dom', defaultExport: true }, { specifier: 'react-dom/client' }],
+			'react-dom-entry.mjs',
+		);
+
+		const dependencies: AssetDefinition[] = [
+			AssetFactory.createNodeModuleScript({
+				position: 'head',
+				importPath: reactEntry,
+				name: 'react',
+				excludeFromHtml: true,
+				bundleOptions: { naming: 'react.js' },
+				attributes: runtimeAttrs,
+			}),
+			AssetFactory.createNodeModuleScript({
+				position: 'head',
+				importPath: reactDomEntry,
+				name: 'react-dom',
+				excludeFromHtml: true,
+				bundleOptions: {
+					naming: 'react-dom.js',
+					plugins: [reactRuntimeAliasPlugin, reactDomRuntimeInteropPlugin],
+				},
+				attributes: runtimeAttrs,
+			}),
+		];
+
+		if (this.config.routerAdapter) {
+			const runtimeAliasPlugin = this.createRuntimeAliasPlugin();
+			const mappedSpecifiers = new Set(Object.keys(this.getSpecifierMap()));
+			const unresolvedExternals = this.config.routerAdapter.bundle.externals.filter(
+				(external) => !mappedSpecifiers.has(external),
+			);
+
+			dependencies.push(
+				AssetFactory.createNodeModuleScript({
+					position: 'head',
+					importPath: this.config.routerAdapter.bundle.importPath,
+					name: this.config.routerAdapter.bundle.outputName,
+					excludeFromHtml: true,
+					bundleOptions: {
+						naming: `${this.config.routerAdapter.bundle.outputName}.js`,
+						external: unresolvedExternals,
+						plugins: [runtimeAliasPlugin],
+					},
+					attributes: runtimeAttrs,
+				}),
+			);
+		}
+
+		return dependencies;
+	}
+
+	createRuntimeAliasPlugin(): EcoBuildPlugin {
+		const specifierMap = this.getSpecifierMap();
+		const escapeRegExp = (value: string): string => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+		const filter = new RegExp(
+			`^(${Object.keys(specifierMap)
+				.map((key) => escapeRegExp(key))
+				.join('|')})$`,
+		);
+
+		return {
+			name: 'react-plugin-runtime-alias',
+			setup(build) {
+				build.onResolve({ filter }, (args) => {
+					const mappedPath = specifierMap[args.path];
+					if (!mappedPath) {
+						return undefined;
+					}
+
+					return {
+						path: mappedPath,
+						external: true,
+					};
+				});
+			},
+		};
+	}
+
+	private buildImportMapSourceUrl(fileName: string): string {
+		return `/${AssetFactory.RESOLVED_ASSETS_VENDORS_DIR}/${fileName}`;
+	}
+
+	private createRuntimeSpecifierAliasPlugin(specifierMap: Record<string, string>, external = true): EcoBuildPlugin {
+		const escapeRegExp = (value: string): string => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+		const filter = new RegExp(
+			`^(${Object.keys(specifierMap)
+				.map((key) => escapeRegExp(key))
+				.join('|')})$`,
+		);
+
+		return {
+			name: 'react-plugin-runtime-specifier-alias',
+			setup(build) {
+				build.onResolve({ filter }, (args) => {
+					const mappedPath = specifierMap[args.path];
+					if (!mappedPath) {
+						return undefined;
+					}
+
+					return {
+						path: mappedPath,
+						external,
+					};
+				});
+			},
+		};
+	}
+
+	private createReactDomRuntimeInteropPlugin(): EcoBuildPlugin {
+		const reactDomFileFilter = /[\\/]react-dom[\\/].*\.js$/;
+		const reactRequirePattern = /\brequire\((['"])react\1\)/g;
+
+		return {
+			name: 'react-dom-runtime-interop',
+			setup(build) {
+				build.onLoad({ filter: reactDomFileFilter }, (args) => {
+					const content = fs.readFileSync(args.path, 'utf-8');
+					if (!reactRequirePattern.test(content)) {
+						return undefined;
+					}
+
+					reactRequirePattern.lastIndex = 0;
+					const rewritten = content.replace(reactRequirePattern, '__ecopages_react_runtime');
+
+					return {
+						contents: `import * as __ecopages_react_runtime from 'react';\n${rewritten}`,
+						loader: 'js',
+						resolveDir: path.dirname(args.path),
+					};
+				});
+			},
+		};
+	}
+
+	private getRuntimeArtifactsDir(): string {
+		const tmpDir = path.join(process.cwd(), 'node_modules', '.cache', 'ecopages-react-runtime');
+		fs.mkdirSync(tmpDir, { recursive: true });
+		return tmpDir;
+	}
+
+	private createRuntimeEntry(modules: RuntimeModuleConfig[], fileName: string): string {
+		const tmpDir = this.getRuntimeArtifactsDir();
+		const requireFromRoot = createRequire(path.join(process.cwd(), 'package.json'));
+		const seenExports = new Set<string>();
+		const statements: string[] = [];
+
+		for (const module of modules) {
+			if (module.defaultExport) {
+				statements.push(`import __ecopages_default_export__ from '${module.specifier}';`);
+				statements.push('export default __ecopages_default_export__;');
+			}
+
+			const exportNames = this.getModuleExportNames(module.specifier, requireFromRoot).filter(
+				(name) => !seenExports.has(name),
+			);
+
+			if (exportNames.length > 0) {
+				statements.push(`export { ${exportNames.join(', ')} } from '${module.specifier}';`);
+				for (const exportName of exportNames) {
+					seenExports.add(exportName);
+				}
+			}
+		}
+
+		const filePath = path.join(tmpDir, fileName);
+		fs.writeFileSync(filePath, statements.join('\n'), 'utf-8');
+		return filePath;
+	}
+
+	private getModuleExportNames(specifier: string, requireFromRoot: ReturnType<typeof createRequire>): string[] {
+		const moduleExports = requireFromRoot(specifier);
+
+		return Object.keys(moduleExports)
+			.filter((name) => name !== '__esModule' && name !== 'default')
+			.filter((name) => this.isValidExportName(name))
+			.sort();
+	}
+
+	private isValidExportName(name: string): boolean {
+		return /^[$A-Z_a-z][$\w]*$/.test(name);
+	}
+}

package/src/utils/client-graph-boundary-plugin.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @module ClientGraphBoundaryPlugin
+ *
+ * This module defines the primary esbuild plugin responsible for securing the Ecopages
+ * isomorphic compilation pipeline. It ensures that backend-only code, sensitive Node.js APIs,
+ * and massive server utilities do not accidentally leak into the browser bundle.
+ *
+ * It achieves this by intercepting all client module compilation passes and applying the
+ * `analyzeReachability` AST pass. If a forbidden import (e.g. `node:fs` or `*.server.ts`)
+ * is completely unreachable from the client component's `render` function, it is surgically
+ * pruned. If a forbidden import IS reachable, the build is intentionally failed to prevent
+ * runtime hydration crashes.
+ *
+ * Additionally, this plugin provides a build-time transform that statically resolves and
+ * inlines `fs.readFileSync(path.resolve(...))` calls to prevent server/client data mismatches.
+ */
+import type { EcoBuildPlugin } from '@ecopages/core/build/build-types';
+/**
+ * Configuration options for the Client Graph Boundary esbuild plugin.
+ *
+ * This plugin serves as the primary security layer between server-only logic and the client-side JavaScript bundle.
+ * It prevents Node.js built-ins (`node:fs`, `node:path`) and backend-exclusive dependencies (e.g. `pg`, `redis`)
+ * from accidentally leaking into the browser compilation step, which would cause immediate crashes.
+ */
+type ClientGraphBoundaryOptions = {
+    /** Absolute path to the current working directory, used as a root fallback for resolving inline file reads. */
+    absWorkingDir?: string;
+    /**
+     * Array of module specifiers that are explicitly whitelisted to be bundled in the client code.
+     * This is typically populated by parsing `modules: ["..."]` declarations in React/Lit components.
+     */
+    declaredModules?: string[];
+    /** Array of emergency escape-hatch specifiers that always bypass the boundary checks regardless of component declarations. */
+    alwaysAllowSpecifiers?: string[];
+};
+/**
+ * Instantiates the client graph boundary esbuild plugin.
+ *
+ * @param options - Configuration options for the graph boundary.
+ * @returns The resulting `EcoBuildPlugin`.
+ */
+export declare function createClientGraphBoundaryPlugin(options?: ClientGraphBoundaryOptions): EcoBuildPlugin;
+export {};

package/src/utils/client-graph-boundary-plugin.js

@@ -0,0 +1,356 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, extname, resolve } from "node:path";
+import { parseSync } from "oxc-parser";
+import { analyzeReachability } from "./reachability-analyzer";
+const SOURCE_FILE_FILTER = /\.(tsx?|jsx?)$/;
+function isBareSpecifier(specifier) {
+  if (specifier.startsWith(".")) return false;
+  if (specifier.startsWith("/")) return false;
+  if (specifier.includes("://")) return false;
+  return true;
+}
+function isProjectAliasSpecifier(specifier) {
+  return specifier.startsWith("@/") || specifier.startsWith("~/") || specifier.startsWith("ecopages:");
+}
+function toModuleBaseSpecifier(specifier) {
+  if (!isBareSpecifier(specifier) || specifier.startsWith("node:")) {
+    return specifier;
+  }
+  if (specifier.startsWith("@")) {
+    const [scope, name2] = specifier.split("/");
+    if (!scope || !name2) return specifier;
+    return `${scope}/${name2}`;
+  }
+  const [name] = specifier.split("/");
+  return name ?? specifier;
+}
+function parseDeclaredModules(moduleDeclarations) {
+  const map = /* @__PURE__ */ new Map();
+  for (const declaration of moduleDeclarations ?? []) {
+    const source = declaration.trim();
+    if (source.length === 0) continue;
+    const openBraceIndex = source.indexOf("{");
+    if (openBraceIndex < 0) {
+      map.set(toModuleBaseSpecifier(source), "*");
+      continue;
+    }
+    const closeBraceIndex = source.indexOf("}", openBraceIndex);
+    const rawPkg = source.slice(0, openBraceIndex).trim();
+    if (rawPkg.length === 0) continue;
+    const pkg = toModuleBaseSpecifier(rawPkg);
+    const namedImportsStr = closeBraceIndex > openBraceIndex ? source.slice(openBraceIndex + 1, closeBraceIndex) : source.slice(openBraceIndex + 1);
+    const namedImports = namedImportsStr.split(",").map((s) => s.trim()).filter(Boolean);
+    const existing = map.get(pkg);
+    if (existing === "*") continue;
+    if (!existing) {
+      if (namedImports.length === 0) {
+        map.set(pkg, "*");
+      } else {
+        map.set(pkg, new Set(namedImports));
+      }
+    } else {
+      for (const name of namedImports) {
+        existing.add(name);
+      }
+    }
+  }
+  return map;
+}
+function mergeDeclaredModulesMap(a, b) {
+  const result = new Map(a);
+  for (const [pkg, imports] of b.entries()) {
+    const existing = result.get(pkg);
+    if (existing === "*") continue;
+    if (imports === "*") {
+      result.set(pkg, "*");
+      continue;
+    }
+    if (!existing) {
+      result.set(pkg, imports);
+    } else {
+      for (const name of imports) {
+        existing.add(name);
+      }
+    }
+  }
+  return result;
+}
+function parserLanguageForFile(filename) {
+  const extension = extname(filename).toLowerCase();
+  if (extension === ".tsx") return "tsx";
+  if (extension === ".ts") return "ts";
+  if (extension === ".jsx") return "jsx";
+  return "js";
+}
+function transformModuleImports(source, filename, globallyAllowed) {
+  let result;
+  try {
+    result = parseSync(filename, source, {
+      sourceType: "module",
+      lang: parserLanguageForFile(filename)
+    });
+  } catch {
+    return { transformed: source, modified: false };
+  }
+  const { program } = result;
+  const localDeclared = [];
+  function walk(node) {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (const child of node) walk(child);
+      return;
+    }
+    if (node.type === "Property" && node.key?.name === "modules" && node.value?.type === "ArrayExpression") {
+      for (const el of node.value.elements) {
+        if ((el.type === "StringLiteral" || el.type === "Literal") && typeof el.value === "string") {
+          localDeclared.push(el.value);
+        }
+      }
+    }
+    for (const key in node) {
+      if (key !== "type" && key !== "start" && key !== "end") {
+        walk(node[key]);
+      }
+    }
+  }
+  walk(program);
+  const locallyAllowed = parseDeclaredModules(localDeclared);
+  const allowedMap = mergeDeclaredModulesMap(globallyAllowed, locallyAllowed);
+  const reachability = analyzeReachability(source, filename, program);
+  const edits = [];
+  function processSpecifier(specifier) {
+    const moduleBase = toModuleBaseSpecifier(specifier);
+    const explicitRules = allowedMap.get(moduleBase);
+    if (specifier.startsWith("node:") || specifier.includes(".server.")) {
+      if (explicitRules) {
+        return { allowed: true, rules: explicitRules };
+      }
+      return { allowed: false };
+    }
+    if (isProjectAliasSpecifier(specifier)) return { allowed: true, rules: explicitRules ?? "*" };
+    if (!isBareSpecifier(specifier)) return { allowed: true, rules: explicitRules ?? "*" };
+    return { allowed: true, rules: explicitRules ?? "*" };
+  }
+  function walkImports(node) {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (const child of node) walkImports(child);
+      return;
+    }
+    if (node.type === "ImportDeclaration") {
+      const specifier = node.source.value;
+      const reachableRules = reachability.reachableImports.get(specifier);
+      const { allowed, rules } = processSpecifier(specifier);
+      if (!allowed) {
+        if (reachableRules && !reachability.isFallbackRoots) {
+          throw new Error(
+            `[Ecopages Client Reachability] Forbidden client import '${specifier}' at ${filename}:${node.start}. This import is explicitly reachable from the React render function.`
+          );
+        } else {
+          edits.push({ start: node.start, end: node.end, replacement: "" });
+        }
+        return;
+      }
+      if (rules instanceof Set && node.specifiers && node.specifiers.length > 0) {
+        let keptSpecifierCount = 0;
+        let defaultImportLocal;
+        let namespaceImportLocal;
+        const namedImportNodes = [];
+        for (const spec of node.specifiers) {
+          if (spec.type === "ImportSpecifier") {
+            const importedName = spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value;
+            if (rules.has(importedName)) {
+              keptSpecifierCount += 1;
+              const localName = spec.local?.name;
+              if (localName && localName !== importedName) {
+                namedImportNodes.push(`${importedName} as ${localName}`);
+              } else {
+                namedImportNodes.push(importedName);
+              }
+            }
+          } else if (spec.type === "ImportDefaultSpecifier") {
+            if (rules.has("default")) {
+              keptSpecifierCount += 1;
+              defaultImportLocal = spec.local.name;
+            }
+          } else if (spec.type === "ImportNamespaceSpecifier") {
+            if (rules.has("*")) {
+              keptSpecifierCount += 1;
+              namespaceImportLocal = spec.local.name;
+            }
+          }
+        }
+        if (keptSpecifierCount === 0) {
+          edits.push({ start: node.start, end: node.end, replacement: "" });
+        } else if (keptSpecifierCount < node.specifiers.length) {
+          let newDeclaration = "";
+          if (defaultImportLocal && namespaceImportLocal) {
+            newDeclaration = `import ${defaultImportLocal}, * as ${namespaceImportLocal} from '${specifier}';`;
+          } else if (namespaceImportLocal) {
+            newDeclaration = `import * as ${namespaceImportLocal} from '${specifier}';`;
+          } else if (defaultImportLocal && namedImportNodes.length > 0) {
+            newDeclaration = `import ${defaultImportLocal}, { ${namedImportNodes.join(", ")} } from '${specifier}';`;
+          } else if (defaultImportLocal) {
+            newDeclaration = `import ${defaultImportLocal} from '${specifier}';`;
+          } else {
+            newDeclaration = `import { ${namedImportNodes.join(", ")} } from '${specifier}';`;
+          }
+          edits.push({ start: node.start, end: node.end, replacement: newDeclaration });
+        }
+        return;
+      }
+      if (!reachableRules && (!node.specifiers || node.specifiers.length === 0)) {
+        edits.push({ start: node.start, end: node.end, replacement: "" });
+      }
+      return;
+    }
+    if (node.type === "ExportNamedDeclaration" && node.source) {
+      const specifier = node.source.value;
+      const { allowed } = processSpecifier(specifier);
+      if (!allowed) {
+        if (!reachability.isFallbackRoots) {
+          throw new Error(
+            `[Ecopages Client Reachability] Forbidden client export from '${specifier}' at ${filename}:${node.start}.`
+          );
+        } else {
+          edits.push({ start: node.start, end: node.end, replacement: "" });
+        }
+      }
+      return;
+    }
+    if (node.type === "ExportAllDeclaration" && node.source) {
+      const specifier = node.source.value;
+      const { allowed } = processSpecifier(specifier);
+      if (!allowed) {
+        if (!reachability.isFallbackRoots) {
+          throw new Error(
+            `[Ecopages Client Reachability] Forbidden client export * from '${specifier}' at ${filename}:${node.start}.`
+          );
+        } else {
+          edits.push({ start: node.start, end: node.end, replacement: "" });
+        }
+      }
+      return;
+    }
+    if (node.type === "ImportExpression" && node.source?.value) {
+      const specifier = node.source.value;
+      const { allowed } = processSpecifier(specifier);
+      const reachableRules = reachability.reachableImports.get(specifier);
+      if (!reachableRules) {
+        if (!allowed) {
+          edits.push({ start: node.start, end: node.end, replacement: "Promise.resolve({})" });
+        }
+        return;
+      }
+      if (!allowed) {
+        if (!reachability.isFallbackRoots) {
+          throw new Error(
+            `[Ecopages Client Reachability] Forbidden dynamic import('${specifier}') at ${filename}:${node.start}. This import is explicitly reachable from the React render function.`
+          );
+        } else {
+          edits.push({ start: node.start, end: node.end, replacement: "Promise.resolve({})" });
+        }
+      }
+      return;
+    }
+    if (node.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === "require") {
+      const arg = node.arguments?.[0];
+      if (arg && (arg.type === "StringLiteral" || arg.type === "Literal") && typeof arg.value === "string") {
+        const specifier = arg.value;
+        const { allowed } = processSpecifier(specifier);
+        const reachableRules = reachability.reachableImports.get(specifier);
+        if (!reachableRules) {
+          if (!allowed) {
+            edits.push({ start: node.start, end: node.end, replacement: "({})" });
+          }
+        } else if (!allowed) {
+          if (!reachability.isFallbackRoots) {
+            throw new Error(
+              `[Ecopages Client Reachability] Forbidden require('${specifier}') at ${filename}:${node.start}. This import is explicitly reachable from the React render function.`
+            );
+          } else {
+            edits.push({ start: node.start, end: node.end, replacement: "({})" });
+          }
+        }
+      }
+    }
+    for (const key in node) {
+      if (key !== "type" && key !== "start" && key !== "end") {
+        walkImports(node[key]);
+      }
+    }
+  }
+  walkImports(program);
+  if (edits.length === 0) {
+    return { transformed: source, modified: false };
+  }
+  edits.sort((a, b) => b.start - a.start);
+  let transformed = source;
+  for (const edit of edits) {
+    transformed = transformed.slice(0, edit.start) + edit.replacement + transformed.slice(edit.end);
+  }
+  return { transformed, modified: true };
+}
+function createClientGraphBoundaryPlugin(options) {
+  return {
+    name: "ecopages-client-graph-boundary",
+    setup(build) {
+      const absWorkingDir = options?.absWorkingDir ?? process.cwd();
+      const globallyDeclaredSources = parseDeclaredModules(options?.declaredModules);
+      for (const alwaysAllow of options?.alwaysAllowSpecifiers ?? []) {
+        globallyDeclaredSources.set(toModuleBaseSpecifier(alwaysAllow), "*");
+      }
+      build.onLoad({ filter: SOURCE_FILE_FILTER }, (args) => {
+        let source;
+        try {
+          source = readFileSync(args.path, "utf-8");
+        } catch {
+          return void 0;
+        }
+        let transformed = source;
+        let modified = false;
+        if (source.includes("readFileSync")) {
+          const readFileTransformed = transformed.replace(
+            /\bfs\.readFileSync\s*\(\s*path\.resolve\s*\(\s*(['"`])([^'"`\n]+)\1\s*\)\s*,\s*['"`]utf-?8['"`]\s*\)/g,
+            (_match, _q, relPath) => {
+              modified = true;
+              try {
+                const sourceDir = dirname(args.path);
+                const srcDirIndex = args.path.lastIndexOf("/src/");
+                const inferredProjectRoot = srcDirIndex >= 0 ? args.path.slice(0, srcDirIndex) : void 0;
+                const candidates = [
+                  resolve(absWorkingDir, relPath),
+                  resolve(process.cwd(), relPath),
+                  resolve(sourceDir, relPath),
+                  ...inferredProjectRoot ? [resolve(inferredProjectRoot, relPath)] : []
+                ];
+                const absolutePath = candidates.find((candidate) => existsSync(candidate));
+                if (!absolutePath) return '""';
+                const content = readFileSync(absolutePath, "utf-8");
+                return JSON.stringify(content);
+              } catch {
+                return '""';
+              }
+            }
+          );
+          transformed = readFileTransformed;
+        }
+        const { transformed: oxcTransformed, modified: importsModified } = transformModuleImports(
+          transformed,
+          args.path,
+          globallyDeclaredSources
+        );
+        if (importsModified) {
+          modified = true;
+          transformed = oxcTransformed;
+        }
+        if (!modified) return void 0;
+        const ext = extname(args.path).slice(1);
+        return { contents: transformed, loader: ext };
+      });
+    }
+  };
+}
+export {
+  createClientGraphBoundaryPlugin
+};