wireweaver 0.1.0

package/dist/vite-plugin.cjs

@@ -0,0 +1,652 @@
+"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/vite-plugin.ts
+var vite_plugin_exports = {};
+__export(vite_plugin_exports, {
+  default: () => vite_plugin_default,
+  transformSource: () => transformSource,
+  wireWeaverEsbuildPlugin: () => wireWeaverEsbuildPlugin,
+  wireWeaverPlugin: () => wireWeaverPlugin
+});
+module.exports = __toCommonJS(vite_plugin_exports);
+var import_typescript = __toESM(require("typescript"), 1);
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_node_fs = require("fs");
+function wireWeaverPlugin(options = {}) {
+  let implementations = /* @__PURE__ */ new Map();
+  let beanRegistrations = /* @__PURE__ */ new Map();
+  let projectRoot = process.cwd();
+  return {
+    name: "wireweaver",
+    enforce: "pre",
+    configResolved(config) {
+      projectRoot = config.root;
+    },
+    buildStart() {
+      const extraScanDirs = resolveExtraScanDirs(projectRoot, options.extraScanDirs);
+      implementations = discoverInterfaceImplementations(projectRoot, extraScanDirs);
+      beanRegistrations = discoverBeanRegistrations(projectRoot, implementations, extraScanDirs);
+    },
+    transform(code, id) {
+      if (!/\.(ts|tsx)$/.test(id) || id.endsWith(".d.ts")) return null;
+      return transformSource(code, id, implementations, beanRegistrations);
+    }
+  };
+}
+var vite_plugin_default = wireWeaverPlugin;
+function wireWeaverEsbuildPlugin(options = {}) {
+  let implementations = /* @__PURE__ */ new Map();
+  let beanRegistrations = /* @__PURE__ */ new Map();
+  return {
+    name: "wireweaver",
+    setup(build) {
+      build.onStart(() => {
+        const cwd = process.cwd();
+        const extraScanDirs = resolveExtraScanDirs(cwd, options.extraScanDirs);
+        implementations = discoverInterfaceImplementations(cwd, extraScanDirs);
+        beanRegistrations = discoverBeanRegistrations(cwd, implementations, extraScanDirs);
+      });
+      build.onLoad({ filter: /\.(ts|tsx)$/ }, async (args) => {
+        if (args.path.endsWith(".d.ts")) return void 0;
+        const source = await (0, import_promises.readFile)(args.path, "utf8");
+        const result = transformSource(source, args.path, implementations, beanRegistrations);
+        if (!result) return void 0;
+        return { contents: result.code, loader: "ts" };
+      });
+    }
+  };
+}
+function transformSource(code, fileName, implementations = /* @__PURE__ */ new Map(), beanRegistrations = /* @__PURE__ */ new Map()) {
+  const sourceFile = import_typescript.default.createSourceFile(
+    fileName,
+    code,
+    import_typescript.default.ScriptTarget.Latest,
+    /* setParentNodes */
+    true,
+    import_typescript.default.ScriptKind.TS
+  );
+  const replacements = [];
+  const importsToInject = /* @__PURE__ */ new Map();
+  const sideEffectImports = /* @__PURE__ */ new Set();
+  const declaredSymbols = collectDeclaredSymbols(sourceFile);
+  const typeOnlySymbols = collectTypeOnlySymbols(sourceFile);
+  const localImplementations = discoverLocalImplementations(sourceFile, fileName);
+  const localBeanRegistrations = new Map(beanRegistrations);
+  collectBeanRegistrationsFromFile(sourceFile, fileName, implementations, localBeanRegistrations);
+  function resolveImplementations(typeName) {
+    return localImplementations.get(typeName) ?? implementations.get(typeName);
+  }
+  function visit(node) {
+    if (import_typescript.default.isClassDeclaration(node)) {
+      const decorators = import_typescript.default.getDecorators(node);
+      if (decorators) {
+        for (const decorator of decorators) {
+          if (!import_typescript.default.isCallExpression(decorator.expression)) continue;
+          const callExpr = decorator.expression;
+          if (!import_typescript.default.isIdentifier(callExpr.expression)) continue;
+          const decoratorName = callExpr.expression.text;
+          if (!isDIComponentDecoratorName(decoratorName)) continue;
+          if (callExpr.arguments.length !== 0) continue;
+          const genericTypeParams = new Set(
+            (node.typeParameters ?? []).map((tp) => tp.name.text)
+          );
+          const dependencyNames = getConstructorDependencies(node).flatMap((dependency) => {
+            if (genericTypeParams.has(dependency.typeName)) return [];
+            const candidates = resolveImplementations(dependency.typeName);
+            if (candidates && candidates.length > 0) {
+              const match = pickImplementationForParameter(dependency, candidates);
+              if (!match) {
+                throw new Error(
+                  `WireWeaver: multiple implementations found for ${dependency.typeName} but none matched constructor parameter '${dependency.paramName ?? "unknown"}' in ${fileName}.`
+                );
+              }
+              if (!declaredSymbols.has(match.className) && normalizeFilePath(fileName) !== normalizeFilePath(match.filePath)) {
+                const importPath = match.importSpecifier ?? toImportPath(fileName, match.filePath);
+                const names = importsToInject.get(importPath) ?? /* @__PURE__ */ new Set();
+                names.add(match.className);
+                importsToInject.set(importPath, names);
+              }
+              const beanFile = localBeanRegistrations.get(match.className);
+              if (beanFile && normalizeFilePath(beanFile) !== normalizeFilePath(fileName) && normalizeFilePath(beanFile) !== normalizeFilePath(match.filePath)) {
+                sideEffectImports.add(toImportPath(fileName, beanFile));
+              }
+              return [match.className];
+            }
+            if (typeOnlySymbols.has(dependency.typeName)) return [];
+            const beanFileForConcrete = localBeanRegistrations.get(dependency.typeName);
+            if (beanFileForConcrete && normalizeFilePath(beanFileForConcrete) !== normalizeFilePath(fileName)) {
+              sideEffectImports.add(toImportPath(fileName, beanFileForConcrete));
+            }
+            return [dependency.typeName];
+          });
+          if (dependencyNames.length === 0) continue;
+          replacements.push({
+            start: callExpr.getStart(sourceFile),
+            end: callExpr.getEnd(),
+            text: `${decoratorName}([${dependencyNames.join(", ")}])`
+          });
+        }
+      }
+    }
+    if (import_typescript.default.isMethodDeclaration(node)) {
+      const isStaticMethod = (import_typescript.default.getModifiers(node) ?? []).some((m) => m.kind === import_typescript.default.SyntaxKind.StaticKeyword);
+      if (isStaticMethod) {
+        const decorators = import_typescript.default.getDecorators(node);
+        if (decorators) {
+          for (const decorator of decorators) {
+            if (!import_typescript.default.isCallExpression(decorator.expression)) continue;
+            const callExpr = decorator.expression;
+            if (!import_typescript.default.isIdentifier(callExpr.expression)) continue;
+            const decoratorName = callExpr.expression.text;
+            if (!isDIBeanDecoratorName(decoratorName)) continue;
+            if (callExpr.arguments.length !== 0) continue;
+            if (!node.type || !import_typescript.default.isTypeReferenceNode(node.type)) continue;
+            if (!import_typescript.default.isIdentifier(node.type.typeName)) continue;
+            const returnTypeName = node.type.typeName.text;
+            const candidates = resolveImplementations(returnTypeName);
+            let registrationClassName;
+            if (candidates && candidates.length > 0) {
+              if (candidates.length > 1) {
+                throw new Error(
+                  `WireWeaver: @${decoratorName}() has multiple implementations for return type ${returnTypeName} in ${fileName}. Specify the class explicitly: @${decoratorName}(ConcreteClass).`
+                );
+              }
+              const match = candidates[0];
+              registrationClassName = match.className;
+              if (!declaredSymbols.has(match.className) && normalizeFilePath(fileName) !== normalizeFilePath(match.filePath)) {
+                const importPath = match.importSpecifier ?? toImportPath(fileName, match.filePath);
+                const names = importsToInject.get(importPath) ?? /* @__PURE__ */ new Set();
+                names.add(match.className);
+                importsToInject.set(importPath, names);
+              }
+            } else if (!typeOnlySymbols.has(returnTypeName)) {
+              registrationClassName = returnTypeName;
+            }
+            if (registrationClassName) {
+              replacements.push({
+                start: callExpr.getStart(sourceFile),
+                end: callExpr.getEnd(),
+                text: `${decoratorName}(${registrationClassName})`
+              });
+            }
+          }
+        }
+      }
+    }
+    if (import_typescript.default.isCallExpression(node)) {
+      const callee = node.expression;
+      if (import_typescript.default.isIdentifier(callee) && isDIResolveFunctionName(callee.text)) {
+        if (node.typeArguments?.length === 1 && node.arguments.length === 0) {
+          const typeArg = node.typeArguments[0];
+          if (import_typescript.default.isTypeReferenceNode(typeArg) && import_typescript.default.isIdentifier(typeArg.typeName)) {
+            const typeName = typeArg.typeName.text;
+            const candidates = resolveImplementations(typeName);
+            if (candidates && candidates.length > 0) {
+              if (candidates.length > 1) {
+                throw new Error(
+                  `WireWeaver: multiple implementations found for ${typeName} in ${fileName}. Cannot disambiguate a ${callee.text}<${typeName}>() call \u2014 use ${callee.text}(ConcreteClass) instead.`
+                );
+              }
+              const match = candidates[0];
+              if (!declaredSymbols.has(match.className) && normalizeFilePath(fileName) !== normalizeFilePath(match.filePath)) {
+                const importPath = match.importSpecifier ?? toImportPath(fileName, match.filePath);
+                const names = importsToInject.get(importPath) ?? /* @__PURE__ */ new Set();
+                names.add(match.className);
+                importsToInject.set(importPath, names);
+              }
+              const beanFile = localBeanRegistrations.get(match.className);
+              if (beanFile && normalizeFilePath(beanFile) !== normalizeFilePath(fileName) && normalizeFilePath(beanFile) !== normalizeFilePath(match.filePath)) {
+                sideEffectImports.add(toImportPath(fileName, beanFile));
+              }
+              replacements.push({
+                start: node.getStart(sourceFile),
+                end: node.getEnd(),
+                text: `${callee.text}(${match.className})`
+              });
+            }
+          }
+        }
+        if (node.arguments.length === 1 && (!node.typeArguments || node.typeArguments.length === 0)) {
+          const arg = node.arguments[0];
+          if (import_typescript.default.isIdentifier(arg)) {
+            const beanFile = localBeanRegistrations.get(arg.text);
+            if (beanFile && normalizeFilePath(beanFile) !== normalizeFilePath(fileName)) {
+              sideEffectImports.add(toImportPath(fileName, beanFile));
+            }
+          }
+        }
+      }
+    }
+    import_typescript.default.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  if (replacements.length === 0 && importsToInject.size === 0 && sideEffectImports.size === 0) return null;
+  const importInsertions = buildImportInsertions(code, sourceFile, importsToInject, sideEffectImports, declaredSymbols);
+  replacements.push(...importInsertions);
+  replacements.sort((a, b) => b.start - a.start);
+  let result = code;
+  for (const r of replacements) {
+    result = result.slice(0, r.start) + r.text + result.slice(r.end);
+  }
+  return { code: result };
+}
+function discoverLocalImplementations(sourceFile, fileName) {
+  const localImpls = /* @__PURE__ */ new Map();
+  function visitNode(node) {
+    if (import_typescript.default.isClassDeclaration(node) && node.name) {
+      for (const clause of node.heritageClauses ?? []) {
+        if (clause.token !== import_typescript.default.SyntaxKind.ImplementsKeyword) continue;
+        for (const type of clause.types) {
+          const interfaceName = import_typescript.default.isIdentifier(type.expression) ? type.expression.text : void 0;
+          if (!interfaceName) continue;
+          const existing = localImpls.get(interfaceName) ?? [];
+          existing.push({ className: node.name.text, filePath: fileName });
+          localImpls.set(interfaceName, existing);
+        }
+      }
+    }
+    import_typescript.default.forEachChild(node, visitNode);
+  }
+  visitNode(sourceFile);
+  return localImpls;
+}
+function discoverBeanRegistrations(root, implementations, extraScanDirs = []) {
+  const result = /* @__PURE__ */ new Map();
+  collectBeanRegistrationsFromDir(root, implementations, result, false);
+  for (const dir of extraScanDirs) {
+    collectBeanRegistrationsFromDir(dir, implementations, result, true);
+  }
+  return result;
+}
+function collectBeanRegistrationsFromDir(root, implementations, result, allowNodeModules) {
+  const tsconfigPath = import_typescript.default.findConfigFile(root, import_typescript.default.sys.fileExists, "tsconfig.json");
+  if (!tsconfigPath) return;
+  const configFile = import_typescript.default.readConfigFile(tsconfigPath, import_typescript.default.sys.readFile);
+  if (configFile.error) return;
+  const parsedConfig = import_typescript.default.parseJsonConfigFileContent(configFile.config, import_typescript.default.sys, getDirName(tsconfigPath));
+  const program = import_typescript.default.createProgram({ rootNames: parsedConfig.fileNames, options: parsedConfig.options });
+  for (const sourceFile of program.getSourceFiles()) {
+    if (sourceFile.isDeclarationFile) continue;
+    if (!allowNodeModules && sourceFile.fileName.includes("/node_modules/")) continue;
+    collectBeanRegistrationsFromFile(sourceFile, sourceFile.fileName, implementations, result);
+  }
+}
+function collectBeanRegistrationsFromFile(sourceFile, filePath, globalImplementations, result) {
+  const localImpls = discoverLocalImplementations(sourceFile, filePath);
+  const typeOnlySymbols = collectTypeOnlySymbols(sourceFile);
+  function resolveToClassName(typeName) {
+    const local = localImpls.get(typeName);
+    if (local && local.length === 1) return local[0].className;
+    const global = globalImplementations.get(typeName);
+    if (global && global.length === 1) return global[0].className;
+    if (!typeOnlySymbols.has(typeName)) return typeName;
+    return void 0;
+  }
+  function visitNode(node) {
+    if (import_typescript.default.isMethodDeclaration(node)) {
+      const isStatic = (import_typescript.default.getModifiers(node) ?? []).some((m) => m.kind === import_typescript.default.SyntaxKind.StaticKeyword);
+      if (isStatic) {
+        for (const decorator of import_typescript.default.getDecorators(node) ?? []) {
+          if (!import_typescript.default.isCallExpression(decorator.expression)) continue;
+          if (!import_typescript.default.isIdentifier(decorator.expression.expression)) continue;
+          if (!isDIBeanDecoratorName(decorator.expression.expression.text)) continue;
+          const args = decorator.expression.arguments;
+          if (args.length > 0 && import_typescript.default.isIdentifier(args[0])) {
+            result.set(args[0].text, filePath);
+          } else if (node.type && import_typescript.default.isTypeReferenceNode(node.type) && import_typescript.default.isIdentifier(node.type.typeName)) {
+            const className = resolveToClassName(node.type.typeName.text);
+            if (className) result.set(className, filePath);
+          }
+        }
+      }
+    }
+    import_typescript.default.forEachChild(node, visitNode);
+  }
+  visitNode(sourceFile);
+}
+function discoverInterfaceImplementations(root, extraScanDirs = []) {
+  const implementations = /* @__PURE__ */ new Map();
+  const allClassHeritage = /* @__PURE__ */ new Map();
+  const beanReturnTypes = /* @__PURE__ */ new Set();
+  scanSourceFilesForImplementations(root, implementations, allClassHeritage, beanReturnTypes, false);
+  for (const dir of extraScanDirs) {
+    const packageRoot = findPackageRoot(dir);
+    scanSourceFilesForImplementations(dir, implementations, allClassHeritage, beanReturnTypes, true, packageRoot);
+  }
+  for (const typeName of beanReturnTypes) {
+    const entries = allClassHeritage.get(typeName);
+    if (!entries) continue;
+    for (const entry of entries) {
+      const existing = implementations.get(entry.interfaceName) ?? [];
+      if (existing.some((i) => i.className === typeName && normalizeFilePath(i.filePath) === normalizeFilePath(entry.filePath))) {
+        continue;
+      }
+      existing.push({ className: typeName, filePath: entry.filePath, importSpecifier: entry.importSpecifier });
+      implementations.set(entry.interfaceName, existing);
+    }
+  }
+  return implementations;
+}
+function scanSourceFilesForImplementations(root, implementations, allClassHeritage, beanReturnTypes, allowNodeModules, packageRoot) {
+  const tsconfigPath = import_typescript.default.findConfigFile(root, import_typescript.default.sys.fileExists, "tsconfig.json");
+  if (!tsconfigPath) return;
+  const configFile = import_typescript.default.readConfigFile(tsconfigPath, import_typescript.default.sys.readFile);
+  if (configFile.error) return;
+  const parsedConfig = import_typescript.default.parseJsonConfigFileContent(
+    configFile.config,
+    import_typescript.default.sys,
+    getDirName(tsconfigPath)
+  );
+  const program = import_typescript.default.createProgram({
+    rootNames: parsedConfig.fileNames,
+    options: parsedConfig.options
+  });
+  for (const sourceFile of program.getSourceFiles()) {
+    if (sourceFile.isDeclarationFile) continue;
+    if (!allowNodeModules && sourceFile.fileName.includes("/node_modules/")) continue;
+    import_typescript.default.forEachChild(sourceFile, (node) => {
+      if (import_typescript.default.isClassDeclaration(node) && node.name) {
+        const importSpecifier = packageRoot ? resolvePackageImportSpecifier(node.name.text, packageRoot) : void 0;
+        for (const clause of node.heritageClauses ?? []) {
+          if (clause.token !== import_typescript.default.SyntaxKind.ImplementsKeyword) continue;
+          for (const type of clause.types) {
+            const interfaceName = import_typescript.default.isIdentifier(type.expression) ? type.expression.text : void 0;
+            if (!interfaceName) continue;
+            const heritageEntries = allClassHeritage.get(node.name.text) ?? [];
+            if (!heritageEntries.some((e) => e.interfaceName === interfaceName && normalizeFilePath(e.filePath) === normalizeFilePath(sourceFile.fileName))) {
+              heritageEntries.push({ interfaceName, filePath: sourceFile.fileName, importSpecifier });
+              allClassHeritage.set(node.name.text, heritageEntries);
+            }
+            if (!hasServiceDecorator(node)) continue;
+            const existing = implementations.get(interfaceName) ?? [];
+            if (existing.some((impl) => impl.className === node.name.text && normalizeFilePath(impl.filePath) === normalizeFilePath(sourceFile.fileName))) {
+              continue;
+            }
+            existing.push({ className: node.name.text, filePath: sourceFile.fileName, importSpecifier });
+            implementations.set(interfaceName, existing);
+          }
+        }
+      }
+      if (import_typescript.default.isClassDeclaration(node)) {
+        for (const member of node.members) {
+          if (!import_typescript.default.isMethodDeclaration(member)) continue;
+          const isStatic = (import_typescript.default.getModifiers(member) ?? []).some((m) => m.kind === import_typescript.default.SyntaxKind.StaticKeyword);
+          if (!isStatic) continue;
+          const memberDecs = import_typescript.default.getDecorators(member) ?? member.modifiers?.filter(import_typescript.default.isDecorator) ?? [];
+          for (const dec of memberDecs) {
+            if (!import_typescript.default.isCallExpression(dec.expression)) continue;
+            if (!import_typescript.default.isIdentifier(dec.expression.expression)) continue;
+            if (!isDIBeanDecoratorName(dec.expression.expression.text)) continue;
+            const args = dec.expression.arguments;
+            if (args.length > 0 && import_typescript.default.isIdentifier(args[0])) {
+              beanReturnTypes.add(args[0].text);
+            } else if (member.type && import_typescript.default.isTypeReferenceNode(member.type) && import_typescript.default.isIdentifier(member.type.typeName)) {
+              beanReturnTypes.add(member.type.typeName.text);
+            }
+          }
+        }
+      }
+    });
+  }
+}
+function hasServiceDecorator(classNode) {
+  const decorators = import_typescript.default.getDecorators(classNode) ?? classNode.modifiers?.filter(import_typescript.default.isDecorator) ?? [];
+  for (const decorator of decorators) {
+    if (!import_typescript.default.isCallExpression(decorator.expression)) continue;
+    if (!import_typescript.default.isIdentifier(decorator.expression.expression)) continue;
+    if (isDIComponentDecoratorName(decorator.expression.expression.text)) return true;
+  }
+  return false;
+}
+function isDIComponentDecoratorName(name) {
+  return name === "Service" || name === "Component";
+}
+function isDIResolveFunctionName(name) {
+  return name === "resolve" || name === "getService";
+}
+function isDIBeanDecoratorName(name) {
+  return name === "Bean" || name === "Instance";
+}
+function collectTypeOnlySymbols(sourceFile) {
+  const symbols = /* @__PURE__ */ new Set();
+  for (const statement of sourceFile.statements) {
+    if (import_typescript.default.isImportDeclaration(statement) && statement.importClause) {
+      const isEntirelyTypeOnly = statement.importClause.isTypeOnly;
+      const bindings = statement.importClause.namedBindings;
+      if (bindings && import_typescript.default.isNamedImports(bindings)) {
+        for (const element of bindings.elements) {
+          if (isEntirelyTypeOnly || element.isTypeOnly) {
+            symbols.add(element.name.text);
+          }
+        }
+      }
+    }
+  }
+  function collectTypeDeclarations(node) {
+    if (import_typescript.default.isInterfaceDeclaration(node) && node.name) {
+      symbols.add(node.name.text);
+    }
+    if (import_typescript.default.isTypeAliasDeclaration(node) && node.name) {
+      symbols.add(node.name.text);
+    }
+    import_typescript.default.forEachChild(node, collectTypeDeclarations);
+  }
+  collectTypeDeclarations(sourceFile);
+  return symbols;
+}
+function collectDeclaredSymbols(sourceFile) {
+  const symbols = /* @__PURE__ */ new Set();
+  for (const statement of sourceFile.statements) {
+    if (import_typescript.default.isImportDeclaration(statement) && statement.importClause) {
+      if (statement.importClause.name) {
+        symbols.add(statement.importClause.name.text);
+      }
+      const namedBindings = statement.importClause.namedBindings;
+      if (namedBindings && import_typescript.default.isNamedImports(namedBindings)) {
+        for (const element of namedBindings.elements) {
+          symbols.add(element.name.text);
+        }
+      }
+    }
+    if (import_typescript.default.isClassDeclaration(statement) && statement.name) {
+      symbols.add(statement.name.text);
+    }
+  }
+  return symbols;
+}
+function buildImportInsertions(code, sourceFile, importsToInject, sideEffectImports, declaredSymbols) {
+  const replacements = [];
+  for (const importPath of sideEffectImports) {
+    if (!findImportByModule(sourceFile, importPath)) {
+      const insertionPoint = getImportInsertionPoint(sourceFile);
+      replacements.push({ start: insertionPoint, end: insertionPoint, text: `import '${importPath}';
+` });
+    }
+  }
+  for (const [importPath, names] of importsToInject.entries()) {
+    const unresolved = [...names].filter((name) => !declaredSymbols.has(name));
+    if (unresolved.length === 0) continue;
+    const existing = findImportByModule(sourceFile, importPath);
+    if (existing && existing.importClause?.namedBindings && import_typescript.default.isNamedImports(existing.importClause.namedBindings)) {
+      const existingNames = new Set(existing.importClause.namedBindings.elements.map((element) => element.name.text));
+      const missing = unresolved.filter((name) => !existingNames.has(name));
+      if (missing.length === 0) continue;
+      const namedImports = existing.importClause.namedBindings;
+      replacements.push({
+        start: namedImports.getStart(sourceFile) + 1,
+        end: namedImports.getEnd() - 1,
+        text: `${[...existingNames, ...missing].sort().join(", ")}`
+      });
+      continue;
+    }
+    const insertionPoint = getImportInsertionPoint(sourceFile);
+    replacements.push({
+      start: insertionPoint,
+      end: insertionPoint,
+      text: `import { ${unresolved.sort().join(", ")} } from '${importPath}';
+`
+    });
+  }
+  return replacements;
+}
+function findImportByModule(sourceFile, moduleSpecifier) {
+  for (const statement of sourceFile.statements) {
+    if (!import_typescript.default.isImportDeclaration(statement)) continue;
+    if (!import_typescript.default.isStringLiteral(statement.moduleSpecifier)) continue;
+    if (statement.moduleSpecifier.text !== moduleSpecifier) continue;
+    if (statement.importClause?.isTypeOnly) continue;
+    return statement;
+  }
+  return void 0;
+}
+function getImportInsertionPoint(sourceFile) {
+  let end = 0;
+  for (const statement of sourceFile.statements) {
+    if (!import_typescript.default.isImportDeclaration(statement)) break;
+    end = statement.getEnd();
+  }
+  if (end === 0) return 0;
+  const fileText = sourceFile.getFullText();
+  if (fileText[end] === "\r" && fileText[end + 1] === "\n") return end + 2;
+  if (fileText[end] === "\n") return end + 1;
+  return end;
+}
+function toImportPath(fromFile, toFile) {
+  const fromDir = getDirName(fromFile);
+  const target = normalizeFilePath(toFile);
+  let relativePath = getRelativePath(fromDir, target).replace(/\.(ts|tsx|js|jsx)$/, "");
+  if (!relativePath.startsWith(".")) relativePath = `./${relativePath}`;
+  return relativePath;
+}
+function normalizeFilePath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function getDirName(filePath) {
+  const normalized = normalizeFilePath(filePath);
+  const slashIndex = normalized.lastIndexOf("/");
+  return slashIndex >= 0 ? normalized.slice(0, slashIndex) : ".";
+}
+function getRelativePath(fromDir, toPath) {
+  const fromParts = normalizeFilePath(fromDir).split("/").filter(Boolean);
+  const toParts = normalizeFilePath(toPath).split("/").filter(Boolean);
+  if (fromParts[0]?.endsWith(":") && toParts[0]?.endsWith(":") && fromParts[0] !== toParts[0]) {
+    return normalizeFilePath(toPath);
+  }
+  let shared = 0;
+  while (shared < fromParts.length && shared < toParts.length && fromParts[shared] === toParts[shared]) {
+    shared += 1;
+  }
+  const up = new Array(Math.max(fromParts.length - shared, 0)).fill("..");
+  const down = toParts.slice(shared);
+  const relative = [...up, ...down].join("/");
+  return relative || ".";
+}
+function getConstructorDependencies(classNode) {
+  const constructorDeclaration = classNode.members.find(import_typescript.default.isConstructorDeclaration);
+  if (!constructorDeclaration) return [];
+  const dependencies = [];
+  for (const parameter of constructorDeclaration.parameters) {
+    if (!parameter.type || !import_typescript.default.isTypeReferenceNode(parameter.type)) continue;
+    if (!import_typescript.default.isIdentifier(parameter.type.typeName)) continue;
+    dependencies.push({
+      typeName: parameter.type.typeName.text,
+      paramName: import_typescript.default.isIdentifier(parameter.name) ? parameter.name.text : void 0
+    });
+  }
+  return dependencies;
+}
+function pickImplementationForParameter(dependency, candidates) {
+  if (candidates.length === 1) return candidates[0];
+  if (!dependency.paramName) return void 0;
+  const normalizedParameterName = normalizeSymbolName(dependency.paramName);
+  for (const candidate of candidates) {
+    if (normalizeSymbolName(candidate.className) === normalizedParameterName) return candidate;
+    if (normalizeSymbolName(toCamelCase(candidate.className)) === normalizedParameterName) return candidate;
+    const parameterWithoutServiceSuffix = stripServiceSuffix(normalizedParameterName);
+    const candidateWithoutServiceSuffix = stripServiceSuffix(normalizeSymbolName(toCamelCase(candidate.className)));
+    if (candidateWithoutServiceSuffix === parameterWithoutServiceSuffix) return candidate;
+  }
+  return void 0;
+}
+function toCamelCase(name) {
+  if (name.length === 0) return name;
+  return name[0].toLowerCase() + name.slice(1);
+}
+function normalizeSymbolName(name) {
+  return name.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+}
+function stripServiceSuffix(name) {
+  return name.endsWith("service") ? name.slice(0, -"service".length) : name;
+}
+function resolveExtraScanDirs(root, extraScanDirs) {
+  if (!extraScanDirs || extraScanDirs.length === 0) return [];
+  return extraScanDirs.map((dir) => (0, import_node_path.isAbsolute)(dir) ? dir : (0, import_node_path.resolve)(root, dir));
+}
+function findPackageRoot(startDir) {
+  let current = startDir;
+  while (true) {
+    if ((0, import_node_fs.existsSync)((0, import_node_path.join)(current, "package.json"))) return current;
+    const parent = (0, import_node_path.dirname)(current);
+    if (parent === current) return void 0;
+    current = parent;
+  }
+}
+function resolvePackageImportSpecifier(className, packageRoot) {
+  try {
+    const pkgJsonPath = (0, import_node_path.join)(packageRoot, "package.json");
+    if (!(0, import_node_fs.existsSync)(pkgJsonPath)) return void 0;
+    const pkgJson = JSON.parse((0, import_node_fs.readFileSync)(pkgJsonPath, "utf-8"));
+    const packageName = pkgJson.name;
+    if (!packageName) return void 0;
+    const exports2 = pkgJson.exports;
+    if (!exports2) return void 0;
+    for (const [subPath, entry] of Object.entries(exports2)) {
+      const typesFile = typeof entry === "string" ? entry : entry?.types;
+      if (!typesFile || !typesFile.endsWith(".d.ts")) continue;
+      const absTypesFile = (0, import_node_path.join)(packageRoot, typesFile);
+      if (!(0, import_node_fs.existsSync)(absTypesFile)) continue;
+      const content = (0, import_node_fs.readFileSync)(absTypesFile, "utf-8");
+      if (new RegExp(`\\b${className}\\b`).test(content)) {
+        const normalizedSub = subPath === "." ? "" : subPath.replace(/^\./, "");
+        return packageName + normalizedSub;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transformSource,
+  wireWeaverEsbuildPlugin,
+  wireWeaverPlugin
+});
+if (typeof module.exports.default === "function") module.exports = Object.assign(module.exports.default, module.exports);