@unlockable/vite-plugin-unlock 0.1.0

package/dist/index.cjs

@@ -0,0 +1,809 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  unlock: () => unlock
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/plugin.ts
+var import_path5 = __toESM(require("path"), 1);
+var import_fs4 = __toESM(require("fs"), 1);
+
+// src/config.ts
+var import_path = __toESM(require("path"), 1);
+var import_fs = __toESM(require("fs"), 1);
+var import_module = require("module");
+
+// src/constants.ts
+var DEFAULT_EXTENSIONS = [
+  ".tsx",
+  ".ts",
+  ".jsx",
+  ".js",
+  ".vue",
+  ".svelte",
+  ".mts",
+  ".mjs"
+];
+var DEFAULT_OVERRIDE_DIR = "./src/overrides";
+var DEFAULT_SRC_DIR = "src";
+var MAX_SCAN_DEPTH = 20;
+var PLUGIN_NAME = "vite-plugin-unlock";
+
+// src/utils.ts
+var PREFIX = `[${PLUGIN_NAME}]`;
+function createLogger(debug) {
+  return {
+    info(msg) {
+      if (debug) console.log(`${PREFIX} ${msg}`);
+    },
+    warn(msg) {
+      console.warn(`${PREFIX} ${msg}`);
+    },
+    error(msg) {
+      console.error(`${PREFIX} ${msg}`);
+    }
+  };
+}
+function normalizePath(p) {
+  return p.replace(/\\/g, "/");
+}
+function stripExtension(filename) {
+  return filename.replace(/\.(tsx?|jsx?|mts|mjs|vue|svelte)$/, "");
+}
+function generateAlias(packageName) {
+  const parts = packageName.split("/");
+  const lastPart = parts[parts.length - 1];
+  return `~${lastPart}`;
+}
+
+// src/config.ts
+function findPackageSrcPath(packageName, srcDir) {
+  const cwd = process.cwd();
+  try {
+    const req = (0, import_module.createRequire)(import_path.default.join(cwd, "package.json"));
+    const pkgJsonPath = req.resolve(`${packageName}/package.json`);
+    const pkgRoot = import_path.default.dirname(pkgJsonPath);
+    const srcPath = import_path.default.join(pkgRoot, srcDir);
+    if (import_fs.default.existsSync(srcPath)) return srcPath;
+    return pkgRoot;
+  } catch {
+  }
+  const parts = packageName.startsWith("@") ? packageName.split("/") : [packageName];
+  const candidates = [
+    import_path.default.join(cwd, "node_modules", ...parts, srcDir),
+    import_path.default.join(cwd, ".yalc", ...parts, srcDir)
+  ];
+  for (const dir of candidates) {
+    if (import_fs.default.existsSync(dir)) return dir;
+  }
+  const rootCandidates = [
+    import_path.default.join(cwd, "node_modules", ...parts),
+    import_path.default.join(cwd, ".yalc", ...parts)
+  ];
+  for (const dir of rootCandidates) {
+    if (import_fs.default.existsSync(dir)) return dir;
+  }
+  return null;
+}
+function resolveTarget(input) {
+  const target = typeof input === "string" ? {
+    package: input,
+    alias: generateAlias(input),
+    srcDir: DEFAULT_SRC_DIR,
+    srcPath: ""
+  } : {
+    package: input.package,
+    alias: input.alias ?? generateAlias(input.package),
+    srcDir: input.srcDir ?? DEFAULT_SRC_DIR,
+    srcPath: "",
+    entryRedirect: input.entryRedirect,
+    hmr: input.hmr
+  };
+  const srcPath = findPackageSrcPath(target.package, target.srcDir);
+  if (!srcPath) return null;
+  target.srcPath = srcPath;
+  if (target.entryRedirect && target.hmr) {
+    const pkgDir = import_path.default.dirname(srcPath);
+    const entryFile = import_path.default.resolve(pkgDir, target.entryRedirect.to);
+    if (import_fs.default.existsSync(entryFile)) {
+      target.entryFilePath = entryFile;
+    }
+  }
+  return target;
+}
+var CONFIG_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+function findConfigFile(basename, overrideDirs) {
+  for (const dir of overrideDirs) {
+    for (const ext of CONFIG_EXTENSIONS) {
+      const p = import_path.default.resolve(dir, `${basename}${ext}`);
+      if (import_fs.default.existsSync(p)) return p;
+    }
+  }
+  return null;
+}
+function resolveOptions(options) {
+  const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
+  const overrideInput = options.overrides ?? DEFAULT_OVERRIDE_DIR;
+  const overrideDirs = (Array.isArray(overrideInput) ? overrideInput : [overrideInput]).map((dir) => import_path.default.resolve(process.cwd(), dir));
+  const targets = [];
+  for (const input of options.targets) {
+    const resolved = resolveTarget(input);
+    if (resolved) {
+      targets.push(resolved);
+    }
+  }
+  const patches = (options.patches ?? []).map((p) => ({
+    target: p.target,
+    configFile: p.configFile,
+    apply: p.apply,
+    configPath: findConfigFile(p.configFile, overrideDirs)
+  }));
+  return {
+    targets,
+    overrideDirs,
+    match: options.match ?? "basename",
+    onConflict: options.onConflict ?? "error",
+    debug: options.debug ?? false,
+    extensions,
+    extensionSet: new Set(extensions),
+    patches,
+    hmrBoundaries: options.hmrBoundaries ?? []
+  };
+}
+
+// src/scanner.ts
+var import_path2 = __toESM(require("path"), 1);
+var import_fs2 = __toESM(require("fs"), 1);
+function collectFiles(dir, extensionSet, depth = 0) {
+  if (depth > MAX_SCAN_DEPTH) return [];
+  const results = [];
+  let entries;
+  try {
+    entries = import_fs2.default.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    const fullPath = import_path2.default.resolve(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...collectFiles(fullPath, extensionSet, depth + 1));
+    } else if (entry.isFile()) {
+      const ext = import_path2.default.extname(entry.name);
+      if (extensionSet.has(ext)) {
+        results.push(fullPath);
+      }
+    }
+  }
+  return results;
+}
+function getOverrideKey(filePath, baseDir, match) {
+  const normalized = normalizePath(filePath);
+  const parts = normalized.split("/").filter(Boolean);
+  if (parts.length === 0) return null;
+  const fileName = parts[parts.length - 1];
+  const baseName = stripExtension(fileName);
+  if (!baseName) return null;
+  if (match === "path") {
+    const normalizedBase = normalizePath(baseDir);
+    const relative = normalizePath(
+      import_path2.default.relative(normalizedBase, normalized)
+    );
+    return stripExtension(relative);
+  }
+  if (baseName === "index") {
+    return parts.length >= 2 ? parts[parts.length - 2] || null : null;
+  }
+  return baseName;
+}
+function scanTarget(target, opts) {
+  const map = /* @__PURE__ */ new Map();
+  for (const f of collectFiles(target.srcPath, opts.extensionSet)) {
+    const key = getOverrideKey(f, target.srcPath, opts.match);
+    if (key) map.set(key, f);
+  }
+  return map;
+}
+function scanAllTargets(opts, logger) {
+  const combined = /* @__PURE__ */ new Map();
+  for (const target of opts.targets) {
+    const targetMap = scanTarget(target, opts);
+    logger.info(
+      `Scanned ${targetMap.size} files in ${target.package} (${target.srcPath})`
+    );
+    for (const [key, filePath] of targetMap) {
+      combined.set(key, { target, filePath });
+    }
+  }
+  return combined;
+}
+function detectNamespace(filePath, overrideDir) {
+  const relative = normalizePath(import_path2.default.relative(overrideDir, filePath));
+  const scopedMatch = relative.match(/^(@[^/]+\/[^/]+)\//);
+  if (scopedMatch) return scopedMatch[1];
+  return null;
+}
+function scanOverrides(opts, logger) {
+  const flat = /* @__PURE__ */ new Map();
+  const namespaced = /* @__PURE__ */ new Map();
+  const targetPackages = new Set(opts.targets.map((t) => t.package));
+  for (const dir of opts.overrideDirs) {
+    if (!import_fs2.default.existsSync(dir)) continue;
+    for (const fullPath of collectFiles(dir, opts.extensionSet).sort()) {
+      const relative = normalizePath(import_path2.default.relative(dir, fullPath));
+      if (relative.split("/").some((part) => part.startsWith("_"))) continue;
+      const ns = detectNamespace(fullPath, dir);
+      if (ns && targetPackages.has(ns)) {
+        const nsDir = import_path2.default.join(dir, ns);
+        const key = getOverrideKey(fullPath, nsDir, opts.match);
+        if (key && key !== "index") {
+          if (!namespaced.has(ns)) namespaced.set(ns, /* @__PURE__ */ new Map());
+          namespaced.get(ns).set(key, fullPath);
+          logger.info(`Override [${ns}]: ${key} -> ${fullPath}`);
+        }
+      } else {
+        const key = getOverrideKey(fullPath, dir, opts.match);
+        if (key && key !== "index") {
+          flat.set(key, fullPath);
+          logger.info(`Override: ${key} -> ${fullPath}`);
+        }
+      }
+    }
+  }
+  return { flat, namespaced };
+}
+
+// src/resolver.ts
+var import_path3 = __toESM(require("path"), 1);
+var import_fs3 = __toESM(require("fs"), 1);
+function findImporterTarget(importer, opts) {
+  const norm = normalizePath(importer);
+  for (const target of opts.targets) {
+    const normSrc = normalizePath(target.srcPath);
+    if (norm.startsWith(normSrc + "/") || norm === normSrc) {
+      return target;
+    }
+    const pkgDir = normalizePath(import_path3.default.dirname(target.srcPath));
+    if (norm.startsWith(pkgDir + "/")) {
+      return target;
+    }
+  }
+  return null;
+}
+function resolveEntryRedirect(resolvedId, opts, logger) {
+  const norm = normalizePath(resolvedId).replace(/\?.*$/, "");
+  for (const target of opts.targets) {
+    if (target.entryRedirect) {
+      const fromPattern = normalizePath(target.entryRedirect.from);
+      if (norm.endsWith(`/${fromPattern}`) || norm.includes(`/${fromPattern}`)) {
+        const pkgDir = import_path3.default.dirname(target.srcPath);
+        const srcEntry = import_path3.default.join(pkgDir, target.entryRedirect.to);
+        if (import_fs3.default.existsSync(srcEntry)) {
+          logger.info(
+            `Entry redirect: ${import_path3.default.basename(resolvedId)} -> ${target.entryRedirect.to}`
+          );
+          return srcEntry;
+        }
+      }
+    }
+    if (!target.entryRedirect) {
+      const parts = target.package.split("/");
+      const lastPart = parts[parts.length - 1];
+      if (norm.includes(`/${lastPart}/dist/app.`)) {
+        const srcEntry = norm.replace(
+          /\/dist\/app\.(mjs|js)$/,
+          "/src/app.tsx"
+        );
+        if (import_fs3.default.existsSync(srcEntry)) {
+          logger.info(`Entry redirect (auto): dist/app -> src/app.tsx`);
+          return srcEntry;
+        }
+      }
+    }
+  }
+  return null;
+}
+
+// src/watcher.ts
+var import_path4 = __toESM(require("path"), 1);
+function setupWatcher(server, state, opts, logger) {
+  let debounceTimer = null;
+  const handleStructuralChange = (filePath) => {
+    const ext = import_path4.default.extname(filePath);
+    if (!opts.extensionSet.has(ext)) return;
+    const normFile = normalizePath(filePath);
+    const isOverrideFile = opts.overrideDirs.some(
+      (dir) => normFile.startsWith(normalizePath(dir) + "/")
+    );
+    if (!isOverrideFile) return;
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      const oldFlat = new Map(state.flatOverrides);
+      const oldNamespaced = new Map(
+        [...state.namespacedOverrides].map(
+          ([k, v]) => [k, new Map(v)]
+        )
+      );
+      const { flat, namespaced } = scanOverrides(opts, logger);
+      const fileOverrides = /* @__PURE__ */ new Map();
+      for (const [key, overridePath] of flat) {
+        if (state.targetFiles.has(key)) {
+          fileOverrides.set(key, overridePath);
+        }
+      }
+      Object.assign(state, {
+        flatOverrides: fileOverrides,
+        namespacedOverrides: namespaced
+      });
+      let hasChanges = false;
+      const allKeys = /* @__PURE__ */ new Set([...oldFlat.keys(), ...fileOverrides.keys()]);
+      for (const key of allKeys) {
+        const wasOverride = oldFlat.has(key);
+        const isOverride = fileOverrides.has(key);
+        if (wasOverride === isOverride && oldFlat.get(key) === fileOverrides.get(key))
+          continue;
+        const action = isOverride ? wasOverride ? "changed" : "created" : "deleted";
+        logger.info(`Override "${key}" ${action}`);
+        invalidateForKey(key, isOverride, oldFlat, state, server, logger);
+        hasChanges = true;
+      }
+      const allNs = /* @__PURE__ */ new Set([
+        ...oldNamespaced.keys(),
+        ...namespaced.keys()
+      ]);
+      for (const ns of allNs) {
+        const oldMap = oldNamespaced.get(ns) ?? /* @__PURE__ */ new Map();
+        const newMap = namespaced.get(ns) ?? /* @__PURE__ */ new Map();
+        const nsKeys = /* @__PURE__ */ new Set([...oldMap.keys(), ...newMap.keys()]);
+        for (const key of nsKeys) {
+          const was = oldMap.has(key);
+          const is = newMap.has(key);
+          if (was === is && oldMap.get(key) === newMap.get(key)) continue;
+          const action = is ? was ? "changed" : "created" : "deleted";
+          logger.info(`Override [${ns}] "${key}" ${action}`);
+          invalidateForKey(key, is, oldMap, state, server, logger);
+          hasChanges = true;
+        }
+      }
+      if (hasChanges) {
+        logger.info("Structural change detected -> full reload");
+        const ws = server.hot ?? server.ws;
+        ws.send({ type: "full-reload" });
+      }
+    }, 50);
+  };
+  server.watcher.on("add", handleStructuralChange);
+  server.watcher.on("unlink", handleStructuralChange);
+  server.watcher.on("change", (filePath) => {
+    const ext = import_path4.default.extname(filePath);
+    if (!opts.extensionSet.has(ext)) return;
+    const normFile = normalizePath(filePath);
+    const isOverrideFile = opts.overrideDirs.some(
+      (dir) => normFile.startsWith(normalizePath(dir) + "/")
+    );
+    if (!isOverrideFile) return;
+    const basename = stripExtension(import_path4.default.basename(filePath));
+    if (!basename) return;
+    const isTrackedOverride = state.flatOverrides.has(basename) || [...state.namespacedOverrides.values()].some((m) => m.has(basename));
+    if (!isTrackedOverride) return;
+    const trackedMods = server.moduleGraph.getModulesByFile(normFile);
+    if (trackedMods && trackedMods.size > 0) return;
+    const targetInfo = state.targetFiles.get(basename);
+    if (!targetInfo) return;
+    const origMods = server.moduleGraph.getModulesByFile(
+      normalizePath(targetInfo.filePath)
+    );
+    if (origMods) {
+      for (const mod of origMods) {
+        server.moduleGraph.invalidateModule(mod);
+      }
+      logger.info(`Override content changed: ${basename} -> reload`);
+      const ws = server.hot ?? server.ws;
+      ws.send({ type: "full-reload" });
+    }
+  });
+  if (opts.patches.length > 0) {
+    const handlePatchConfigStructural = (filePath) => {
+      const basename = stripExtension(import_path4.default.basename(filePath));
+      if (!basename) return;
+      const normFile = normalizePath(filePath);
+      const isOverrideFile = opts.overrideDirs.some(
+        (dir) => normFile.startsWith(normalizePath(dir) + "/")
+      );
+      if (!isOverrideFile) return;
+      for (const patch of opts.patches) {
+        if (basename !== patch.configFile) continue;
+        const newPath = findConfigFile(patch.configFile, opts.overrideDirs);
+        if (newPath === patch.configPath) continue;
+        patch.configPath = newPath;
+        logger.info(
+          `Patch config ${newPath ? "detected" : "removed"}: ${patch.configFile}`
+        );
+        invalidatePatchTarget(patch, server, logger);
+        const ws = server.hot ?? server.ws;
+        ws.send({ type: "full-reload" });
+      }
+    };
+    const handlePatchConfigContentEdit = (filePath) => {
+      const normFile = normalizePath(filePath);
+      for (const patch of opts.patches) {
+        if (!patch.configPath) continue;
+        if (normalizePath(patch.configPath) !== normFile) continue;
+        logger.info(`Patch config content changed: ${patch.configFile}`);
+        invalidatePatchTarget(patch, server, logger);
+        const ws = server.hot ?? server.ws;
+        ws.send({ type: "full-reload" });
+        return;
+      }
+    };
+    server.watcher.on("add", handlePatchConfigStructural);
+    server.watcher.on("unlink", handlePatchConfigStructural);
+    server.watcher.on("change", handlePatchConfigContentEdit);
+  }
+  for (const dir of opts.overrideDirs) {
+    server.watcher.add(dir);
+  }
+}
+function invalidatePatchTarget(patch, server, logger) {
+  const { moduleGraph } = server;
+  const roots = /* @__PURE__ */ new Set();
+  const timestamp = Date.now();
+  for (const mod of moduleGraph.idToModuleMap.values()) {
+    if (mod.file && patch.target.test(normalizePath(mod.file))) {
+      moduleGraph.invalidateModule(mod, /* @__PURE__ */ new Set(), timestamp, true);
+      roots.add(mod);
+      logger.info(`Invalidated patch target: ${import_path4.default.basename(mod.file)}`);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const queue = [];
+  for (const mod of roots) {
+    for (const parent of mod.importers) {
+      queue.push(parent);
+    }
+  }
+  while (queue.length > 0) {
+    const mod = queue.shift();
+    if (seen.has(mod)) continue;
+    seen.add(mod);
+    moduleGraph.invalidateModule(mod, seen, timestamp, true);
+    for (const parent of mod.importers) {
+      queue.push(parent);
+    }
+  }
+  if (roots.size > 0 && seen.size > 0) {
+    logger.info(`Invalidated ${seen.size} ancestor modules`);
+  }
+}
+function invalidateForKey(key, isNowOverride, oldOverrides, state, server, logger) {
+  const { moduleGraph } = server;
+  const roots = /* @__PURE__ */ new Set();
+  const targetInfo = state.targetFiles.get(key);
+  if (targetInfo) {
+    const mods = moduleGraph.getModulesByFile(
+      normalizePath(targetInfo.filePath)
+    );
+    if (mods) for (const mod of mods) roots.add(mod);
+  }
+  const overridePath = isNowOverride ? state.flatOverrides.get(key) : oldOverrides.get(key);
+  if (overridePath) {
+    const mods = moduleGraph.getModulesByFile(normalizePath(overridePath));
+    if (mods) for (const mod of mods) roots.add(mod);
+  }
+  if (roots.size > 0) {
+    for (const mod of roots) {
+      moduleGraph.invalidateModule(mod);
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const queue = [];
+    for (const mod of roots) {
+      for (const parent of mod.importers) {
+        queue.push(parent);
+      }
+    }
+    while (queue.length > 0) {
+      const mod = queue.shift();
+      if (seen.has(mod)) continue;
+      seen.add(mod);
+      moduleGraph.invalidateModule(mod);
+      for (const parent of mod.importers) {
+        queue.push(parent);
+      }
+    }
+    logger.info(`Invalidated "${key}" + ${seen.size} ancestor modules`);
+  } else {
+    logger.info(`Override map updated for "${key}" (module not in graph yet)`);
+  }
+}
+
+// src/plugin.ts
+function unlock(userOptions) {
+  const opts = resolveOptions(userOptions);
+  const logger = createLogger(opts.debug);
+  if (opts.targets.length === 0) {
+    logger.warn("No target packages found. Plugin will be inactive.");
+    return { name: PLUGIN_NAME };
+  }
+  const targetFiles = scanAllTargets(opts, logger);
+  const { flat, namespaced } = scanOverrides(opts, logger);
+  const fileOverrides = /* @__PURE__ */ new Map();
+  for (const [key, overridePath] of flat) {
+    if (targetFiles.has(key)) {
+      fileOverrides.set(key, overridePath);
+    } else {
+      logger.warn(
+        `Override "${key}" does not match any file in target packages \u2014 skipped`
+      );
+    }
+  }
+  if (opts.targets.length > 1 && fileOverrides.size > 0) {
+    detectConflicts(fileOverrides, targetFiles, opts, logger, scanTarget);
+  }
+  const state = {
+    flatOverrides: fileOverrides,
+    namespacedOverrides: namespaced,
+    targetFiles
+  };
+  const totalFileOverrides = fileOverrides.size + [...namespaced.values()].reduce((sum, m) => sum + m.size, 0);
+  if (totalFileOverrides > 0) {
+    logger.info(`Active overrides: ${totalFileOverrides}`);
+    if (fileOverrides.size > 0) {
+      logger.info(`  File-level: ${[...fileOverrides.keys()].join(", ")}`);
+    }
+    for (const [ns, map] of namespaced) {
+      logger.info(`  [${ns}]: ${[...map.keys()].join(", ")}`);
+    }
+  }
+  for (const patch of opts.patches) {
+    if (patch.configPath) {
+      logger.info(`Patch: ${patch.configFile} -> ${patch.configPath}`);
+    } else {
+      logger.info(`Patch: ${patch.configFile} (no config file found)`);
+    }
+  }
+  return {
+    name: PLUGIN_NAME,
+    enforce: "pre",
+    config(config) {
+      config.server = config.server || {};
+      config.server.fs = config.server.fs || {};
+      config.server.fs.allow = config.server.fs.allow || [];
+      for (const dir of opts.overrideDirs) {
+        config.server.fs.allow.push(import_path5.default.resolve(dir));
+      }
+      config.optimizeDeps = config.optimizeDeps || {};
+      config.optimizeDeps.exclude = config.optimizeDeps.exclude || [];
+      for (const target of opts.targets) {
+        config.optimizeDeps.exclude.push(target.package);
+        if (config.optimizeDeps.include) {
+          config.optimizeDeps.include = config.optimizeDeps.include.filter(
+            (dep) => dep !== target.package
+          );
+        }
+      }
+      config.resolve = config.resolve || {};
+      config.resolve.alias = config.resolve.alias || {};
+      for (const target of opts.targets) {
+        if (Array.isArray(config.resolve.alias)) {
+          config.resolve.alias.push({
+            find: target.alias,
+            replacement: target.srcPath
+          });
+        } else {
+          ;
+          config.resolve.alias[target.alias] = target.srcPath;
+        }
+      }
+      for (const target of opts.targets) {
+        const entryFile = import_path5.default.join(target.srcPath, "app.tsx");
+        if (import_fs4.default.existsSync(entryFile)) {
+          const existing = config.optimizeDeps.entries;
+          if (Array.isArray(existing)) {
+            existing.push(entryFile);
+          } else if (typeof existing === "string") {
+            config.optimizeDeps.entries = [existing, entryFile];
+          } else {
+            config.optimizeDeps.entries = [entryFile];
+          }
+        }
+      }
+    },
+    async resolveId(source, importer) {
+      if (source.startsWith("\0") || !importer || importer.startsWith("\0"))
+        return null;
+      const target = findImporterTarget(importer, opts);
+      if (target) {
+        const basename = stripExtension(import_path5.default.basename(source));
+        if (basename && basename !== "index") {
+          const nsOverrides = state.namespacedOverrides.get(target.package);
+          if (nsOverrides?.has(basename)) {
+            const p = nsOverrides.get(basename);
+            logger.info(
+              `Override [${target.package}]: ${basename} -> ${import_path5.default.basename(p)}`
+            );
+            return p;
+          }
+          if (state.flatOverrides.has(basename)) {
+            const p = state.flatOverrides.get(basename);
+            logger.info(`Override: ${basename} -> ${import_path5.default.basename(p)}`);
+            return p;
+          }
+        }
+        if (source === target.package || source.startsWith(target.package + "/")) {
+          const resolved = await this.resolve(source, importer, {
+            skipSelf: true
+          });
+          if (resolved) {
+            const redirect = resolveEntryRedirect(
+              resolved.id,
+              opts,
+              logger
+            );
+            if (redirect) return redirect;
+          }
+        }
+        return null;
+      }
+      for (const target2 of opts.targets) {
+        if (source !== target2.package && !source.startsWith(target2.package + "/"))
+          continue;
+        const resolved = await this.resolve(source, importer, {
+          skipSelf: true
+        });
+        if (resolved) {
+          const redirect = resolveEntryRedirect(resolved.id, opts, logger);
+          if (redirect) return redirect;
+        }
+      }
+      return null;
+    },
+    load(id) {
+      const target = findImporterTarget(id, opts);
+      if (!target) return null;
+      const basename = stripExtension(import_path5.default.basename(id));
+      if (!basename || basename === "index") return null;
+      const nsOverrides = state.namespacedOverrides.get(target.package);
+      const overridePath = nsOverrides?.get(basename) ?? state.flatOverrides.get(basename);
+      if (overridePath && import_fs4.default.existsSync(overridePath)) {
+        this.addWatchFile(overridePath);
+        const normalizedPath = normalizePath(overridePath).replace(/"/g, '\\"');
+        logger.info(
+          `Load override: ${basename} -> ${import_path5.default.basename(overridePath)}`
+        );
+        return `export { default } from "${normalizedPath}"
+export * from "${normalizedPath}"`;
+      }
+      const normalizedId = normalizePath(id);
+      for (const patch of opts.patches) {
+        if (!patch.target.test(normalizedId)) continue;
+        if (!patch.configPath || !import_fs4.default.existsSync(patch.configPath)) continue;
+        this.addWatchFile(patch.configPath);
+        let original;
+        try {
+          original = import_fs4.default.readFileSync(id, "utf-8");
+        } catch (err) {
+          logger.error(`Failed to read file for patching: ${id}`);
+          return null;
+        }
+        const patched = patch.apply(original, patch.configPath);
+        logger.info(
+          `Patch applied: ${import_path5.default.basename(id)} via ${patch.configFile}`
+        );
+        return { code: patched, map: null };
+      }
+      return null;
+    },
+    transform(code, id) {
+      for (const target of opts.targets) {
+        if (!target.hmr || !target.entryFilePath) continue;
+        const normId = normalizePath(id);
+        const normEntry = normalizePath(target.entryFilePath);
+        if (normId !== normEntry) continue;
+        let modified = false;
+        if (target.hmr.cssRedirect) {
+          const { from, to } = target.hmr.cssRedirect;
+          const importPattern = `import "${from}"`;
+          if (code.includes(importPattern)) {
+            code = code.replace(importPattern, `import "${to}"`);
+            logger.info(`CSS rewritten: ${from} -> ${to}`);
+            modified = true;
+          }
+        }
+        if (target.hmr.entryBoundary) {
+          code += "\nif (import.meta.hot) { import.meta.hot.accept() }";
+          logger.info(
+            `HMR boundary injected: ${target.package} entry`
+          );
+          modified = true;
+        }
+        if (modified) return { code, map: null };
+      }
+      if (opts.hmrBoundaries.length > 0) {
+        const normId = normalizePath(id);
+        if (!normId.includes("/node_modules/")) {
+          const needsBoundary = opts.hmrBoundaries.some(
+            (p) => code.includes(p)
+          );
+          if (needsBoundary) {
+            logger.info(
+              `HMR boundary injected: ${import_path5.default.basename(id)}`
+            );
+            return {
+              code: code + "\nif (import.meta.hot) { import.meta.hot.accept() }",
+              map: null
+            };
+          }
+        }
+      }
+      return null;
+    },
+    configureServer(server) {
+      const fsConfig = server.config.server?.fs;
+      if (fsConfig && Array.isArray(fsConfig.allow)) {
+        for (const dir of opts.overrideDirs) {
+          const resolved = import_path5.default.resolve(dir);
+          if (!fsConfig.allow.includes(resolved)) {
+            fsConfig.allow.push(resolved);
+          }
+        }
+      }
+      setupWatcher(server, state, opts, logger);
+    }
+  };
+}
+function detectConflicts(flat, _targetFiles, opts, logger, scan) {
+  const perTargetMaps = opts.targets.map((t) => ({
+    target: t,
+    files: scan(t, opts)
+  }));
+  for (const [key] of flat) {
+    const matchingTargets = perTargetMaps.filter(({ files }) => files.has(key));
+    if (matchingTargets.length > 1) {
+      const names = matchingTargets.map(({ target }) => target.package).join(", ");
+      if (opts.onConflict === "error") {
+        throw new Error(
+          `[${PLUGIN_NAME}] Override "${key}" matches files in multiple targets: ${names}. Use namespaced overrides (overrides/@scope/pkg/${key}.tsx) or set onConflict: "warn".`
+        );
+      } else if (opts.onConflict === "warn") {
+        logger.warn(
+          `Override "${key}" matches files in multiple targets: ${names}. Using first match.`
+        );
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  unlock
+});
+//# sourceMappingURL=index.cjs.map