@reliverse/dler 1.2.0

package/bin/libs/sdk/sdk-impl/build/build-library.js

@@ -0,0 +1,865 @@
+import { relinka } from "@reliverse/relinka";
+import { build as bunBuild } from "bun";
+import fs from "fs-extra";
+import MagicString from "magic-string";
+import pAll from "p-all";
+import path from "pathe";
+import prettyBytes from "pretty-bytes";
+import prettyMilliseconds from "pretty-ms";
+import { build as unifiedBuild } from "./bundlers/unified/build.js";
+import { ensuredir } from "./bundlers/unified/utils.js";
+import {
+  getBunSourcemapOption,
+  getUnifiedSourcemapOption,
+  renameEntryFile
+} from "../utils/utils-build.js";
+import {
+  CONCURRENCY_DEFAULT,
+  PROJECT_ROOT,
+  validExtensions
+} from "../utils/utils-consts.js";
+import { determineDistName } from "../utils/utils-determine.js";
+import {
+  copyRootFile,
+  deleteSpecificFiles,
+  getDirectorySize,
+  outDirBinFilesCount
+} from "../utils/utils-fs.js";
+import {
+  createJsrJSON,
+  renameTsxFiles
+} from "../utils/utils-jsr-json.js";
+import {
+  convertImportExtensionsJsToTs,
+  convertImportPaths
+} from "../utils/utils-paths.js";
+import {
+  getElapsedPerfTime
+} from "../utils/utils-perf.js";
+import { library_createPackageJSON } from "../utils/utils-pkg-json-libs.js";
+const BIN_DIR_NAME = "bin";
+const REPLACEMENT_MARKER = "// dler-replace-me";
+const FILES_TO_COPY_ROOT = ["README.md", "LICENSE"];
+const TYPES_REPLACEMENT_PATH = "src/types.ts";
+const ALIAS_PREFIX_TO_CONVERT = "~/";
+export async function library_buildLibrary(options) {
+  const { libName, mainDir } = options;
+  let replacedFiles = [];
+  const replacementConfig = {
+    librarySrcDir: path.resolve(PROJECT_ROOT, mainDir),
+    replacementFilePath: path.resolve(PROJECT_ROOT, TYPES_REPLACEMENT_PATH),
+    replacementMarker: REPLACEMENT_MARKER
+  };
+  try {
+    relinka("info", `Running pre-build replacements for ${libName}...`);
+    replacedFiles = await preBuildReplacements(replacementConfig);
+    relinka("verbose", `Pre-build: ${replacedFiles.length} files modified.`);
+    await executeBuildTasks(options);
+  } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    relinka(
+      "error",
+      `Build process for ${libName} failed: ${error.message}`,
+      error.stack
+    );
+    throw error;
+  } finally {
+    if (replacedFiles.length > 0) {
+      relinka(
+        "verbose",
+        `Reverting ${replacedFiles.length} pre-build changes for ${libName}...`
+      );
+      try {
+        await postBuildReplacements(replacedFiles);
+        relinka("verbose", `Done reverting changes for ${libName}.`);
+      } catch (revertError) {
+        const error = revertError instanceof Error ? revertError : new Error(String(revertError));
+        relinka(
+          "error",
+          `CRITICAL: Failed to revert pre-build changes for ${libName}: ${error.message}. Source files may be left modified!`,
+          error.stack
+        );
+      }
+    } else {
+      relinka("verbose", `No pre-build changes to revert for ${libName}.`);
+    }
+  }
+}
+async function executeBuildTasks(options) {
+  const { commonPubRegistry, libName } = options;
+  const buildTasks = [];
+  if (commonPubRegistry === "jsr" || commonPubRegistry === "npm-jsr") {
+    if (!options.jsr) {
+      throw new Error(
+        `JSR build requested for ${libName} but 'options.jsr' is missing.`
+      );
+    }
+    relinka("info", `Queueing JSR build for lib ${libName}...`);
+    buildTasks.push(() => library_buildJsrDist(options));
+  }
+  if (commonPubRegistry === "npm" || commonPubRegistry === "npm-jsr") {
+    if (!options.npm) {
+      throw new Error(
+        `NPM build requested for ${libName} but 'options.npm' is missing.`
+      );
+    }
+    relinka("info", `Queueing NPM build for lib ${libName}...`);
+    buildTasks.push(() => library_buildNpmDist(options));
+  }
+  if (buildTasks.length === 0) {
+    relinka(
+      "warn",
+      `No valid build targets specified by 'commonPubRegistry' ("${commonPubRegistry}") for lib ${libName}. Skipping build.`
+    );
+    return;
+  }
+  if (buildTasks.length > 1) {
+    relinka("info", `Building lib ${libName} for NPM and JSR concurrently...`);
+    await pAll(buildTasks, { concurrency: CONCURRENCY_DEFAULT });
+  } else {
+    relinka(
+      "info",
+      `Building lib ${libName} for ${options.commonPubRegistry || "single target"}...`
+    );
+    const task = buildTasks[0];
+    if (task) {
+      await task();
+    }
+  }
+}
+async function library_buildJsrDist(options) {
+  const { libName, libMainFile, libsList } = options;
+  if (!options.jsr) {
+    throw new Error(
+      `Internal Error: library_buildJsrDist called for ${libName} but options.jsr is missing.`
+    );
+  }
+  const jsrOptions = options.jsr;
+  const { jsrOutDir, distJsrBuilder, distJsrOutFilesExt } = jsrOptions;
+  const targetType = "jsr";
+  relinka("info", `[JSR] Initializing JSR build for ${libName}...`);
+  const libSourceDirResolved = path.resolve(PROJECT_ROOT, options.mainDir);
+  const entryFilePathResolved = path.resolve(libSourceDirResolved, libMainFile);
+  const outputDirRootResolved = path.resolve(PROJECT_ROOT, jsrOutDir);
+  const outputDirBinResolved = path.resolve(
+    outputDirRootResolved,
+    BIN_DIR_NAME
+  );
+  const bundlerEntryPoint = distJsrBuilder === "jsr" ? libSourceDirResolved : entryFilePathResolved;
+  const libConfig = libsList[libName];
+  const libDeclarations = libConfig?.libDeclarations ?? false;
+  const buildParams = {
+    targetType,
+    builder: distJsrBuilder,
+    libSourceDir: libSourceDirResolved,
+    entryFilePath: bundlerEntryPoint,
+    outputDirRoot: outputDirRootResolved,
+    outputDirBin: outputDirBinResolved,
+    libDeclarations,
+    distJsrOutFilesExt,
+    options
+    // libDirName is generally not needed/used for JSR target logic
+  };
+  await buildDistributionTarget(buildParams);
+  relinka(
+    "verbose",
+    `[JSR] Performing JSR-specific transformations in ${outputDirBinResolved}`
+  );
+  await convertImportExtensionsJsToTs({ dirPath: outputDirBinResolved });
+  await renameTsxFiles(outputDirBinResolved);
+  await createJsrJSON(
+    outputDirRootResolved,
+    true,
+    libName,
+    libConfig?.libDescription ?? ""
+  );
+  const dirSize = await getDirectorySize(outputDirRootResolved, options.isDev);
+  const filesCount = await outDirBinFilesCount(outputDirBinResolved);
+  relinka(
+    "success",
+    `[JSR] JSR distribution for ${libName} built successfully (${filesCount} files, ${prettyBytes(dirSize)}) -> ${outputDirRootResolved}`
+  );
+}
+async function library_buildNpmDist(options) {
+  const { libName, libMainFile, libsList } = options;
+  if (!options.npm) {
+    throw new Error(
+      `Internal Error: library_buildNpmDist called for ${libName} but options.npm is missing.`
+    );
+  }
+  const npmOptions = options.npm;
+  const { npmOutDir, distNpmBuilder, coreEntrySrcDir } = npmOptions;
+  const distJsrOutFilesExt = options.jsr?.distJsrOutFilesExt || "ts";
+  const targetType = "npm";
+  const distName = determineDistName(npmOutDir, false, libsList);
+  relinka("info", `[NPM:${distName}] Initializing NPM build for ${libName}...`);
+  const coreEntrySrcDirResolved = path.resolve(PROJECT_ROOT, coreEntrySrcDir);
+  const outputDirRootResolved = path.resolve(PROJECT_ROOT, npmOutDir);
+  const outputDirBinResolved = path.resolve(
+    outputDirRootResolved,
+    BIN_DIR_NAME
+  );
+  const { libSpecificSrcDir, libDirName } = await determineNpmSourceDirectory(
+    libName,
+    libMainFile,
+    coreEntrySrcDirResolved,
+    libsList,
+    distName
+  );
+  const entryFilePathResolved = path.resolve(
+    libSpecificSrcDir,
+    path.basename(libMainFile)
+  );
+  if (!await fs.pathExists(entryFilePathResolved)) {
+    const relativeEntryPath = path.relative(
+      PROJECT_ROOT,
+      entryFilePathResolved
+    );
+    const relativeSrcDir = path.relative(PROJECT_ROOT, libSpecificSrcDir);
+    throw new Error(
+      `[NPM:${distName}] Library entry file not found: ${relativeEntryPath} (expected in: ${relativeSrcDir})`
+    );
+  }
+  relinka(
+    "verbose",
+    `[NPM:${distName}] Using entry file: ${entryFilePathResolved}`
+  );
+  const libConfig = libsList[libName];
+  const libDeclarations = libConfig?.libDeclarations ?? false;
+  const buildParams = {
+    targetType,
+    builder: distNpmBuilder,
+    libSourceDir: libSpecificSrcDir,
+    entryFilePath: entryFilePathResolved,
+    outputDirRoot: outputDirRootResolved,
+    outputDirBin: outputDirBinResolved,
+    libDeclarations,
+    distJsrOutFilesExt,
+    options,
+    libDirName
+    // Pass determined libDirName
+  };
+  await buildDistributionTarget(buildParams);
+  const dirSize = await getDirectorySize(outputDirRootResolved, options.isDev);
+  const filesCount = await outDirBinFilesCount(outputDirBinResolved);
+  relinka(
+    "success",
+    `[NPM:${distName}] NPM distribution for ${libName} built successfully (${filesCount} files, ${prettyBytes(dirSize)}) -> ${outputDirRootResolved}`
+  );
+}
+async function buildDistributionTarget(params) {
+  const {
+    targetType,
+    builder,
+    entryFilePath,
+    // Entry for bundler (file path or dir path for 'jsr' copy)
+    outputDirRoot,
+    outputDirBin,
+    libDeclarations,
+    distJsrOutFilesExt,
+    options,
+    libDirName
+  } = params;
+  const {
+    libName,
+    timer,
+    libMainFile,
+    libsList,
+    rmDepsMode,
+    rmDepsPatterns,
+    // Transpile/Bundle Options from `options`
+    libTranspileMinify,
+    transpileTarget,
+    transpileFormat,
+    transpileSplitting,
+    transpileSourcemap,
+    transpilePublicPath,
+    transpileEsbuild,
+    transpileStub,
+    transpileWatch,
+    unifiedBundlerOutExt
+  } = options;
+  const isJsr = targetType === "jsr";
+  const logPrefix = isJsr ? "[JSR]" : `[NPM:${determineDistName(path.relative(PROJECT_ROOT, outputDirRoot), false, libsList)}]`;
+  relinka("info", `${logPrefix} Starting build target processing...`);
+  await ensuredir(outputDirRoot);
+  await ensuredir(outputDirBin);
+  relinka("info", `${logPrefix} Using builder: ${builder}`);
+  const bundleRequest = {
+    builder,
+    entryPoint: entryFilePath,
+    outDir: outputDirBin,
+    libName,
+    timer,
+    libDeclarations,
+    libTranspileMinify,
+    transpileTarget,
+    transpileFormat,
+    transpileSplitting,
+    transpileSourcemap,
+    transpilePublicPath,
+    transpileEsbuild,
+    transpileStub,
+    transpileWatch,
+    unifiedBundlerOutExt
+  };
+  await library_bundleWithBuilder(bundleRequest);
+  const commonStepsParams = {
+    coreEntryFileName: path.basename(libMainFile),
+    outDirRoot: outputDirRoot,
+    outDirBin: outputDirBin,
+    isJsr,
+    libName,
+    libsList,
+    rmDepsMode,
+    rmDepsPatterns,
+    unifiedBundlerOutExt,
+    distJsrOutFilesExt,
+    deleteFiles: isJsr,
+    libDirName
+  };
+  await library_performCommonBuildSteps(commonStepsParams);
+  relinka("info", `${logPrefix} Completed build target processing.`);
+}
+async function library_bundleWithBuilder(params) {
+  const { builder, ...executorParams } = params;
+  const { entryPoint, outDir, libName } = executorParams;
+  relinka(
+    "verbose",
+    `[${libName}] Bundling using '${builder}' builder... Entry: ${entryPoint}, Out: ${outDir}`
+  );
+  switch (builder) {
+    case "jsr":
+      await library_bundleUsingJsrCopy(entryPoint, outDir, libName);
+      break;
+    case "bun":
+      await library_bundleUsingBun(entryPoint, outDir, libName, {
+        timer: executorParams.timer,
+        libTranspileMinify: executorParams.libTranspileMinify,
+        transpileTarget: executorParams.transpileTarget,
+        transpileFormat: executorParams.transpileFormat,
+        transpileSplitting: executorParams.transpileSplitting,
+        transpileSourcemap: executorParams.transpileSourcemap,
+        transpilePublicPath: executorParams.transpilePublicPath
+      });
+      break;
+    case "rollup":
+    case "mkdist":
+      await library_bundleUsingUnified(
+        entryPoint,
+        outDir,
+        builder,
+        // Pass the specific unified builder name
+        path.dirname(entryPoint),
+        // Source directory context
+        {
+          timer: executorParams.timer,
+          libDeclarations: executorParams.libDeclarations,
+          libTranspileMinify: executorParams.libTranspileMinify,
+          transpileSourcemap: executorParams.transpileSourcemap,
+          transpileEsbuild: executorParams.transpileEsbuild,
+          transpileStub: executorParams.transpileStub,
+          unifiedBundlerOutExt: executorParams.unifiedBundlerOutExt
+        }
+      );
+      break;
+    default:
+      throw new Error(`Unsupported library builder specified: ${builder}`);
+  }
+  relinka("verbose", `[${libName}] Bundling finished using '${builder}'.`);
+}
+async function library_bundleUsingJsrCopy(srcDir, destDir, libName) {
+  relinka(
+    "verbose",
+    `[JSR Copy:${libName}] Starting copy: ${srcDir} -> ${destDir}`
+  );
+  await ensuredir(destDir);
+  try {
+    const copyOptions = { overwrite: true };
+    await fs.copy(srcDir, destDir, copyOptions);
+    relinka(
+      "success",
+      `[JSR Copy:${libName}] Completed copying library source from ${srcDir} to ${destDir}`
+    );
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    relinka(
+      "error",
+      `[JSR Copy:${libName}] Failed to copy library source from ${srcDir} to ${destDir}: ${errorMessage}`,
+      error instanceof Error ? error.stack : void 0
+    );
+    throw new Error(`[JSR Copy:${libName}] Failed: ${errorMessage}`);
+  }
+}
+async function library_bundleUsingBun(entryPoint, outDirBin, libName, options) {
+  const {
+    timer,
+    libTranspileMinify,
+    transpileTarget,
+    transpileFormat,
+    transpileSplitting,
+    transpileSourcemap,
+    transpilePublicPath
+  } = options;
+  relinka("verbose", `[Bun:${libName}] Starting Bun build...`);
+  if (!await fs.pathExists(entryPoint)) {
+    throw new Error(
+      `[Bun:${libName}] Library entry file not found: ${entryPoint}`
+    );
+  }
+  if (!(await fs.stat(entryPoint)).isFile()) {
+    throw new Error(
+      `[Bun:${libName}] Entry point must be a file for Bun bundler: ${entryPoint}`
+    );
+  }
+  try {
+    const buildConfig = {
+      entrypoints: [entryPoint],
+      outdir: outDirBin,
+      target: transpileTarget,
+      format: transpileFormat,
+      splitting: transpileSplitting,
+      minify: libTranspileMinify,
+      sourcemap: getBunSourcemapOption(transpileSourcemap),
+      publicPath: transpilePublicPath,
+      naming: {
+        entry: "[dir]/[name].[ext]",
+        chunk: "[name]-[hash].[ext]",
+        asset: "[name]-[hash].[ext]"
+      },
+      define: {
+        "process.env.NODE_ENV": JSON.stringify(
+          process.env.NODE_ENV || "production"
+        )
+      },
+      plugins: [],
+      loader: {},
+      banner: `/* ${libName} - Bundled by @reliverse/dler (Bun) */`,
+      throw: true
+      // Ensure build errors are thrown
+    };
+    const buildResult = await bunBuild(buildConfig);
+    const duration = getElapsedPerfTime(timer);
+    if (buildResult.success) {
+      relinka(
+        "success",
+        `[Bun:${libName}] Library build completed in ${prettyMilliseconds(duration)} (${buildResult.outputs.length} outputs).`
+      );
+      if (buildResult.logs?.length > 0) {
+        for (const log of buildResult.logs) {
+          relinka("verbose", `[Bun Log:${log.level}] ${log.message}`);
+        }
+      }
+    } else {
+      relinka(
+        "error",
+        `[Bun:${libName}] Library build failed after ${prettyMilliseconds(duration)}.`
+      );
+      if (buildResult.logs?.length > 0) {
+        for (const log of buildResult.logs) {
+          relinka("error", `[Bun Log:${log.level}] ${log.message}`);
+        }
+      }
+      throw new Error(
+        `[Bun:${libName}] Build process reported failure. Check logs.`
+      );
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    relinka(
+      "error",
+      `[Bun:${libName}] Library build threw an error: ${errorMessage}`,
+      error instanceof Error ? error.stack : void 0
+    );
+    throw new Error(`[Bun:${libName}] Bundle failed: ${errorMessage}`);
+  }
+}
+async function library_bundleUsingUnified(entryPoint, outDirBin, builder, sourceDirContext, options) {
+  const {
+    timer,
+    libDeclarations,
+    libTranspileMinify,
+    transpileSourcemap,
+    transpileEsbuild,
+    transpileStub,
+    unifiedBundlerOutExt
+  } = options;
+  relinka("verbose", `[Unified:${builder}] Starting ${builder} build...`);
+  const rootDir = PROJECT_ROOT;
+  let validatedExt = unifiedBundlerOutExt;
+  if (!validExtensions.includes(validatedExt)) {
+    relinka(
+      "warn",
+      `[Unified:${builder}] Invalid output extension '${validatedExt}', defaulting to 'js'.`
+    );
+    validatedExt = "js";
+  }
+  const inputRelative = path.relative(rootDir, entryPoint);
+  const outDirRelative = path.relative(rootDir, outDirBin);
+  const unifiedBuildConfig = {
+    clean: false,
+    declaration: libDeclarations ? "compatible" : false,
+    entries: [
+      {
+        builder,
+        input: inputRelative,
+        outDir: outDirRelative,
+        ext: validatedExt
+      }
+    ],
+    rollup: {
+      emitCJS: false,
+      esbuild: {
+        minify: libTranspileMinify,
+        target: transpileEsbuild
+      },
+      inlineDependencies: true,
+      output: {
+        sourcemap: getUnifiedSourcemapOption(transpileSourcemap)
+      }
+    },
+    hooks: {},
+    stub: transpileStub
+  };
+  try {
+    await unifiedBuild(rootDir, unifiedBuildConfig, outDirBin);
+    const duration = getElapsedPerfTime(timer);
+    relinka(
+      "success",
+      `[Unified:${builder}] Library build completed in ${prettyMilliseconds(duration)}.`
+    );
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    relinka(
+      "error",
+      `[Unified:${builder}] Library build failed: ${errorMessage}`,
+      error instanceof Error ? error.stack : void 0
+    );
+    throw new Error(`[Unified:${builder}] Bundle failed: ${errorMessage}`);
+  }
+}
+async function library_performCommonBuildSteps(params) {
+  const {
+    coreEntryFileName,
+    outDirRoot,
+    outDirBin,
+    isJsr,
+    libName,
+    libsList,
+    rmDepsMode,
+    rmDepsPatterns,
+    unifiedBundlerOutExt,
+    distJsrOutFilesExt,
+    deleteFiles = false,
+    libDirName
+  } = params;
+  const targetType = isJsr ? "JSR" : "NPM";
+  const logPrefix = `[Common:${targetType}:${libName}]`;
+  relinka("verbose", `${logPrefix} Performing common steps in ${outDirRoot}`);
+  await library_createPackageJSON(
+    libName,
+    outDirRoot,
+    isJsr,
+    libsList,
+    rmDepsMode,
+    rmDepsPatterns,
+    unifiedBundlerOutExt
+  );
+  relinka("verbose", `${logPrefix} Created package.json.`);
+  if (deleteFiles) {
+    await deleteSpecificFiles(outDirBin);
+    relinka(
+      "verbose",
+      `${logPrefix} Deleted specific files from ${outDirBin}.`
+    );
+  }
+  await copyRootFile(outDirRoot, FILES_TO_COPY_ROOT);
+  relinka(
+    "verbose",
+    `${logPrefix} Copied root files (${FILES_TO_COPY_ROOT.join(", ")}) to ${outDirRoot}`
+  );
+  const stripSegments = libDirName ? [`libs/${libDirName}`] : [];
+  relinka(
+    "verbose",
+    `${logPrefix} Converting alias paths in ${outDirBin}, stripping: [${stripSegments.join(", ")}]`
+  );
+  await convertImportPaths({
+    baseDir: outDirBin,
+    aliasPrefix: ALIAS_PREFIX_TO_CONVERT,
+    fromType: "alias",
+    toType: "relative",
+    libsList,
+    strip: stripSegments
+  });
+  relinka("verbose", `${logPrefix} Renaming entry file in ${outDirBin}.`);
+  await renameEntryFile(
+    isJsr,
+    outDirBin,
+    coreEntryFileName,
+    unifiedBundlerOutExt,
+    distJsrOutFilesExt
+  );
+  relinka("verbose", `${logPrefix} Completed common build steps.`);
+}
+async function determineNpmSourceDirectory(libName, mainFile, coreEntrySrcDirResolved, libsList, distName) {
+  const logPrefix = `[NPM:${distName}:${libName}]`;
+  const libConfig = libsList?.[libName];
+  let libSpecificSrcDir = coreEntrySrcDirResolved;
+  let libDirName;
+  if (libConfig?.libMainFile) {
+    if (libConfig.libDirName) {
+      const potentialLibDirName = libConfig.libDirName;
+      const potentialPath = path.join(
+        coreEntrySrcDirResolved,
+        "libs",
+        potentialLibDirName
+      );
+      if (await fs.pathExists(potentialPath)) {
+        libSpecificSrcDir = potentialPath;
+        libDirName = potentialLibDirName;
+        relinka(
+          "verbose",
+          `${logPrefix} Using explicit libDirName '${libDirName}' to set source dir: ${libSpecificSrcDir}`
+        );
+      } else {
+        relinka(
+          "warn",
+          `${logPrefix} Explicit libDirName '${potentialLibDirName}' provided, but path not found: ${potentialPath}. Falling back.`
+        );
+        libDirName = void 0;
+      }
+    } else {
+      const baseLibsDir = path.join(PROJECT_ROOT, "src", "libs");
+      try {
+        const absoluteLibMainFile = path.resolve(
+          PROJECT_ROOT,
+          libConfig.libMainFile
+        );
+        if (absoluteLibMainFile.startsWith(baseLibsDir + path.sep)) {
+          const mainFilePathRelative = path.relative(
+            baseLibsDir,
+            absoluteLibMainFile
+          );
+          const pathSegments = mainFilePathRelative.split(path.sep);
+          if (pathSegments.length > 1) {
+            const inferredDirName = pathSegments[0];
+            const potentialPath = inferredDirName ? path.join(baseLibsDir, inferredDirName) : baseLibsDir;
+            if (await fs.pathExists(potentialPath)) {
+              libDirName = inferredDirName;
+              libSpecificSrcDir = potentialPath;
+              relinka(
+                "verbose",
+                `${logPrefix} Inferred libDirName '${libDirName}' from libMainFile. Source dir: ${libSpecificSrcDir}`
+              );
+            } else {
+              relinka(
+                "verbose",
+                `${logPrefix} Inferred directory '${inferredDirName}' from libMainFile does not exist. Falling back.`
+              );
+              libDirName = void 0;
+            }
+          } else {
+            relinka(
+              "verbose",
+              `${logPrefix} libMainFile '${libConfig.libMainFile}' is directly in base libs dir? No specific subdir inferred.`
+            );
+          }
+        } else {
+          relinka(
+            "verbose",
+            `${logPrefix} libMainFile '${libConfig.libMainFile}' is outside the expected '${baseLibsDir}' structure.`
+          );
+        }
+      } catch (pathError) {
+        relinka(
+          "warn",
+          `${logPrefix} Could not reliably determine relative path for ${libConfig.libMainFile}. Falling back. Error: ${pathError instanceof Error ? pathError.message : String(pathError)}`
+        );
+      }
+    }
+  } else {
+    relinka(
+      "verbose",
+      `${logPrefix} No libMainFile configured. Using core source directory: ${coreEntrySrcDirResolved}`
+    );
+  }
+  if (!await fs.pathExists(libSpecificSrcDir)) {
+    relinka(
+      "warn",
+      `${logPrefix} Determined source directory does not exist: ${libSpecificSrcDir}. Falling back to core source dir: ${coreEntrySrcDirResolved}`
+    );
+    libSpecificSrcDir = coreEntrySrcDirResolved;
+    libDirName = void 0;
+  }
+  relinka(
+    "verbose",
+    `${logPrefix} Final determined library source directory: ${libSpecificSrcDir}`
+  );
+  return { libSpecificSrcDir, libDirName };
+}
+async function preBuildReplacements(config) {
+  const { librarySrcDir, replacementFilePath, replacementMarker } = config;
+  const replacedFiles = [];
+  if (!await fs.pathExists(replacementFilePath)) {
+    relinka(
+      "warn",
+      `Replacement content file not found: ${replacementFilePath}. Skipping pre-build replacements.`
+    );
+    return [];
+  }
+  if (!await fs.pathExists(librarySrcDir)) {
+    relinka(
+      "warn",
+      `Library source directory for replacement scan not found: ${librarySrcDir}. Skipping pre-build replacements.`
+    );
+    return [];
+  }
+  relinka(
+    "verbose",
+    `Reading replacement content from: ${replacementFilePath}`
+  );
+  const replacementContent = await fs.readFile(replacementFilePath, "utf-8");
+  const allFiles = [];
+  relinka("verbose", `Scanning for .ts/.tsx files in: ${librarySrcDir}`);
+  await collectTsFilesRecursively(librarySrcDir, allFiles);
+  relinka(
+    "verbose",
+    `Found ${allFiles.length} potential files for replacement scan.`
+  );
+  const escapedMarker = replacementMarker.replace(
+    /[.*+?^${}()|[\]\\]/g,
+    "\\$&"
+  );
+  const regex = new RegExp(`^.*${escapedMarker}\\s*$`, "gm");
+  for (const filePath of allFiles) {
+    try {
+      const originalCode = await fs.readFile(filePath, "utf-8");
+      if (!originalCode.includes(replacementMarker)) {
+        continue;
+      }
+      const magic = new MagicString(originalCode);
+      let replacementOccurred = false;
+      let match;
+      while (true) {
+        match = regex.exec(originalCode);
+        if (match === null) break;
+        replacementOccurred = true;
+        const lineContent = match[0];
+        const matchStartIndex = match.index;
+        const matchEndIndex = matchStartIndex + lineContent.length;
+        let lineStartIndex = matchStartIndex;
+        while (lineStartIndex > 0 && originalCode[lineStartIndex - 1] !== "\n") {
+          lineStartIndex--;
+        }
+        let lineEndIndex = matchEndIndex;
+        while (lineEndIndex > lineStartIndex && lineEndIndex - 1 < originalCode.length && originalCode[lineEndIndex - 1] !== void 0 && originalCode[lineEndIndex - 1] !== null && typeof originalCode[lineEndIndex - 1] === "string" && /\s/.test(originalCode[lineEndIndex - 1])) {
+          lineEndIndex--;
+        }
+        if (lineEndIndex < originalCode.length && originalCode[lineEndIndex] === "\r")
+          lineEndIndex++;
+        if (lineEndIndex < originalCode.length && originalCode[lineEndIndex] === "\n")
+          lineEndIndex++;
+        relinka(
+          "verbose",
+          `Replacing line in ${path.relative(PROJECT_ROOT, filePath)} (range ${lineStartIndex}-${lineEndIndex})`
+        );
+        const contentToInsert = replacementContent.endsWith("\n") ? replacementContent : `${replacementContent}
+`;
+        magic.overwrite(lineStartIndex, lineEndIndex, contentToInsert);
+      }
+      if (replacementOccurred) {
+        const updatedCode = magic.toString();
+        if (updatedCode !== originalCode) {
+          replacedFiles.push({
+            filePath,
+            newContent: updatedCode,
+            originalContent: originalCode
+          });
+          await fs.writeFile(filePath, updatedCode, "utf-8");
+          relinka(
+            "info",
+            `Applied pre-build replacement in ${path.relative(PROJECT_ROOT, filePath)}`
+          );
+        } else {
+          relinka(
+            "verbose",
+            `Replacement marker found but content identical after processing ${filePath}. Skipping write.`
+          );
+        }
+      }
+    } catch (fileError) {
+      relinka(
+        "error",
+        `Failed processing file for replacement ${filePath}: ${fileError instanceof Error ? fileError.message : String(fileError)}`
+      );
+    }
+  }
+  return replacedFiles;
+}
+async function postBuildReplacements(replacedFiles) {
+  if (replacedFiles.length === 0) {
+    return;
+  }
+  relinka(
+    "verbose",
+    `Reverting modifications in ${replacedFiles.length} files...`
+  );
+  const revertTasks = replacedFiles.map((record) => async () => {
+    try {
+      await fs.writeFile(record.filePath, record.originalContent, "utf-8");
+      relinka(
+        "verbose",
+        `Reverted changes in ${path.relative(PROJECT_ROOT, record.filePath)}`
+      );
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      relinka(
+        "error",
+        `Failed to revert file ${record.filePath}: ${error.message}`,
+        error.stack
+      );
+      throw new Error(`Failed to revert ${record.filePath}`);
+    }
+  });
+  try {
+    await pAll(revertTasks, { concurrency: 1, stopOnError: false });
+    relinka("verbose", "Attempted revert for all modified files.");
+  } catch (aggregateError) {
+    relinka(
+      "error",
+      "One or more files failed to revert during post-build cleanup. Check preceding error logs.",
+      aggregateError instanceof Error ? aggregateError : void 0
+    );
+    throw aggregateError;
+  }
+}
+async function collectTsFilesRecursively(dir, fileList) {
+  try {
+    if (!await fs.pathExists(dir)) {
+      relinka("warn", `Directory not found for scanning: ${dir}`);
+      return;
+    }
+    if (!(await fs.stat(dir)).isDirectory()) {
+      relinka("warn", `Path is not a directory, cannot scan: ${dir}`);
+      return;
+    }
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name !== "node_modules" && !entry.name.startsWith("dist") && entry.name !== ".git" && entry.name !== ".svn" && entry.name !== ".hg" && entry.name !== ".turbo" && entry.name !== ".next" && entry.name !== ".nuxt") {
+          await collectTsFilesRecursively(fullPath, fileList);
+        }
+      } else if (entry.isFile() && /\.(ts|tsx)$/i.test(entry.name)) {
+        fileList.push(fullPath);
+      }
+    }
+  } catch (error) {
+    relinka(
+      "error",
+      `Failed to read directory during file collection: ${dir}`,
+      error instanceof Error ? error : void 0
+    );
+    throw error;
+  }
+}