@ecopages/core 0.2.0-alpha.53 → 0.2.0-alpha.55

package/src/build/rolldown-build-adapter.js

@@ -0,0 +1,260 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { rolldown } from "rolldown";
+import { isDeclaredAppPackageImport, normalizeNodeRuntimeBuildOutputs } from "./runtime-build-output-normalizer.js";
+import { collectBrowserRuntimeImportRewriteMap, rewriteBrowserRuntimeImports } from "./browser-runtime-plugin.js";
+import { createRolldownPluginBridge } from "./rolldown-plugin-bridge.js";
+import { createServerSideCssShimPlugin } from "./server-side-css-shim-plugin.js";
+const moduleRequire = createRequire(import.meta.url);
+const corePackageRequire = createRequire(new URL("../../package.json", import.meta.url));
+function tryResolveModule(id, resolver) {
+  try {
+    return resolver.resolve(id);
+  } catch {
+    return void 0;
+  }
+}
+function transpileProfileToOptions(profile) {
+  switch (profile) {
+    case "browser-script":
+    case "hmr-runtime":
+    case "hmr-entrypoint":
+      return {
+        target: "browser",
+        format: "esm",
+        sourcemap: "none"
+      };
+  }
+}
+function mapRolldownFormat(value) {
+  switch (value) {
+    case "cjs":
+      return "cjs";
+    case "iife":
+      return "iife";
+    case "esm":
+    default:
+      return "esm";
+  }
+}
+function mapRolldownPlatform(value) {
+  if (value === "browser") return "browser";
+  if (value === "node") return "node";
+  if (value && /^(?:es\d+|chrome\d+|edge\d+|firefox\d+|safari\d+|hermes|deno\d+|ios\d+)$/.test(value)) {
+    return "node";
+  }
+  return "neutral";
+}
+function mapRolldownSourcemap(value) {
+  switch (value) {
+    case "none":
+      return false;
+    case "inline":
+      return "inline";
+    case "external":
+    case "linked":
+      return "hidden";
+    default:
+      return true;
+  }
+}
+function mapRolldownJsx(jsx) {
+  const { factory, fragment, ...rest } = jsx;
+  const out = { ...rest };
+  if (factory !== void 0) {
+    out.pragma = factory;
+  }
+  if (fragment !== void 0) {
+    out.pragmaFrag = fragment;
+  }
+  return out;
+}
+function toEntryFileNamesPattern(value) {
+  if (!value) {
+    return void 0;
+  }
+  const literal = !/\[[^\]]+\]/u.test(value);
+  const stripped = value.replaceAll(/\.?\[ext\]/g, "");
+  if (stripped.length === 0) {
+    return void 0;
+  }
+  return { pattern: stripped, literal };
+}
+function getJavaScriptOutExtension(options, literal) {
+  if (literal) {
+    return void 0;
+  }
+  if (options.target === "browser") {
+    return ".js";
+  }
+  if (options.format === "cjs") {
+    return ".cjs";
+  }
+  return ".mjs";
+}
+function normalizeOutputPath(outputPath, outdir) {
+  return path.isAbsolute(outputPath) ? path.normalize(outputPath) : path.normalize(path.join(outdir, outputPath));
+}
+function normalizeModulePath(modulePath, contextRoot) {
+  return path.isAbsolute(modulePath) ? path.normalize(modulePath) : path.normalize(path.resolve(contextRoot, modulePath));
+}
+function extractDependencyGraph(chunks, contextRoot) {
+  const entrypoints = {};
+  for (const chunk of chunks) {
+    if (!chunk.facadeModuleId) {
+      continue;
+    }
+    const entrypointPath = normalizeModulePath(chunk.facadeModuleId, contextRoot);
+    entrypoints[entrypointPath] = Array.from(
+      /* @__PURE__ */ new Set([entrypointPath, ...chunk.moduleIds.map((id) => normalizeModulePath(id, contextRoot))])
+    );
+  }
+  return { entrypoints };
+}
+function toBuildLogs(error) {
+  if (error instanceof Error) {
+    return [{ message: error.message }];
+  }
+  return [{ message: "Unknown build error" }];
+}
+function isPackageImport(id) {
+  return !id.startsWith(".") && !path.isAbsolute(id) && !id.startsWith("/") && !id.startsWith("node:") && !id.startsWith("@/") && !id.startsWith("~/") && !id.startsWith("#") && !id.includes(":");
+}
+function shouldBundlePackageImport(id, contextRoot) {
+  if (isDeclaredAppPackageImport(id, contextRoot)) {
+    const appRootRequire = createRequire(path.join(contextRoot, "package.json"));
+    const appResolvedPath = tryResolveModule(id, appRootRequire);
+    return Boolean(appResolvedPath && /\.(?:[cm]?ts|tsx|jsx)$/u.test(appResolvedPath));
+  }
+  const coreResolvedPath = tryResolveModule(id, corePackageRequire);
+  return Boolean(coreResolvedPath && /\.(?:[cm]?ts|tsx|jsx)$/u.test(coreResolvedPath));
+}
+function createExternalMatcher(options) {
+  const explicitExternals = new Set(options.external ?? []);
+  const externalPackages = options.externalPackages === true;
+  const contextRoot = options.root ? path.resolve(options.root) : process.cwd();
+  return (id) => {
+    if (explicitExternals.has(id)) {
+      return true;
+    }
+    if (!externalPackages || !isPackageImport(id)) {
+      return false;
+    }
+    return !shouldBundlePackageImport(id, contextRoot);
+  };
+}
+function rewriteBrowserRuntimeImportsInOutputs(result, contextRoot, plugins) {
+  if (!result.success || result.outputs.length === 0) {
+    return result;
+  }
+  const specifierMap = collectBrowserRuntimeImportRewriteMap(plugins);
+  if (specifierMap.size === 0) {
+    return result;
+  }
+  const moduleRequireFromContext = createRequire(path.join(contextRoot, "package.json"));
+  for (const output of result.outputs) {
+    if (!/\.(?:[cm]?js)$/u.test(output.path)) {
+      continue;
+    }
+    const code = moduleRequireFromContext("node:fs").readFileSync(output.path, "utf-8");
+    const rewritten = rewriteBrowserRuntimeImports(code, specifierMap, output.path);
+    if (rewritten !== code) {
+      moduleRequireFromContext("node:fs").writeFileSync(output.path, rewritten);
+    }
+  }
+  return result;
+}
+function rewriteNodeRuntimeImportsInOutputs(result, contextRoot) {
+  if (!result.success || result.outputs.length === 0) {
+    return result;
+  }
+  normalizeNodeRuntimeBuildOutputs(
+    result.outputs.map((output) => output.path),
+    contextRoot
+  );
+  return result;
+}
+class RolldownBuildAdapter {
+  ownership = "rolldown";
+  async buildOrThrow(options) {
+    const contextRoot = options.root ? path.resolve(options.root) : process.cwd();
+    const outdir = path.resolve(options.outdir ?? "dist/assets");
+    const plugins = options.plugins ?? [];
+    const external = createExternalMatcher(options);
+    const transformOptions = {};
+    if (options.define) {
+      transformOptions.define = options.define;
+    }
+    if (options.jsx) {
+      transformOptions.jsx = mapRolldownJsx(options.jsx);
+    }
+    if (options.target && /^(?:es|chrome|edge|firefox|safari|hermes|deno|ios)/.test(options.target)) {
+      transformOptions.target = options.target;
+    }
+    const bundle = await rolldown({
+      input: options.entrypoints,
+      cwd: contextRoot,
+      external,
+      platform: mapRolldownPlatform(options.target),
+      transform: Object.keys(transformOptions).length > 0 ? transformOptions : void 0,
+      resolve: options.conditions ? { conditionNames: options.conditions } : void 0,
+      treeshake: typeof options.treeshaking === "boolean" ? options.treeshaking : true,
+      plugins: [createServerSideCssShimPlugin(), ...createRolldownPluginBridge(plugins, contextRoot)]
+    });
+    const entryFileNames = toEntryFileNamesPattern(options.naming);
+    const jsExtension = getJavaScriptOutExtension(options, entryFileNames?.literal ?? false);
+    const finalEntryFileNames = entryFileNames ? jsExtension ? `${entryFileNames.pattern}${jsExtension}` : entryFileNames.pattern : jsExtension ? `[name]${jsExtension}` : "[name]";
+    const output = await bundle.write({
+      dir: outdir,
+      format: mapRolldownFormat(options.format),
+      minify: !!options.minify,
+      entryFileNames: finalEntryFileNames,
+      chunkFileNames: "[name]-[hash].js",
+      assetFileNames: "[name]-[hash][extname]",
+      sourcemap: mapRolldownSourcemap(options.sourcemap)
+    });
+    await bundle.close();
+    const outputs = output.output.map((entry) => ({ path: normalizeOutputPath(entry.fileName, outdir) }));
+    const entryChunks = output.output.filter(
+      (entry) => entry.type === "chunk" && entry.isEntry
+    );
+    const dependencyGraph = extractDependencyGraph(
+      entryChunks.map((chunk) => ({ facadeModuleId: chunk.facadeModuleId, moduleIds: chunk.moduleIds })),
+      contextRoot
+    );
+    const baseResult = {
+      success: true,
+      logs: [],
+      outputs,
+      dependencyGraph
+    };
+    return rewriteNodeRuntimeImportsInOutputs(
+      rewriteBrowserRuntimeImportsInOutputs(baseResult, contextRoot, plugins),
+      contextRoot
+    );
+  }
+  async build(options) {
+    try {
+      return await this.buildOrThrow(options);
+    } catch (error) {
+      return {
+        success: false,
+        logs: toBuildLogs(error),
+        outputs: []
+      };
+    }
+  }
+  resolve(importPath, rootDir) {
+    return moduleRequire.resolve(importPath, { paths: [rootDir] });
+  }
+  getTranspileOptions(profile) {
+    return transpileProfileToOptions(profile);
+  }
+}
+function createRolldownBuildAdapter() {
+  return new RolldownBuildAdapter();
+}
+export {
+  RolldownBuildAdapter,
+  createRolldownBuildAdapter
+};

package/src/build/rolldown-plugin-bridge.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Bundler plugin bridge.
+ *
+ * @remarks
+ * Translates an array of `EcoBuildPlugin` instances (the runtime-agnostic
+ * plugin contract used by Ecopages processors and integrations) into
+ * the bundler's native `Plugin` array. The bridge exposes the same
+ * three hooks (`onResolve`, `onLoad`, `module`) the `EcoBuildPlugin`
+ * contract uses, but maps them to the bundler's `resolveId`/`load`
+ * hooks.
+ *
+ * The shared `EcoBuildPlugin` contract stays the boundary between
+ * integrations and bundler backends.
+ *
+ * **Namespace handling.**
+ *
+ * The shared `EcoBuildPlugin` contract scopes `onResolve`/`onLoad`
+ * handlers with a `namespace` string. The bundler encodes namespaces
+ * into the module id (no separate field). The bridge prepends
+ * `<namespace>:` to the resolved id when the result includes a
+ * namespace, and matches `onLoad`/`onResolve` filters against that
+ * prefix. The bridge strips the prefix before forwarding the id back
+ * to the callback so plugin code keeps seeing the same `path` shape
+ * it did on the historical contract.
+ *
+ * **Plugin ordering is semantically significant.**
+ *
+ * The bundler's `resolveId` and `load` are "first" hooks: the first
+ * plugin that returns a non-null value wins. Because the bridge
+ * translates each `EcoBuildPlugin` into its own bundler plugin and
+ * preserves the array order, the position of each plugin in the
+ * `plugins` array determines its priority:
+ *
+ * - **Index 0** has the highest priority.
+ * - **Last index** has the lowest priority.
+ *
+ * When adding new integrations or processors, ensure security-critical
+ * plugins (e.g. `ecopages-client-graph-boundary`) are placed **before**
+ * general-purpose loaders in the array so they always get first refusal
+ * on every source file.
+ */
+import type { Plugin } from 'rolldown';
+import type { EcoBuildPlugin } from './build-types.js';
+/**
+ * Creates a Rolldown `Plugin` array that drives the supplied
+ * `EcoBuildPlugin` instances. Each `EcoBuildPlugin` becomes its own
+ * Rolldown plugin so that the order of registrations is preserved as
+ * plugin priority.
+ */
+export declare function createRolldownPluginBridge(plugins: EcoBuildPlugin[], contextRoot: string): Plugin[];

package/src/build/rolldown-plugin-bridge.js

@@ -0,0 +1,194 @@
+import path from "node:path";
+import { escapeRegExp } from "./browser-runtime-plugin-helpers.js";
+const NAMESPACE_SEPARATOR = ":";
+function joinNamespace(namespace, value) {
+  return namespace ? `${namespace}${NAMESPACE_SEPARATOR}${value}` : value;
+}
+function splitNamespace(id) {
+  const separatorIndex = id.indexOf(NAMESPACE_SEPARATOR);
+  if (separatorIndex <= 0) {
+    return { namespace: void 0, path: id };
+  }
+  return {
+    namespace: id.slice(0, separatorIndex),
+    path: id.slice(separatorIndex + 1)
+  };
+}
+function inferRolldownModuleTypeFromPath(filePath) {
+  const extension = path.extname(filePath).toLowerCase();
+  switch (extension) {
+    case ".ts":
+      return "ts";
+    case ".tsx":
+      return "tsx";
+    case ".jsx":
+      return "jsx";
+    case ".json":
+      return "json";
+    case ".css":
+      return "css";
+    default:
+      return "js";
+  }
+}
+function normalizeRolldownModuleType(loader) {
+  switch (loader) {
+    case "js":
+    case "jsx":
+    case "ts":
+    case "tsx":
+    case "json":
+    case "css":
+    case "text":
+    case "base64":
+    case "dataurl":
+    case "binary":
+    case "empty":
+      return loader;
+    case "global-css":
+    case "local-css":
+      return "css";
+    case "file":
+    case "copy":
+      return "asset";
+    default:
+      return void 0;
+  }
+}
+function convertLoadResultToModuleSource(result) {
+  if (result.loader === "object" && result.exports && typeof result.exports === "object") {
+    return Object.entries(result.exports).map(
+      ([key, value]) => key === "default" ? `export default ${JSON.stringify(value)};` : `export const ${key} = ${JSON.stringify(value)};`
+    ).join("\n");
+  }
+  return void 0;
+}
+function buildIdFilter(filter, namespace) {
+  if (!namespace) {
+    return filter;
+  }
+  return new RegExp(`^${escapeRegExp(namespace)}${NAMESPACE_SEPARATOR}${filter.source.slice(1)}`);
+}
+function resolvePluginPath(value, importer, contextRoot) {
+  if (path.isAbsolute(value)) {
+    return value;
+  }
+  if (value.startsWith(".") || value.startsWith("..")) {
+    const baseDir = importer ? path.dirname(importer) : contextRoot;
+    return path.resolve(baseDir, value);
+  }
+  return value;
+}
+function convertPluginOnLoadResult(args, result) {
+  if (!result || typeof result !== "object") {
+    return void 0;
+  }
+  const candidate = result;
+  const { path: sourcePath } = splitNamespace(args.id);
+  const sourceFromExports = convertLoadResultToModuleSource(candidate);
+  if (sourceFromExports) {
+    const description = {
+      code: sourceFromExports,
+      moduleType: "js"
+    };
+    return description;
+  }
+  if (typeof candidate.contents === "string" || candidate.contents instanceof Uint8Array) {
+    const code = typeof candidate.contents === "string" ? candidate.contents : new TextDecoder().decode(candidate.contents);
+    const description = {
+      code,
+      moduleType: normalizeRolldownModuleType(candidate.loader) ?? inferRolldownModuleTypeFromPath(sourcePath)
+    };
+    return description;
+  }
+  return void 0;
+}
+function convertPluginOnResolveResult(result, importer, contextRoot) {
+  if (!result || typeof result !== "object") {
+    return void 0;
+  }
+  const candidate = result;
+  if (typeof candidate.path !== "string" && typeof candidate.namespace !== "string") {
+    if (typeof candidate.external !== "boolean") {
+      return void 0;
+    }
+  }
+  const partial = { id: "" };
+  if (typeof candidate.path === "string") {
+    partial.id = joinNamespace(candidate.namespace, resolvePluginPath(candidate.path, importer, contextRoot));
+  } else if (typeof candidate.namespace === "string") {
+    partial.id = joinNamespace(candidate.namespace, "");
+  }
+  if (typeof candidate.external === "boolean") {
+    partial.external = candidate.external;
+  }
+  return partial;
+}
+function wrapEcoPlugin(ecoPlugin, contextRoot, moduleCounter) {
+  const resolveRegistrations = [];
+  const loadRegistrations = [];
+  const registerResolve = (filter, callback) => {
+    resolveRegistrations.push({ filter, callback });
+  };
+  const registerLoad = (filter, callback) => {
+    loadRegistrations.push({ filter, callback });
+  };
+  return {
+    name: `ecopages-plugin-bridge:${ecoPlugin.name}`,
+    buildStart: async () => {
+      const bridge = {
+        onResolve: (options, callback) => {
+          registerResolve(buildIdFilter(options.filter, options.namespace), callback);
+        },
+        onLoad: (options, callback) => {
+          registerLoad(buildIdFilter(options.filter, options.namespace), callback);
+        },
+        module: (specifier, callback) => {
+          const namespace = `ecopages-module-${moduleCounter.value}`;
+          moduleCounter.value += 1;
+          const filter = new RegExp(`^${escapeRegExp(specifier)}$`);
+          registerResolve(filter, async () => ({
+            path: joinNamespace(namespace, specifier)
+          }));
+          registerLoad(buildIdFilter(/.*/, namespace), async () => callback());
+        }
+      };
+      await ecoPlugin.setup(bridge);
+    },
+    resolveId: async (source, importer, _extraOptions) => {
+      for (const { filter, callback } of resolveRegistrations) {
+        if (!filter.test(source)) {
+          continue;
+        }
+        const { namespace, path: sourcePath } = splitNamespace(source);
+        const result = await callback({ path: sourcePath, importer, namespace });
+        const converted = convertPluginOnResolveResult(result, importer, contextRoot);
+        if (converted !== void 0) {
+          return converted;
+        }
+      }
+      return void 0;
+    },
+    load: async (id) => {
+      for (const { filter, callback } of loadRegistrations) {
+        if (!filter.test(id)) {
+          continue;
+        }
+        const { namespace, path: sourcePath } = splitNamespace(id);
+        const result = await callback({ path: sourcePath, namespace });
+        const converted = convertPluginOnLoadResult({ id }, result);
+        if (converted !== void 0) {
+          return converted;
+        }
+      }
+      return void 0;
+    }
+  };
+}
+function createRolldownPluginBridge(plugins, contextRoot) {
+  const moduleCounter = { value: 0 };
+  return plugins.map((ecoPlugin) => wrapEcoPlugin(ecoPlugin, contextRoot, moduleCounter));
+}
+export {
+  createRolldownPluginBridge
+};

package/src/build/runtime-build-executor.d.ts

@@ -4,11 +4,18 @@ import { type BuildExecutor } from './build-adapter.js';
  * Installs the app-owned runtime build executor for one app instance.
  *
  * @remarks
- * This is the single runtime executor boundary for adapter-owned startup.
- * Bun-native ownership may reuse `DevBuildCoordinator` in development, while
- * Vite-host ownership stays on a plain host-owned executor boundary with no
- * Bun-specific coordination policy.
+ * Wraps the app-owned adapter in a {@link SerializedBuildExecutor} so
+ * every dev-watch caller issues builds against a single FIFO queue.
+ * Plugin injection is applied here via {@link withBuildExecutorPlugins}
+ * so app-owned plugins are merged into every rebuild without callers
+ * having to know about the manifest.
+ *
+ * Idempotent across calls: re-invoking replaces the existing executor
+ * on `appConfig.runtime` with a fresh wrapper.
+ *
+ * @param appConfig - The app config whose runtime state is updated.
+ *   The function reads the existing executor (falling back to the
+ *   app-owned adapter) and writes the wrapped executor back.
+ * @returns The installed {@link BuildExecutor}.
  */
-export declare function installAppRuntimeBuildExecutor(appConfig: EcoPagesAppConfig, options: {
-    development: boolean;
-}): BuildExecutor;
+export declare function installAppRuntimeBuildExecutor(appConfig: EcoPagesAppConfig): BuildExecutor;

package/src/build/runtime-build-executor.js

@@ -1,19 +1,16 @@
 import {
   getAppBuildAdapter,
   getAppBuildExecutor,
-  getAppBuildOwnership,
   getAppServerBuildPlugins,
-  setAppBuildExecutor
+  setAppBuildExecutor,
+  withBuildExecutorPlugins
 } from "./build-adapter.js";
-import { createOrReuseAppBuildExecutor, withBuildExecutorPlugins } from "./dev-build-coordinator.js";
-function installAppRuntimeBuildExecutor(appConfig, options) {
-  const buildOwnership = getAppBuildOwnership(appConfig);
-  const buildExecutor = buildOwnership === "bun-native" ? createOrReuseAppBuildExecutor({
-    development: options.development,
-    adapter: getAppBuildAdapter(appConfig),
-    currentExecutor: getAppBuildExecutor(appConfig),
-    getPlugins: () => getAppServerBuildPlugins(appConfig)
-  }) : withBuildExecutorPlugins(getAppBuildAdapter(appConfig), () => getAppServerBuildPlugins(appConfig));
+import { SerializedBuildExecutor } from "./serialized-build-executor.js";
+function installAppRuntimeBuildExecutor(appConfig) {
+  const baseExecutor = getAppBuildExecutor(appConfig) ?? getAppBuildAdapter(appConfig);
+  const buildExecutor = new SerializedBuildExecutor(
+    withBuildExecutorPlugins(baseExecutor, () => getAppServerBuildPlugins(appConfig))
+  );
   setAppBuildExecutor(appConfig, buildExecutor);
   return buildExecutor;
 }

package/src/build/runtime-build-output-normalizer.d.ts

@@ -0,0 +1,3 @@
+export declare function isDeclaredAppPackageImport(specifier: string, rootDir: string): boolean;
+export declare function normalizeNodeRuntimeBuildOutputFile(filePath: string, rootDir: string): void;
+export declare function normalizeNodeRuntimeBuildOutputs(outputPaths: string[], rootDir: string): void;

package/src/build/runtime-build-output-normalizer.js

@@ -0,0 +1,111 @@
+import { createRequire } from "node:module";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+const corePackageRequire = createRequire(new URL("../../package.json", import.meta.url));
+const appDeclaredPackageCache = /* @__PURE__ */ new Map();
+function tryResolveRuntimeImport(specifier, resolver) {
+  try {
+    return resolver.resolve(specifier);
+  } catch {
+    return void 0;
+  }
+}
+function isBareRuntimeImport(specifier) {
+  return !specifier.startsWith(".") && !path.isAbsolute(specifier) && !specifier.startsWith("/") && !specifier.startsWith("node:") && !specifier.startsWith("@/") && !specifier.startsWith("~/") && !specifier.startsWith("#") && !specifier.includes(":");
+}
+function getPackageNameFromSpecifier(specifier) {
+  if (specifier.startsWith("@")) {
+    return specifier.split("/").slice(0, 2).join("/");
+  }
+  return specifier.split("/")[0] ?? specifier;
+}
+function getDeclaredAppPackages(rootDir) {
+  const cacheKey = path.resolve(rootDir);
+  const cached = appDeclaredPackageCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const packageJsonPath = path.resolve(rootDir, "package.json");
+  const declaredPackages = /* @__PURE__ */ new Set();
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+      const entries = packageJson[field];
+      if (!entries || typeof entries !== "object") {
+        continue;
+      }
+      for (const packageName of Object.keys(entries)) {
+        declaredPackages.add(packageName);
+      }
+    }
+  } catch {
+    appDeclaredPackageCache.set(cacheKey, declaredPackages);
+    return declaredPackages;
+  }
+  appDeclaredPackageCache.set(cacheKey, declaredPackages);
+  return declaredPackages;
+}
+function isDeclaredAppPackageImport(specifier, rootDir) {
+  return getDeclaredAppPackages(rootDir).has(getPackageNameFromSpecifier(specifier));
+}
+function rewriteRuntimeImportSpecifier(specifier, quote, rootDir) {
+  if (!isBareRuntimeImport(specifier)) {
+    return void 0;
+  }
+  if (isDeclaredAppPackageImport(specifier, rootDir)) {
+    return void 0;
+  }
+  const resolvedPath = tryResolveRuntimeImport(specifier, corePackageRequire);
+  if (!resolvedPath || !/\.(?:[cm]?[jt]s|tsx|jsx)$/u.test(resolvedPath)) {
+    return void 0;
+  }
+  return `${quote}${pathToFileURL(resolvedPath).href}${quote}`;
+}
+function rewriteRuntimeBuildOutputImports(code, rootDir) {
+  const rewriteSpecifier = (prefix, quote, specifier) => {
+    const rewrittenSpecifier = rewriteRuntimeImportSpecifier(specifier, quote, rootDir);
+    return `${prefix}${rewrittenSpecifier ?? `${quote}${specifier}${quote}`}`;
+  };
+  const withResolvedPackages = code.replace(
+    /(\bfrom\s+)(['"])([^'"\\]+)\2/g,
+    (_match, prefix, quote, specifier) => rewriteSpecifier(prefix, quote, specifier)
+  ).replace(
+    /(\bimport\s+)(['"])([^'"\\]+)\2/g,
+    (_match, prefix, quote, specifier) => rewriteSpecifier(prefix, quote, specifier)
+  ).replace(
+    /(\bimport\s*\(\s*)(['"])([^'"\\]+)\2/g,
+    (_match, prefix, quote, specifier) => rewriteSpecifier(prefix, quote, specifier)
+  );
+  return withResolvedPackages.replace(
+    /(['"])(@oxc-project\/runtime\/(?:helpers(?:\/esm)?\/[^'"\\]+))\1/g,
+    (match, quote, specifier) => {
+      const resolvedPath = tryResolveRuntimeImport(specifier, corePackageRequire);
+      return resolvedPath ? `${quote}${pathToFileURL(resolvedPath).href}${quote}` : match;
+    }
+  );
+}
+function normalizeNodeRuntimeBuildOutputFile(filePath, rootDir) {
+  if (!/\.(?:[cm]?js)$/u.test(filePath)) {
+    return;
+  }
+  const fileSystem = corePackageRequire("node:fs");
+  if (!fileSystem.existsSync(filePath)) {
+    return;
+  }
+  const code = fileSystem.readFileSync(filePath, "utf-8");
+  const rewritten = rewriteRuntimeBuildOutputImports(code, rootDir);
+  if (rewritten !== code) {
+    fileSystem.writeFileSync(filePath, rewritten);
+  }
+}
+function normalizeNodeRuntimeBuildOutputs(outputPaths, rootDir) {
+  for (const outputPath of outputPaths) {
+    normalizeNodeRuntimeBuildOutputFile(outputPath, rootDir);
+  }
+}
+export {
+  isDeclaredAppPackageImport,
+  normalizeNodeRuntimeBuildOutputFile,
+  normalizeNodeRuntimeBuildOutputs
+};